sonolus-d4dj-engine 1.1.1

package/README.md

@@ -0,0 +1,88 @@
+# Sonolus D4DJ Engine
+
+A recreation of D4DJ Groovy Mix engine in Sonolus.
+
+Unfinished.
+
+Todo list:
+
+- [x] Finish writing play mode
+- [x] Make it customizable
+- [x] Finish writing tutorial mode
+- [x] Finish writing preview mode
+- [x] Finish writing watch mode
+- [ ] Designed particle effect for D4DJ
+
+## Links
+
+-   [Sonolus Website](https://sonolus.com)
+-   [Sonolus Wiki](https://github.com/NonSpicyBurrito/sonolus-wiki)
+
+## Installation
+
+```
+npm install sonolus-bandori-engine
+```
+
+## Custom Resources
+
+### Skin Sprites
+
+| Name                                          |
+| --------------------------------------------- |
+| `DJ Stage`                                    |
+| `DJ Scratch Note`                             |
+| `DJ Scratch Arrow`                            |
+| `DJ Slider`                                   |
+| `DJ Slider Bar`                               |
+| `DJ Line`                                     |
+
+### Effect Clips
+
+| Name                                          |
+| --------------------------------------------- |
+| `DJ Scratch Empty`                            |
+| `DJ Scratch Perfect`                          |
+| `DJ Tap 1 Good`                               |
+| `DJ Tap 1 Great`                              |
+| `DJ Tap 1 Perfect`                            |
+| `DJ Tap 2 Good`                               |
+| `DJ Tap 2 Great`                              |
+| `DJ Tap 2 Perfect`                            |
+| `DJ Long Good`                                |
+| `DJ Long Great`                               |
+| `DJ Long Perfect`                             |
+| `DJ Slider Good`                              |
+| `DJ Slider Great`                             |
+| `DJ Slider Perfect`                           |
+| `DJ Slider Flick Perfect`                     |
+
+## Documentation
+
+### `version`
+
+Package version.
+
+### `databaseEngineItem`
+
+Partial database engine item compatible with [sonolus-express](https://github.com/NonSpicyBurrito/sonolus-express).
+
+### `b34djToLevelData(chart, offset?)`
+
+Converts D4DJ (bangbangboom-editor) chart to Level Data.
+
+-   `chart`: D4DJ chart.
+-   `offset`: offset (default: `0`).
+
+### Assets
+
+The following assets are exposed as package entry points:
+
+-   `EngineConfiguration`
+-   `EnginePlayData`
+-   `EngineWatchData`
+-   `EnginePreviewData`
+-   `EngineTutorialData`
+-   `EngineThumbnail`
+
+In Node.js, you can obtain path to assets using `require.resolve('sonolus-d4dj-engine/EngineConfiguration')` or `import.meta.resolve('sonolus-d4dj-engine/EngineConfiguration')`.

package/dist/b34dj/convert.cjs

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.b34djToLevelData = void 0;
+function b34djToLevelData(chartData, offset = 0) {
+    let chart = Object.values(chartData);
+    chart[2] = chart[2].map((obj) => Object.values(obj));
+    chart[3] = chart[3].map((obj) => Object.values(obj));
+    const timescale = chart[2];
+    chart[2] = [];
+    timescale.forEach((ts) => {
+        const i = chart[2].findIndex((tsc) => (tsc[0] === ts[0]) && (tsc[1] === ts[1]));
+        if (i === -1)
+            chart[2].push(ts);
+        else
+            chart[2][i][2] = 3;
+    });
+    chart = JSON.parse(JSON.stringify(chart)
+        .replaceAll('"Tap1"', "0")
+        .replaceAll('"Tap2"', "1")
+        .replaceAll('"ScratchLeft"', "2")
+        .replaceAll('"ScratchRight"', "3")
+        .replaceAll('"StopStart"', "4")
+        .replaceAll('"StopEnd"', "5")
+        .replaceAll('"LongStart"', "6")
+        .replaceAll('"LongMiddle"', "7")
+        .replaceAll('"LongEnd"', "8")
+        .replaceAll('"Slide"', "9"));
+    const temp = chart[1];
+    chart[1] = chart[2];
+    chart[2] = temp;
+    chart[3] = chart[3].map((note) => {
+        const temp = note[1];
+        note[1] = note[2];
+        note[2] = temp;
+        return note;
+    });
+    return parse(chart, offset);
+}
+exports.b34djToLevelData = b34djToLevelData;
+;
+function parse(chart, offset = 0) {
+    let sus = {
+        bgmOffset: offset,
+        entities: [
+            {
+                archetype: "Initialization",
+                data: [],
+            },
+            {
+                archetype: "Stage",
+                data: [],
+            },
+            {
+                archetype: "#BPM_CHANGE",
+                data: [
+                    {
+                        name: "#TIME",
+                        value: 0,
+                    },
+                    {
+                        name: "#BPM",
+                        value: 60,
+                    },
+                ],
+            },
+            {
+                archetype: "TimeScaleGroup",
+                data: [
+                    {
+                        name: "first",
+                        ref: "tsc:0:0",
+                    },
+                    {
+                        name: "length",
+                        value: chart[1].length + 1,
+                    },
+                    {
+                        name: "next",
+                        ref: "tsg:1",
+                    },
+                ],
+                name: "tsg:0",
+            },
+            {
+                archetype: "TimeScaleGroup",
+                data: [
+                    {
+                        name: "first",
+                        ref: "tsc:1:0",
+                    },
+                    {
+                        name: "length",
+                        value: 1,
+                    },
+                    {
+                        name: "next",
+                        ref: "tsg:2",
+                    },
+                ],
+                name: "tsg:1",
+            },
+            {
+                archetype: "TimeScaleGroup",
+                data: [
+                    {
+                        name: "first",
+                        ref: "tsc:2:0",
+                    },
+                    {
+                        name: "length",
+                        value: 1,
+                    },
+                    {
+                        name: "next",
+                        ref: "tsg:3",
+                    },
+                ],
+                name: "tsg:2",
+            },
+            {
+                archetype: "TimeScaleChange",
+                data: [
+                    {
+                        name: "#BEAT",
+                        value: 0,
+                    },
+                    {
+                        name: "timeScale",
+                        value: 1,
+                    },
+                    {
+                        name: "next",
+                        ref: `tsc:0:1`,
+                    },
+                ],
+                name: `tsc:0:0`,
+            },
+            {
+                archetype: "TimeScaleChange",
+                data: [
+                    {
+                        name: "#BEAT",
+                        value: 0,
+                    },
+                    {
+                        name: "timeScale",
+                        value: 1,
+                    },
+                    {
+                        name: "next",
+                        value: -1,
+                    },
+                ],
+                name: `tsc:1:0`,
+            },
+            {
+                archetype: "TimeScaleChange",
+                data: [
+                    {
+                        name: "#BEAT",
+                        value: 0,
+                    },
+                    {
+                        name: "timeScale",
+                        value: 1,
+                    },
+                    {
+                        name: "next",
+                        value: -1,
+                    },
+                ],
+                name: `tsc:2:0`,
+            },
+        ],
+    };
+    let ts = chart[1].map((arr, i) => ({
+        archetype: "TimeScaleChange",
+        data: [
+            {
+                name: "#BEAT",
+                value: arr[0],
+            },
+            {
+                name: "timeScale",
+                value: arr[1],
+            },
+            {
+                name: "disc",
+                value: arr[2],
+            },
+            {
+                name: "next",
+                ref: `tsc:0:${i + 2}`,
+            },
+        ],
+        name: `tsc:0:${i + 1}`,
+    }));
+    let bl = chart[2].map((time) => ({
+        archetype: "BarLine",
+        data: [
+            {
+                name: "#BEAT",
+                value: time,
+            },
+            {
+                name: "timeScaleGroup",
+                ref: "tsg:0",
+            },
+        ],
+    }));
+    let notes = note(chart);
+    sus.entities.push(...ts, ...notes, ...bl);
+    return sus;
+}
+function note(chart) {
+    let hold = [];
+    let slider = [];
+    let notes = {};
+    let sol = chart[3].map((arr, i) => {
+        const sus = {
+            archetype: arr[1] === 0
+                ? "DarkTapNote"
+                : arr[1] === 1
+                    ? "LightTapNote"
+                    : arr[1] === 2 || arr[1] === 3
+                        ? "ScratchNote"
+                        : arr[1] === 4
+                            ? "StopStartNote"
+                            : arr[1] === 5
+                                ? "StopEndNote"
+                                : arr[1] === 6
+                                    ? "HoldStartNote"
+                                    : arr[1] === 8
+                                        ? "HoldEndNote"
+                                        : arr[1] === 7
+                                            ? "HoldMiddleNote"
+                                            : arr[4] !== 0
+                                                ? "SliderFlickNote"
+                                                : "SliderTickNote",
+            data: [
+                {
+                    name: "#BEAT",
+                    value: arr[2],
+                },
+                {
+                    name: "lane",
+                    value: arr[0] - 3,
+                },
+                {
+                    name: "timeScaleGroup",
+                    ref: arr[0] === 0
+                        ? "tsg:1"
+                        : arr[0] === 6
+                            ? "tsg:2"
+                            : "tsg:0",
+                },
+            ],
+            name: `note${i}`,
+        };
+        notes[arr[2]]
+            ? notes[arr[2]].push({ name: `note${i}`, lane: arr[0] })
+            : (notes[arr[2]] = [{ name: `note${i}`, lane: arr[0] }]);
+        if (arr[3] && (arr[1] === 4 || arr[1] === 6)) {
+            let note = {};
+            note.head = sus.name;
+            note.tail = `note${arr[3]}`;
+            hold.push(note);
+            sus.data.push({
+                name: "tail",
+                ref: `note${arr[3]}`,
+            });
+        }
+        if (arr[1] === 9) {
+            if (arr[3] > 0) {
+                slider.push({ prev: sus.name, next: `note${arr[3]}` });
+                sus.data.push({
+                    name: "next",
+                    ref: `note${arr[3]}`,
+                });
+            }
+            const sld = slider.find((note) => note.next === sus.name);
+            if (sld)
+                sus.data.push({
+                    name: "prev",
+                    ref: sld.prev,
+                });
+        }
+        if (arr[1] === 5 || arr[1] === 8) {
+            sus.data.push({
+                name: "head",
+                ref: hold.find((note) => note.tail === sus.name).head,
+            });
+        }
+        if (arr[4])
+            sus.data.push({
+                name: "direction",
+                value: arr[4],
+            });
+        return sus;
+    });
+    hold.forEach(({ head, tail }, i) => sol.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) {
+            sol.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[0].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[1].name,
+                    },
+                ],
+            });
+        }
+        else if (sim.length === 3) {
+            sol.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[0].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[1].name,
+                    },
+                ],
+            });
+            sol.push({
+                archetype: "SimLine",
+                data: [
+                    {
+                        name: "a",
+                        ref: sim[1].name,
+                    },
+                    {
+                        name: "b",
+                        ref: sim[2].name,
+                    },
+                ],
+            });
+        }
+    }
+    return sol;
+}

