sonolus-pjsekai-js 1.0.7

package/README.md

@@ -0,0 +1,153 @@
+# Sonolus Pjsekai Js
+
+Compiled and expanded version of [pjsekai-sonolus-engine](https://github.com/NonSpicyBurrito/sonolus-pjsekai-engine)
+
+## Custom Resources
+
+### Skin Sprites
+
+| Name                                          |
+| --------------------------------------------- |
+| `Sekai Stage`                                 |
+| `Sekai Note Red Left`                         |
+| `Sekai Note Red Middle`                       |
+| `Sekai Note Red Right`                        |
+| `Sekai Note Green Left`                       |
+| `Sekai Note Green Middle`                     |
+| `Sekai Note Green Right`                      |
+| `Sekai Note Yellow Left`                      |
+| `Sekai Note Yellow Middle`                    |
+| `Sekai Note Yellow Right`                     |
+| `Sekai Note Cyan Left`                        |
+| `Sekai Note Cyan Middle`                      |
+| `Sekai Note Cyan Right`                       |
+| `Sekai Diamond Green`                         |
+| `Sekai Diamond Yellow`                        |
+| `Sekai Trace Note Red`                        |
+| `Sekai Trace Note Red Left`                   |
+| `Sekai Trace Note Red Middle`                 |
+| `Sekai Trace Note Red Right`                  |
+| `Sekai Trace Note Green`                      |
+| `Sekai Trace Note Green Left`                 |
+| `Sekai Trace Note Green Middle`               |
+| `Sekai Trace Note Green Right`                |
+| `Sekai Trace Note Yellow`                     |
+| `Sekai Trace Note Yellow Left`                |
+| `Sekai Trace Note Yellow Middle`              |
+| `Sekai Trace Note Yellow Right`               |
+| `Sekai Trace Diamond Red`                     |
+| `Sekai Trace Diamond Green`                   |
+| `Sekai Trace Diamond Yellow`                  |
+| `Sekai Slide Connection Green`                |
+| `Sekai Slide Connection Green Active`         |
+| `Sekai Slide Connection Yellow`               |
+| `Sekai Slide Connection Yellow Active`        |
+| `Sekai Active Slide Connection Green`         |
+| `Sekai Active Slide Connection Green Active`  |
+| `Sekai Active Slide Connection Yellow`        |
+| `Sekai Active Slide Connection Yellow Active` |
+| `Sekai Slot Glow Red`                         |
+| `Sekai Slot Glow Green`                       |
+| `Sekai Slot Glow Yellow`                      |
+| `Sekai Slot Glow Cyan`                        |
+| `Sekai Slot Red`                              |
+| `Sekai Slot Green`                            |
+| `Sekai Slot Yellow`                           |
+| `Sekai Slot Cyan`                             |
+| `Sekai Flick Arrow Red Up 1`                  |
+| `Sekai Flick Arrow Red Up 2`                  |
+| `Sekai Flick Arrow Red Up 3`                  |
+| `Sekai Flick Arrow Red Up 4`                  |
+| `Sekai Flick Arrow Red Up 5`                  |
+| `Sekai Flick Arrow Red Up 6`                  |
+| `Sekai Flick Arrow Red Left 1`                |
+| `Sekai Flick Arrow Red Left 2`                |
+| `Sekai Flick Arrow Red Left 3`                |
+| `Sekai Flick Arrow Red Left 4`                |
+| `Sekai Flick Arrow Red Left 5`                |
+| `Sekai Flick Arrow Red Left 6`                |
+| `Sekai Flick Arrow Yellow Up 1`               |
+| `Sekai Flick Arrow Yellow Up 2`               |
+| `Sekai Flick Arrow Yellow Up 3`               |
+| `Sekai Flick Arrow Yellow Up 4`               |
+| `Sekai Flick Arrow Yellow Up 5`               |
+| `Sekai Flick Arrow Yellow Up 6`               |
+| `Sekai Flick Arrow Yellow Left 1`             |
+| `Sekai Flick Arrow Yellow Left 2`             |
+| `Sekai Flick Arrow Yellow Left 3`             |
+| `Sekai Flick Arrow Yellow Left 4`             |
+| `Sekai Flick Arrow Yellow Left 5`             |
+| `Sekai Flick Arrow Yellow Left 6`             |
+| `Perfect`                                     |
+| `Great`                                       |
+| `Good`                                        |
+| `Bad`                                         |
+| `Miss`                                        |
+| `C0 - C9`                                     |
+| `AP0 - AP9`                                   |
+| `Combo`                                       |
+| `Fast`                                        |
+| `Late`                                        |
+| `Flick`                                       |
+
+### Effect Clips
+
+| Name                   |
+| ---------------------- |
+| `Sekai Tick`           |
+| `Sekai Trace`          |
+| `Sekai Critical Tap`   |
+| `Sekai Critical Trace` |
+| `Sekai Critical Flick` |
+| `Sekai Critical Hold`  |
+| `Sekai Critical Tick`  |
+
+### Particle Effects
+
+| Name                                   |
+| -------------------------------------- |
+| `Sekai Trace Note Circular Green`      |
+| `Sekai Trace Note Linear Green`        |
+| `Sekai Trace Note Circular Yellow`     |
+| `Sekai Trace Note Linear Yellow`       |
+| `Sekai Note Lane Linear`               |
+| `Sekai Critical Lane Linear`           |
+| `Sekai Critical Flick Lane Linear`     |
+| `Sekai Critical Slide Circular Yellow` |
+| `Sekai Critical Slide Linear Yellow`   |
+| `Sekai Critical Flick Circular Yellow` |
+| `Sekai Critical Flick Linear Yellow`   |
+
+## Documentation
+
+### `version`
+
+Package version.
+
+### `databaseEngineItem`
+
+Partial database engine item compatible with [sonolus-express](https://github.com/NonSpicyBurrito/sonolus-express).
+
+### `susToUSC(sus)`
+
+Converts sus chart to USC (Universal Sekai Chart).
+
+- `sus`: sus chart.
+
+### `uscToLevelData(usc, offset?)`
+
+Converts USC (Universal Sekai Chart) to Level Data.
+
+- `usc`: usc chart.
+- `offset`: offset (default: `0`).
+
+### Assets
+
+The following assets are exposed as package entry points:
+
+- `EngineConfiguration`
+- `EnginePlayData`
+- `EngineWatchData`
+- `EnginePreviewData`
+- `EngineTutorialData`
+- `EngineThumbnail`

package/dist/index.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseEngineItem = exports.version = exports.uscToLevelData = exports.susToUSC = void 0;
+var convert_cjs_1 = require("./sus/convert.cjs");
+Object.defineProperty(exports, "susToUSC", { enumerable: true, get: function () { return convert_cjs_1.susToUSC; } });
+var convert_cjs_2 = require("./usc/convert.cjs");
+Object.defineProperty(exports, "uscToLevelData", { enumerable: true, get: function () { return convert_cjs_2.uscToLevelData; } });
+__exportStar(require("./usc/index.cjs"), exports);
+exports.version = '1.0.7';
+exports.databaseEngineItem = {
+    name: 'prosekaR',
+    version: 13,
+    title: {
+        en: 'ProSeka R',
+        ja: 'プロセカ R',
+        ko: '프로세카 R',
+        zhs: '世界计划 R',
+        zht: '世界計劃 R',
+    },
+    subtitle: {
+        en: 'ProSeka Rush',
+        ja: 'プロセカ ラッシュ',
+        ko: '프로세카 러쉬',
+        zhs: '世界计划 匆忙',
+        zht: '世界計劃 匆忙',
+    },
+    author: {
+        en: 'Hyeon2#7895',
+    },
+    description: {
+        en: [
+            'A recreation of Project Sekai: Colorful Stage! engine in Sonolus.',
+            `Version: ${exports.version}`,
+            '',
+            'Forked from the pjsekai engine by Burrito#1000.',
+            'https://github.com/NonSpicyBurrito/sonolus-pjsekai-engine',
+            '',
+            'Github:',
+            'https://github.com/hyeon2006/sonolus-pjsekai-js'
+        ].join('\n'),
+        ko: [
+            '프로젝트 세카이: 컬러풀 스테이지! 엔진을 Sonolus로 재현했습니다.',
+            `버전: ${exports.version}`,
+            '',
+            'Burrito#1000의 pjsekai 엔진에서 포크되었습니다.',
+            'https://github.com/NonSpicyBurrito/sonolus-pjsekai-engine',
+            '',
+            '깃허브:',
+            'https://github.com/hyeon2006/sonolus-pjsekai-js'
+        ].join('\n'),
+    },
+};

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+export { susToUSC } from './sus/convert.cjs';
+export { uscToLevelData } from './usc/convert.cjs';
+export * from './usc/index.cjs';
+export declare const version = "1.0.7";
+export declare const databaseEngineItem: {
+    readonly name: "prosekaR";
+    readonly version: 13;
+    readonly title: {
+        readonly en: "ProSeka R";
+        readonly ja: "プロセカ R";
+        readonly ko: "프로세카 R";
+        readonly zhs: "世界计划 R";
+        readonly zht: "世界計劃 R";
+    };
+    readonly subtitle: {
+        readonly en: "ProSeka Rush";
+        readonly ja: "プロセカ ラッシュ";
+        readonly ko: "프로세카 러쉬";
+        readonly zhs: "世界计划 匆忙";
+        readonly zht: "世界計劃 匆忙";
+    };
+    readonly author: {
+        readonly en: "Hyeon2#7895";
+    };
+    readonly description: {
+        readonly en: string;
+        readonly ko: string;
+    };
+};

package/dist/sus/analyze.cjs

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyze = void 0;
+const analyze = (sus) => {
+    const { lines, measureChanges, meta } = parse(sus);
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    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 timeScaleChanges = [];
+    const tapNotes = [];
+    const directionalNotes = [];
+    const streams = new Map();
+    for (const [index, line] of lines.entries()) {
+        const [header, data] = line;
+        const measureOffset = measureChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? 0;
+        // Time Scale Changes
+        if (header.length === 5 && header.startsWith('TIL')) {
+            timeScaleChanges.push(...toTimeScaleChanges(line, toTick));
+            continue;
+        }
+        // BPM
+        if (header.length === 5 && header.startsWith('BPM')) {
+            bpms.set(header.substring(3), +data);
+            continue;
+        }
+        // BPM Changes
+        if (header.length === 5 && header.endsWith('08')) {
+            bpmChanges.push(...toBpmChanges(line, measureOffset, bpms, toTick));
+            continue;
+        }
+        // Tap Notes
+        if (header.length === 5 && header[3] === '1') {
+            tapNotes.push(...toNotes(line, measureOffset, toTick));
+            continue;
+        }
+        // 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, toTick));
+            }
+            else {
+                streams.set(key, {
+                    type: +header[3],
+                    notes: toNotes(line, measureOffset, toTick),
+                });
+            }
+            continue;
+        }
+        // Directional Notes
+        if (header.length === 5 && header[3] === '5') {
+            directionalNotes.push(...toNotes(line, measureOffset, toTick));
+            continue;
+        }
+    }
+    const slides = [...streams.values()].flatMap(toSlides);
+    return {
+        offset,
+        ticksPerBeat,
+        timeScaleChanges,
+        bpmChanges,
+        tapNotes,
+        directionalNotes,
+        slides,
+    };
+};
+exports.analyze = analyze;
+const parse = (sus) => {
+    const lines = [];
+    const measureChanges = [];
+    const meta = new Map();
+    for (const line of sus
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('#'))) {
+        const isLine = line.includes(':');
+        const index = line.indexOf(isLine ? ':' : ' ');
+        if (index === -1)
+            continue;
+        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 {
+            meta.set(left, right);
+        }
+    }
+    return {
+        lines,
+        measureChanges,
+        meta,
+    };
+};
+const getTicksPerBeat = (meta) => {
+    const request = meta.get('REQUEST');
+    if (!request)
+        return;
+    if (!request.startsWith('"ticks_per_beat ') || !request.endsWith('"'))
+        return;
+    return +request.slice(16, -1);
+};
+const getBarLengths = (lines, measureChanges) => {
+    const barLengths = [];
+    for (const [index, line] of lines.entries()) {
+        const [header, data] = line;
+        if (header.length !== 5)
+            continue;
+        if (!header.endsWith('02'))
+            continue;
+        const measure = +header.substring(0, 3) +
+            (measureChanges.find(([changeIndex]) => changeIndex <= index)?.[1] ?? 0);
+        if (Number.isNaN(measure))
+            continue;
+        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, 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),
+        };
+    });
+};
+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/analyze.d.cts

