sonolus-next-rush-engine 1.0.2 → 1.0.4

package/dist/extended/convert.js

@@ -143,6 +143,35 @@ function getNum(e, name, def = 0) {
     const val = getField(e, name);
     return typeof val === 'number' ? val : def;
 }
+function nearlyEqual(a, b) {
+    return Math.abs(a - b) < 1e-6;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function unlerp(a, b, x) {
+    return (x - a) / (b - a);
+}
+function clamp01(x) {
+    return Math.min(1, Math.max(0, x));
+}
+function applyEase(type, x) {
+    const t = clamp01(x);
+    switch (type) {
+        case EaseType.IN_QUAD:
+            return t * t;
+        case EaseType.OUT_QUAD:
+            return 1 - (1 - t) * (1 - t);
+        case EaseType.IN_OUT_QUAD:
+            return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+        case EaseType.OUT_IN_QUAD:
+            return t < 0.5
+                ? (1 - (1 - 2 * t) * (1 - 2 * t)) / 2
+                : 0.5 + ((2 * t - 1) * (2 * t - 1)) / 2;
+        default:
+            return t;
+    }
+}
 function resolveOriginal(ext, ref) {
     if (typeof ref === 'number')
         return ext.get(ref);
@@ -157,6 +186,42 @@ export const extendedToLevelData = (data, offset = 0) => {
     finalEntities.push(defaultTsg);
     const init = new EntityBuilder('Initialization');
     finalEntities.push(init);
+    const bpmChanges = ext
+        .getByArch('#BPM_CHANGE')
+        .map(({ e }) => ({ beat: getNum(e, '#BEAT'), bpm: getNum(e, '#BPM') }))
+        .sort((a, b) => a.beat - b.beat);
+    const bpmChangeInfos = [];
+    let lastBeat = 0;
+    let lastTime = 0;
+    let lastBpm = bpmChanges[0]?.bpm ?? 120;
+    for (const change of bpmChanges) {
+        lastTime += ((change.beat - lastBeat) * 60) / lastBpm;
+        bpmChangeInfos.push({ ...change, time: lastTime });
+        lastBeat = change.beat;
+        lastBpm = change.bpm;
+    }
+    function beatToTime(beat) {
+        if (bpmChangeInfos.length === 0)
+            return (beat * 60) / 120;
+        let current = bpmChangeInfos[0];
+        for (const change of bpmChangeInfos) {
+            if (change.beat > beat)
+                break;
+            current = change;
+        }
+        return current.time + ((beat - current.beat) * 60) / current.bpm;
+    }
+    function timeToBeat(time) {
+        if (bpmChangeInfos.length === 0)
+            return (time * 120) / 60;
+        let current = bpmChangeInfos[0];
+        for (const change of bpmChangeInfos) {
+            if (change.time > time)
+                break;
+            current = change;
+        }
+        return current.beat + ((time - current.time) * current.bpm) / 60;
+    }
     for (const { e } of ext.getByArch('#BPM_CHANGE')) {
         const bpm = new EntityBuilder('#BPM_CHANGE');
         bpm.set('#BEAT', getNum(e, '#BEAT'));
@@ -165,6 +230,8 @@ export const extendedToLevelData = (data, offset = 0) => {
     }
     const timescaleGroupsByIndex = new Map();
     const timescaleGroupsByName = new Map();
+    const timescaleChangesByIndex = new Map();
+    const timescaleChangesByName = new Map();
     for (const { idx, e } of ext.getByArch('TimeScaleGroup')) {
         const group = new EntityBuilder('#TIMESCALE_GROUP');
         finalEntities.push(group);
@@ -173,10 +240,15 @@ export const extendedToLevelData = (data, offset = 0) => {
             timescaleGroupsByName.set(e.name, group);
         let rawRef = getField(e, 'first');
         const changes = [];
+        const changeInfos = [];
         while (rawRef !== undefined) {
             const raw = resolveOriginal(ext, rawRef);
             if (!raw)
                 break;
+            changeInfos.push({
+                beat: getNum(raw, '#BEAT'),
+                timeScale: getNum(raw, 'timeScale'),
+            });
             const change = new EntityBuilder('#TIMESCALE_CHANGE');
             change.set('#BEAT', getNum(raw, '#BEAT'));
             change.set('#TIMESCALE', getNum(raw, 'timeScale'));
@@ -197,6 +269,10 @@ export const extendedToLevelData = (data, offset = 0) => {
             group.set('first', changes[0]);
         }
         finalEntities.push(...changes);
+        changeInfos.sort((a, b) => a.beat - b.beat);
+        timescaleChangesByIndex.set(idx, changeInfos);
+        if (e.name)
+            timescaleChangesByName.set(e.name, changeInfos);
     }
     function getTSG(ref) {
         if (typeof ref === 'number')
@@ -205,6 +281,59 @@ export const extendedToLevelData = (data, offset = 0) => {
             return timescaleGroupsByName.get(ref);
         return undefined;
     }
+    function getTSGChanges(ref) {
+        if (typeof ref === 'number')
+            return timescaleChangesByIndex.get(ref) ?? [];
+        if (typeof ref === 'string')
+            return timescaleChangesByName.get(ref) ?? [];
+        return [];
+    }
+    function timeToScaledTime(time, changes) {
+        if (changes.length === 0)
+            return time;
+        const firstTime = beatToTime(changes[0].beat);
+        if (time < firstTime)
+            return time;
+        let scaledTime = firstTime;
+        for (let i = 0; i < changes.length; i++) {
+            const start = changes[i];
+            const startTime = beatToTime(start.beat);
+            const endTime = i === changes.length - 1 ? undefined : beatToTime(changes[i + 1].beat);
+            if (endTime === undefined || time < endTime) {
+                return scaledTime + (time - startTime) * start.timeScale;
+            }
+            scaledTime += (endTime - startTime) * start.timeScale;
+        }
+        return time;
+    }
+    function scaledTimeToTime(scaledTime, changes) {
+        if (changes.length === 0)
+            return scaledTime;
+        const firstTime = beatToTime(changes[0].beat);
+        if (scaledTime < firstTime)
+            return scaledTime;
+        let currentScaledTime = firstTime;
+        for (let i = 0; i < changes.length; i++) {
+            const start = changes[i];
+            const startTime = beatToTime(start.beat);
+            const endTime = i === changes.length - 1 ? undefined : beatToTime(changes[i + 1].beat);
+            if (endTime === undefined) {
+                if (start.timeScale === 0)
+                    return Number.POSITIVE_INFINITY;
+                return startTime + (scaledTime - currentScaledTime) / start.timeScale;
+            }
+            const nextScaledTime = currentScaledTime + (endTime - startTime) * start.timeScale;
+            const minScaledTime = Math.min(currentScaledTime, nextScaledTime);
+            const maxScaledTime = Math.max(currentScaledTime, nextScaledTime);
+            if (minScaledTime <= scaledTime && scaledTime <= maxScaledTime) {
+                if (Math.abs(nextScaledTime - currentScaledTime) < 1e-6)
+                    return startTime;
+                return lerp(startTime, endTime, unlerp(currentScaledTime, nextScaledTime, scaledTime));
+            }
+            currentScaledTime = nextScaledTime;
+        }
+        return scaledTime;
+    }
     const notesByIndex = new Map();
     const notesByName = new Map();
     const connectorsByIndex = new Map();
@@ -234,15 +363,93 @@ export const extendedToLevelData = (data, offset = 0) => {
             return notesByName.get(ref);
         return undefined;
     }
+    function shouldUseStartAsHead(startRef, headRef) {
+        if (startRef === headRef)
+            return false;
+        const start = resolveOriginal(ext, startRef);
+        const head = resolveOriginal(ext, headRef);
+        if (!start || !head)
+            return false;
+        if (head.archetype !== 'HiddenSlideStartNote')
+            return false;
+        if (!['NormalSlideStartNote', 'CriticalSlideStartNote'].includes(start.archetype))
+            return false;
+        return (nearlyEqual(getNum(start, '#BEAT'), getNum(head, '#BEAT')) &&
+            nearlyEqual(getNum(start, 'lane'), getNum(head, 'lane')) &&
+            nearlyEqual(getNum(start, 'size'), getNum(head, 'size')));
+    }
+    function createConnectorAnchor(beat, lane, size, tsg, kind) {
+        const anchor = new EntityBuilder('AnchorNote');
+        anchor.set('#BEAT', beat);
+        anchor.set('lane', lane);
+        anchor.set('size', size);
+        anchor.set('direction', FlickDirection.UP_OMNI);
+        anchor.set('#TIMESCALE_GROUP', tsg || defaultTsg);
+        anchor.set('isAttached', 0);
+        anchor.set('connectorEase', EaseType.LINEAR);
+        anchor.set('isSeparator', 1);
+        anchor.set('segmentKind', kind);
+        anchor.set('segmentAlpha', 1);
+        anchor.set('segmentLayer', 0);
+        finalEntities.push(anchor);
+        return anchor;
+    }
+    function getConnectorSplitAnchors(headOriginal, tailOriginal, tsg, kind, ease) {
+        const headBeat = getNum(headOriginal, '#BEAT');
+        const tailBeat = getNum(tailOriginal, '#BEAT');
+        if (tailBeat <= headBeat)
+            return [];
+        const headTsgRef = getField(headOriginal, 'timeScaleGroup');
+        const tailTsgRef = getField(tailOriginal, 'timeScaleGroup');
+        const headChanges = getTSGChanges(headTsgRef);
+        const tailChanges = getTSGChanges(tailTsgRef);
+        const splitBeats = headChanges
+            .map(({ beat }) => beat)
+            .filter((beat) => headBeat + 1e-6 < beat && beat < tailBeat - 1e-6);
+        if (splitBeats.length === 0)
+            return [];
+        const headScaledTime = timeToScaledTime(beatToTime(headBeat), headChanges);
+        const tailScaledTime = timeToScaledTime(beatToTime(tailBeat), tailChanges);
+        if (Math.abs(tailScaledTime - headScaledTime) < 1e-6)
+            return [];
+        if (ease !== EaseType.LINEAR) {
+            const sampleCount = 8;
+            for (let i = 1; i < sampleCount; i++) {
+                const scaledTime = lerp(headScaledTime, tailScaledTime, i / sampleCount);
+                const beat = timeToBeat(scaledTimeToTime(scaledTime, headChanges));
+                if (Number.isFinite(beat) && headBeat + 1e-6 < beat && beat < tailBeat - 1e-6) {
+                    splitBeats.push(beat);
+                }
+            }
+        }
+        const uniqueSplitBeats = [...splitBeats]
+            .sort((a, b) => a - b)
+            .filter((beat, i, beats) => i === 0 || !nearlyEqual(beat, beats[i - 1]));
+        const headLane = getNum(headOriginal, 'lane');
+        const tailLane = getNum(tailOriginal, 'lane');
+        const headSize = getNum(headOriginal, 'size');
+        const tailSize = getNum(tailOriginal, 'size');
+        return uniqueSplitBeats.map((beat) => {
+            const scaledTime = timeToScaledTime(beatToTime(beat), headChanges);
+            const frac = unlerp(headScaledTime, tailScaledTime, scaledTime);
+            const easedFrac = applyEase(ease, frac);
+            return createConnectorAnchor(beat, lerp(headLane, tailLane, easedFrac), lerp(headSize, tailSize, easedFrac), tsg, kind);
+        });
+    }
     for (const { idx, e } of ext.connectors) {
         const startRef = getField(e, 'start');
         const headRef = getField(e, 'head');
-        const head = getNote(headRef);
-        const tail = getNote(getField(e, 'tail'));
-        const segmentHead = getNote(startRef);
+        const tailRef = getField(e, 'tail');
+        const rawHead = getNote(headRef);
+        const tail = getNote(tailRef);
+        const activeHead = getNote(startRef);
+        const usesStartAsHead = shouldUseStartAsHead(startRef, headRef);
+        const head = usesStartAsHead ? activeHead : rawHead;
+        const headOriginal = resolveOriginal(ext, usesStartAsHead ? startRef : headRef);
+        const tailOriginal = resolveOriginal(ext, tailRef);
         const endRef = getField(e, 'end');
-        let segmentTail = getNote(endRef);
-        if (!segmentTail) {
+        let activeTail = getNote(endRef);
+        if (!activeTail) {
             const currentTailRef = getField(e, 'tail');
             let ultimateTailRef = currentTailRef;
             const visited = new Set();
@@ -257,32 +464,49 @@ export const extendedToLevelData = (data, offset = 0) => {
                     break;
                 }
             }
-            segmentTail = getNote(ultimateTailRef);
+            activeTail = getNote(ultimateTailRef);
         }
-        if (!segmentTail) {
-            segmentTail = tail;
+        if (!activeTail) {
+            activeTail = tail;
         }
-        if (!head || !tail || !segmentHead || !segmentTail)
+        if (!head || !tail || !activeHead || !activeTail)
             continue;
         const kind = activeConnectorKindMapping[e.archetype];
         const ease = easeTypeMapping[getNum(e, 'ease')] ?? EaseType.LINEAR;
-        const connector = new EntityBuilder('Connector');
-        connector.set('head', head);
-        connector.set('tail', tail);
-        connector.set('segmentHead', segmentHead);
-        connector.set('segmentTail', segmentTail);
-        connector.set('activeHead', segmentHead);
-        connector.set('activeTail', segmentTail);
-        head.set('connectorEase', ease);
-        head.set('segmentKind', kind);
+        const tsg = headOriginal ? getTSG(getField(headOriginal, 'timeScaleGroup')) : undefined;
+        const splitAnchors = headOriginal && tailOriginal
+            ? getConnectorSplitAnchors(headOriginal, tailOriginal, tsg, kind, ease)
+            : [];
+        const segmentEase = splitAnchors.length > 0 ? EaseType.LINEAR : ease;
+        const segmentNotes = [head, ...splitAnchors, tail];
+        for (let i = 0; i < segmentNotes.length - 1; i++) {
+            const segmentHead = segmentNotes[i];
+            const segmentTail = segmentNotes[i + 1];
+            const connector = new EntityBuilder('Connector');
+            connector.set('head', segmentHead);
+            connector.set('tail', segmentTail);
+            connector.set('segmentHead', segmentHead);
+            connector.set('segmentTail', segmentTail);
+            connector.set('activeHead', activeHead);
+            connector.set('activeTail', activeTail);
+            finalEntities.push(connector);
+        }
+        const connectorLink = new EntityBuilder('Connector');
+        connectorLink.set('head', head);
+        connectorLink.set('tail', tail);
+        connectorLink.set('activeHead', activeHead);
+        connectorLink.set('activeTail', activeTail);
+        for (const segmentHead of segmentNotes.slice(0, -1)) {
+            segmentHead.set('connectorEase', segmentEase);
+            segmentHead.set('segmentKind', kind);
+            segmentHead.set('segmentAlpha', 1);
+        }
         tail.set('segmentKind', kind);
-        segmentHead.set('segmentKind', kind);
-        segmentHead.set('segmentAlpha', 1);
-        segmentTail.set('segmentAlpha', 1);
-        finalEntities.push(connector);
-        connectorsByIndex.set(idx, connector);
+        tail.set('segmentAlpha', 1);
+        activeHead.set('segmentKind', kind);
+        connectorsByIndex.set(idx, connectorLink);
         if (e.name)
-            connectorsByName.set(e.name, connector);
+            connectorsByName.set(e.name, connectorLink);
     }
     function getConn(ref) {
         if (typeof ref === 'number')

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-next-rush-engine",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Perspective-lane rhythm game for Sonolus",
   "author": "Hyeon2",
   "repository": {