sonolus-next-rush-plus-engine 1.3.7 → 1.3.8

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,12 +1,13 @@
 import { detectMMWSType } from './mmw/analyze.js';
 import { mmwsToUSC } from './mmw/convert.js';
+import { ucmmwsToLevelData } from './mmw/convert.js';
 import { susToUSC } from './sus/convert.js';
 import { uscToLevelData } from './usc/convert.js';
 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 };
+export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData };
 export * from './usc/index.js';
 export const convertToLevelData = (input, offset = 0) => {
     if (isLevelData(input)) {
@@ -17,11 +18,20 @@ export const convertToLevelData = (input, offset = 0) => {
         usc = input;
     }
     else if (input instanceof Uint8Array) {
-        usc = mmwsToUSC(input);
-        if (detectMMWSType(input) == 'MMWS')
-            return uscToLevelData(usc, offset, true, true);
-        else if (detectMMWSType(input) == 'CCMMWS')
-            return uscToLevelData(usc, offset, false, false);
+        const type = detectMMWSType(input);
+        if (type === 'UCMMWS') {
+            return ucmmwsToLevelData(input);
+        }
+        if (type === 'MMWS' || type === 'CCMMWS') {
+            usc = mmwsToUSC(input);
+            if (type === 'MMWS') {
+                return uscToLevelData(usc, offset, true, true);
+            }
+            else {
+                return uscToLevelData(usc, offset, false, false);
+            }
+        }
+        throw new Error('Unsupported Uint8Array type for MMWS');
     }
     else if (typeof input === 'string') {
         try {
@@ -49,7 +59,7 @@ export const convertToLevelData = (input, offset = 0) => {
     }
     return uscToLevelData(usc, offset, true, true);
 };
-export const version = '1.3.7';
+export const version = '1.3.8';
 export const databaseEngineItem = {
     name: 'next-rush-plus',
     version: 13,

package/dist/mmw/analyze.d.ts

@@ -1,4 +1,4 @@
-declare const FlickType: readonly ["none", "up", "left", "right"];
+declare const FlickType: readonly ["none", "up", "left", "right", "down", "down_left", "down_right"];
 type FlickType = (typeof FlickType)[number];
 declare const StepType: readonly ["visible", "hidden", "ignored"];
 type StepType = (typeof StepType)[number];
@@ -27,6 +27,9 @@ export type Score = {
             tick: number;
             speed: number;
             layer: number;
+            skip?: number;
+            ease?: number;
+            hideNotes?: boolean;
         }[];
         skills: number[];
         fever: {
@@ -42,6 +45,7 @@ export type Score = {
         flags: {
             critical: boolean;
             friction: boolean;
+            dummy?: boolean;
         };
         layer: number;
     }[];
@@ -50,6 +54,7 @@ export type Score = {
             startHidden: boolean;
             endHidden: boolean;
             guide: boolean;
+            dummy?: boolean;
         };
         start: {
             tick: number;
@@ -92,6 +97,7 @@ export type Score = {
         flags: {
             critical: boolean;
             friction: boolean;
+            dummy?: boolean;
         };
         layer: number;
     }[];

package/dist/mmw/analyze.js

@@ -1,5 +1,5 @@
 import { BinarySeeker } from '../lib/binaryseeker/mod.js';
-const FlickType = ['none', 'up', 'left', 'right'];
+const FlickType = ['none', 'up', 'left', 'right', 'down', 'down_left', 'down_right'];
 const StepType = ['visible', 'hidden', 'ignored'];
 const EaseType = ['linear', 'easeIn', 'easeOut', 'easeInOut', 'easeOutIn'];
 /** Detect MMWS Type */
@@ -11,16 +11,27 @@ export const detectMMWSType = (mmws) => {
 export const analyze = (mmws) => {
     const buffer = new BinarySeeker(mmws.buffer);
     const header = buffer.readString();
-    if (header !== 'MMWS' && header !== 'CCMMWS') {
+    if (header !== 'MMWS' && header !== 'CCMMWS' && header !== 'UCMMWS') {
         throw new Error('Invalid MMWS file');
     }
-    const version = buffer.readInt16LE();
-    let cyanvasVersion = buffer.readInt16LE();
-    if (version < 3) {
-        throw new Error('Unsupported MMWS version');
+    let version = 0;
+    let cyanvasVersion = 0;
+    let untitledVersion = 0;
+    if (header === 'UCMMWS') {
+        untitledVersion = buffer.readInt32LE();
+        cyanvasVersion = 6;
+        version = 4;
+    }
+    else if (header === 'CCMMWS') {
+        cyanvasVersion = Math.max(buffer.readInt16LE(), 1);
+        version = buffer.readInt16LE();
     }
-    if (header === 'CCMMWS' && cyanvasVersion === 0) {
-        cyanvasVersion = 1;
+    else {
+        version = buffer.readInt16LE();
+        cyanvasVersion = buffer.readInt16LE();
+    }
+    if (version < 3 && header !== 'UCMMWS') {
+        throw new Error('Unsupported MMWS version');
     }
     const metadataPointer = buffer.readUInt32LE();
     const eventsPointer = buffer.readUInt32LE();
@@ -28,7 +39,6 @@ export const analyze = (mmws) => {
     const holdsPointer = buffer.readUInt32LE();
     const damagesPointer = cyanvasVersion > 0 ? buffer.readUInt32LE() : 0;
     const layersPointer = cyanvasVersion >= 4 ? buffer.readUInt32LE() : 0;
-    // const waypointsPointer = cyanvasVersion >= 5 ? buffer.readUInt32LE() : 0
     buffer.seek(metadataPointer);
     const metadata = {
         title: buffer.readString(),
@@ -36,8 +46,11 @@ export const analyze = (mmws) => {
         artist: buffer.readString(),
         musicFile: buffer.readString(),
         musicOffset: buffer.readFloat32LE(),
-        jacketFile: buffer.readString(),
+        jacketFile: version >= 2 ? buffer.readString() : '',
     };
+    if (cyanvasVersion >= 1) {
+        buffer.readInt32LE();
+    }
     buffer.seek(eventsPointer);
     const events = {
         timeSignatures: [],
@@ -64,29 +77,49 @@ export const analyze = (mmws) => {
             bpm: buffer.readFloat32LE(),
         });
     }
-    const hispeedChangesCount = buffer.readInt32LE();
-    for (let i = 0; i < hispeedChangesCount; i++) {
-        events.hispeedChanges.push({
-            tick: buffer.readInt32LE(),
-            speed: buffer.readFloat32LE(),
-            layer: cyanvasVersion >= 4 ? buffer.readInt32LE() : 0,
-        });
+    if (version >= 3) {
+        const hispeedChangesCount = buffer.readInt32LE();
+        for (let i = 0; i < hispeedChangesCount; i++) {
+            const tick = buffer.readInt32LE();
+            const speed = buffer.readFloat32LE();
+            const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+            let skip = 0;
+            let ease = 0;
+            let hideNotes = false;
+            if (untitledVersion >= 2) {
+                skip = buffer.readFloat32LE();
+                ease = buffer.readInt16LE();
+                hideNotes = !!buffer.readInt16LE();
+            }
+            events.hispeedChanges.push({
+                tick,
+                speed,
+                layer,
+                skip,
+                ease,
+                hideNotes,
+            });
+        }
     }
-    const skillsCount = buffer.readInt32LE();
-    for (let i = 0; i < skillsCount; i++) {
-        events.skills.push(buffer.readInt32LE());
+    if (version >= 2) {
+        const skillsCount = buffer.readInt32LE();
+        for (let i = 0; i < skillsCount; i++) {
+            const skillTick = buffer.readInt32LE();
+            events.skills.push(skillTick);
+        }
+        events.fever.start = buffer.readInt32LE();
+        events.fever.end = buffer.readInt32LE();
     }
-    events.fever.start = buffer.readInt32LE();
-    events.fever.end = buffer.readInt32LE();
     buffer.seek(tapsPointer);
     const taps = [];
     const tapsCount = buffer.readInt32LE();
     for (let i = 0; i < tapsCount; i++) {
         const tick = buffer.readInt32LE();
-        const lane = buffer.readInt32LE();
-        const width = buffer.readInt32LE();
+        const lane = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
+        const width = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
         const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
-        const flickType = FlickType[buffer.readInt32LE()];
+        const flickTypeRaw = buffer.readInt32LE();
+        const flickType = FlickType[flickTypeRaw] || 'none';
         const flags = buffer.readInt32LE();
         taps.push({
             tick,
@@ -96,6 +129,7 @@ export const analyze = (mmws) => {
             flags: {
                 critical: !!(flags & (1 << 0)),
                 friction: !!(flags & (1 << 1)),
+                dummy: cyanvasVersion >= 6 && untitledVersion >= 1 ? !!(flags & (1 << 2)) : false,
             },
             layer,
         });
@@ -106,8 +140,8 @@ export const analyze = (mmws) => {
     for (let i = 0; i < holdsCount; i++) {
         const holdFlags = version >= 4 ? buffer.readInt32LE() : 0;
         const startTick = buffer.readInt32LE();
-        const startLane = buffer.readInt32LE();
-        const startWidth = buffer.readInt32LE();
+        const startLane = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
+        const startWidth = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
         const startLayer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
         const startFlags = buffer.readInt32LE();
         const startEase = EaseType[buffer.readInt32LE()];
@@ -117,10 +151,10 @@ export const analyze = (mmws) => {
         const steps = [];
         for (let j = 0; j < stepsCount; j++) {
             const tick = buffer.readInt32LE();
-            const lane = buffer.readInt32LE();
-            const width = buffer.readInt32LE();
+            const lane = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
+            const width = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
             const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
-            buffer.readInt32LE(); // unused flags
+            buffer.readInt32LE();
             const type = StepType[buffer.readInt32LE()];
             const ease = EaseType[buffer.readInt32LE()];
             steps.push({
@@ -133,16 +167,18 @@ export const analyze = (mmws) => {
             });
         }
         const endTick = buffer.readInt32LE();
-        const endLane = buffer.readInt32LE();
-        const endWidth = buffer.readInt32LE();
+        const endLane = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
+        const endWidth = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
         const endLayer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
-        const endFlickType = FlickType[buffer.readInt32LE()];
+        const endFlickTypeRaw = buffer.readInt32LE();
+        const endFlickType = FlickType[endFlickTypeRaw] || 'none';
         const endFlags = buffer.readInt32LE();
         holds.push({
             flags: {
                 startHidden: !!(holdFlags & (1 << 0)),
                 endHidden: !!(holdFlags & (1 << 1)),
                 guide: !!(holdFlags & (1 << 2)),
+                dummy: !!(holdFlags & (1 << 3)),
             },
             start: {
                 tick: startTick,
@@ -183,10 +219,11 @@ export const analyze = (mmws) => {
         const damagesCount = buffer.readInt32LE();
         for (let i = 0; i < damagesCount; i++) {
             const tick = buffer.readInt32LE();
-            const lane = buffer.readInt32LE();
-            const width = buffer.readInt32LE();
+            const lane = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
+            const width = cyanvasVersion >= 6 ? buffer.readFloat32LE() : buffer.readInt32LE();
             const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
-            const flickType = FlickType[buffer.readInt32LE()];
+            const flickTypeRaw = buffer.readInt32LE();
+            const flickType = FlickType[flickTypeRaw] || 'none';
             const flags = buffer.readInt32LE();
             damages.push({
                 tick,
@@ -197,6 +234,7 @@ export const analyze = (mmws) => {
                 flags: {
                     critical: !!(flags & (1 << 0)),
                     friction: !!(flags & (1 << 1)),
+                    dummy: cyanvasVersion >= 6 && untitledVersion >= 1 ? !!(flags & (1 << 2)) : false,
                 },
             });
         }

package/dist/mmw/convert.d.ts

@@ -1,4 +1,5 @@
 import { USC } from '../usc/index.js';
+import { type LevelData } from '@sonolus/core';
 /**
  * Convert MMWS or CCMMWS to a USC
  */
@@ -7,3 +8,7 @@ export declare const mmwsToUSC: (mmws: Uint8Array) => USC;
  * Convert CCMMWS to a USC
  */
 export declare const ccmmwsToUSC: (mmws: Uint8Array) => USC;
+/**
+ * Convert UCMMWS to a LevelData
+ */
+export declare const ucmmwsToLevelData: (mmws: Uint8Array) => LevelData;

package/dist/mmw/convert.js

@@ -1,5 +1,57 @@
 import { USCColor, } from '../usc/index.js';
 import { analyze } from './analyze.js';
+const SONOLUS_CONNECTOR_EASES = {
+    outin: 5,
+    out: 3,
+    linear: 1,
+    in: 2,
+    inout: 4,
+};
+const mmwEaseToSonolusEase = (ease) => {
+    switch (ease) {
+        case 'linear':
+            return SONOLUS_CONNECTOR_EASES.linear;
+        case 'easeIn':
+            return SONOLUS_CONNECTOR_EASES.in;
+        case 'easeOut':
+            return SONOLUS_CONNECTOR_EASES.out;
+        case 'easeInOut':
+            return SONOLUS_CONNECTOR_EASES.inout;
+        case 'easeOutIn':
+            return SONOLUS_CONNECTOR_EASES.outin;
+        default:
+            return SONOLUS_CONNECTOR_EASES.linear;
+    }
+};
+const EPSILON = 1e-6;
+const TICKS_PER_BEAT = 480;
+const laneToSonolusLane = (lane, width) => {
+    return lane - 6 + width / 2;
+};
+const flickTypeToDirection = (type) => {
+    switch (type) {
+        case 'up':
+            return 0;
+        case 'left':
+            return 1;
+        case 'right':
+            return 2;
+        case 'down':
+            return 3;
+        case 'down_left':
+            return 4;
+        case 'down_right':
+            return 5;
+        default:
+            return 0;
+    }
+};
+const resolveConnectorKind = (isCritical, isDummy) => {
+    if (isDummy) {
+        return isCritical ? 52 : 51;
+    }
+    return isCritical ? 1 : 0;
+};
 const mmwsEaseToUSCEase = {
     linear: 'linear',
     easeOut: 'out',
@@ -7,7 +59,6 @@ const mmwsEaseToUSCEase = {
     easeInOut: 'inout',
     easeOutIn: 'outin',
 };
-const ticksPerBeat = 480;
 const laneToUSCLane = ({ lane, width }) => {
     return lane - 6 + width / 2;
 };
@@ -23,7 +74,7 @@ export const mmwsToUSC = (mmws) => {
     for (const bpmChange of score.events.bpmChanges) {
         usc.objects.push({
             type: 'bpm',
-            beat: bpmChange.tick / ticksPerBeat,
+            beat: bpmChange.tick / TICKS_PER_BEAT,
             bpm: bpmChange.bpm,
         });
     }
@@ -34,10 +85,16 @@ export const mmwsToUSC = (mmws) => {
     for (const hispeedChange of score.events.hispeedChanges) {
         const key = hispeedChange.layer;
         if (!tsGroups.has(key)) {
-            throw new Error('Invalid layer');
+            if (!tsGroups.has(0))
+                tsGroups.set(0, []);
+            tsGroups.get(0).push({
+                beat: hispeedChange.tick / TICKS_PER_BEAT,
+                timeScale: hispeedChange.speed,
+            });
+            continue;
         }
         tsGroups.get(key).push({
-            beat: hispeedChange.tick / ticksPerBeat,
+            beat: hispeedChange.tick / TICKS_PER_BEAT,
             timeScale: hispeedChange.speed,
         });
     }
@@ -50,14 +107,14 @@ export const mmwsToUSC = (mmws) => {
     for (const tap of score.taps) {
         const uscTap = {
             type: 'single',
-            beat: tap.tick / ticksPerBeat,
+            beat: tap.tick / TICKS_PER_BEAT,
             timeScaleGroup: tap.layer,
             critical: tap.flags.critical,
             lane: laneToUSCLane(tap),
             size: tap.width / 2,
             trace: tap.flags.friction,
         };
-        if (tap.flickType !== 'none') {
+        if (tap.flickType === 'up' || tap.flickType === 'left' || tap.flickType === 'right') {
             uscTap.direction = tap.flickType;
         }
         usc.objects.push(uscTap);
@@ -65,7 +122,7 @@ export const mmwsToUSC = (mmws) => {
     for (const hold of score.holds) {
         const uscStartNote = {
             type: 'start',
-            beat: hold.start.tick / ticksPerBeat,
+            beat: hold.start.tick / TICKS_PER_BEAT,
             timeScaleGroup: hold.start.layer,
             critical: hold.start.flags.critical,
             ease: mmwsEaseToUSCEase[hold.start.ease],
@@ -79,14 +136,16 @@ export const mmwsToUSC = (mmws) => {
         };
         const uscEndNote = {
             type: 'end',
-            beat: hold.end.tick / ticksPerBeat,
+            beat: hold.end.tick / TICKS_PER_BEAT,
             timeScaleGroup: hold.end.layer,
             critical: hold.end.flags.critical,
             lane: laneToUSCLane(hold.end),
             size: hold.end.width / 2,
             judgeType: hold.flags.endHidden ? 'none' : hold.end.flags.friction ? 'trace' : 'normal',
         };
-        if (hold.end.flickType !== 'none') {
+        if (hold.end.flickType === 'up' ||
+            hold.end.flickType === 'left' ||
+            hold.end.flickType === 'right') {
             uscEndNote.direction = hold.end.flickType;
         }
         if (hold.flags.guide) {
@@ -95,7 +154,7 @@ export const mmwsToUSC = (mmws) => {
                 fade: hold.fadeType === 0 ? 'out' : hold.fadeType === 1 ? 'none' : 'in',
                 color: Object.entries(USCColor).find(([, i]) => i === hold.guideColor)[0],
                 midpoints: [hold.start, ...hold.steps, hold.end].map((step) => ({
-                    beat: step.tick / ticksPerBeat,
+                    beat: step.tick / TICKS_PER_BEAT,
                     lane: laneToUSCLane(step),
                     size: step.width / 2,
                     timeScaleGroup: step.layer,
@@ -111,7 +170,7 @@ export const mmwsToUSC = (mmws) => {
                 connections: [
                     uscStartNote,
                     ...hold.steps.map((step) => {
-                        const beat = step.tick / ticksPerBeat;
+                        const beat = step.tick / TICKS_PER_BEAT;
                         const lane = laneToUSCLane(step);
                         const size = step.width / 2;
                         if (step.type === 'ignored') {
@@ -146,7 +205,7 @@ export const mmwsToUSC = (mmws) => {
     for (const damage of score.damages) {
         const uscDamage = {
             type: 'damage',
-            beat: damage.tick / ticksPerBeat,
+            beat: damage.tick / TICKS_PER_BEAT,
             timeScaleGroup: damage.layer,
             lane: laneToUSCLane(damage),
             size: damage.width / 2,
@@ -159,3 +218,464 @@ export const mmwsToUSC = (mmws) => {
  * Convert CCMMWS to a USC
  */
 export const ccmmwsToUSC = mmwsToUSC;
+/**
+ * Convert UCMMWS to a LevelData
+ */
+export const ucmmwsToLevelData = (mmws) => {
+    const score = analyze(mmws);
+    const entities = [];
+    const allIntermediateEntities = [];
+    const simLineEligibleNotes = [];
+    const timeScaleGroupIntermediates = [];
+    const createIntermediate = (archetype, data, isSimEligible = false) => {
+        const intermediateEntity = { archetype, data };
+        allIntermediateEntities.push(intermediateEntity);
+        if (isSimEligible) {
+            simLineEligibleNotes.push(intermediateEntity);
+        }
+        return intermediateEntity;
+    };
+    createIntermediate('Initialization', {});
+    createIntermediate('Stage', {});
+    if (score.events.bpmChanges.length === 0) {
+        createIntermediate('#BPM_CHANGE', { '#BEAT': 0, '#BPM': 120 });
+    }
+    for (const bpm of score.events.bpmChanges) {
+        createIntermediate('#BPM_CHANGE', {
+            '#BEAT': bpm.tick / TICKS_PER_BEAT,
+            '#BPM': bpm.bpm,
+        });
+    }
+    for (const skillTick of score.events.skills) {
+        createIntermediate('Skill', { '#BEAT': skillTick / TICKS_PER_BEAT });
+    }
+    if (score.events.fever.start > 0) {
+        createIntermediate('FeverChance', { '#BEAT': score.events.fever.start / TICKS_PER_BEAT });
+    }
+    if (score.events.fever.end > 0) {
+        createIntermediate('FeverStart', { '#BEAT': score.events.fever.end / TICKS_PER_BEAT });
+    }
+    const layerChanges = new Map();
+    for (let i = 0; i < Math.max(1, score.numLayers); i++) {
+        layerChanges.set(i, []);
+    }
+    for (const hs of score.events.hispeedChanges) {
+        if (!layerChanges.has(hs.layer)) {
+            if (!layerChanges.has(0))
+                layerChanges.set(0, []);
+            layerChanges.get(0).push(hs);
+            continue;
+        }
+        layerChanges.get(hs.layer).push(hs);
+    }
+    for (let i = 0; i < Math.max(1, score.numLayers); i++) {
+        const changes = layerChanges.get(i) || [];
+        if (changes.length === 0 || changes[0].tick !== 0) {
+            changes.unshift({
+                tick: 0,
+                speed: 1,
+                layer: i,
+                skip: 0,
+                ease: 0,
+                hideNotes: false,
+            });
+        }
+        changes.sort((a, b) => a.tick - b.tick);
+        const groupIntermediate = createIntermediate('#TIMESCALE_GROUP', {});
+        timeScaleGroupIntermediates[i] = groupIntermediate;
+        let lastChangeIntermediate = null;
+        for (const hs of changes) {
+            const data = {
+                '#BEAT': hs.tick / TICKS_PER_BEAT,
+                '#TIMESCALE': hs.speed === 0 ? 0.000001 : hs.speed,
+                '#TIMESCALE_SKIP': hs.skip || 0,
+                '#TIMESCALE_EASE': hs.ease || 0,
+                '#TIMESCALE_GROUP': groupIntermediate,
+            };
+            if (hs.hideNotes) {
+                data['hideNotes'] = 1;
+            }
+            const newChangeIntermediate = createIntermediate('#TIMESCALE_CHANGE', data);
+            if (lastChangeIntermediate === null) {
+                groupIntermediate.data['first'] = newChangeIntermediate;
+            }
+            else {
+                lastChangeIntermediate.data['next'] = newChangeIntermediate;
+            }
+            lastChangeIntermediate = newChangeIntermediate;
+        }
+    }
+    for (const tap of score.taps) {
+        const name_parts = [];
+        name_parts.push(tap.flags.critical ? 'Critical' : 'Normal');
+        if (tap.flickType !== 'none') {
+            name_parts.push(tap.flags.friction ? 'TraceFlick' : 'Flick');
+        }
+        else {
+            name_parts.push(tap.flags.friction ? 'Trace' : 'Tap');
+        }
+        name_parts.push('Note');
+        const archetype = tap.flags.dummy ? `Fake${name_parts.join('')}` : name_parts.join('');
+        const timeScaleGroupRef = timeScaleGroupIntermediates[tap.layer] || timeScaleGroupIntermediates[0];
+        const data = {
+            '#BEAT': tap.tick / TICKS_PER_BEAT,
+            lane: laneToSonolusLane(tap.lane, tap.width),
+            size: tap.width,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: tap.flags.critical ? 2 : 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        };
+        if (tap.flickType !== 'none') {
+            data['direction'] = flickTypeToDirection(tap.flickType);
+        }
+        createIntermediate(archetype, data, true);
+    }
+    for (const damage of score.damages) {
+        const archetype = damage.flags.dummy ? 'FakeDamageNote' : 'DamageNote';
+        const timeScaleGroupRef = timeScaleGroupIntermediates[damage.layer] || timeScaleGroupIntermediates[0];
+        createIntermediate(archetype, {
+            '#BEAT': damage.tick / TICKS_PER_BEAT,
+            lane: laneToSonolusLane(damage.lane, damage.width),
+            size: damage.width,
+            direction: 0,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        });
+    }
+    for (const hold of score.holds) {
+        const timeScaleGroupRef = timeScaleGroupIntermediates[hold.start.layer] || timeScaleGroupIntermediates[0];
+        if (hold.flags.guide) {
+            const points = [hold.start, ...hold.steps, hold.end];
+            points.sort((a, b) => a.tick - b.tick);
+            let prevMidpointIntermediate = null;
+            let headMidpointIntermediate = null;
+            const guideConnectors = [];
+            const stepSize = Math.max(1, points.length - 1);
+            let stepIdx = 0;
+            for (const point of points) {
+                let segmentAlpha = 1;
+                if (hold.fadeType === 0) {
+                    segmentAlpha = 1 - 0.8 * (stepIdx / stepSize);
+                }
+                else if (hold.fadeType === 2) {
+                    segmentAlpha = 1 - 0.8 * ((stepSize - stepIdx) / stepSize);
+                }
+                const sonolusColorId = 101 + hold.guideColor;
+                const midpointIntermediate = createIntermediate('AnchorNote', {
+                    '#BEAT': point.tick / TICKS_PER_BEAT,
+                    lane: laneToSonolusLane(point.lane, point.width),
+                    size: point.width,
+                    direction: 0,
+                    isAttached: 0,
+                    connectorEase: 'ease' in point
+                        ? mmwEaseToSonolusEase(point.ease)
+                        : SONOLUS_CONNECTOR_EASES.linear,
+                    isSeparator: 0,
+                    segmentKind: sonolusColorId,
+                    segmentAlpha: segmentAlpha,
+                    segmentLayer: 0,
+                    '#TIMESCALE_GROUP': timeScaleGroupRef,
+                });
+                if (headMidpointIntermediate === null) {
+                    headMidpointIntermediate = midpointIntermediate;
+                }
+                if (prevMidpointIntermediate !== null) {
+                    const connectorIntermediate = createIntermediate('Connector', {
+                        head: prevMidpointIntermediate,
+                        tail: midpointIntermediate,
+                    });
+                    guideConnectors.push(connectorIntermediate);
+                    prevMidpointIntermediate.data['next'] = midpointIntermediate;
+                }
+                prevMidpointIntermediate = midpointIntermediate;
+                stepIdx++;
+            }
+            if (headMidpointIntermediate && prevMidpointIntermediate) {
+                for (const conn of guideConnectors) {
+                    conn.data['segmentHead'] = headMidpointIntermediate;
+                    conn.data['segmentTail'] = prevMidpointIntermediate;
+                    conn.data['activeHead'] = headMidpointIntermediate;
+                    conn.data['activeTail'] = prevMidpointIntermediate;
+                }
+                if (hold.fadeType === 2) {
+                    headMidpointIntermediate.data['segmentAlpha'] = 0;
+                }
+                else if (hold.fadeType === 0) {
+                    prevMidpointIntermediate.data['segmentAlpha'] = 0;
+                }
+            }
+        }
+        else {
+            let prevJointIntermediate = null;
+            let prevNoteIntermediate = null;
+            let headNoteIntermediate = null;
+            let currentSegmentHead = null;
+            const queuedAttachIntermediates = [];
+            const connectors = [];
+            const pendingSegmentConnectors = [];
+            const events = [];
+            events.push({
+                tick: hold.start.tick,
+                lane: hold.start.lane,
+                width: hold.start.width,
+                type: 'start',
+                critical: hold.start.flags.critical,
+                friction: hold.start.flags.friction,
+                flick: 'none',
+                ease: hold.start.ease,
+            });
+            for (const step of hold.steps) {
+                if (step.type === 'ignored') {
+                    events.push({
+                        tick: step.tick,
+                        lane: step.lane,
+                        width: step.width,
+                        type: 'attach',
+                        critical: hold.start.flags.critical,
+                        friction: false,
+                        flick: 'none',
+                        ease: step.ease,
+                    });
+                }
+                else {
+                    if (step.type === 'visible') {
+                        events.push({
+                            tick: step.tick,
+                            lane: step.lane,
+                            width: step.width,
+                            type: 'tick',
+                            critical: hold.start.flags.critical,
+                            friction: false,
+                            flick: 'none',
+                            ease: step.ease,
+                        });
+                    }
+                    else {
+                        events.push({
+                            tick: step.tick,
+                            lane: step.lane,
+                            width: step.width,
+                            type: 'attach',
+                            critical: hold.start.flags.critical,
+                            friction: false,
+                            flick: 'none',
+                            ease: step.ease,
+                        });
+                    }
+                }
+            }
+            events.push({
+                tick: hold.end.tick,
+                lane: hold.end.lane,
+                width: hold.end.width,
+                type: 'end',
+                critical: hold.end.flags.critical,
+                friction: hold.end.flags.friction,
+                flick: hold.end.flickType,
+            });
+            events.sort((a, b) => a.tick - b.tick);
+            let nextHiddenTickBeat = Math.floor((hold.start.tick / TICKS_PER_BEAT) * 2 + 1) / 2;
+            for (const event of events) {
+                let isSimLineEligible = false;
+                let isAttached = false;
+                const name_parts = [];
+                if (event.type === 'start') {
+                    if (hold.flags.startHidden) {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(event.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Head');
+                        name_parts.push(event.friction ? 'Trace' : 'Tap');
+                        isSimLineEligible = true;
+                    }
+                }
+                else if (event.type === 'end') {
+                    if (hold.flags.endHidden) {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(event.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Tail');
+                        if (event.flick !== 'none') {
+                            name_parts.push(event.friction ? 'TraceFlick' : 'Flick');
+                        }
+                        else {
+                            name_parts.push(event.friction ? 'Trace' : 'Release');
+                        }
+                        isSimLineEligible = true;
+                    }
+                }
+                else if (event.type === 'tick') {
+                    name_parts.push(event.critical ? 'Critical' : 'Normal');
+                    name_parts.push('Tick');
+                }
+                else {
+                    isAttached = true;
+                    if (event.critical) {
+                        name_parts.push('Critical');
+                        name_parts.push('Tick');
+                    }
+                    else {
+                        name_parts.push('TransientHiddenTick');
+                    }
+                }
+                name_parts.push('Note');
+                let archetype = name_parts.join('');
+                if (hold.flags.dummy)
+                    archetype = `Fake${archetype}`;
+                const data = {
+                    '#BEAT': event.tick / TICKS_PER_BEAT,
+                    lane: laneToSonolusLane(event.lane, event.width),
+                    size: event.width,
+                    isAttached: isAttached ? 1 : 0,
+                    connectorEase: event.ease
+                        ? mmwEaseToSonolusEase(event.ease)
+                        : SONOLUS_CONNECTOR_EASES.linear,
+                    isSeparator: 0,
+                    segmentKind: event.critical ? 2 : 1,
+                    segmentAlpha: 1,
+                    segmentLayer: 0,
+                    '#TIMESCALE_GROUP': timeScaleGroupRef,
+                };
+                if (event.flick && event.flick !== 'none') {
+                    data['direction'] = flickTypeToDirection(event.flick);
+                }
+                else {
+                    data['direction'] = 0;
+                }
+                const connectionIntermediate = createIntermediate(archetype, data, isSimLineEligible);
+                if (headNoteIntermediate === null) {
+                    headNoteIntermediate = connectionIntermediate;
+                }
+                if (currentSegmentHead === null) {
+                    currentSegmentHead = connectionIntermediate;
+                }
+                connectionIntermediate.data['activeHead'] = headNoteIntermediate;
+                if (isAttached) {
+                    queuedAttachIntermediates.push(connectionIntermediate);
+                }
+                else {
+                    if (prevJointIntermediate !== null) {
+                        for (const attachIntermediate of queuedAttachIntermediates) {
+                            attachIntermediate.data['attachHead'] = prevJointIntermediate;
+                            attachIntermediate.data['attachTail'] = connectionIntermediate;
+                        }
+                        queuedAttachIntermediates.length = 0;
+                        while (nextHiddenTickBeat + EPSILON <
+                            connectionIntermediate.data['#BEAT']) {
+                            createIntermediate('TransientHiddenTickNote', {
+                                '#BEAT': nextHiddenTickBeat,
+                                '#TIMESCALE_GROUP': timeScaleGroupRef,
+                                lane: connectionIntermediate.data['lane'],
+                                size: connectionIntermediate.data['size'],
+                                direction: 0,
+                                isAttached: 1,
+                                connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+                                isSeparator: 0,
+                                segmentKind: 1,
+                                segmentAlpha: 0,
+                                activeHead: headNoteIntermediate,
+                                attachHead: prevJointIntermediate,
+                                attachTail: connectionIntermediate,
+                            });
+                            nextHiddenTickBeat += 0.5;
+                        }
+                        const connectorIntermediate = createIntermediate('Connector', {
+                            head: prevJointIntermediate,
+                            tail: connectionIntermediate,
+                            kind: resolveConnectorKind(event.critical, !!hold.flags.dummy),
+                        });
+                        connectors.push(connectorIntermediate);
+                        pendingSegmentConnectors.push(connectorIntermediate);
+                    }
+                    prevJointIntermediate = connectionIntermediate;
+                }
+                if (prevNoteIntermediate !== null) {
+                    prevNoteIntermediate.data['next'] = connectionIntermediate;
+                }
+                prevNoteIntermediate = connectionIntermediate;
+            }
+            if (headNoteIntermediate && prevJointIntermediate) {
+                if (currentSegmentHead) {
+                    for (const conn of pendingSegmentConnectors) {
+                        conn.data['segmentHead'] = currentSegmentHead;
+                        conn.data['segmentTail'] = prevJointIntermediate;
+                    }
+                }
+                for (const conn of connectors) {
+                    conn.data['activeHead'] = headNoteIntermediate;
+                    conn.data['activeTail'] = prevJointIntermediate;
+                }
+            }
+        }
+    }
+    simLineEligibleNotes.sort((a, b) => {
+        const beatA = a.data['#BEAT'];
+        const beatB = b.data['#BEAT'];
+        if (Math.abs(beatA - beatB) > EPSILON)
+            return beatA - beatB;
+        const laneA = a.data['lane'];
+        const laneB = b.data['lane'];
+        return laneA - laneB;
+    });
+    const simGroups = [];
+    let currentSimGroup = [];
+    for (const simNote of simLineEligibleNotes) {
+        if (currentSimGroup.length === 0 ||
+            Math.abs(simNote.data['#BEAT'] - currentSimGroup[0].data['#BEAT']) < 1e-2) {
+            currentSimGroup.push(simNote);
+        }
+        else {
+            simGroups.push(currentSimGroup);
+            currentSimGroup = [simNote];
+        }
+    }
+    if (currentSimGroup.length > 0)
+        simGroups.push(currentSimGroup);
+    for (const simGroup of simGroups) {
+        for (let i = 0; i < simGroup.length - 1; i++) {
+            createIntermediate('SimLine', {
+                left: simGroup[i],
+                right: simGroup[i + 1],
+            });
+        }
+    }
+    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) {
+                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+            }
+        }
+        entities.push(entity);
+    }
+    return {
+        bgmOffset: score.metadata.musicOffset / 1000,
+        entities,
+    };
+};

package/package.json

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