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

package/dist/extended/convert.d.ts

@@ -0,0 +1,11 @@
+import { type LevelData } from '@sonolus/core';
+export type ExtendedEntityData = {
+    archetype: string;
+    data: Record<string, number | string>;
+};
+export type ExtendedLevelData = {
+    bgmOffset: number;
+    entities: ExtendedEntityData[];
+};
+/** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
+export declare const extendedToLevelData: (data: ExtendedLevelData, offset?: number) => LevelData;

package/dist/extended/convert.js

@@ -0,0 +1,358 @@
+const ConnectorKind = {
+    ACTIVE_NORMAL: 1,
+    ACTIVE_CRITICAL: 2,
+    GUIDE_NEUTRAL: 101,
+    GUIDE_RED: 102,
+    GUIDE_GREEN: 103,
+    GUIDE_BLUE: 104,
+    GUIDE_YELLOW: 105,
+    GUIDE_PURPLE: 106,
+    GUIDE_CYAN: 107,
+    GUIDE_BLACK: 108,
+};
+const FlickDirection = {
+    UP_OMNI: 0,
+    UP_LEFT: 1,
+    UP_RIGHT: 2,
+};
+const EaseType = {
+    LINEAR: 1,
+    IN_QUAD: 2,
+    OUT_QUAD: 3,
+    IN_OUT_QUAD: 4,
+    OUT_IN_QUAD: 5,
+};
+const noteTypeMapping = {
+    NormalTapNote: 'NormalTapNote',
+    CriticalTapNote: 'CriticalTapNote',
+    NormalFlickNote: 'NormalFlickNote',
+    CriticalFlickNote: 'CriticalFlickNote',
+    NormalSlideStartNote: 'NormalHeadTapNote',
+    CriticalSlideStartNote: 'CriticalHeadTapNote',
+    NormalSlideEndNote: 'NormalTailReleaseNote',
+    CriticalSlideEndNote: 'CriticalTailReleaseNote',
+    NormalSlideEndFlickNote: 'NormalTailFlickNote',
+    CriticalSlideEndFlickNote: 'CriticalTailFlickNote',
+    IgnoredSlideTickNote: 'TransientHiddenTickNote',
+    NormalSlideTickNote: 'NormalTickNote',
+    CriticalSlideTickNote: 'CriticalTickNote',
+    HiddenSlideTickNote: 'AnchorNote',
+    NormalAttachedSlideTickNote: 'NormalTickNote',
+    CriticalAttachedSlideTickNote: 'CriticalTickNote',
+    NormalTraceNote: 'NormalTraceNote',
+    CriticalTraceNote: 'CriticalTraceNote',
+    DamageNote: 'DamageNote',
+    NormalTraceFlickNote: 'NormalTraceFlickNote',
+    CriticalTraceFlickNote: 'CriticalTraceFlickNote',
+    NonDirectionalTraceFlickNote: 'NormalTraceFlickNote',
+    HiddenSlideStartNote: 'AnchorNote',
+    NormalTraceSlideStartNote: 'NormalHeadTraceNote',
+    CriticalTraceSlideStartNote: 'CriticalHeadTraceNote',
+    NormalTraceSlideEndNote: 'NormalTailTraceNote',
+    CriticalTraceSlideEndNote: 'CriticalTailTraceNote',
+};
+const activeConnectorKindMapping = {
+    NormalSlideConnector: ConnectorKind.ACTIVE_NORMAL,
+    CriticalSlideConnector: ConnectorKind.ACTIVE_CRITICAL,
+};
+const flickDirectionMapping = {
+    [-1]: FlickDirection.UP_LEFT,
+    0: FlickDirection.UP_OMNI,
+    1: FlickDirection.UP_RIGHT,
+};
+const easeTypeMapping = {
+    [-2]: EaseType.OUT_IN_QUAD,
+    [-1]: EaseType.OUT_QUAD,
+    0: EaseType.LINEAR,
+    1: EaseType.IN_QUAD,
+    2: EaseType.IN_OUT_QUAD,
+};
+const fadeAlphaMapping = {
+    0: [1.0, 0.0],
+    1: [1.0, 1.0],
+    2: [0.0, 1.0],
+};
+const guideKindMapping = {
+    0: ConnectorKind.GUIDE_NEUTRAL,
+    1: ConnectorKind.GUIDE_RED,
+    2: ConnectorKind.GUIDE_GREEN,
+    3: ConnectorKind.GUIDE_BLUE,
+    4: ConnectorKind.GUIDE_YELLOW,
+    5: ConnectorKind.GUIDE_PURPLE,
+    6: ConnectorKind.GUIDE_CYAN,
+    7: ConnectorKind.GUIDE_BLACK,
+};
+/** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
+export const extendedToLevelData = (data, offset = 0) => {
+    const allIntermediateEntities = [];
+    const createIntermediate = (archetype, entityData) => {
+        const intermediateEntity = { archetype, data: entityData };
+        allIntermediateEntities.push(intermediateEntity);
+        return intermediateEntity;
+    };
+    createIntermediate('Initialization', {});
+    for (const entity of data.entities) {
+        if (entity.archetype === '#BPM_CHANGE') {
+            createIntermediate('#BPM_CHANGE', {
+                '#BEAT': entity.data['#BEAT'],
+                '#BPM': 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;
+                }
+            }
+        }
+    }
+    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 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);
+        }
+    }
+    for (const [i, note] of notesByOriginalIndex.entries()) {
+        const entity = data.entities[i];
+        const timescaleGroupIndex = entity.data['timeScaleGroup'] ?? -1;
+        if (timescaleGroupIndex >= 0 && timescaleGroupsByIndex.has(timescaleGroupIndex)) {
+            note.data['#TIMESCALE_GROUP'] = timescaleGroupsByIndex.get(timescaleGroupIndex);
+        }
+        const attachIndex = entity.data['attach'] ?? -1;
+        if (attachIndex > 0) {
+            const attachConnector = connectorsByOriginalIndex.get(attachIndex);
+            if (attachConnector) {
+                note.data['attachHead'] = attachConnector.data['head'];
+                note.data['attachTail'] = attachConnector.data['tail'];
+                note.data['isAttached'] = 1;
+            }
+        }
+        const slideIndex = entity.data['slide'] ?? -1;
+        if (slideIndex > 0) {
+            const slideConnector = connectorsByOriginalIndex.get(slideIndex);
+            if (slideConnector) {
+                note.data['activeHead'] = slideConnector.data['activeHead'];
+            }
+        }
+    }
+    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 });
+            }
+        }
+    }
+    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);
+        if (anchors) {
+            for (const anchor of anchors) {
+                if (anchorPositions.get(anchor)?.has(pos))
+                    continue;
+                if (anchor.data['lane'] === lane &&
+                    anchor.data['size'] === size &&
+                    anchor.data['#TIMESCALE_GROUP'] === timescaleGroup &&
+                    (segmentKind === -1 ||
+                        anchor.data['segmentKind'] === segmentKind ||
+                        anchor.data['segmentKind'] === -1) &&
+                    (segmentAlpha === -1 ||
+                        anchor.data['segmentAlpha'] === segmentAlpha ||
+                        anchor.data['segmentAlpha'] === -1) &&
+                    (connectorEase === -1 ||
+                        anchor.data['connectorEase'] === connectorEase ||
+                        anchor.data['connectorEase'] === -1)) {
+                    if (segmentKind !== -1 && anchor.data['segmentKind'] === -1) {
+                        anchor.data['segmentKind'] = segmentKind;
+                    }
+                    if (segmentAlpha !== -1 && anchor.data['segmentAlpha'] === -1) {
+                        anchor.data['segmentAlpha'] = segmentAlpha;
+                    }
+                    if (connectorEase !== -1 && anchor.data['connectorEase'] === -1) {
+                        anchor.data['connectorEase'] = connectorEase;
+                    }
+                    anchorPositions.get(anchor).add(pos);
+                    return anchor;
+                }
+            }
+        }
+        const anchor = createIntermediate('AnchorNote', {
+            '#BEAT': beat,
+            lane,
+            size,
+            '#TIMESCALE_GROUP': timescaleGroup,
+            segmentKind,
+            segmentAlpha,
+            connectorEase,
+        });
+        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,
+            });
+        }
+    }
+    for (const anchorList of anchorsByBeat.values()) {
+        for (const anchor of anchorList) {
+            if (anchor.data['segmentKind'] === -1) {
+                anchor.data['segmentKind'] = ConnectorKind.GUIDE_NEUTRAL;
+            }
+            if (anchor.data['segmentAlpha'] === -1) {
+                anchor.data['segmentAlpha'] = 1.0;
+            }
+            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;
+            }
+        }
+    }
+    allIntermediateEntities.sort((a, b) => {
+        const isInitA = a.archetype === 'Initialization' ? 0 : 1;
+        const isInitB = b.archetype === 'Initialization' ? 0 : 1;
+        if (isInitA !== isInitB)
+            return isInitA - isInitB;
+        const beatA = typeof a.data['#BEAT'] === 'number' ? a.data['#BEAT'] : -1;
+        const beatB = typeof b.data['#BEAT'] === 'number' ? b.data['#BEAT'] : -1;
+        return beatA - beatB;
+    });
+    const entities = [];
+    const intermediateToRef = new Map();
+    let entityRefCounter = 0;
+    const getRef = (intermediateEntity) => {
+        let ref = intermediateToRef.get(intermediateEntity);
+        if (ref)
+            return ref;
+        ref = (entityRefCounter++).toString(16);
+        intermediateToRef.set(intermediateEntity, ref);
+        return ref;
+    };
+    for (const intermediateEntity of allIntermediateEntities) {
+        const entity = {
+            archetype: intermediateEntity.archetype,
+            name: getRef(intermediateEntity),
+            data: [],
+        };
+        for (const [dataName, dataValue] of Object.entries(intermediateEntity.data)) {
+            if (typeof dataValue === 'number') {
+                entity.data.push({ name: dataName, value: dataValue });
+            }
+            else if (dataValue !== undefined && dataValue !== null) {
+                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+            }
+        }
+        entities.push(entity);
+    }
+    return {
+        bgmOffset: data.bgmOffset + offset,
+        entities,
+    };
+};

package/dist/index.d.ts

@@ -4,10 +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';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData };
+import { extendedToLevelData } from './extended/convert.js';
+export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData };
 export * from './usc/index.js';
 export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
-export declare const version = "1.5.6";
+export declare const version = "1.5.7";
 export declare const databaseEngineItem: {
     readonly name: "next-rush-plus";
     readonly version: 13;

package/dist/index.js

@@ -7,7 +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';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData };
+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)) {
@@ -59,7 +60,7 @@ export const convertToLevelData = (input, offset = 0) => {
     }
     return uscToLevelData(usc, offset, true, true);
 };
-export const version = '1.5.6';
+export const version = '1.5.7';
 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.6",
+  "version": "1.5.7",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {
@@ -36,10 +36,10 @@
     "@sonolus/core": "~7.15.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.2",
+    "@biomejs/biome": "~2.4.4",
     "@sonolus/sonolus.js": "~9.7.0",
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.3.3",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.56.0"
+    "typescript-eslint": "^8.56.1"
   }
 }