sonolus-d4dj-engine 1.1.19 → 1.2.0

package/README.md

@@ -74,6 +74,13 @@ Converts D4DJ (bangbangboom-editor) chart to Level Data.
 -   `chart`: D4DJ chart.
 -   `offset`: offset (default: `0`).
 
+### `d4cToLevelData(chart, offset?)`
+
+Converts D4C chart to Level Data.
+
+-   `chart`: D4C chart.
+-   `offset`: offset (default: `0`).
+
 ### Assets
 
 The following assets are exposed as package entry points:

package/dist/d4c/convert.cjs

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.d4cToLevelData = void 0;
+const index_cjs_1 = require("./index.cjs");
+function d4cToLevelData(chart, offset = 0) {
+    // let d4chart: any = []
+    // d4chart[0] = chart.MusicName
+    // d4chart[1] = []
+    // d4chart[2] = chart.BarLineList
+    // d4chart[3] = chart.NoteDataList.map((note: B34DJNoteData) => [note.LaneId, D4DJNoteType[note.Type], note.Time, note.NextId, note.Direction, note.EffectType, note.EffectParameter])
+    // const timescale = chart.SoflanDataList.map((soflan: B34DJSoflanData) => [soflan.Time, soflan.TimeScale, soflan.LeftRight])
+    // timescale.forEach((ts: any) => {
+    //     const i = d4chart[1].findIndex((tsc: number[]) => (tsc[0] === ts[0]) && (tsc[1] === ts[1]))
+    //     if (i === -1) d4chart[1].push(ts)
+    //     else d4chart[1][i][2] = 3
+    // })
+    let disc = {
+        left: chart.TimeScaleGroupList.flatMap(tsg => tsg.SoflanDataList).filter((soflan) => [1, 3].includes(soflan.LeftRight)).sort((a, b) => a.Beat - b.Beat),
+        right: chart.TimeScaleGroupList.flatMap(tsg => tsg.SoflanDataList).filter((soflan) => [2, 3].includes(soflan.LeftRight)).sort((a, b) => a.Beat - b.Beat)
+    };
+    chart.TimeScaleGroupList.push({ id: -4, SoflanDataList: disc.left }, { id: -3, SoflanDataList: disc.right });
+    let data = {
+        bgmOffset: chart.Offset + offset,
+        entities: [
+            {
+                archetype: "Initialization",
+                data: [],
+            },
+            {
+                archetype: "Stage",
+                data: [
+                    {
+                        name: "discTsgL",
+                        ref: "tsg:-4"
+                    },
+                    {
+                        name: "discTsgR",
+                        ref: "tsg:-3"
+                    }
+                ],
+            },
+        ],
+    };
+    let bpm = chart.BpmDataList.map(({ Bpm, Beat }) => ({
+        archetype: "#BPM_CHANGE",
+        data: [
+            {
+                name: "#BEAT",
+                value: Beat,
+            },
+            {
+                name: "#BPM",
+                value: Bpm,
+            },
+        ],
+    }));
+    let ts = chart.TimeScaleGroupList.map(({ id, SoflanDataList }) => ([
+        {
+            archetype: "TimeScaleGroup",
+            data: [
+                {
+                    name: "first",
+                    ref: `tsc:${id}:-1`,
+                },
+                {
+                    name: "length",
+                    value: SoflanDataList.length + 1,
+                }
+            ],
+            name: `tsg:${id}`,
+        },
+        {
+            archetype: "TimeScaleChange",
+            data: [
+                {
+                    name: "#BEAT",
+                    value: 0,
+                },
+                {
+                    name: "timeScale",
+                    value: 1,
+                },
+                {
+                    name: "next",
+                    ref: `tsc:${id}:0`,
+                },
+            ],
+            name: `tsc:${id}:-1`,
+        }, ...SoflanDataList.map(({ Beat, TimeScale }, i) => ({
+            archetype: "TimeScaleChange",
+            data: [
+                {
+                    name: "#BEAT",
+                    value: Beat,
+                },
+                {
+                    name: "timeScale",
+                    value: TimeScale,
+                },
+                {
+                    name: "next",
+                    ref: `tsc:${id}:${i + 1}`,
+                },
+            ],
+            name: `tsc:${id}:${i}`,
+        }))
+    ]));
+    let bl = chart.BarLine.List.map((br) => ({
+        archetype: "BarLine",
+        data: [
+            {
+                name: "#BEAT",
+                value: typeof br == "number" ? br : br.Time,
+            },
+            {
+                name: "timeScaleGroup",
+                ref: typeof br == "number" ? `tsg:${chart.BarLine.DefaultTimeScaleGroupId}` : `tsg:${br.TimeScaleGroupId || chart.BarLine.DefaultTimeScaleGroupId}`,
+            },
+        ],
+    }));
+    let notes = note(chart);
+    data.entities.push(...bpm, ...ts.flat(), ...notes, ...bl);
+    return data;
+}
+exports.d4cToLevelData = d4cToLevelData;
+function note(chart) {
+    let hold = [];
+    let slider = [];
+    let notes = {};
+    let nots = chart.NoteDataList.map(({ Beat, Type, LaneId, NextId, Direction, EffectType, EffectParameter, TimeScaleGroupId }, i) => {
+        const not = {
+            archetype: Type === index_cjs_1.D4CNoteType.Tap1
+                ? "DarkTapNote"
+                : Type === index_cjs_1.D4CNoteType.Tap2
+                    ? "LightTapNote"
+                    : Type === index_cjs_1.D4CNoteType.Scratch
+                        ? "ScratchNote"
+                        : Type === index_cjs_1.D4CNoteType.StopStart
+                            ? "StopStartNote"
+                            : Type === index_cjs_1.D4CNoteType.StopEnd
+                                ? "StopEndNote"
+                                : Type === index_cjs_1.D4CNoteType.LongStart
+                                    ? "HoldStartNote"
+                                    : Type === index_cjs_1.D4CNoteType.LongEnd
+                                        ? "HoldEndNote"
+                                        : Type === index_cjs_1.D4CNoteType.LongMiddle
+                                            ? "HoldMiddleNote"
+                                            : Direction !== 0
+                                                ? "SliderFlickNote"
+                                                : "SliderTickNote",
+            data: [
+                {
+                    name: "#BEAT",
+                    value: Beat,
+                },
+                {
+                    name: "lane",
+                    value: LaneId - 3,
+                },
+                {
+                    name: "timeScaleGroup",
+                    ref: `tsg:${TimeScaleGroupId}`,
+                },
+            ],
+            name: `note${i}`,
+        };
+        notes[Beat]
+            ? notes[Beat].push({ name: `note${i}`, lane: LaneId })
+            : (notes[Beat] = [{ name: `note${i}`, lane: LaneId }]);
+        if (NextId && (Type === index_cjs_1.D4CNoteType.LongStart || Type === index_cjs_1.D4CNoteType.StopStart)) {
+            let note = {};
+            note.head = not.name;
+            note.tail = `note${NextId}`;
+            hold.push(note);
+            not.data.push({
+                name: "tail",
+                ref: `note${NextId}`,
+            });
+        }
+        if (Type === index_cjs_1.D4CNoteType.Slide) {
+            if (NextId && NextId > 0) {
+                slider.push({ prev: not.name, next: `note${NextId}` });
+                not.data.push({
+                    name: "next",
+                    ref: `note${NextId}`,
+                });
+            }
+            const sld = slider.find((note) => note.next === not.name);
+            if (sld)
+                not.data.push({
+                    name: "prev",
+                    ref: sld.prev,
+                });
+        }
+        if (Type === index_cjs_1.D4CNoteType.LongEnd || Type === index_cjs_1.D4CNoteType.StopEnd) {
+            not.data.push({
+                name: "head",
+                ref: hold.find((note) => note.tail === not.name).head,
+            });
+        }
+        if (Direction)
+            not.data.push({
+                name: "direction",
+                value: Direction,
+            });
+        return not;
+    });
+    hold.forEach(({ head, tail }, i) => nots.splice(parseInt(head.replace("note", "")) + 1 + i, 0, {
+        archetype: "HoldConnector",
+        data: [
+            {
+                name: "head",
+                ref: head,
+            },
+            {
+                name: "tail",
+                ref: tail,
+            },
+        ],
+    }));
+    for (const beat in notes) {
+        const sim = notes[beat].sort((a, b) => a.lane - b.lane);
+        if (sim.length === 2) {
+            nots.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[0].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[1].name,
+                    },
+                ],
+            });
+        }
+        else if (sim.length === 3) {
+            nots.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[0].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[1].name,
+                    },
+                ],
+            });
+            nots.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[1].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[2].name,
+                    },
+                ],
+            });
+        }
+    }
+    return nots;
+}