package/dist/b34dj/convert.d.cts

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

package/dist/b34dj/index.cjs

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

package/dist/b34dj/index.d.cts

@@ -0,0 +1,19 @@
+export type B34DJChart = {
+    MusicName: "music_0000001";
+    BarLineList: number[];
+    SoflanDataList: B34DJSoflanData[];
+};
+export type B34DJSoflanData = {
+    Time: number;
+    TimeScale: number;
+    LeftRight: number;
+};
+export type B34DJNoteData = {
+    LaneId: number;
+    Time: number;
+    Type: "Tap1" | "Tap2" | "ScratchLeft" | "ScratchRight" | "StopStart" | "StopEnd" | "LongStart" | "LongMiddle" | "LongEnd" | "Slide";
+    NextId: number;
+    Direction: number;
+    EffectType: number;
+    EffectParameter: number;
+};

package/dist/index.cjs

@@ -0,0 +1,46 @@
+"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.b34djToLevelData = void 0;
+var convert_cjs_1 = require("./b34dj/convert.cjs");
+Object.defineProperty(exports, "b34djToLevelData", { enumerable: true, get: function () { return convert_cjs_1.b34djToLevelData; } });
+__exportStar(require("./b34dj/index.cjs"), exports);
+exports.version = '1.1.1';
+exports.databaseEngineItem = {
+    name: 'd4dj',
+    version: 12,
+    title: {
+        en: 'D4DJ'
+    },
+    subtitle: {
+        en: 'D4DJ Groovy Mix',
+        ja: 'D4DJグルミク',
+    },
+    author: {
+        en: 'Gorengan Hunter',
+    },
+    description: {
+        en: [
+            'A recreation of D4DJ Groovy Mix engine in Sonolus.',
+            '',
+            'Version:',
+            exports.version,
+            '',
+            'GitHub Repository:',
+            'https://github.com/gorenganhunter/sonolus-d4dj-engine',
+        ].join('\n'),
+    },
+};

