sonolus-next-rush-plus-engine 1.3.3 → 1.3.4-kizuruki

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,7 +1,54 @@
-export { susToUSC } from './sus/convert.js';
-export { uscToLevelData } from './usc/convert.js';
+import { mmwsToUSC } from './mmw/convert.js';
+import { susToUSC } from './sus/convert.js';
+import { uscToLevelData } from './usc/convert.js';
+export { susToUSC, mmwsToUSC, uscToLevelData };
 export * from './usc/index.js';
-export const version = '1.3.3';
+export const convertToLevelData = (input, offset = 0) => {
+    if (isLevelData(input)) {
+        return input;
+    }
+    let usc;
+    if (isUSC(input)) {
+        usc = input;
+    }
+    else if (input instanceof Uint8Array) {
+        usc = mmwsToUSC(input);
+    }
+    else if (typeof input === 'string') {
+        try {
+            const parsed = JSON.parse(input);
+            if (isLevelData(parsed)) {
+                return parsed;
+            }
+            if (isUSC(parsed)) {
+                usc = parsed;
+            }
+            else {
+                usc = susToUSC(input);
+            }
+        }
+        catch {
+            usc = susToUSC(input);
+        }
+    }
+    else {
+        throw new Error('Unsupported input type: Input must be string(SUS/USC/LevelData), Uint8Array(MMWS), or USC/LevelData object.');
+    }
+    return uscToLevelData(usc, offset);
+};
+function isUSC(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'objects' in data &&
+        Array.isArray(data.objects));
+}
+function isLevelData(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'entities' in data &&
+        Array.isArray(data.entities));
+}
+export const version = '1.3.4-kizuruki';
 export const databaseEngineItem = {
     name: 'next-rush-plus',
     version: 13,

package/dist/mmw/analyze.d.ts

@@ -0,0 +1,101 @@
+declare const FlickType: readonly ["none", "up", "left", "right"];
+type FlickType = (typeof FlickType)[number];
+declare const StepType: readonly ["visible", "hidden", "ignored"];
+type StepType = (typeof StepType)[number];
+declare const EaseType: readonly ["linear", "easeIn", "easeOut", "easeInOut", "easeOutIn"];
+export type EaseType = (typeof EaseType)[number];
+export type Score = {
+    metadata: {
+        title: string;
+        author: string;
+        artist: string;
+        musicFile: string;
+        musicOffset: number;
+        jacketFile: string;
+    };
+    events: {
+        timeSignatures: {
+            measure: number;
+            numerator: number;
+            denominator: number;
+        }[];
+        bpmChanges: {
+            tick: number;
+            bpm: number;
+        }[];
+        hispeedChanges: {
+            tick: number;
+            speed: number;
+            layer: number;
+        }[];
+        skills: number[];
+        fever: {
+            start: number;
+            end: number;
+        };
+    };
+    taps: {
+        tick: number;
+        lane: number;
+        width: number;
+        flickType: FlickType;
+        flags: {
+            critical: boolean;
+            friction: boolean;
+        };
+        layer: number;
+    }[];
+    holds: {
+        flags: {
+            startHidden: boolean;
+            endHidden: boolean;
+            guide: boolean;
+        };
+        start: {
+            tick: number;
+            lane: number;
+            width: number;
+            flags: {
+                critical: boolean;
+                friction: boolean;
+            };
+            layer: number;
+            ease: EaseType;
+        };
+        fadeType: number;
+        guideColor: number;
+        steps: {
+            tick: number;
+            lane: number;
+            width: number;
+            type: StepType;
+            ease: EaseType;
+            layer: number;
+        }[];
+        end: {
+            tick: number;
+            lane: number;
+            width: number;
+            flickType: FlickType;
+            flags: {
+                critical: boolean;
+                friction: boolean;
+            };
+            layer: number;
+        };
+    }[];
+    damages: {
+        tick: number;
+        lane: number;
+        width: number;
+        flickType: FlickType;
+        flags: {
+            critical: boolean;
+            friction: boolean;
+        };
+        layer: number;
+    }[];
+    numLayers: number;
+};
+export declare const analyze: (mmws: Uint8Array) => Score;
+export {};

package/dist/mmw/analyze.js

@@ -0,0 +1,212 @@
+import BinarySeeker from '@sevenc-nanashi/binaryseeker';
+const FlickType = ['none', 'up', 'left', 'right'];
+const StepType = ['visible', 'hidden', 'ignored'];
+const EaseType = ['linear', 'easeIn', 'easeOut', 'easeInOut', 'easeOutIn'];
+export const analyze = (mmws) => {
+    const buffer = new BinarySeeker(mmws.buffer);
+    const header = buffer.readString();
+    if (header !== 'MMWS' && header !== 'CCMMWS') {
+        throw new Error('Invalid MMWS file');
+    }
+    const version = buffer.readInt16LE();
+    let cyanvasVersion = buffer.readInt16LE();
+    if (version < 3) {
+        throw new Error('Unsupported MMWS version');
+    }
+    if (header === 'CCMMWS' && cyanvasVersion === 0) {
+        cyanvasVersion = 1;
+    }
+    const metadataPointer = buffer.readUInt32LE();
+    const eventsPointer = buffer.readUInt32LE();
+    const tapsPointer = buffer.readUInt32LE();
+    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(),
+        author: buffer.readString(),
+        artist: buffer.readString(),
+        musicFile: buffer.readString(),
+        musicOffset: buffer.readFloat32LE(),
+        jacketFile: buffer.readString(),
+    };
+    buffer.seek(eventsPointer);
+    const events = {
+        timeSignatures: [],
+        bpmChanges: [],
+        hispeedChanges: [],
+        skills: [],
+        fever: {
+            start: 0,
+            end: 0,
+        },
+    };
+    const timeSignaturesCount = buffer.readInt32LE();
+    for (let i = 0; i < timeSignaturesCount; i++) {
+        events.timeSignatures.push({
+            measure: buffer.readInt32LE(),
+            numerator: buffer.readInt32LE(),
+            denominator: buffer.readInt32LE(),
+        });
+    }
+    const bpmChangesCount = buffer.readInt32LE();
+    for (let i = 0; i < bpmChangesCount; i++) {
+        events.bpmChanges.push({
+            tick: buffer.readInt32LE(),
+            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,
+        });
+    }
+    const skillsCount = buffer.readInt32LE();
+    for (let i = 0; i < skillsCount; i++) {
+        events.skills.push(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 layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+        const flickType = FlickType[buffer.readInt32LE()];
+        const flags = buffer.readInt32LE();
+        taps.push({
+            tick,
+            lane,
+            width,
+            flickType,
+            flags: {
+                critical: !!(flags & (1 << 0)),
+                friction: !!(flags & (1 << 1)),
+            },
+            layer,
+        });
+    }
+    buffer.seek(holdsPointer);
+    const holds = [];
+    const holdsCount = buffer.readInt32LE();
+    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 startLayer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+        const startFlags = buffer.readInt32LE();
+        const startEase = EaseType[buffer.readInt32LE()];
+        const fadeType = cyanvasVersion >= 2 ? buffer.readInt32LE() : 0;
+        const guideColor = cyanvasVersion >= 3 ? buffer.readInt32LE() : startFlags & (1 << 0) ? 4 : 2;
+        const stepsCount = buffer.readInt32LE();
+        const steps = [];
+        for (let j = 0; j < stepsCount; j++) {
+            const tick = buffer.readInt32LE();
+            const lane = buffer.readInt32LE();
+            const width = buffer.readInt32LE();
+            const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+            buffer.readInt32LE(); // unused flags
+            const type = StepType[buffer.readInt32LE()];
+            const ease = EaseType[buffer.readInt32LE()];
+            steps.push({
+                tick,
+                lane,
+                width,
+                type,
+                ease,
+                layer,
+            });
+        }
+        const endTick = buffer.readInt32LE();
+        const endLane = buffer.readInt32LE();
+        const endWidth = buffer.readInt32LE();
+        const endLayer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+        const endFlickType = FlickType[buffer.readInt32LE()];
+        const endFlags = buffer.readInt32LE();
+        holds.push({
+            flags: {
+                startHidden: !!(holdFlags & (1 << 0)),
+                endHidden: !!(holdFlags & (1 << 1)),
+                guide: !!(holdFlags & (1 << 2)),
+            },
+            start: {
+                tick: startTick,
+                lane: startLane,
+                width: startWidth,
+                ease: startEase,
+                flags: {
+                    critical: !!(startFlags & (1 << 0)),
+                    friction: !!(startFlags & (1 << 1)),
+                },
+                layer: startLayer,
+            },
+            fadeType,
+            guideColor,
+            steps,
+            end: {
+                tick: endTick,
+                lane: endLane,
+                width: endWidth,
+                flags: {
+                    critical: !!(endFlags & (1 << 0)),
+                    friction: !!(endFlags & (1 << 1)),
+                },
+                flickType: endFlickType,
+                layer: endLayer,
+            },
+        });
+    }
+    events.timeSignatures.sort((a, b) => a.measure - b.measure);
+    events.bpmChanges.sort((a, b) => a.tick - b.tick);
+    events.hispeedChanges.sort((a, b) => a.tick - b.tick);
+    events.skills.sort((a, b) => a - b);
+    taps.sort((a, b) => a.tick - b.tick);
+    holds.sort((a, b) => a.start.tick - b.start.tick);
+    const damages = [];
+    if (cyanvasVersion >= 1) {
+        buffer.seek(damagesPointer);
+        const damagesCount = buffer.readInt32LE();
+        for (let i = 0; i < damagesCount; i++) {
+            const tick = buffer.readInt32LE();
+            const lane = buffer.readInt32LE();
+            const width = buffer.readInt32LE();
+            const layer = cyanvasVersion >= 4 ? buffer.readInt32LE() : 0;
+            const flickType = FlickType[buffer.readInt32LE()];
+            const flags = buffer.readInt32LE();
+            damages.push({
+                tick,
+                lane,
+                width,
+                flickType,
+                layer,
+                flags: {
+                    critical: !!(flags & (1 << 0)),
+                    friction: !!(flags & (1 << 1)),
+                },
+            });
+        }
+        damages.sort((a, b) => a.tick - b.tick);
+    }
+    let numLayers = 1;
+    if (cyanvasVersion >= 4) {
+        buffer.seek(layersPointer);
+        numLayers = buffer.readInt32LE();
+    }
+    return {
+        metadata,
+        events,
+        taps,
+        holds,
+        damages,
+        numLayers,
+    };
+};

