sonolus-next-rush-engine 2.3.2 → 2.3.3-kizu

package/dist/extended/convert.js

@@ -67,6 +67,20 @@ const activeSlideStartArchetypes = new Set([
     'NormalTraceSlideStartNote',
     'CriticalTraceSlideStartNote',
 ]);
+const slideTickArchetypes = new Set([
+    'IgnoredSlideTickNote',
+    'NormalSlideTickNote',
+    'CriticalSlideTickNote',
+    'HiddenSlideTickNote',
+    'NormalAttachedSlideTickNote',
+    'CriticalAttachedSlideTickNote',
+]);
+const scoredSlideTickArchetypes = new Set([
+    'NormalSlideTickNote',
+    'CriticalSlideTickNote',
+    'NormalAttachedSlideTickNote',
+    'CriticalAttachedSlideTickNote',
+]);
 const flickDirectionMapping = {
     [-1]: FlickDirection.UP_LEFT,
     0: FlickDirection.UP_OMNI,
@@ -94,6 +108,18 @@ const guideKindMapping = {
     6: ConnectorKind.GUIDE_CYAN,
     7: ConnectorKind.GUIDE_BLACK,
 };
+function lastIndexLeq(arr, x, key) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (key(arr[mid]) <= x)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo - 1;
+}
 class ExtData {
     constructor(entities) {
         this.byArch = new Map();
@@ -142,15 +168,22 @@ class EntityBuilder {
         return this.values['#BEAT'] ?? -1;
     }
 }
+const fieldMapCache = new WeakMap();
 function getField(e, name) {
-    const field = e.data.find((x) => x.name === name);
-    if (!field)
-        return undefined;
-    if (field.value !== undefined)
-        return field.value;
-    if (field.ref !== undefined)
-        return field.ref;
-    return undefined;
+    let fields = fieldMapCache.get(e);
+    if (!fields) {
+        fields = new Map();
+        for (const field of e.data) {
+            if (fields.has(field.name))
+                continue;
+            if (field.value !== undefined)
+                fields.set(field.name, field.value);
+            else if (field.ref !== undefined)
+                fields.set(field.name, field.ref);
+        }
+        fieldMapCache.set(e, fields);
+    }
+    return fields.get(name);
 }
 function getNum(e, name, def = 0) {
     const val = getField(e, name);
@@ -236,23 +269,13 @@ export const extendedToLevelData = (data, offset = 0) => {
     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;
-        }
+        const current = bpmChangeInfos[Math.max(0, lastIndexLeq(bpmChangeInfos, beat, (c) => c.beat))];
         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;
-        }
+        const current = bpmChangeInfos[Math.max(0, lastIndexLeq(bpmChangeInfos, time, (c) => c.time))];
         return current.beat + ((time - current.time) * current.bpm) / 60;
     }
     for (const { e } of ext.getByArch('#BPM_CHANGE')) {
@@ -281,6 +304,8 @@ export const extendedToLevelData = (data, offset = 0) => {
             changeInfos.push({
                 beat: getNum(raw, '#BEAT'),
                 timeScale: getNum(raw, 'timeScale'),
+                time: 0,
+                scaledTime: 0,
             });
             const change = new EntityBuilder('#TIMESCALE_CHANGE');
             change.set('#BEAT', getNum(raw, '#BEAT'));
@@ -303,6 +328,14 @@ export const extendedToLevelData = (data, offset = 0) => {
         }
         finalEntities.push(...changes);
         changeInfos.sort((a, b) => a.beat - b.beat);
+        for (let i = 0; i < changeInfos.length; i++) {
+            changeInfos[i].time = beatToTime(changeInfos[i].beat);
+            changeInfos[i].scaledTime =
+                i === 0
+                    ? changeInfos[i].time
+                    : changeInfos[i - 1].scaledTime +
+                        (changeInfos[i].time - changeInfos[i - 1].time) * changeInfos[i - 1].timeScale;
+        }
         timescaleChangesByIndex.set(idx, changeInfos);
         if (e.name)
             timescaleChangesByName.set(e.name, changeInfos);
@@ -324,46 +357,31 @@ export const extendedToLevelData = (data, offset = 0) => {
     function timeToScaledTime(time, changes) {
         if (changes.length === 0)
             return time;
-        const firstTime = beatToTime(changes[0].beat);
-        if (time < firstTime)
+        if (time < changes[0].time)
             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;
+        const current = changes[Math.max(0, lastIndexLeq(changes, time, (c) => c.time))];
+        return current.scaledTime + (time - current.time) * current.timeScale;
     }
     function scaledTimeToTime(scaledTime, changes) {
         if (changes.length === 0)
             return scaledTime;
-        const firstTime = beatToTime(changes[0].beat);
-        if (scaledTime < firstTime)
+        if (scaledTime < changes[0].time)
             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 (i === changes.length - 1) {
                 if (start.timeScale === 0)
                     return Number.POSITIVE_INFINITY;
-                return startTime + (scaledTime - currentScaledTime) / start.timeScale;
+                return start.time + (scaledTime - start.scaledTime) / start.timeScale;
             }
-            const nextScaledTime = currentScaledTime + (endTime - startTime) * start.timeScale;
-            const minScaledTime = Math.min(currentScaledTime, nextScaledTime);
-            const maxScaledTime = Math.max(currentScaledTime, nextScaledTime);
+            const next = changes[i + 1];
+            const minScaledTime = Math.min(start.scaledTime, next.scaledTime);
+            const maxScaledTime = Math.max(start.scaledTime, next.scaledTime);
             if (minScaledTime <= scaledTime && scaledTime <= maxScaledTime) {
-                if (Math.abs(nextScaledTime - currentScaledTime) < 1e-6)
-                    return startTime;
-                return lerp(startTime, endTime, unlerp(currentScaledTime, nextScaledTime, scaledTime));
+                if (Math.abs(next.scaledTime - start.scaledTime) < 1e-6)
+                    return start.time;
+                return lerp(start.time, next.time, unlerp(start.scaledTime, next.scaledTime, scaledTime));
             }
-            currentScaledTime = nextScaledTime;
         }
         return scaledTime;
     }
@@ -399,8 +417,16 @@ export const extendedToLevelData = (data, offset = 0) => {
         return undefined;
     }
     function getTimeScaleAt(changes, beat) {
-        const change = [...changes].reverse().find((change) => change.beat < beat - 1e-6);
-        return change?.timeScale ?? 1;
+        let lo = 0;
+        let hi = changes.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (changes[mid].beat < beat - 1e-6)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo > 0 ? changes[lo - 1].timeScale : 1;
     }
     function shouldUseStartAsHead(startRef, headRef) {
         if (startRef === headRef)
@@ -491,22 +517,10 @@ export const extendedToLevelData = (data, offset = 0) => {
         return getNum(tailOriginal, '#BEAT') < getNum(headOriginal, '#BEAT') - 1e-6;
     }
     function isSlideTickRef(ref) {
-        return [
-            'IgnoredSlideTickNote',
-            'NormalSlideTickNote',
-            'CriticalSlideTickNote',
-            'HiddenSlideTickNote',
-            'NormalAttachedSlideTickNote',
-            'CriticalAttachedSlideTickNote',
-        ].includes(resolveOriginal(ext, ref)?.archetype ?? '');
+        return slideTickArchetypes.has(resolveOriginal(ext, ref)?.archetype ?? '');
     }
     function isScoredSlideTickRef(ref) {
-        return [
-            'NormalSlideTickNote',
-            'CriticalSlideTickNote',
-            'NormalAttachedSlideTickNote',
-            'CriticalAttachedSlideTickNote',
-        ].includes(resolveOriginal(ext, ref)?.archetype ?? '');
+        return scoredSlideTickArchetypes.has(resolveOriginal(ext, ref)?.archetype ?? '');
     }
     function getUltimateTailRef(archetype, startRef, tailRef) {
         let ultimateTailRef = tailRef;
@@ -622,23 +636,37 @@ export const extendedToLevelData = (data, offset = 0) => {
         return getUltimateStartRef(archetype, startRef, headRef);
     }
     const activeTailRefsByStart = new Map();
+    let activeTailCandidatesByStart;
+    function getActiveTailCandidates(key) {
+        if (!activeTailCandidatesByStart) {
+            activeTailCandidatesByStart = new Map();
+            for (const { e } of ext.connectors) {
+                const startRef = getField(e, 'start');
+                const headRef = getField(e, 'head');
+                if (isIgnoredSlideTickRef(headRef))
+                    continue;
+                const endRef = getField(e, 'end');
+                const connectorActiveStartRef = getConnectorActiveStartRef(e.archetype, startRef, headRef, endRef);
+                const { tailRef } = resolveConnectorTailRef(e.archetype, startRef, getField(e, 'tail'));
+                const connectorKey = refKey(connectorActiveStartRef);
+                const candidate = { archetype: e.archetype, endRef, tailRef };
+                const list = activeTailCandidatesByStart.get(connectorKey);
+                if (list)
+                    list.push(candidate);
+                else
+                    activeTailCandidatesByStart.set(connectorKey, [candidate]);
+            }
+        }
+        return activeTailCandidatesByStart.get(key) ?? [];
+    }
     function getActiveTailRef(activeStartRef) {
         const key = refKey(activeStartRef);
         if (activeTailRefsByStart.has(key))
             return activeTailRefsByStart.get(key);
         let activeTailRef;
         let activeTailBeat = Number.NEGATIVE_INFINITY;
-        for (const { e } of ext.connectors) {
-            const startRef = getField(e, 'start');
-            const headRef = getField(e, 'head');
-            if (isIgnoredSlideTickRef(headRef))
-                continue;
-            const endRef = getField(e, 'end');
-            const connectorActiveStartRef = getConnectorActiveStartRef(e.archetype, startRef, headRef, endRef);
-            if (refKey(connectorActiveStartRef) !== key)
-                continue;
-            const { tailRef } = resolveConnectorTailRef(e.archetype, startRef, getField(e, 'tail'));
-            const candidateTailRef = endRef ?? getUltimateTailRef(e.archetype, activeStartRef, tailRef);
+        for (const { archetype, endRef, tailRef } of getActiveTailCandidates(key)) {
+            const candidateTailRef = endRef ?? getUltimateTailRef(archetype, activeStartRef, tailRef);
             const candidateTailBeat = getRefBeat(candidateTailRef);
             if (candidateTailBeat >= activeTailBeat) {
                 activeTailBeat = candidateTailBeat;

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 = "2.3.2";
+export declare const version = "2.3.3-kizu";
 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 = '2.3.2';
+export const version = '2.3.3-kizu';
 export const databaseEngineItem = {
     name: 'next-rush',
     version: 13,

package/dist/mmw/convert.js

@@ -25,6 +25,7 @@ const mmwEaseToSonolusEase = (ease) => {
 };
 const EPSILON = 1e-6;
 const TICKS_PER_BEAT = 480;
+const uscColorByValue = new Map(Object.entries(USCColor).map(([name, value]) => [value, name]));
 const laneToSonolusLane = (lane, width) => {
     return lane - 6 + width / 2;
 };
@@ -152,7 +153,7 @@ export const mmwsToUSC = (mmws) => {
             const uscGuide = {
                 type: 'guide',
                 fade: hold.fadeType === 0 ? 'out' : hold.fadeType === 1 ? 'none' : 'in',
-                color: Object.entries(USCColor).find(([, i]) => i === hold.guideColor)?.[0],
+                color: uscColorByValue.get(hold.guideColor),
                 midpoints: [hold.start, ...hold.steps, hold.end].map((step) => ({
                     beat: step.tick / TICKS_PER_BEAT,
                     lane: laneToUSCLane(step),

package/dist/sus/analyze.js

@@ -58,10 +58,24 @@ export const analyze = (sus) => {
         timeScaleChanges.push(scaledChanges);
         return newIndex;
     };
+    const measureChangesAsc = [...measureChanges].reverse();
+    const timeScaleGroupChangesAsc = [...timeScaleGroupChanges].reverse();
+    let measureChangeCursor = -1;
+    let timeScaleGroupChangeCursor = -1;
     lines.forEach((line, index) => {
         const [header, data] = line;
-        const measureOffset = measureChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? 0;
-        const timeScaleGroupName = timeScaleGroupChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? '00';
+        while (measureChangeCursor + 1 < measureChangesAsc.length &&
+            measureChangesAsc[measureChangeCursor + 1][0] <= index) {
+            measureChangeCursor++;
+        }
+        while (timeScaleGroupChangeCursor + 1 < timeScaleGroupChangesAsc.length &&
+            timeScaleGroupChangesAsc[timeScaleGroupChangeCursor + 1][0] <= index) {
+            timeScaleGroupChangeCursor++;
+        }
+        const measureOffset = measureChangeCursor >= 0 ? measureChangesAsc[measureChangeCursor][1] : 0;
+        const timeScaleGroupName = timeScaleGroupChangeCursor >= 0
+            ? timeScaleGroupChangesAsc[timeScaleGroupChangeCursor][1]
+            : '00';
         let timeScaleGroup = timeScaleGroups.get(timeScaleGroupName);
         if (timeScaleGroup === undefined) {
             timeScaleGroup = timeScaleGroups.size;
@@ -168,14 +182,18 @@ const getTicksPerBeat = (meta) => {
 };
 const getBarLengths = (lines, measureChanges) => {
     const barLengths = [];
+    const measureChangesAsc = [...measureChanges].reverse();
+    let cursor = -1;
     lines.forEach((line, index) => {
         const [header, data] = line;
+        while (cursor + 1 < measureChangesAsc.length && measureChangesAsc[cursor + 1][0] <= index) {
+            cursor++;
+        }
         if (header.length !== 5)
             return;
         if (!header.endsWith('02'))
             return;
-        const measure = +header.substring(0, 3) +
-            (measureChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? 0);
+        const measure = +header.substring(0, 3) + (cursor >= 0 ? measureChangesAsc[cursor][1] : 0);
         if (Number.isNaN(measure))
             return;
         barLengths.push({ measure, length: +data });
@@ -192,12 +210,20 @@ const getToTick = (barLengths, ticksPerBeat) => {
             ticks += (measure - prev.measure) * prev.length * ticksPerBeat;
         }
         return { measure, ticksPerMeasure: length * ticksPerBeat, ticks };
-    })
-        .reverse();
+    });
     return (measure, p, q) => {
-        const bar = bars.find((bar) => measure >= bar.measure);
-        if (!bar)
+        let lo = 0;
+        let hi = bars.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (bars[mid].measure <= measure)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        if (lo === 0)
             throw new Error('Unexpected missing bar');
+        const bar = bars[lo - 1];
         return (bar.ticks +
             (measure - bar.measure) * bar.ticksPerMeasure +
             (p * bar.ticksPerMeasure) / q);

package/dist/sus/convert.js

@@ -11,6 +11,7 @@ export const chsLikeToUSC = (score) => {
     const preventSingles = new Set();
     const dedupeSingles = new Set();
     const dedupeSlides = new Map();
+    const removedSlides = new Set();
     const requests = {
         sideLane: false,
         laneOffset: 0,
@@ -309,12 +310,14 @@ export const chsLikeToUSC = (score) => {
         const key = getKey(startNote);
         const dupe = dedupeSlides.get(key);
         if (dupe)
-            objects.splice(objects.indexOf(dupe), 1);
+            removedSlides.add(dupe);
         dedupeSlides.set(key, object);
     }
     return {
         offset: score.offset,
-        objects,
+        objects: removedSlides.size
+            ? objects.filter((object) => !removedSlides.has(object))
+            : objects,
     };
 };
 const getKey = (note) => `${note.lane}-${note.tick}`;

package/package.json

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