sonolus-next-rush-plus-engine 1.1.4 → 1.1.6

package/README.md

@@ -5,7 +5,7 @@ A new Project Sekai inspired engine for [Sonolus](https://sonolus.com).
 ## Installation
 
 ```
-npm install @next-sekai/sonolus-next-sekai-engine
+npm install sonolus-next-rush-plus-engine
 ```
 
 ## Documentation

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { susToUSC } from './sus/convert.js';
+export { uscToLevelData } from './usc/convert.js';
+export * from './usc/index.js';
+export declare const version = "1.1.6";
+export declare const databaseEngineItem: {
+    readonly name: "next-rush-plus";
+    readonly version: 13;
+    readonly title: {
+        readonly en: "Next RUSH+";
+    };
+    readonly subtitle: {
+        readonly en: "Next RUSH+";
+    };
+    readonly author: {
+        readonly en: "Next RUSH+";
+    };
+    readonly description: {
+        readonly en: string;
+        readonly ko: string;
+    };
+};

package/dist/index.js

@@ -0,0 +1,31 @@
+export { susToUSC } from './sus/convert.js';
+export { uscToLevelData } from './usc/convert.js';
+export * from './usc/index.js';
+export const version = '1.1.6';
+export const databaseEngineItem = {
+    name: 'next-rush-plus',
+    version: 13,
+    title: {
+        en: 'Next RUSH+',
+    },
+    subtitle: {
+        en: 'Next RUSH+',
+    },
+    author: {
+        en: 'Next RUSH+',
+    },
+    description: {
+        en: [
+            "Next SEKAI's expansion engine",
+            `Version: ${version}`,
+            '',
+            'https://github.com/Next-SEKAI/sonolus-next-sekai-engine',
+        ].join('\n'),
+        ko: [
+            'Next SEKAI의 확장 엔진',
+            `버전: ${version}`,
+            '',
+            'https://github.com/Next-SEKAI/sonolus-next-sekai-engine',
+        ].join('\n'),
+    },
+};

package/dist/sus/analyze.d.ts

@@ -0,0 +1,32 @@
+type Meta = Map<string, string[]>;
+export type TimeScaleChangeObject = {
+    tick: number;
+    timeScale: number;
+};
+export type BpmChangeObject = {
+    tick: number;
+    bpm: number;
+};
+export type NoteObject = {
+    tick: number;
+    lane: number;
+    width: number;
+    type: number;
+    timeScaleGroup: number;
+};
+export type SlideObject = {
+    type: number;
+    notes: NoteObject[];
+};
+export type Score = {
+    offset: number;
+    ticksPerBeat: number;
+    timeScaleChanges: TimeScaleChangeObject[][];
+    bpmChanges: BpmChangeObject[];
+    tapNotes: NoteObject[];
+    directionalNotes: NoteObject[];
+    slides: SlideObject[];
+    meta: Meta;
+};
+export declare const analyze: (sus: string) => Score;
+export {};

package/dist/sus/analyze.js

@@ -0,0 +1,251 @@
+export const analyze = (sus) => {
+    if (!sus || sus.trim().length === 0) {
+        throw new Error('The sus file does not exist');
+    }
+    const { lines, measureChanges, timeScaleGroupChanges, meta } = parse(sus);
+    const offset = -+(meta.get('WAVEOFFSET') || '0');
+    if (Number.isNaN(offset))
+        throw new Error('Unexpected offset');
+    const ticksPerBeat = getTicksPerBeat(meta);
+    if (!ticksPerBeat)
+        throw new Error('Missing or unexpected ticks per beat');
+    const barLengths = getBarLengths(lines, measureChanges);
+    const toTick = getToTick(barLengths, ticksPerBeat);
+    const bpms = new Map();
+    const bpmChanges = [];
+    const timeScaleGroups = new Map();
+    const timeScaleChanges = [];
+    const tapNotes = [];
+    const directionalNotes = [];
+    const streams = new Map();
+    for (const [, timeScaleGroup] of timeScaleGroupChanges) {
+        if (timeScaleGroups.has(timeScaleGroup))
+            continue;
+        timeScaleGroups.set(timeScaleGroup, timeScaleGroups.size);
+        timeScaleChanges.push([]);
+    }
+    // Time Scale Changes
+    for (const line of lines) {
+        const [header] = line;
+        if (header.length === 5 && header.startsWith('TIL')) {
+            const timeScaleGroup = header.substring(3, 5);
+            const timeScaleIndex = timeScaleGroups.get(timeScaleGroup);
+            if (timeScaleIndex === undefined) {
+                continue;
+            }
+            timeScaleChanges[timeScaleIndex].push(...toTimeScaleChanges(line, toTick));
+        }
+    }
+    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';
+        let timeScaleGroup = timeScaleGroups.get(timeScaleGroupName);
+        if (timeScaleGroup === undefined) {
+            timeScaleGroup = timeScaleGroups.size;
+            timeScaleGroups.set(timeScaleGroupName, timeScaleGroups.size);
+            timeScaleChanges.push([]);
+        }
+        // Hispeed definitions
+        if (header.length === 5 && header.startsWith('TIL')) {
+            return;
+        }
+        // BPM
+        if (header.length === 5 && header.startsWith('BPM')) {
+            bpms.set(header.substring(3), +data);
+            return;
+        }
+        // BPM Changes
+        if (header.length === 5 && header.endsWith('08')) {
+            bpmChanges.push(...toBpmChanges(line, measureOffset, bpms, toTick));
+            return;
+        }
+        // Tap Notes
+        if (header.length === 5 && header[3] === '1') {
+            tapNotes.push(...toNotes(line, measureOffset, timeScaleGroup, toTick));
+            return;
+        }
+        // Streams
+        if (header.length === 6 && (header[3] === '3' || header[3] === '9')) {
+            const key = `${header[5]}-${header[3]}`;
+            const stream = streams.get(key);
+            if (stream) {
+                stream.notes.push(...toNotes(line, measureOffset, timeScaleGroup, toTick));
+            }
+            else {
+                streams.set(key, {
+                    type: +header[3],
+                    notes: toNotes(line, measureOffset, timeScaleGroup, toTick),
+                });
+            }
+            return;
+        }
+        // Directional Notes
+        if (header.length === 5 && header[3] === '5') {
+            directionalNotes.push(...toNotes(line, measureOffset, timeScaleGroup, toTick));
+            return;
+        }
+    });
+    const slides = [...streams.values()].flatMap(toSlides);
+    return {
+        offset,
+        ticksPerBeat,
+        timeScaleChanges,
+        bpmChanges,
+        tapNotes,
+        directionalNotes,
+        slides,
+        meta,
+    };
+};
+const parse = (sus) => {
+    const lines = [];
+    const measureChanges = [];
+    const timeScaleGroupChanges = [];
+    const meta = new Map();
+    sus.split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('#'))
+        .forEach((line) => {
+        const isLine = line.includes(':');
+        const index = line.indexOf(isLine ? ':' : ' ');
+        if (index === -1)
+            return;
+        const left = line.substring(1, index).trim();
+        const right = line.substring(index + 1).trim();
+        if (isLine) {
+            lines.push([left, right]);
+        }
+        else if (left === 'MEASUREBS') {
+            measureChanges.unshift([lines.length, +right]);
+        }
+        else if (left === 'HISPEED') {
+            timeScaleGroupChanges.unshift([lines.length, right]);
+        }
+        else {
+            if (!meta.has(left))
+                meta.set(left, []);
+            meta.get(left)?.push(right);
+        }
+    });
+    return {
+        lines,
+        measureChanges,
+        timeScaleGroupChanges,
+        meta,
+    };
+};
+const getTicksPerBeat = (meta) => {
+    const request = meta.get('REQUEST');
+    if (!request)
+        return;
+    const tpbRequest = request.find((r) => JSON.parse(r).startsWith('ticks_per_beat'));
+    if (!tpbRequest)
+        return;
+    return +JSON.parse(tpbRequest).split(' ')[1];
+};
+const getBarLengths = (lines, measureChanges) => {
+    const barLengths = [];
+    lines.forEach((line, index) => {
+        const [header, data] = line;
+        if (header.length !== 5)
+            return;
+        if (!header.endsWith('02'))
+            return;
+        const measure = +header.substring(0, 3) +
+            (measureChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? 0);
+        if (Number.isNaN(measure))
+            return;
+        barLengths.push({ measure, length: +data });
+    });
+    return barLengths;
+};
+const getToTick = (barLengths, ticksPerBeat) => {
+    let ticks = 0;
+    const bars = barLengths
+        .sort((a, b) => a.measure - b.measure)
+        .map(({ measure, length }, i, values) => {
+        if (i) {
+            const prev = values[i - 1];
+            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)
+            throw new Error('Unexpected missing bar');
+        return (bar.ticks +
+            (measure - bar.measure) * bar.ticksPerMeasure +
+            (p * bar.ticksPerMeasure) / q);
+    };
+};
+const toBpmChanges = (line, measureOffset, bpms, toTick) => toRaws(line, measureOffset, toTick).map(({ tick, value }) => ({
+    tick,
+    bpm: bpms.get(value) ?? 0,
+}));
+const toTimeScaleChanges = ([, data], toTick) => {
+    if (!data.startsWith('"') || !data.endsWith('"'))
+        throw new Error('Unexpected time scale changes');
+    return data
+        .slice(1, -1)
+        .split(',')
+        .map((segment) => segment.trim())
+        .filter((segment) => !!segment)
+        .map((segment) => {
+        const [l, rest] = segment.split("'");
+        const [m, r] = rest.split(':');
+        const measure = +l;
+        const tick = +m;
+        const timeScale = +r;
+        if (Number.isNaN(measure) || Number.isNaN(tick) || Number.isNaN(timeScale))
+            throw new Error('Unexpected time scale change');
+        return {
+            tick: toTick(measure, 0, 1) + tick,
+            timeScale,
+        };
+    })
+        .sort((a, b) => a.tick - b.tick);
+};
+const toNotes = (line, measureOffset, timeScaleGroup, toTick) => {
+    const [header] = line;
+    const lane = parseInt(header[4], 36);
+    return toRaws(line, measureOffset, toTick).map(({ tick, value }) => {
+        const width = parseInt(value[1], 36);
+        return {
+            tick,
+            lane,
+            width,
+            type: parseInt(value[0], 36),
+            timeScaleGroup,
+        };
+    });
+};
+const toSlides = (stream) => {
+    const slides = [];
+    let notes;
+    for (const note of stream.notes.sort((a, b) => a.tick - b.tick)) {
+        if (!notes) {
+            notes = [];
+            slides.push({
+                type: stream.type,
+                notes,
+            });
+        }
+        notes.push(note);
+        if (note.type === 2) {
+            notes = undefined;
+        }
+    }
+    return slides;
+};
+const toRaws = ([header, data], measureOffset, toTick) => {
+    const measure = +header.substring(0, 3) + measureOffset;
+    return (data.match(/.{2}/g) ?? [])
+        .map((value, i, values) => value !== '00' && {
+        tick: toTick(measure, i, values.length),
+        value,
+    })
+        .filter((object) => !!object);
+};

package/dist/sus/convert.d.ts

@@ -0,0 +1,5 @@
+import { USC } from '../usc/index.js';
+import { Score } from './analyze.js';
+/** Convert a SUS to a USC */
+export declare const susToUSC: (sus: string) => USC;
+export declare const chsLikeToUSC: (score: Score) => USC;

package/dist/sus/convert.js

@@ -0,0 +1,320 @@
+import { analyze } from './analyze.js';
+/** Convert a SUS to a USC */
+export const susToUSC = (sus) => chsLikeToUSC(analyze(sus));
+export const chsLikeToUSC = (score) => {
+    const flickMods = new Map();
+    const traceMods = new Set();
+    const criticalMods = new Set();
+    const tickRemoveMods = new Set();
+    const slideStartEndRemoveMods = new Set();
+    const easeMods = new Map();
+    const preventSingles = new Set();
+    const dedupeSingles = new Set();
+    const dedupeSlides = new Map();
+    const requests = {
+        sideLane: false,
+        laneOffset: 0,
+    };
+    const requestsRaw = score.meta.get('REQUEST');
+    if (requestsRaw) {
+        for (const request of requestsRaw) {
+            try {
+                const [key, value] = JSON.parse(request).split(' ', 2);
+                switch (key) {
+                    case 'side_lane':
+                        requests.sideLane = value === 'true';
+                        break;
+                    case 'lane_offset':
+                        requests.laneOffset = Number(value);
+                        break;
+                }
+            }
+            catch (_e) {
+                // Noop
+            }
+        }
+    }
+    for (const slide of score.slides) {
+        if (slide.type !== 3)
+            continue;
+        for (const note of slide.notes) {
+            const key = getKey(note);
+            switch (note.type) {
+                case 1:
+                case 2:
+                case 3:
+                case 5:
+                    preventSingles.add(key);
+                    break;
+            }
+        }
+    }
+    for (const note of score.directionalNotes) {
+        const key = getKey(note);
+        switch (note.type) {
+            case 1:
+                flickMods.set(key, 'up');
+                break;
+            case 3:
+                flickMods.set(key, 'left');
+                break;
+            case 4:
+                flickMods.set(key, 'right');
+                break;
+            case 2:
+                easeMods.set(key, 'in');
+                break;
+            case 5:
+            case 6:
+                easeMods.set(key, 'out');
+                break;
+        }
+    }
+    for (const note of score.tapNotes) {
+        const key = getKey(note);
+        switch (note.type) {
+            case 2:
+                criticalMods.add(key);
+                break;
+            case 5:
+                traceMods.add(key);
+                break;
+            case 6:
+                traceMods.add(key);
+                criticalMods.add(key);
+                break;
+            case 3:
+                tickRemoveMods.add(key);
+                break;
+            case 7:
+                slideStartEndRemoveMods.add(key);
+                break;
+            case 8:
+                criticalMods.add(key);
+                slideStartEndRemoveMods.add(key);
+                break;
+        }
+    }
+    const objects = [];
+    for (const timeScaleChanges of score.timeScaleChanges) {
+        objects.push({
+            type: 'timeScaleGroup',
+            changes: timeScaleChanges.map((timeScaleChange) => ({
+                beat: timeScaleChange.tick / score.ticksPerBeat,
+                timeScale: timeScaleChange.timeScale,
+            })),
+        });
+    }
+    for (const bpmChange of score.bpmChanges) {
+        objects.push({
+            type: 'bpm',
+            beat: bpmChange.tick / score.ticksPerBeat,
+            bpm: bpmChange.bpm,
+        });
+    }
+    for (const note of score.tapNotes) {
+        if (note.lane === 0 && note.type === 4) {
+            objects.push({
+                type: 'skill',
+                beat: note.tick / score.ticksPerBeat,
+            });
+            continue;
+        }
+        if (note.lane === 15 && note.type === 1) {
+            objects.push({
+                type: 'feverChance',
+                beat: note.tick / score.ticksPerBeat,
+            });
+            continue;
+        }
+        if (note.lane === 15 && note.type === 2) {
+            objects.push({
+                type: 'feverStart',
+                beat: note.tick / score.ticksPerBeat,
+            });
+            continue;
+        }
+        if (!requests.sideLane && (note.lane <= 1 || note.lane >= 14))
+            continue;
+        if (note.type !== 1 &&
+            note.type !== 2 &&
+            note.type !== 5 &&
+            note.type !== 6 &&
+            note.type !== 4)
+            continue;
+        const key = getKey(note);
+        if (preventSingles.has(key))
+            continue;
+        if (dedupeSingles.has(key))
+            continue;
+        dedupeSingles.add(key);
+        let object;
+        switch (note.type) {
+            case 1:
+            case 2:
+            case 5:
+            case 6: {
+                object = {
+                    type: 'single',
+                    beat: note.tick / score.ticksPerBeat,
+                    lane: note.lane - 8 + note.width / 2 + requests.laneOffset,
+                    size: note.width / 2,
+                    critical: [2, 6].includes(note.type),
+                    trace: [5, 6].includes(note.type),
+                    timeScaleGroup: note.timeScaleGroup,
+                };
+                const flickMod = flickMods.get(key);
+                if (flickMod)
+                    object.direction = flickMod;
+                break;
+            }
+            case 4:
+                object = {
+                    type: 'damage',
+                    beat: note.tick / score.ticksPerBeat,
+                    lane: note.lane - 8 + note.width / 2 + requests.laneOffset,
+                    size: note.width / 2,
+                    timeScaleGroup: note.timeScaleGroup,
+                };
+                break;
+            default:
+                continue;
+        }
+        objects.push(object);
+    }
+    for (const slide of score.slides) {
+        const startNote = slide.notes.find(({ type }) => type === 1 || type === 2);
+        if (!startNote)
+            continue;
+        const object = {
+            type: slide.type === 3 ? 'slide' : 'guide',
+            critical: criticalMods.has(getKey(startNote)),
+            connections: [],
+        };
+        for (const note of slide.notes) {
+            const key = getKey(note);
+            const beat = note.tick / score.ticksPerBeat;
+            const lane = note.lane - 8 + note.width / 2 + requests.laneOffset;
+            const size = note.width / 2;
+            const timeScaleGroup = note.timeScaleGroup;
+            const critical = ('critical' in object && object.critical) || criticalMods.has(key);
+            const ease = easeMods.get(key) ?? 'linear';
+            let judgeType = 'normal';
+            if (traceMods.has(key))
+                judgeType = 'trace';
+            switch (note.type) {
+                case 1: {
+                    if (object.type == 'guide' || slideStartEndRemoveMods.has(key)) {
+                        const connection = {
+                            type: 'start',
+                            beat,
+                            lane,
+                            size,
+                            critical,
+                            ease,
+                            judgeType: 'none',
+                            timeScaleGroup,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'start',
+                            beat,
+                            lane,
+                            size,
+                            critical,
+                            ease: easeMods.get(key) ?? 'linear',
+                            judgeType,
+                            timeScaleGroup,
+                        };
+                        object.connections.push(connection);
+                    }
+                    break;
+                }
+                case 2: {
+                    if (object.type == 'guide' || slideStartEndRemoveMods.has(key)) {
+                        const connection = {
+                            type: 'end',
+                            beat,
+                            lane,
+                            size,
+                            critical,
+                            judgeType: 'none',
+                            timeScaleGroup,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'end',
+                            beat,
+                            lane,
+                            size,
+                            critical,
+                            judgeType,
+                            timeScaleGroup,
+                        };
+                        const flickMod = flickMods.get(key);
+                        if (flickMod)
+                            connection.direction = flickMod;
+                        object.connections.push(connection);
+                    }
+                    break;
+                }
+                case 3: {
+                    if (tickRemoveMods.has(key)) {
+                        const connection = {
+                            type: 'attach',
+                            beat,
+                            critical,
+                            timeScaleGroup,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'tick',
+                            beat,
+                            lane,
+                            size,
+                            critical,
+                            ease,
+                            judgeType,
+                            timeScaleGroup,
+                        };
+                        object.connections.push(connection);
+                    }
+                    break;
+                }
+                case 5: {
+                    if (tickRemoveMods.has(key))
+                        break;
+                    const connection = {
+                        type: 'tick',
+                        beat,
+                        lane,
+                        size,
+                        ease,
+                        timeScaleGroup,
+                    };
+                    object.connections.push(connection);
+                    break;
+                }
+            }
+        }
+        objects.push(object);
+        if (object.type == 'guide')
+            continue;
+        const key = getKey(startNote);
+        const dupe = dedupeSlides.get(key);
+        if (dupe)
+            objects.splice(objects.indexOf(dupe), 1);
+        dedupeSlides.set(key, object);
+    }
+    return {
+        offset: score.offset,
+        objects,
+    };
+};
+const getKey = (note) => `${note.lane}-${note.tick}`;

package/dist/usc/convert.d.ts

@@ -0,0 +1,3 @@
+import { type LevelData } from '@sonolus/core';
+import { USC } from './index.js';
+export declare const uscToLevelData: (usc: USC, offset?: number) => LevelData;

package/dist/usc/convert.js

@@ -0,0 +1,472 @@
+const SONOLUS_DIRECTIONS = {
+    left: 1,
+    up: 0,
+    right: 2,
+};
+const SONOLUS_CONNECTOR_EASES = {
+    outin: 5,
+    out: 3,
+    linear: 1,
+    in: 2,
+    inout: 4,
+};
+const mapUscEaseToSonolusEase = (ease) => {
+    const uscEase = ease ?? 'linear';
+    return uscEase;
+};
+const SONOLUS_GUIDE_COLORS = {
+    neutral: 101,
+    red: 102,
+    green: 103,
+    blue: 104,
+    yellow: 105,
+    purple: 106,
+    cyan: 107,
+    black: 108,
+};
+const EPSILON = 1e-6;
+export const uscToLevelData = (usc, offset = 0) => {
+    const allUscObjects = usc.objects ?? [];
+    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', {});
+    const bpmChanges = allUscObjects.filter((o) => o.type === 'bpm');
+    const timeScaleGroups = allUscObjects.filter((o) => o.type === 'timeScaleGroup');
+    const singleNotes = allUscObjects.filter((o) => o.type === 'single');
+    const damageNotes = allUscObjects.filter((o) => o.type === 'damage');
+    const slideNotes = allUscObjects.filter((o) => o.type === 'slide' || (o.type === 'guide' && !('midpoints' in o)));
+    const guideNotes = allUscObjects.filter((o) => o.type === 'guide' && 'midpoints' in o);
+    const skills = allUscObjects.filter((o) => o.type === 'skill');
+    const feverChance = allUscObjects
+        .filter((o) => o.type === 'feverChance')
+        .sort((a, b) => a.beat - b.beat)
+        .slice(0, 1);
+    const feverStart = allUscObjects
+        .filter((o) => o.type === 'feverStart')
+        .sort((a, b) => a.beat - b.beat)
+        .slice(0, 1);
+    if (bpmChanges.length === 0) {
+        bpmChanges.push({ type: 'bpm', beat: 0, bpm: 160 });
+    }
+    for (const bpmChange of bpmChanges) {
+        createIntermediate('#BPM_CHANGE', {
+            '#BEAT': bpmChange.beat,
+            '#BPM': bpmChange.bpm,
+        });
+    }
+    if (timeScaleGroups.length === 0) {
+        timeScaleGroups.push({
+            type: 'timeScaleGroup',
+            changes: [{ beat: 0, timeScale: 1 }],
+        });
+    }
+    for (const skill of skills) {
+        createIntermediate('Skill', {
+            '#BEAT': skill.beat,
+        });
+    }
+    for (const fc of feverChance) {
+        createIntermediate('FeverChance', {
+            '#BEAT': fc.beat,
+        });
+    }
+    for (const fs of feverStart) {
+        createIntermediate('FeverStart', {
+            '#BEAT': fs.beat,
+        });
+    }
+    for (const timeScaleGroup of timeScaleGroups) {
+        const groupIntermediateEntity = createIntermediate('#TIMESCALE_GROUP', {});
+        timeScaleGroupIntermediates.push(groupIntermediateEntity);
+        let lastChangeIntermediate = null;
+        const changes = [...timeScaleGroup.changes].sort((a, b) => a.beat - b.beat);
+        for (const timeScaleChange of changes) {
+            const newChangeIntermediate = createIntermediate('#TIMESCALE_CHANGE', {
+                '#BEAT': timeScaleChange.beat,
+                '#TIMESCALE': timeScaleChange.timeScale === 0 ? 0.000001 : timeScaleChange.timeScale,
+                '#TIMESCALE_SKIP': 0,
+                '#TIMESCALE_GROUP': groupIntermediateEntity,
+                '#TIMESCALE_EASE': 0,
+            });
+            if (lastChangeIntermediate === null) {
+                groupIntermediateEntity.data['first'] = newChangeIntermediate;
+            }
+            else {
+                lastChangeIntermediate.data['next'] = newChangeIntermediate;
+            }
+            lastChangeIntermediate = newChangeIntermediate;
+        }
+    }
+    for (const singleNote of singleNotes) {
+        const name_parts = [];
+        name_parts.push(singleNote.critical ? 'Critical' : 'Normal');
+        if (singleNote.direction === undefined || singleNote.direction === null) {
+            name_parts.push(singleNote.trace ? 'Trace' : 'Tap');
+        }
+        else {
+            name_parts.push(singleNote.trace ? 'TraceFlick' : 'Flick');
+        }
+        name_parts.push('Note');
+        const archetype = name_parts.join('');
+        const timeScaleGroupRef = timeScaleGroupIntermediates[singleNote.timeScaleGroup ?? 0];
+        let sonolusDirName;
+        if (singleNote.direction === undefined || singleNote.direction === null) {
+            sonolusDirName = 'up';
+        }
+        else {
+            sonolusDirName = singleNote.direction;
+        }
+        const data = {
+            '#BEAT': singleNote.beat,
+            lane: singleNote.lane,
+            size: singleNote.size,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: singleNote.critical ? 2 : 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        };
+        const directionValue = SONOLUS_DIRECTIONS[sonolusDirName];
+        if (directionValue !== undefined) {
+            data['direction'] = directionValue;
+        }
+        createIntermediate(archetype, data, true);
+    }
+    for (const damageNote of damageNotes) {
+        const archetype = 'DamageNote';
+        const timeScaleGroupRef = timeScaleGroupIntermediates[damageNote.timeScaleGroup ?? 0];
+        createIntermediate(archetype, {
+            '#BEAT': damageNote.beat,
+            lane: damageNote.lane,
+            size: damageNote.size,
+            direction: SONOLUS_DIRECTIONS.up,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        });
+    }
+    for (const slideNote of slideNotes) {
+        let prevJointIntermediate = null;
+        let prevNoteIntermediate = null;
+        let headNoteIntermediate = null;
+        let currentSegmentHead = null;
+        const queuedAttachIntermediates = [];
+        const connectors = [];
+        const pendingSegmentConnectors = [];
+        const connections = [...slideNote.connections].sort((a, b) => a.beat - b.beat);
+        if (connections.length === 0)
+            continue;
+        const stepSize = Math.max(1, connections.length - 1);
+        let nextHiddenTickBeat = Math.floor(connections[0].beat * 2 + 1) / 2;
+        let stepIdx = 0;
+        for (const connectionNote of connections) {
+            let isSimLineEligible = false;
+            let isAttached = false;
+            const name_parts = [];
+            switch (connectionNote.type) {
+                case 'start':
+                    if (connectionNote.judgeType === 'none') {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Head');
+                        if (connectionNote.judgeType === 'trace')
+                            name_parts.push('Trace');
+                        else if (connectionNote.judgeType === 'normal')
+                            name_parts.push('Tap');
+                        isSimLineEligible = true;
+                    }
+                    break;
+                case 'end':
+                    if (connectionNote.judgeType === 'none') {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Tail');
+                        if (connectionNote.direction === undefined ||
+                            connectionNote.direction === null) {
+                            if (connectionNote.judgeType === 'trace')
+                                name_parts.push('Trace');
+                            else if (connectionNote.judgeType === 'normal')
+                                name_parts.push('Release');
+                        }
+                        else {
+                            if (connectionNote.judgeType === 'trace')
+                                name_parts.push('TraceFlick');
+                            else if (connectionNote.judgeType === 'normal')
+                                name_parts.push('Flick');
+                        }
+                        isSimLineEligible = true;
+                    }
+                    break;
+                case 'tick':
+                    if (connectionNote.critical !== undefined) {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        if (connectionNote.judgeType === 'trace')
+                            name_parts.push('Trace');
+                        else
+                            name_parts.push('Tick');
+                    }
+                    else {
+                        name_parts.push('Anchor');
+                    }
+                    break;
+                case 'attach':
+                    isAttached = true;
+                    if (connectionNote.critical !== undefined) {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Tick');
+                    }
+                    else {
+                        name_parts.push('TransientHiddenTick');
+                    }
+                    break;
+            }
+            name_parts.push('Note');
+            const archetype = name_parts.join('');
+            const timeScaleGroupRef = timeScaleGroupIntermediates[connectionNote.timeScaleGroup ?? 0];
+            let sonolusDirName;
+            const direction = connectionNote.direction;
+            if (direction === undefined || direction === null) {
+                sonolusDirName = 'up';
+            }
+            else {
+                sonolusDirName = direction;
+            }
+            const sonolusEaseValue = SONOLUS_CONNECTOR_EASES[mapUscEaseToSonolusEase('ease' in connectionNote ? connectionNote.ease : undefined)];
+            let segmentAlpha = 1;
+            if (slideNote.type === 'guide') {
+                // 공식: 1 - (0.8 * (현재단계 / 전체구간)) -> 1에서 0.2까지 감소
+                segmentAlpha = 1 - 0.8 * (stepIdx / stepSize);
+            }
+            const isSeparatorValue = slideNote.type == 'slide' ? 0 : 1;
+            const data = {
+                '#BEAT': connectionNote.beat,
+                lane: 'lane' in connectionNote ? connectionNote.lane : 0,
+                size: 'size' in connectionNote ? connectionNote.size : 0,
+                isAttached: isAttached ? 1 : 0,
+                connectorEase: sonolusEaseValue,
+                isSeparator: isSeparatorValue,
+                segmentKind: slideNote.type == 'slide'
+                    ? slideNote.critical
+                        ? 2
+                        : 1
+                    : slideNote.critical
+                        ? 105
+                        : 103,
+                segmentAlpha: segmentAlpha,
+                segmentLayer: slideNote.type == 'slide' ? 0 : 1,
+                '#TIMESCALE_GROUP': timeScaleGroupRef,
+            };
+            const directionValue = SONOLUS_DIRECTIONS[sonolusDirName];
+            if (directionValue !== undefined) {
+                data['direction'] = directionValue;
+            }
+            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 (slideNote.type == 'slide' &&
+                        nextHiddenTickBeat + EPSILON <
+                            connectionIntermediate.data['#BEAT']) {
+                        createIntermediate('TransientHiddenTickNote', {
+                            '#BEAT': nextHiddenTickBeat,
+                            '#TIMESCALE_GROUP': timeScaleGroupIntermediates[0],
+                            lane: connectionIntermediate.data['lane'],
+                            size: connectionIntermediate.data['size'],
+                            direction: SONOLUS_DIRECTIONS.up,
+                            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,
+                    });
+                    connectors.push(connectorIntermediate);
+                    pendingSegmentConnectors.push(connectorIntermediate);
+                }
+                prevJointIntermediate = connectionIntermediate;
+            }
+            if (isSeparatorValue === 1) {
+                for (const conn of pendingSegmentConnectors) {
+                    conn.data['segmentHead'] = currentSegmentHead;
+                    conn.data['segmentTail'] = connectionIntermediate;
+                }
+                pendingSegmentConnectors.length = 0;
+                currentSegmentHead = connectionIntermediate;
+            }
+            if (prevNoteIntermediate !== null) {
+                prevNoteIntermediate.data['next'] = connectionIntermediate;
+            }
+            prevNoteIntermediate = connectionIntermediate;
+            stepIdx++;
+        }
+        if (!headNoteIntermediate || !prevJointIntermediate) {
+            continue;
+        }
+        if (currentSegmentHead) {
+            for (const conn of pendingSegmentConnectors) {
+                conn.data['segmentHead'] = currentSegmentHead;
+                conn.data['segmentTail'] = prevJointIntermediate;
+            }
+        }
+        for (const connectorIntermediate of connectors) {
+            connectorIntermediate.data['activeHead'] = headNoteIntermediate;
+            connectorIntermediate.data['activeTail'] = prevJointIntermediate;
+        }
+    }
+    for (const guideNote of guideNotes) {
+        const connections = [...guideNote.midpoints].sort((a, b) => a.beat - b.beat);
+        let prevMidpointIntermediate = null;
+        let headMidpointIntermediate = null;
+        const guideConnectors = [];
+        for (const midpointNote of connections) {
+            const timeScaleGroupRef = timeScaleGroupIntermediates[midpointNote.timeScaleGroup ?? 0];
+            const midpointIntermediate = createIntermediate('AnchorNote', {
+                '#BEAT': midpointNote.beat,
+                lane: midpointNote.lane,
+                size: midpointNote.size,
+                direction: SONOLUS_DIRECTIONS.up,
+                isAttached: 0,
+                connectorEase: SONOLUS_CONNECTOR_EASES[mapUscEaseToSonolusEase(midpointNote.ease)],
+                isSeparator: 0,
+                segmentKind: SONOLUS_GUIDE_COLORS[guideNote.color],
+                segmentAlpha: 1,
+                '#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;
+        }
+        if (!headMidpointIntermediate || !prevMidpointIntermediate) {
+            continue;
+        }
+        for (const connectorIntermediate of guideConnectors) {
+            connectorIntermediate.data['segmentHead'] = headMidpointIntermediate;
+            connectorIntermediate.data['segmentTail'] = prevMidpointIntermediate;
+            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'];
+        const beatB = noteB.data['#BEAT'];
+        if (beatA !== beatB)
+            return beatA - beatB;
+        const laneA = noteA.data['lane'];
+        const laneB = noteB.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++) {
+            const leftNote = simGroup[i];
+            const rightNote = simGroup[i + 1];
+            createIntermediate('SimLine', {
+                left: leftNote,
+                right: rightNote,
+            });
+        }
+    }
+    const entities = [];
+    const intermediateToRef = new Map();
+    let entityRefCounter = 0;
+    const getRef = (intermediateEntity) => {
+        let ref = intermediateToRef.get(intermediateEntity);
+        if (ref)
+            return ref;
+        ref = (entityRefCounter++).toString(16);
+        intermediateToRef.set(intermediateEntity, ref);
+        return ref;
+    };
+    for (const intermediateEntity of allIntermediateEntities) {
+        const entity = {
+            archetype: intermediateEntity.archetype,
+            name: getRef(intermediateEntity),
+            data: [],
+        };
+        for (const [dataName, dataValue] of Object.entries(intermediateEntity.data)) {
+            if (typeof dataValue === 'number') {
+                entity.data.push({ name: dataName, value: dataValue });
+            }
+            else if (dataValue !== undefined) {
+                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+            }
+        }
+        entities.push(entity);
+    }
+    return {
+        bgmOffset: usc.offset + offset,
+        entities,
+    };
+};

package/dist/usc/index.d.ts

@@ -0,0 +1,96 @@
+export type USC = {
+    offset: number;
+    objects: USCObject[];
+};
+export type USCObject = USCBpmChange | USCTimeScaleChange | USCSingleNote | USCSlideNote | USCGuideNote | USCDamageNote | USCEvent;
+type BaseUSCObject = {
+    beat: number;
+    timeScaleGroup: number;
+};
+export type USCBpmChange = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'bpm';
+    bpm: number;
+};
+export type USCTimeScaleChange = {
+    type: 'timeScaleGroup';
+    changes: {
+        beat: number;
+        timeScale: number;
+    }[];
+};
+type BaseUSCNote = BaseUSCObject & {
+    lane: number;
+    size: number;
+};
+export type USCSingleNote = BaseUSCNote & {
+    type: 'single';
+    critical: boolean;
+    trace: boolean;
+    direction?: 'left' | 'up' | 'right' | 'none';
+};
+export type USCDamageNote = BaseUSCNote & {
+    type: 'damage';
+};
+export type USCConnectionStartNote = BaseUSCNote & {
+    type: 'start';
+    critical: boolean;
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+    judgeType: 'normal' | 'trace' | 'none';
+};
+export type USCConnectionTickNote = BaseUSCNote & {
+    type: 'tick';
+    critical?: boolean;
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+    judgeType?: 'normal' | 'trace';
+};
+export type USCConnectionAttachNote = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'attach';
+    critical?: boolean;
+    timeScaleGroup?: number;
+};
+export type USCConnectionEndNote = BaseUSCNote & {
+    type: 'end';
+    critical: boolean;
+    direction?: 'left' | 'up' | 'right';
+    judgeType: 'normal' | 'trace' | 'none';
+};
+export type USCSlideNote = {
+    type: 'slide' | 'guide';
+    critical: boolean;
+    connections: [
+        USCConnectionStartNote,
+        ...(USCConnectionTickNote | USCConnectionAttachNote)[],
+        USCConnectionEndNote
+    ];
+};
+export declare const USCColor: {
+    neutral: number;
+    red: number;
+    green: number;
+    blue: number;
+    yellow: number;
+    purple: number;
+    cyan: number;
+    black: number;
+};
+export type USCColor = keyof typeof USCColor;
+export type USCGuideMidpointNote = BaseUSCNote & {
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+};
+export declare const USCFade: {
+    in: number;
+    out: number;
+    none: number;
+};
+export type USCFade = keyof typeof USCFade;
+export type USCGuideNote = {
+    type: 'guide';
+    color: USCColor;
+    fade: USCFade;
+    midpoints: USCGuideMidpointNote[];
+};
+export type USCEvent = {
+    type: 'skill' | 'feverChance' | 'feverStart';
+    beat: number;
+};
+export {};

package/dist/usc/index.js

@@ -0,0 +1,15 @@
+export const USCColor = {
+    neutral: 0,
+    red: 1,
+    green: 2,
+    blue: 3,
+    yellow: 4,
+    purple: 5,
+    cyan: 6,
+    black: 7,
+};
+export const USCFade = {
+    in: 2,
+    out: 0,
+    none: 1,
+};

package/package.json

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