package/dist/d4c/convert.d.cts

@@ -0,0 +1,3 @@
+import { LevelData } from '@sonolus/core';
+import { D4CChartData } from './index.cjs';
+export declare function d4cToLevelData(chart: D4CChartData, offset?: number): LevelData;

package/dist/d4c/index.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.D4CNoteType = void 0;
+var D4CNoteType;
+(function (D4CNoteType) {
+    D4CNoteType["Tap1"] = "Tap1";
+    D4CNoteType["Tap2"] = "Tap2";
+    D4CNoteType["Scratch"] = "Scratch";
+    D4CNoteType["StopStart"] = "StopStart";
+    D4CNoteType["StopEnd"] = "StopEnd";
+    D4CNoteType["LongStart"] = "LongStart";
+    D4CNoteType["LongMiddle"] = "LongMiddle";
+    D4CNoteType["LongEnd"] = "LongEnd";
+    D4CNoteType["Slide"] = "Slide";
+})(D4CNoteType || (exports.D4CNoteType = D4CNoteType = {}));

package/dist/d4c/index.d.cts

@@ -0,0 +1,48 @@
+export declare enum D4CNoteType {
+    Tap1 = "Tap1",
+    Tap2 = "Tap2",
+    Scratch = "Scratch",
+    StopStart = "StopStart",
+    StopEnd = "StopEnd",
+    LongStart = "LongStart",
+    LongMiddle = "LongMiddle",
+    LongEnd = "LongEnd",
+    Slide = "Slide"
+}
+export type D4CNoteData = {
+    LaneId: number;
+    Type: D4CNoteType;
+    Beat: number;
+    NextId?: number;
+    TimeScaleGroupId: number;
+    Direction?: number;
+    EffectType?: number;
+    EffectParameter?: number;
+};
+export type D4CSoflanData = {
+    Beat: number;
+    TimeScale: number;
+    LeftRight: number;
+};
+export type D4CSoflanGroup = {
+    id: number;
+    SoflanDataList: D4CSoflanData[];
+};
+export type D4CBarLineData = number | {
+    Time: number;
+    TimeScaleGroupId?: string;
+};
+export type D4CChartData = {
+    Offset: number;
+    BpmDataList: D4CBpmData[];
+    TimeScaleGroupList: D4CSoflanGroup[];
+    BarLine: {
+        DefaultTimeScaleGroupId: number;
+        List: D4CBarLineData[];
+    };
+    NoteDataList: D4CNoteData[];
+};
+export type D4CBpmData = {
+    Beat: number;
+    Bpm: number;
+};

