sonolus-pjsekai-js 1.1.12 → 1.2.0

package/dist/sus/decode.cjs

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uscToSUS = void 0;
+const TICKS_PER_BEAT = 480;
+const uscToSUS = (uscData) => {
+    const usc = uscData.usc ? uscData.usc : uscData;
+    const susLines = [];
+    const noteData = new Map();
+    let slideChannelCounter = 0;
+    // (메타데이터 및 전역 정의 생성은 이전과 동일)
+    susLines.push(`#TITLE ""`, `#ARTIST ""`, `#DESIGNER ""`, `#WAVEOFFSET ${-usc.offset}`, `#REQUEST "ticks_per_beat ${TICKS_PER_BEAT}"`, ``);
+    const ticksPerMeasure = TICKS_PER_BEAT * 4;
+    const bpmObjects = usc.objects.filter((obj) => obj.type === "bpm");
+    const bpmDefinitions = new Map();
+    let bpmCounter = 1;
+    for (const bpmObject of bpmObjects) {
+        if (!bpmDefinitions.has(bpmObject.bpm)) {
+            const bpmId = bpmCounter.toString().padStart(2, "0");
+            bpmDefinitions.set(bpmObject.bpm, bpmId);
+            susLines.push(`#BPM${bpmId}: ${bpmObject.bpm}`);
+            bpmCounter++;
+        }
+    }
+    susLines.push(``);
+    const timeScaleGroups = usc.objects.filter((obj) => obj.type === "timeScaleGroup");
+    const tilIdMap = new Map();
+    timeScaleGroups.forEach((group, index) => {
+        const tilId = index.toString().padStart(2, "0");
+        tilIdMap.set(index, tilId);
+        const changesString = group.changes
+            .map(change => {
+            const totalTicks = change.beat * TICKS_PER_BEAT;
+            const measure = Math.floor(totalTicks / ticksPerMeasure);
+            const tickInMeasure = totalTicks % ticksPerMeasure;
+            return `${measure}'${tickInMeasure}:${change.timeScale}`;
+        })
+            .join(", ");
+        susLines.push(`#TIL${tilId}: "${changesString}"`);
+    });
+    susLines.push(``);
+    addNoteData(0, "00002", 0, "4", 0);
+    for (const bpmObject of bpmObjects) {
+        const tick = bpmObject.beat * TICKS_PER_BEAT;
+        const measure = Math.floor(tick / ticksPerMeasure);
+        const tickInMeasure = tick % ticksPerMeasure;
+        const bpmId = bpmDefinitions.get(bpmObject.bpm);
+        if (bpmId) {
+            addNoteData(measure, `${measure.toString().padStart(3, "0")}08`, tickInMeasure, bpmId, 0);
+        }
+    }
+    for (const obj of usc.objects) {
+        switch (obj.type) {
+            case "single":
+            case "damage":
+                processSingleOrDamage(obj);
+                break;
+            case "slide":
+                processSlide(obj);
+                slideChannelCounter++;
+                break;
+            case "guide":
+                processGuide(obj);
+                slideChannelCounter++;
+                break;
+            case "timeScaleGroup":
+            case "bpm":
+                break;
+        }
+    }
+    const sortedMeasures = Array.from(noteData.keys()).sort((a, b) => a - b);
+    let activeTimeScaleGroup = -1;
+    for (const measure of sortedMeasures) {
+        const headerMap = noteData.get(measure);
+        const sortedHeaders = Array.from(headerMap.keys()).sort();
+        for (const header of sortedHeaders) {
+            const notes = headerMap.get(header);
+            if (!notes || notes.length === 0)
+                continue;
+            const noteTimeScaleGroup = notes[0].timeScaleGroup;
+            const tilId = tilIdMap.get(noteTimeScaleGroup);
+            if (noteTimeScaleGroup !== activeTimeScaleGroup && tilId !== undefined) {
+                susLines.push(`#HISPEED ${tilId}`);
+                activeTimeScaleGroup = noteTimeScaleGroup;
+            }
+            if (header.endsWith("02") || header.endsWith("08")) {
+                susLines.push(`#${header}: ${notes[0].value}`);
+                continue;
+            }
+            const granularity = 1920;
+            const data = Array(granularity).fill("00");
+            for (const note of notes) {
+                const index = Math.floor((note.tick / ticksPerMeasure) * granularity);
+                if (index < granularity) {
+                    data[index] = note.value;
+                }
+            }
+            susLines.push(`#${header}: ${data.join("")}`);
+        }
+    }
+    return susLines.join("\r\n");
+    // --- Helper Functions ---
+    function addNoteData(measure, header, tickInMeasure, value, timeScaleGroup) {
+        if (!noteData.has(measure))
+            noteData.set(measure, new Map());
+        const headerMap = noteData.get(measure);
+        if (!headerMap.has(header))
+            headerMap.set(header, []);
+        headerMap.get(header).push({ tick: tickInMeasure, value, timeScaleGroup });
+    }
+    function getSusLaneAndWidth(uscLane, uscSize) {
+        const susWidth = Math.round(uscSize * 2);
+        const susLane = Math.round(uscLane - uscSize + 8);
+        return [Math.max(0, susLane), Math.max(1, susWidth)];
+    }
+    function addTapNote(beat, lane, width, noteType, timeScaleGroup) {
+        const tick = beat * TICKS_PER_BEAT;
+        const measure = Math.floor(tick / ticksPerMeasure);
+        const tickInMeasure = tick % ticksPerMeasure;
+        const laneHex = lane.toString(36);
+        const widthHex = width.toString(36);
+        const header = `${measure.toString().padStart(3, "0")}1${laneHex}`;
+        const value = `${noteType}${widthHex}`;
+        addNoteData(measure, header, tickInMeasure, value, timeScaleGroup);
+    }
+    function processSingleOrDamage(note) {
+        if (note.type === 'damage') {
+            const [lane, width] = getSusLaneAndWidth(note.lane, note.size);
+            addTapNote(note.beat, lane, width, "4", note.timeScaleGroup);
+            return;
+        }
+        const [lane, width] = getSusLaneAndWidth(note.lane, note.size);
+        let susNoteType = "1";
+        if (note.critical && note.trace)
+            susNoteType = "6";
+        else if (note.critical)
+            susNoteType = "2";
+        else if (note.trace)
+            susNoteType = "5";
+        addTapNote(note.beat, lane, width, susNoteType, note.timeScaleGroup);
+        if (note.direction && note.direction !== "none") {
+            let directionalType;
+            switch (note.direction) {
+                case "up":
+                    directionalType = "1";
+                    break;
+                case "left":
+                    directionalType = "3";
+                    break;
+                case "right":
+                    directionalType = "4";
+                    break;
+                default: return;
+            }
+            const [dirLane, dirWidth] = getSusLaneAndWidth(note.lane, note.size);
+            const tick = note.beat * TICKS_PER_BEAT;
+            const measure = Math.floor(tick / ticksPerMeasure);
+            const tickInMeasure = tick % ticksPerMeasure;
+            const dirHeader = `${measure.toString().padStart(3, "0")}5${dirLane.toString(36)}`;
+            const dirValue = `${directionalType}${dirWidth.toString(36)}`;
+            addNoteData(measure, dirHeader, tickInMeasure, dirValue, note.timeScaleGroup);
+        }
+    }
+    // ▼▼▼ 'tick', 'hidden', 'skip' 개념을 최종적으로 수정한 `processSlide` 함수 ▼▼▼
+    function processSlide(slide) {
+        const channel = (slideChannelCounter % 36).toString(36);
+        const sortedConnections = [...slide.connections].sort((a, b) => a.beat - b.beat);
+        let lastKnownLane = 0;
+        let lastKnownWidth = 0;
+        for (const conn of sortedConnections) {
+            const tick = conn.beat * TICKS_PER_BEAT;
+            const measure = Math.floor(tick / ticksPerMeasure);
+            const tickInMeasure = tick % ticksPerMeasure;
+            const timeScaleGroup = conn.timeScaleGroup ?? 0;
+            // --- 3가지 규칙에 따른 분기 처리 ---
+            if (conn.type === "tick") {
+                // `critical` 속성 존재 여부로 '일반 Tick'과 'Hidden'을 구분합니다.
+                if (conn.critical !== undefined) {
+                    // --- 일반 Tick 처리 ---
+                    // 경로에 영향을 주는 보이는 경유점(타입 3)을 생성합니다.
+                    const [lane, width] = getSusLaneAndWidth(conn.lane, conn.size);
+                    lastKnownLane = lane;
+                    lastKnownWidth = width;
+                    const laneHex = lane.toString(36);
+                    const header = `${measure.toString().padStart(3, "0")}3${laneHex}${channel}`;
+                    const value = `3${width.toString(36)}`;
+                    addNoteData(measure, header, tickInMeasure, value, timeScaleGroup);
+                }
+                else {
+                    // --- Hidden 노트 처리 ---
+                    // 경로에 영향을 주는 보이지 않는 경유점(타입 5)을 생성합니다.
+                    // 위치는 직전 노트의 것을 그대로 사용합니다.
+                    const laneHex = lastKnownLane.toString(36);
+                    const widthHex = lastKnownWidth.toString(36);
+                    const header = `${measure.toString().padStart(3, "0")}3${laneHex}${channel}`;
+                    const value = `5${widthHex}`;
+                    addNoteData(measure, header, tickInMeasure, value, timeScaleGroup);
+                }
+            }
+            else if (conn.type === "attach") {
+                // --- Skip 노트 처리 ---
+                // 경로에 영향을 주지 않으므로 아무것도 생성하지 않고 건너뜁니다.
+                continue;
+            }
+            else {
+                // --- Start, End 노트 처리 ---
+                const [lane, width] = getSusLaneAndWidth(conn.lane, conn.size);
+                lastKnownLane = lane;
+                lastKnownWidth = width;
+                const isCritical = slide.critical || conn.critical;
+                let markerType = null;
+                if ("judgeType" in conn) {
+                    if (conn.judgeType === "none")
+                        markerType = isCritical ? "8" : "7";
+                    else if (conn.judgeType === "trace")
+                        markerType = isCritical ? "6" : "5";
+                }
+                if (conn.type === "start" && isCritical && markerType === null) {
+                    markerType = "2";
+                }
+                if (markerType) {
+                    addTapNote(conn.beat, lane, width, markerType, timeScaleGroup);
+                }
+                if ("ease" in conn && conn.ease) {
+                    let easeType = conn.ease;
+                    if (easeType === 'inout')
+                        easeType = 'in';
+                    if (easeType === 'outin')
+                        easeType = 'out';
+                    let directionalType = null;
+                    if (easeType === 'in')
+                        directionalType = '2';
+                    else if (easeType === 'out')
+                        directionalType = '5';
+                    if (directionalType) {
+                        const laneHex = lane.toString(36);
+                        const widthHex = width.toString(36);
+                        const dirHeader = `${measure.toString().padStart(3, "0")}5${laneHex}`;
+                        const dirValue = `${directionalType}${widthHex}`;
+                        addNoteData(measure, dirHeader, tickInMeasure, dirValue, timeScaleGroup);
+                    }
+                }
+                const noteType = conn.type === "start" ? "1" : "2";
+                const laneHex = lane.toString(36);
+                const header = `${measure.toString().padStart(3, "0")}3${laneHex}${channel}`;
+                const value = `${noteType}${width.toString(36)}`;
+                addNoteData(measure, header, tickInMeasure, value, timeScaleGroup);
+                if (conn.type === "end" && conn.direction) {
+                    let directionalType;
+                    switch (conn.direction) {
+                        case "up":
+                            directionalType = "1";
+                            break;
+                        case "left":
+                            directionalType = "3";
+                            break;
+                        case "right":
+                            directionalType = "4";
+                            break;
+                        default: continue;
+                    }
+                    const dirHeader = `${measure.toString().padStart(3, "0")}5${laneHex}`;
+                    const dirValue = `${directionalType}${width.toString(36)}`;
+                    addNoteData(measure, dirHeader, tickInMeasure, dirValue, timeScaleGroup);
+                }
+            }
+        }
+    }
+    function processGuide(guide) {
+        const channel = (slideChannelCounter % 36).toString(36);
+        const sortedMidpoints = [...guide.midpoints].sort((a, b) => a.beat - b.beat);
+        sortedMidpoints.forEach((midpoint, index) => {
+            const tick = midpoint.beat * TICKS_PER_BEAT;
+            const measure = Math.floor(tick / ticksPerMeasure);
+            const tickInMeasure = tick % ticksPerMeasure;
+            let noteType;
+            if (index === 0)
+                noteType = "1";
+            else if (index === sortedMidpoints.length - 1)
+                noteType = "2";
+            else
+                noteType = "3";
+            const [lane, width] = getSusLaneAndWidth(midpoint.lane, midpoint.size);
+            const laneHex = lane.toString(36);
+            const widthHex = width.toString(36);
+            if (guide.fade === "in" && index === 0) {
+                const dirHeader = `${measure.toString().padStart(3, "0")}5${laneHex}`;
+                const dirValue = `2${widthHex}`;
+                addNoteData(measure, dirHeader, tickInMeasure, dirValue, midpoint.timeScaleGroup);
+            }
+            if (guide.fade === "out" && index === sortedMidpoints.length - 1) {
+                const dirHeader = `${measure.toString().padStart(3, "0")}5${laneHex}`;
+                const dirValue = `5${widthHex}`;
+                addNoteData(measure, dirHeader, tickInMeasure, dirValue, midpoint.timeScaleGroup);
+            }
+            if (midpoint.ease) {
+                let easeType = midpoint.ease;
+                if (easeType === 'inout')
+                    easeType = 'in';
+                if (easeType === 'outin')
+                    easeType = 'out';
+                let directionalType = null;
+                if (easeType === 'in')
+                    directionalType = '2';
+                else if (easeType === 'out')
+                    directionalType = '5';
+                if (directionalType) {
+                    const dirHeader = `${measure.toString().padStart(3, "0")}5${laneHex}`;
+                    const dirValue = `${directionalType}${widthHex}`;
+                    addNoteData(measure, dirHeader, tickInMeasure, dirValue, midpoint.timeScaleGroup);
+                }
+            }
+            const header = `${measure.toString().padStart(3, "0")}9${laneHex}${channel}`;
+            const value = `${noteType}${widthHex}`;
+            addNoteData(measure, header, tickInMeasure, value, midpoint.timeScaleGroup);
+        });
+    }
+};
+exports.uscToSUS = uscToSUS;

