sonolus-next-rush-engine 0.1.0

package/dist/sus/analyze.d.ts

@@ -0,0 +1,32 @@
+type Meta = Map<string, string[]>;
+export interface TimeScaleChangeObject {
+    tick: number;
+    timeScale: number;
+}
+export interface BpmChangeObject {
+    tick: number;
+    bpm: number;
+}
+export interface NoteObject {
+    tick: number;
+    lane: number;
+    width: number;
+    type: number;
+    timeScaleGroup: number;
+}
+export interface SlideObject {
+    type: number;
+    notes: NoteObject[];
+}
+export interface 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,287 @@
+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));
+        }
+    }
+    const customSpeedGroups = new Map();
+    const getCustomGroup = (baseGroup, speedRatio) => {
+        const key = `${baseGroup}_${speedRatio}`;
+        const group = customSpeedGroups.get(key);
+        if (group !== undefined)
+            return group;
+        const newIndex = timeScaleChanges.length;
+        customSpeedGroups.set(key, newIndex);
+        const baseChanges = timeScaleChanges[baseGroup] || [];
+        let scaledChanges = [];
+        if (baseChanges.length === 0) {
+            scaledChanges = [{ tick: 0, timeScale: speedRatio }];
+        }
+        else {
+            scaledChanges = baseChanges.map((change) => ({
+                tick: change.tick,
+                timeScale: change.timeScale * speedRatio,
+            }));
+        }
+        timeScaleChanges.push(scaledChanges);
+        return newIndex;
+    };
+    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, getCustomGroup));
+            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, getCustomGroup));
+            }
+            else {
+                streams.set(key, {
+                    type: +header[3],
+                    notes: toNotes(line, measureOffset, timeScaleGroup, toTick, getCustomGroup),
+                });
+            }
+            return;
+        }
+        // Directional Notes
+        if (header.length === 5 && header[3] === '5') {
+            directionalNotes.push(...toNotes(line, measureOffset, timeScaleGroup, toTick, getCustomGroup));
+            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, baseTimeScaleGroup, toTick, getCustomGroup) => {
+    const [header] = line;
+    const lane = parseInt(header[4], 36);
+    return toRaws(line, measureOffset, toTick).map(({ tick, value, speedRatio }) => {
+        const width = parseInt(value[1], 36);
+        const timeScaleGroup = speedRatio !== undefined
+            ? getCustomGroup(baseTimeScaleGroup, speedRatio)
+            : baseTimeScaleGroup;
+        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;
+    const matches = [...data.matchAll(/([0-9a-zA-Z]{2})(?:,([-+]?\d*\.?\d+))?/g)];
+    return matches
+        .map((match, i, values) => {
+        const value = match[1];
+        if (value === '00')
+            return null;
+        const speedRatio = match[2] !== undefined ? parseFloat(match[2]) : undefined;
+        const rawObject = {
+            tick: toTick(measure, i, values.length),
+            value,
+        };
+        if (speedRatio !== undefined) {
+            rawObject.speedRatio = speedRatio;
+        }
+        return rawObject;
+    })
+        .filter((object) => object !== null);
+};

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/analyze.d.ts

@@ -0,0 +1,3 @@
+import { USC } from './index.js';
+/** Check if it is USC */
+export declare function isUSC(data: unknown): data is USC;

package/dist/usc/analyze.js

@@ -0,0 +1,7 @@
+/** Check if it is USC */
+export function isUSC(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'objects' in data &&
+        Array.isArray(data.objects));
+}

package/dist/usc/convert.d.ts

@@ -0,0 +1,4 @@
+import { type LevelData } from '@sonolus/core';
+import { USC } from './index.js';
+/** Convert a USC to a Level Data */
+export declare const uscToLevelData: (usc: USC, offset?: number, smoothGuideFade?: boolean, useGuideLayer?: boolean) => LevelData;