package/dist/index.cjs

@@ -14,12 +14,15 @@ 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.d4djToLevelData = exports.b34djToLevelData = void 0;
+exports.databaseEngineItem = exports.version = exports.d4cToLevelData = exports.d4djToLevelData = exports.b34djToLevelData = void 0;
 var convert_cjs_1 = require("./b34dj/convert.cjs");
 Object.defineProperty(exports, "b34djToLevelData", { enumerable: true, get: function () { return convert_cjs_1.b34djToLevelData; } });
 Object.defineProperty(exports, "d4djToLevelData", { enumerable: true, get: function () { return convert_cjs_1.d4djToLevelData; } });
+var convert_cjs_2 = require("./d4c/convert.cjs");
+Object.defineProperty(exports, "d4cToLevelData", { enumerable: true, get: function () { return convert_cjs_2.d4cToLevelData; } });
 __exportStar(require("./b34dj/index.cjs"), exports);
-exports.version = '1.1.19';
+__exportStar(require("./d4c/index.cjs"), exports);
+exports.version = '1.2.0';
 exports.databaseEngineItem = {
     name: 'd4dj',
     version: 12,

package/dist/index.d.cts

@@ -1,6 +1,8 @@
 export { b34djToLevelData, d4djToLevelData } from './b34dj/convert.cjs';
+export { d4cToLevelData } from './d4c/convert.cjs';
 export * from './b34dj/index.cjs';
-export declare const version = "1.1.19";
+export * from './d4c/index.cjs';
+export declare const version = "1.2.0";
 export declare const databaseEngineItem: {
     readonly name: "d4dj";
     readonly version: 12;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-d4dj-engine",
-  "version": "1.1.19",
+  "version": "1.2.0",
   "description": "A recreation of D4DJ Groovy Mix engine in Sonolus.",
   "type": "module",
   "author": "Gorengan Hunter",