package/dist/mmw/convert.d.ts

@@ -0,0 +1,9 @@
+import { USC } from '../usc/index.js';
+/**
+ * Convert MMWS or CCMMWS to a USC
+ */
+export declare const mmwsToUSC: (mmws: Uint8Array) => USC;
+/**
+ * Convert CCMMWS to a USC
+ */
+export declare const ccmmwsToUSC: (mmws: Uint8Array) => USC;

package/dist/mmw/convert.js

@@ -0,0 +1,161 @@
+import { USCColor, } from '../usc/index.js';
+import { analyze } from './analyze.js';
+const mmwsEaseToUSCEase = {
+    linear: 'linear',
+    easeOut: 'out',
+    easeIn: 'in',
+    easeInOut: 'inout',
+    easeOutIn: 'outin',
+};
+const ticksPerBeat = 480;
+const laneToUSCLane = ({ lane, width }) => {
+    return lane - 6 + width / 2;
+};
+/**
+ * Convert MMWS or CCMMWS to a USC
+ */
+export const mmwsToUSC = (mmws) => {
+    const score = analyze(mmws);
+    const usc = {
+        objects: [],
+        offset: score.metadata.musicOffset / -1000,
+    };
+    for (const bpmChange of score.events.bpmChanges) {
+        usc.objects.push({
+            type: 'bpm',
+            beat: bpmChange.tick / ticksPerBeat,
+            bpm: bpmChange.bpm,
+        });
+    }
+    const tsGroups = new Map();
+    for (let i = 0; i < score.numLayers; i++) {
+        tsGroups.set(i, []);
+    }
+    for (const hispeedChange of score.events.hispeedChanges) {
+        const key = hispeedChange.layer;
+        if (!tsGroups.has(key)) {
+            throw new Error('Invalid layer');
+        }
+        tsGroups.get(key).push({
+            beat: hispeedChange.tick / ticksPerBeat,
+            timeScale: hispeedChange.speed,
+        });
+    }
+    for (const changes of tsGroups.values()) {
+        usc.objects.push({
+            type: 'timeScaleGroup',
+            changes,
+        });
+    }
+    for (const tap of score.taps) {
+        const uscTap = {
+            type: 'single',
+            beat: tap.tick / ticksPerBeat,
+            timeScaleGroup: tap.layer,
+            critical: tap.flags.critical,
+            lane: laneToUSCLane(tap),
+            size: tap.width / 2,
+            trace: tap.flags.friction,
+        };
+        if (tap.flickType !== 'none') {
+            uscTap.direction = tap.flickType;
+        }
+        usc.objects.push(uscTap);
+    }
+    for (const hold of score.holds) {
+        const uscStartNote = {
+            type: 'start',
+            beat: hold.start.tick / ticksPerBeat,
+            timeScaleGroup: hold.start.layer,
+            critical: hold.start.flags.critical,
+            ease: mmwsEaseToUSCEase[hold.start.ease],
+            lane: laneToUSCLane(hold.start),
+            size: hold.start.width / 2,
+            judgeType: hold.flags.startHidden
+                ? 'none'
+                : hold.start.flags.friction
+                    ? 'trace'
+                    : 'normal',
+        };
+        const uscEndNote = {
+            type: 'end',
+            beat: hold.end.tick / ticksPerBeat,
+            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') {
+            uscEndNote.direction = hold.end.flickType;
+        }
+        if (hold.flags.guide) {
+            const uscGuide = {
+                type: 'guide',
+                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,
+                    lane: laneToUSCLane(step),
+                    size: step.width / 2,
+                    timeScaleGroup: step.layer,
+                    ease: 'ease' in step ? mmwsEaseToUSCEase[step.ease] : 'linear',
+                })),
+            };
+            usc.objects.push(uscGuide);
+        }
+        else {
+            const uscSlide = {
+                type: 'slide',
+                critical: hold.start.flags.critical,
+                connections: [
+                    uscStartNote,
+                    ...hold.steps.map((step) => {
+                        const beat = step.tick / ticksPerBeat;
+                        const lane = laneToUSCLane(step);
+                        const size = step.width / 2;
+                        if (step.type === 'ignored') {
+                            return {
+                                type: 'attach',
+                                beat,
+                                critical: hold.start.flags.critical,
+                                timeScaleGroup: step.layer,
+                            };
+                        }
+                        else {
+                            const uscStep = {
+                                type: 'tick',
+                                beat,
+                                timeScaleGroup: step.layer,
+                                lane,
+                                size,
+                                ease: mmwsEaseToUSCEase[step.ease],
+                            };
+                            if (step.type === 'visible') {
+                                uscStep.critical = hold.start.flags.critical;
+                            }
+                            return uscStep;
+                        }
+                    }),
+                    uscEndNote,
+                ],
+            };
+            usc.objects.push(uscSlide);
+        }
+    }
+    for (const damage of score.damages) {
+        const uscDamage = {
+            type: 'damage',
+            beat: damage.tick / ticksPerBeat,
+            timeScaleGroup: damage.layer,
+            lane: laneToUSCLane(damage),
+            size: damage.width / 2,
+        };
+        usc.objects.push(uscDamage);
+    }
+    return usc;
+};
+/**
+ * Convert CCMMWS to a USC
+ */
+export const ccmmwsToUSC = mmwsToUSC;