@@ -0,0 +1,28 @@
+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;
+};
+export type SlideObject = {
+    type: number;
+    notes: NoteObject[];
+};
+export type Score = {
+    offset: number;
+    ticksPerBeat: number;
+    timeScaleChanges: TimeScaleChangeObject[];
+    bpmChanges: BpmChangeObject[];
+    tapNotes: NoteObject[];
+    directionalNotes: NoteObject[];
+    slides: SlideObject[];
+};
+export declare const analyze: (sus: string) => Score;

package/dist/sus/convert.cjs

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.susToUSC = void 0;
+const analyze_cjs_1 = require("./analyze.cjs");
+const susToUSC = (sus) => {
+    const score = (0, analyze_cjs_1.analyze)(sus);
+    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();
+    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 timeScaleChange of score.timeScaleChanges) {
+        objects.push({
+            type: 'timeScale',
+            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 <= 1 || note.lane >= 14)
+            continue;
+        if (note.type !== 1 && note.type !== 2 && note.type !== 5 && note.type !== 6)
+            continue;
+        const key = getKey(note);
+        if (preventSingles.has(key))
+            continue;
+        if (dedupeSingles.has(key))
+            continue;
+        dedupeSingles.add(key);
+        const object = {
+            type: 'single',
+            beat: note.tick / score.ticksPerBeat,
+            lane: note.lane - 8 + note.width / 2,
+            size: note.width / 2,
+            trace: note.type === 5 || note.type === 6,
+            critical: note.type === 2 || note.type === 6,
+        };
+        const flickMod = flickMods.get(key);
+        if (flickMod)
+            object.direction = flickMod;
+        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',
+            active: slide.type === 3,
+            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;
+            const size = note.width / 2;
+            const trace = traceMods.has(key);
+            const critical = object.critical || criticalMods.has(key);
+            const ease = easeMods.get(key) ?? 'linear';
+            switch (note.type) {
+                case 1: {
+                    if (!object.active || slideStartEndRemoveMods.has(key)) {
+                        const connection = {
+                            type: 'ignore',
+                            beat,
+                            lane,
+                            size,
+                            ease,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'start',
+                            beat,
+                            lane,
+                            size,
+                            trace,
+                            critical,
+                            ease: easeMods.get(key) ?? 'linear',
+                        };
+                        object.connections.push(connection);
+                    }
+                    break;
+                }
+                case 2: {
+                    if (!object.active || slideStartEndRemoveMods.has(key)) {
+                        const connection = {
+                            type: 'ignore',
+                            beat,
+                            lane,
+                            size,
+                            ease,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'end',
+                            beat,
+                            lane,
+                            size,
+                            trace,
+                            critical,
+                        };
+                        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,
+                        };
+                        object.connections.push(connection);
+                    }
+                    else {
+                        const connection = {
+                            type: 'tick',
+                            beat,
+                            lane,
+                            size,
+                            trace,
+                            critical,
+                            ease,
+                        };
+                        object.connections.push(connection);
+                    }
+                    break;
+                }
+                case 5: {
+                    if (tickRemoveMods.has(key))
+                        break;
+                    const connection = {
+                        type: 'ignore',
+                        beat,
+                        lane,
+                        size,
+                        ease,
+                    };
+                    object.connections.push(connection);
+                    break;
+                }
+            }
+        }
+        objects.push(object);
+        if (!object.active)
+            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,
+    };
+};
+exports.susToUSC = susToUSC;
+const getKey = (note) => `${note.lane}-${note.tick}`;

