sonolus-pjsekai-js 1.1.12 → 1.2.0

package/package.json

@@ -1,41 +1,41 @@
 {
-  "name": "sonolus-pjsekai-js",
-  "version": "1.1.12",
-  "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",
-    "format": "prettier . --write",
-    "lint": "eslint .",
-    "lint-fix": "eslint . --fix",
-    "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/sonolus.js": "~9.5.6",
-    "@eslint/js": "^9.27.0",
-    "eslint": "^9.27.0",
-    "eslint-config-prettier": "^10.1.5",
-    "prettier": "^3.5.3",
-    "prettier-plugin-organize-imports": "^4.1.0",
-    "typescript": "~5.8.3",
-    "typescript-eslint": "^8.33.0"
-  },
-  "dependencies": {
-    "@sonolus/core": "~7.13.2"
-  }
+    "name": "sonolus-pjsekai-js",
+    "version": "1.2.0",
+    "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",
+        "format": "prettier . --write",
+        "lint": "eslint .",
+        "lint-fix": "eslint . --fix",
+        "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/sonolus.js": "~9.5.6",
+        "@eslint/js": "^9.27.0",
+        "eslint": "^9.27.0",
+        "eslint-config-prettier": "^10.1.5",
+        "prettier": "^3.5.3",
+        "prettier-plugin-organize-imports": "^4.1.0",
+        "typescript": "~5.8.3",
+        "typescript-eslint": "^8.33.0"
+    },
+    "dependencies": {
+        "@sonolus/core": "~7.13.2"
+    }
 }

package/dist/sus/analyze.d.ts

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

package/dist/sus/analyze.js

@@ -1,262 +0,0 @@
-export const analyze = (sus) => {
-    const { lines, measureChanges, timeScaleGroupChanges, meta } = parse(sus);
-    const offset = -+(meta.get("WAVEOFFSET")?.[0] ?? "0");
-    if (Number.isNaN(offset))
-        throw "Unexpected offset";
-    const ticksPerBeat = getTicksPerBeat(meta) ?? 480;
-    if (!ticksPerBeat)
-        throw "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();
-    const guideStreams = 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") {
-            const channel = header[5];
-            const stream = streams.get(channel);
-            if (stream) {
-                stream.push(...toNotes(line, measureOffset, timeScaleGroup, toTick));
-            }
-            else {
-                streams.set(channel, toNotes(line, measureOffset, timeScaleGroup, toTick));
-            }
-            return;
-        }
-        // Guides
-        if (header.length === 6 && header[3] === "9") {
-            const channel = header[5];
-            const stream = guideStreams.get(channel);
-            if (stream) {
-                stream.push(...toNotes(line, measureOffset, timeScaleGroup, toTick));
-            }
-            else {
-                guideStreams.set(channel, 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()].map(toSlides).flat();
-    const guides = [...guideStreams.values()].map(toSlides).flat();
-    return {
-        offset,
-        ticksPerBeat,
-        timeScaleChanges,
-        bpmChanges,
-        tapNotes,
-        directionalNotes,
-        slides,
-        guides,
-        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 current;
-    stream
-        .sort((a, b) => a.tick - b.tick)
-        .forEach((note) => {
-        if (!current) {
-            current = [];
-            slides.push(current);
-        }
-        current.push(note);
-        if (note.type === 2) {
-            current = 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

@@ -1,5 +0,0 @@
-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

@@ -1,301 +0,0 @@
-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 criticalMods = new Set();
-    const tickRemoveMods = new Set();
-    const judgeRemoveMods = 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 slides of [score.slides, score.guides]) {
-        for (const slide of slides) {
-            for (const note of slide) {
-                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 4:
-                judgeRemoveMods.add(key);
-                break;
-            case 3:
-            case 5:
-                tickRemoveMods.add(key);
-                break;
-            case 6:
-                criticalMods.add(key);
-                tickRemoveMods.add(key);
-                break;
-            case 7:
-                judgeRemoveMods.add(key);
-                break;
-            case 8:
-                criticalMods.add(key);
-                judgeRemoveMods.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 (!requests.sideLane && (note.lane <= 1 || note.lane >= 14))
-            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 3:
-            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) || criticalMods.has(key),
-                    trace: [3, 5, 6].includes(note.type) || tickRemoveMods.has(key),
-                    timeScaleGroup: note.timeScaleGroup,
-                };
-                const flickMod = flickMods.get(key);
-                if (flickMod)
-                    object.direction = flickMod;
-                if (easeMods.has(key))
-                    object.direction = "none";
-                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 [isDummy, slides] of [
-        [false, score.slides],
-        [true, score.guides],
-    ]) {
-        for (const slide of slides) {
-            const startNote = slide.find(({ type }) => type === 1 || type === 2);
-            if (!startNote)
-                continue;
-            const endNote = slide.find(({ type }) => type === 2);
-            if (!endNote)
-                continue;
-            const object = {
-                type: "slide",
-                critical: criticalMods.has(getKey(startNote)),
-                connections: [],
-            };
-            for (const note of slide) {
-                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";
-                switch (note.type) {
-                    case 1: {
-                        let judgeType = "normal";
-                        if (tickRemoveMods.has(key))
-                            judgeType = "trace";
-                        if (judgeRemoveMods.has(key))
-                            judgeType = "none";
-                        const connection = {
-                            type: "start",
-                            beat,
-                            lane,
-                            size,
-                            critical,
-                            ease: easeMods.get(key) ?? "linear",
-                            judgeType,
-                            timeScaleGroup,
-                        };
-                        object.connections.push(connection);
-                        break;
-                    }
-                    case 2: {
-                        let judgeType = "normal";
-                        if (tickRemoveMods.has(key))
-                            judgeType = "trace";
-                        if (judgeRemoveMods.has(key))
-                            judgeType = "none";
-                        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,
-                                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;
-                    }
-                }
-            }
-            if (isDummy ||
-                (tickRemoveMods.has(getKey(startNote)) &&
-                    judgeRemoveMods.has(getKey(startNote)))) {
-                objects.push({
-                    type: "guide",
-                    color: criticalMods.has(getKey(startNote)) ? "yellow" : "green",
-                    fade: judgeRemoveMods.has(getKey(endNote)) ? "none" : "out",
-                    midpoints: object.connections.flatMap((connection) => connection.type === "attach"
-                        ? []
-                        : [
-                            {
-                                beat: connection.beat,
-                                lane: connection.lane,
-                                size: connection.size,
-                                ease: connection.type === "end" ? "linear" : connection.ease,
-                                timeScaleGroup: connection.timeScaleGroup,
-                            },
-                        ]),
-                });
-            }
-            else {
-                objects.push(object);
-            }
-            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

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