package/dist/usc/convert.js

@@ -357,8 +357,17 @@ export const uscToLevelData = (usc, offset = 0) => {
         let prevMidpointIntermediate = null;
         let headMidpointIntermediate = null;
         const guideConnectors = [];
+        const stepSize = Math.max(1, connections.length - 1);
+        let stepIdx = 0;
         for (const midpointNote of connections) {
             const timeScaleGroupRef = timeScaleGroupIntermediates[midpointNote.timeScaleGroup ?? 0];
+            let segmentAlpha = 1;
+            if (guideNote.fade === 'out') {
+                segmentAlpha = 1 - 0.8 * (stepIdx / stepSize);
+            }
+            else if (guideNote.fade === 'in') {
+                segmentAlpha = 1 - 0.8 * ((stepSize - stepIdx) / stepSize);
+            }
             const midpointIntermediate = createIntermediate('AnchorNote', {
                 '#BEAT': midpointNote.beat,
                 lane: midpointNote.lane,
@@ -366,9 +375,9 @@ export const uscToLevelData = (usc, offset = 0) => {
                 direction: SONOLUS_DIRECTIONS.up,
                 isAttached: 0,
                 connectorEase: SONOLUS_CONNECTOR_EASES[mapUscEaseToSonolusEase(midpointNote.ease)],
-                isSeparator: 0,
+                isSeparator: 1,
                 segmentKind: SONOLUS_GUIDE_COLORS[guideNote.color],
-                segmentAlpha: 1,
+                segmentAlpha: segmentAlpha,
                 '#TIMESCALE_GROUP': timeScaleGroupRef,
             });
             if (headMidpointIntermediate === null) {
@@ -383,6 +392,7 @@ export const uscToLevelData = (usc, offset = 0) => {
                 prevMidpointIntermediate.data['next'] = midpointIntermediate;
             }
             prevMidpointIntermediate = midpointIntermediate;
+            stepIdx++;
         }
         if (!headMidpointIntermediate || !prevMidpointIntermediate) {
             continue;
@@ -393,16 +403,6 @@ export const uscToLevelData = (usc, offset = 0) => {
             connectorIntermediate.data['activeHead'] = headMidpointIntermediate;
             connectorIntermediate.data['activeTail'] = prevMidpointIntermediate;
         }
-        switch (guideNote.fade) {
-            case 'in':
-                headMidpointIntermediate.data['segmentAlpha'] = 0;
-                break;
-            case 'out':
-                prevMidpointIntermediate.data['segmentAlpha'] = 0;
-                break;
-            case 'none':
-                break;
-        }
     }
     simLineEligibleNotes.sort((noteA, noteB) => {
         const beatA = noteA.data['#BEAT'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-next-rush-plus-engine",
-  "version": "1.3.3",
+  "version": "1.3.4-kizuruki",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {
@@ -33,6 +33,7 @@
     "build": "tsc -p . && node ./build.js"
   },
   "dependencies": {
+    "@sevenc-nanashi/binaryseeker": "npm:@jsr/sevenc-nanashi__binaryseeker@^1.2.1",
     "@sonolus/core": "~7.14.2"
   },
   "devDependencies": {