package/dist/sus/decode.d.cts

@@ -0,0 +1 @@
+export declare const uscToSUS: (uscData: any) => string;

package/dist/sus/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USCFade = exports.USCColor = void 0;
+exports.USCColor = {
+    neutral: 0,
+    red: 1,
+    green: 2,
+    blue: 3,
+    yellow: 4,
+    purple: 5,
+    cyan: 6,
+    black: 7,
+};
+exports.USCFade = {
+    in: 2,
+    out: 0,
+    none: 1,
+};

package/dist/{usc/index.d.ts → sus/index.d.cts}

@@ -7,12 +7,12 @@ type BaseUSCObject = {
     beat: number;
     timeScaleGroup: number;
 };
-export type USCBpmChange = Omit<BaseUSCObject, "timeScaleGroup"> & {
-    type: "bpm";
+export type USCBpmChange = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'bpm';
     bpm: number;
 };
 export type USCTimeScaleChange = {
-    type: "timeScaleGroup";
+    type: 'timeScaleGroup';
     changes: {
         beat: number;
         timeScale: number;
@@ -23,38 +23,38 @@ type BaseUSCNote = BaseUSCObject & {
     size: number;
 };
 export type USCSingleNote = BaseUSCNote & {
-    type: "single";
+    type: 'single';
     critical: boolean;
     trace: boolean;
-    direction?: "left" | "up" | "right" | "none";
+    direction?: 'left' | 'up' | 'right' | 'none';
 };
 export type USCDamageNote = BaseUSCNote & {
-    type: "damage";
+    type: 'damage';
 };
 export type USCConnectionStartNote = BaseUSCNote & {
-    type: "start";
+    type: 'start';
     critical: boolean;
-    ease: "out" | "linear" | "in" | "inOut" | "outIn";
-    judgeType: "normal" | "trace" | "none";
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+    judgeType: 'normal' | 'trace' | 'none';
 };
 export type USCConnectionTickNote = BaseUSCNote & {
-    type: "tick";
+    type: 'tick';
     critical?: boolean;
-    ease: "out" | "linear" | "in" | "inOut" | "outIn";
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
 };
-export type USCConnectionAttachNote = Omit<BaseUSCObject, "timeScaleGroup"> & {
-    type: "attach";
+export type USCConnectionAttachNote = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'attach';
     critical?: boolean;
     timeScaleGroup?: number;
 };
 export type USCConnectionEndNote = BaseUSCNote & {
-    type: "end";
+    type: 'end';
     critical: boolean;
-    direction?: "left" | "up" | "right";
-    judgeType: "normal" | "trace" | "none";
+    direction?: 'left' | 'up' | 'right';
+    judgeType: 'normal' | 'trace' | 'none';
 };
 export type USCSlideNote = {
-    type: "slide";
+    type: 'slide';
     critical: boolean;
     connections: [
         USCConnectionStartNote,
@@ -74,7 +74,7 @@ export declare const USCColor: {
 };
 export type USCColor = keyof typeof USCColor;
 export type USCGuideMidpointNote = BaseUSCNote & {
-    ease: "out" | "linear" | "in" | "inOut" | "outIn";
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
 };
 export declare const USCFade: {
     in: number;
@@ -83,7 +83,7 @@ export declare const USCFade: {
 };
 export type USCFade = keyof typeof USCFade;
 export type USCGuideNote = {
-    type: "guide";
+    type: 'guide';
     color: USCColor;
     fade: USCFade;
     midpoints: USCGuideMidpointNote[];