package/dist/index.d.cts

@@ -0,0 +1,20 @@
+export { b34djToLevelData } from './b34dj/convert.cjs';
+export * from './b34dj/index.cjs';
+export declare const version = "1.1.1";
+export declare const databaseEngineItem: {
+    readonly name: "d4dj";
+    readonly version: 12;
+    readonly title: {
+        readonly en: "D4DJ";
+    };
+    readonly subtitle: {
+        readonly en: "D4DJ Groovy Mix";
+        readonly ja: "D4DJグルミク";
+    };
+    readonly author: {
+        readonly en: "Gorengan Hunter";
+    };
+    readonly description: {
+        readonly en: string;
+    };
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "sonolus-d4dj-engine",
+  "version": "1.1.1",
+  "description": "A recreation of D4DJ Groovy Mix engine in Sonolus.",
+  "type": "module",
+  "author": "Gorengan Hunter",
+  "repository": "github:gorenganhunter/sonolus-d4dj-engine",
+  "license": "MIT",
+  "keywords": [
+    "Sonolus",
+    "D4DJ"
+  ],
+  "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",
+    "check-type": "tsc -p ./lib --noEmit && tsc -p ./shared --noEmit && tsc -p ./play --noEmit && tsc -p ./watch --noEmit && tsc -p ./preview --noEmit && tsc -p ./tutorial --noEmit",
+    "check-lint": "eslint .",
+    "check-format": "prettier . --check",
+    "build": "tsc -p ./lib && sonolus-cli --build ./play && sonolus-cli --build ./watch && sonolus-cli --build ./preview && sonolus-cli --build ./tutorial && node ./lib/build.mjs"
+  },
+  "dependencies": {
+    "@sonolus/core": "~7.9.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^8.57.0",
+    "@sonolus/sonolus.js": "^9.5.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.1",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "typescript": "~5.4.5",
+    "typescript-eslint": "^7.12.0"
+  }
+}