package/dist/sus/convert.d.cts

@@ -0,0 +1,2 @@
+import { USC } from '../usc/index.cjs';
+export declare const susToUSC: (sus: string) => USC;

package/dist/usc/convert.cjs

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uscToLevelData = void 0;
+const core_1 = require("@sonolus/core");
+const uscToLevelData = (usc, offset = 0) => {
+    const entities = [];
+    const timeToIntermediates = new Map();
+    const intermediateToRef = new Map();
+    const intermediateToEntity = new Map();
+    let i = 0;
+    const getRef = (intermediate) => {
+        let ref = intermediateToRef.get(intermediate);
+        if (ref)
+            return ref;
+        ref = (i++).toString(36);
+        intermediateToRef.set(intermediate, ref);
+        const entity = intermediateToEntity.get(intermediate);
+        if (entity)
+            entity.name = ref;
+        return ref;
+    };
+    const append = (intermediate) => {
+        const entity = {
+            archetype: intermediate.archetype,
+            data: [],
+        };
+        if (intermediate.sim) {
+            const beat = intermediate.data[core_1.EngineArchetypeDataName.Beat];
+            if (typeof beat !== 'number')
+                throw new Error('Unexpected beat');
+            const intermediates = timeToIntermediates.get(beat);
+            if (intermediates) {
+                intermediates.push(intermediate);
+            }
+            else {
+                timeToIntermediates.set(beat, [intermediate]);
+            }
+        }
+        const ref = intermediateToRef.get(intermediate);
+        if (ref)
+            entity.name = ref;
+        intermediateToEntity.set(intermediate, entity);
+        entities.push(entity);
+        for (const [name, value] of Object.entries(intermediate.data)) {
+            if (value === undefined)
+                continue;
+            if (typeof value === 'number') {
+                entity.data.push({
+                    name,
+                    value,
+                });
+            }
+            else {
+                entity.data.push({
+                    name,
+                    ref: getRef(value),
+                });
+            }
+        }
+    };
+    append({
+        archetype: 'Initialization',
+        data: {},
+        sim: false,
+    });
+    append({
+        archetype: 'Stage',
+        data: {},
+        sim: false,
+    });
+    for (const object of usc.objects) {
+        handlers[object.type](object, append);
+    }
+    for (const intermediates of timeToIntermediates.values()) {
+        for (let i = 1; i < intermediates.length; i++) {
+            append({
+                archetype: 'SimLine',
+                data: {
+                    a: intermediates[i - 1],
+                    b: intermediates[i],
+                },
+                sim: false,
+            });
+        }
+    }
+    return {
+        bgmOffset: usc.offset + offset,
+        entities,
+    };
+};
+exports.uscToLevelData = uscToLevelData;
+const directions = {
+    left: -1,
+    up: 0,
+    right: 1,
+};
+const eases = {
+    out: -1,
+    linear: 0,
+    in: 1,
+};
+const bpm = (object, append) => {
+    append({
+        archetype: core_1.EngineArchetypeName.BpmChange,
+        data: {
+            [core_1.EngineArchetypeDataName.Beat]: object.beat,
+            [core_1.EngineArchetypeDataName.Bpm]: object.bpm,
+        },
+        sim: false,
+    });
+};
+const timeScale = (object, append) => {
+    append({
+        archetype: core_1.EngineArchetypeName.TimeScaleChange,
+        data: {
+            [core_1.EngineArchetypeDataName.Beat]: object.beat,
+            [core_1.EngineArchetypeDataName.TimeScale]: object.timeScale,
+        },
+        sim: false,
+    });
+};
+const single = (object, append) => {
+    const intermediate = {
+        archetype: object.direction
+            ? object.trace
+                ? object.critical
+                    ? 'CriticalTraceFlickNote'
+                    : 'NormalTraceFlickNote'
+                : object.critical
+                    ? 'CriticalFlickNote'
+                    : 'NormalFlickNote'
+            : object.trace
+                ? object.critical
+                    ? 'CriticalTraceNote'
+                    : 'NormalTraceNote'
+                : object.critical
+                    ? 'CriticalTapNote'
+                    : 'NormalTapNote',
+        data: {
+            [core_1.EngineArchetypeDataName.Beat]: object.beat,
+            lane: object.lane,
+            size: object.size,
+            direction: object.direction && directions[object.direction],
+        },
+        sim: true,
+    };
+    append(intermediate);
+};
+const slide = (object, append) => {
+    const cis = [];
+    const joints = [];
+    const attaches = [];
+    const ends = [];
+    const connections = getConnections(object);
+    for (const [i, connection] of connections.entries()) {
+        if (i === 0) {
+            switch (connection.type) {
+                case 'start': {
+                    const ci = {
+                        archetype: connection.trace
+                            ? connection.critical
+                                ? 'CriticalSlideTraceNote'
+                                : 'NormalSlideTraceNote'
+                            : connection.critical
+                                ? 'CriticalSlideStartNote'
+                                : 'NormalSlideStartNote',
+                        data: {
+                            [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                            lane: connection.lane,
+                            size: connection.size,
+                        },
+                        sim: true,
+                        ease: connection.ease,
+                    };
+                    cis.push(ci);
+                    joints.push(ci);
+                    continue;
+                }
+                case 'ignore': {
+                    const ci = {
+                        archetype: 'IgnoredSlideTickNote',
+                        data: {
+                            [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                            lane: connection.lane,
+                            size: connection.size,
+                        },
+                        sim: false,
+                        ease: connection.ease,
+                    };
+                    cis.push(ci);
+                    joints.push(ci);
+                    continue;
+                }
+                default:
+                    throw new Error('Unexpected slide start');
+            }
+        }
+        if (i === connections.length - 1) {
+            switch (connection.type) {
+                case 'end': {
+                    const ci = {
+                        archetype: connection.direction
+                            ? connection.trace
+                                ? connection.critical
+                                    ? 'CriticalTraceFlickNote'
+                                    : 'NormalTraceFlickNote'
+                                : connection.critical
+                                    ? 'CriticalSlideEndFlickNote'
+                                    : 'NormalSlideEndFlickNote'
+                            : connection.trace
+                                ? connection.critical
+                                    ? 'CriticalSlideEndTraceNote'
+                                    : 'NormalSlideEndTraceNote'
+                                : connection.critical
+                                    ? 'CriticalSlideEndNote'
+                                    : 'NormalSlideEndNote',
+                        data: {
+                            [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                            lane: connection.lane,
+                            size: connection.size,
+                            direction: connection.direction && directions[connection.direction],
+                        },
+                        sim: true,
+                    };
+                    cis.push(ci);
+                    joints.push(ci);
+                    ends.push(ci);
+                    continue;
+                }
+                case 'ignore': {
+                    const ci = {
+                        archetype: 'IgnoredSlideTickNote',
+                        data: {
+                            [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                            lane: connection.lane,
+                            size: connection.size,
+                        },
+                        sim: false,
+                        ease: connection.ease,
+                    };
+                    cis.push(ci);
+                    joints.push(ci);
+                    continue;
+                }
+                default:
+                    throw new Error('Unexpected slide end');
+            }
+        }
+        switch (connection.type) {
+            case 'ignore': {
+                const ci = {
+                    archetype: 'IgnoredSlideTickNote',
+                    data: {
+                        [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                        lane: connection.lane,
+                        size: connection.size,
+                    },
+                    sim: false,
+                    ease: connection.ease,
+                };
+                cis.push(ci);
+                joints.push(ci);
+                break;
+            }
+            case 'tick': {
+                const ci = {
+                    archetype: connection.trace
+                        ? connection.critical
+                            ? 'CriticalSlideTraceNote'
+                            : 'NormalSlideTraceNote'
+                        : connection.critical
+                            ? 'CriticalSlideTickNote'
+                            : 'NormalSlideTickNote',
+                    data: {
+                        [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                        lane: connection.lane,
+                        size: connection.size,
+                    },
+                    sim: false,
+                    ease: connection.ease,
+                };
+                cis.push(ci);
+                joints.push(ci);
+                break;
+            }
+            case 'hidden': {
+                const ci = {
+                    archetype: 'HiddenSlideTickNote',
+                    data: {
+                        [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                    },
+                    sim: false,
+                };
+                cis.push(ci);
+                attaches.push(ci);
+                break;
+            }
+            case 'attach': {
+                const ci = {
+                    archetype: connection.critical
+                        ? 'CriticalAttachedSlideTickNote'
+                        : 'NormalAttachedSlideTickNote',
+                    data: {
+                        [core_1.EngineArchetypeDataName.Beat]: connection.beat,
+                    },
+                    sim: false,
+                };
+                cis.push(ci);
+                attaches.push(ci);
+                break;
+            }
+            default:
+                throw new Error('Unexpected slide tick');
+        }
+    }
+    const connectors = [];
+    const start = cis[0];
+    const end = cis[cis.length - 1];
+    for (const [i, joint] of joints.entries()) {
+        if (i === 0)
+            continue;
+        const head = joints[i - 1];
+        if (!head.ease)
+            throw new Error('Unexpected missing ease');
+        connectors.push({
+            archetype: object.active
+                ? object.critical
+                    ? 'CriticalActiveSlideConnector'
+                    : 'NormalActiveSlideConnector'
+                : object.critical
+                    ? 'CriticalSlideConnector'
+                    : 'NormalSlideConnector',
+            data: {
+                start,
+                end,
+                head,
+                tail: joint,
+                ease: eases[head.ease],
+            },
+            sim: false,
+        });
+    }
+    for (const attach of attaches) {
+        const index = cis.indexOf(attach);
+        const tailIndex = joints.findIndex((c) => cis.indexOf(c) > index);
+        attach.data.attach = connectors[tailIndex - 1];
+    }
+    for (const end of ends) {
+        end.data.slide = connectors[connectors.length - 1];
+    }
+    for (const ci of cis) {
+        append(ci);
+    }
+    for (const connector of connectors) {
+        append(connector);
+    }
+};
+const handlers = {
+    bpm,
+    single,
+    timeScale,
+    slide,
+};
+const getConnections = (object) => {
+    if (!object.active)
+        return object.connections;
+    const connections = [...object.connections];
+    const beats = connections.map(({ beat }) => beat).sort((a, b) => a - b);
+    const min = beats[0];
+    const max = beats[beats.length - 1];
+    const start = Math.max(Math.ceil(min / 0.5) * 0.5, Math.floor(min / 0.5 + 1) * 0.5);
+    for (let beat = start; beat < max; beat += 0.5) {
+        connections.push({
+            type: 'hidden',
+            beat,
+        });
+    }
+    return connections.sort((a, b) => a.beat - b.beat);
+};

package/dist/usc/convert.d.cts

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

package/dist/usc/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/usc/index.d.cts

@@ -0,0 +1,66 @@
+export type USC = {
+    offset: number;
+    objects: USCObject[];
+};
+export type USCObject = USCBpmChange | USCTimeScaleChange | USCSingleNote | USCSlideNote;
+type BaseUSCObject = {
+    beat: number;
+};
+export type USCBpmChange = BaseUSCObject & {
+    type: 'bpm';
+    bpm: number;
+};
+export type USCTimeScaleChange = BaseUSCObject & {
+    type: 'timeScale';
+    timeScale: number;
+};
+type BaseUSCNote = BaseUSCObject & {
+    lane: number;
+    size: number;
+};
+export type USCSingleNote = BaseUSCNote & {
+    type: 'single';
+    trace: boolean;
+    critical: boolean;
+    direction?: 'left' | 'up' | 'right';
+};
+export type USCConnectionStartNote = BaseUSCNote & {
+    type: 'start';
+    trace: boolean;
+    critical: boolean;
+    ease: 'out' | 'linear' | 'in';
+};
+export type USCConnectionIgnoreNote = BaseUSCNote & {
+    type: 'ignore';
+    ease: 'out' | 'linear' | 'in';
+};
+export type USCConnectionTickNote = BaseUSCNote & {
+    type: 'tick';
+    trace: boolean;
+    critical: boolean;
+    ease: 'out' | 'linear' | 'in';
+};
+export type USCConnectionHiddenNote = BaseUSCObject & {
+    type: 'hidden';
+};
+export type USCConnectionAttachNote = BaseUSCObject & {
+    type: 'attach';
+    critical: boolean;
+};
+export type USCConnectionEndNote = BaseUSCNote & {
+    type: 'end';
+    trace: boolean;
+    critical: boolean;
+    direction?: 'left' | 'up' | 'right';
+};
+export type USCSlideNote = {
+    type: 'slide';
+    active: boolean;
+    critical: boolean;
+    connections: [
+        USCConnectionStartNote | USCConnectionIgnoreNote,
+        ...(USCConnectionIgnoreNote | USCConnectionTickNote | USCConnectionHiddenNote | USCConnectionAttachNote)[],
+        USCConnectionEndNote | USCConnectionIgnoreNote
+    ];
+};
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "sonolus-pjsekai-js",
+  "version": "1.0.7",
+  "description": "A recreation of Project Sekai: Colorful Stage! engine in Sonolus",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.cjs",
+    "./EngineConfiguration": "./dist/EngineConfiguration",
+    "./EnginePlayData": "./dist/EnginePlayData",
+    "./EngineWatchData": "./dist/EngineWatchData",
+    "./EnginePreviewData": "./dist/EnginePreviewData",
+    "./EngineTutorialData": "./dist/EngineTutorialData",
+    "./EngineThumbnail": "./dist/thumbnail.png"
+  },
+  "scripts": {
+    "dev:play": "sonolus-cli --dev ./play",
+    "dev:watch": "sonolus-cli --dev ./watch",
+    "dev:preview": "sonolus-cli --dev ./preview",
+    "dev:tutorial": "sonolus-cli --dev ./tutorial",
+    "build": "tsc -p ./lib && sonolus-cli --build ./play && sonolus-cli --build ./watch && sonolus-cli --build ./preview && sonolus-cli --build ./tutorial && node ./lib/build.mjs"
+  },
+  "devDependencies": {
+    "@sonolus/core": "~7.13.1",
+    "@sonolus/sonolus.js": "~9.5.5",
+    "typescript": "~5.8.3"
+  },
+  "dependencies": {
+    "sonolus-pjsekai-js": "file:"
+  }
+}