sonolus-bandori-engine 0.6.5

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 NonSpicyBurrito
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# Sonolus Bandori Engine
+
+A recreation of BanG Dream! Girls Band Party engine in [Sonolus](https://sonolus.com).
+
+## Links
+
+-   [Sonolus Website](https://sonolus.com)
+-   [Sonolus Wiki](https://github.com/NonSpicyBurrito/sonolus-wiki)
+
+## Installation
+
+```
+npm install sonolus-bandori-engine --save
+```
+
+## Custom Resources
+
+Engine ID: `1`
+
+### Skin Sprites
+
+| ID  | Sprite        | Bandori Asset Path                                |
+| --- | ------------- | ------------------------------------------------- |
+| 1   | Stage         | `/ingameskin/fieldskin/{name}/bg_line_rhythm.png` |
+| 2   | Judgment Line | `/ingameskin/fieldskin/{name}/game_play_line.png` |
+
+### Effect Clips
+
+| ID  | Sprite                   | Bandori Asset Path                             |
+| --- | ------------------------ | ---------------------------------------------- |
+| 1   | Directional Flick Single | `/sound/tapseskin/{name}/directional_fl.mp3`   |
+| 2   | Directional Flick Double | `/sound/tapseskin/{name}/directional_fl_2.mp3` |
+| 3   | Directional Flick Triple | `/sound/tapseskin/{name}/directional_fl_3.mp3` |
+
+## Documentation
+
+### `version`
+
+Package version.
+
+### `engineInfo`
+
+Partial engine information compatible with [sonolus-express](https://github.com/NonSpicyBurrito/sonolus-express).
+
+### `engineConfiguration`
+
+Engine Configuration.
+
+-   `engineConfiguration.path`: path to file.
+-   `engineConfiguration.buffer`: buffer of file.
+-   `engineConfiguration.hash`: hash of file.
+
+### `engineData`
+
+Engine Data.
+
+-   `engineData.path`: path to file.
+-   `engineData.buffer`: buffer of file.
+-   `engineData.hash`: hash of file.
+
+### `engineThumbnail`
+
+Engine Thumbnail.
+
+-   `engineThumbnail.path`: path to file.
+-   `engineThumbnail.buffer`: buffer of file.
+-   `engineThumbnail.hash`: hash of file.
+
+### `fromBestdori(chart)`
+
+Converts Bestdori chart to Level Data.
+
+-   `chart`: Bestdori chart.

package/dist/Resource.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export declare class Resource {
+    readonly path: string;
+    private _hash?;
+    private _buffer?;
+    constructor(path: string);
+    get hash(): string;
+    get buffer(): Buffer;
+}

package/dist/Resource.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+class Resource {
+    constructor(path) {
+        this.path = path_1.resolve(__dirname, path);
+    }
+    get hash() {
+        if (!this._hash) {
+            this._hash = crypto_1.createHash('sha1').update(this.buffer).digest('hex');
+        }
+        return this._hash;
+    }
+    get buffer() {
+        if (!this._buffer) {
+            this._buffer = fs_1.readFileSync(this.path);
+        }
+        return this._buffer;
+    }
+}
+exports.Resource = Resource;

package/dist/archetypes.json

@@ -0,0 +1 @@
+{"initializationIndex":0,"stageIndex":1,"tapNoteIndex":2,"flickNoteIndex":3,"directionalFlickNoteIndex":4,"slideStartNoteIndex":5,"slideTickNoteIndex":6,"slideEndNoteIndex":7,"slideFlickNoteIndex":8,"straightSliderIndex":9,"curvedSliderIndex":10}

package/dist/convert.d.ts

@@ -0,0 +1,52 @@
+import { SLevelData } from 'sonolus.js';
+export declare type ChartObject = SingleObject | DirectionalObject | SlideObject | LongObject | BPMObject | SystemObject;
+declare type ObjectBase = {
+    beat: number;
+};
+declare type NoteBase = ObjectBase & {
+    lane: number;
+    flick?: true;
+    skill?: true;
+    charge?: true;
+};
+declare type SingleObject = NoteBase & {
+    type: 'Single';
+};
+declare type DirectionalObject = NoteBase & {
+    type: 'Directional';
+    direction: 'Left' | 'Right';
+    width: number;
+};
+declare type SlideObject = {
+    type: 'Slide';
+    connections: Connection[];
+};
+declare type LongObject = {
+    type: 'Long';
+    connections: Connection[];
+};
+declare type Connection = NoteBase & {
+    hidden?: true;
+};
+declare type BPMObject = ObjectBase & {
+    type: 'BPM';
+    bpm: number;
+};
+declare type SystemObject = ObjectBase & {
+    type: 'System';
+    data: string;
+};
+export declare function fromBestdori(chart: ChartObject[], archetypes: {
+    initializationIndex: number;
+    stageIndex: number;
+    tapNoteIndex: number;
+    flickNoteIndex: number;
+    directionalFlickNoteIndex: number;
+    slideStartNoteIndex: number;
+    slideTickNoteIndex: number;
+    slideEndNoteIndex: number;
+    slideFlickNoteIndex: number;
+    straightSliderIndex: number;
+    curvedSliderIndex: number;
+}): SLevelData;
+export {};

package/dist/convert.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBestdori = void 0;
+function fromBestdori(chart, archetypes) {
+    const chartObjects = repair(chart);
+    const timings = [];
+    let timePerBeat = 0;
+    let beats = 0;
+    let time = 0;
+    chartObjects
+        .filter((chartObject) => chartObject.type === 'BPM')
+        .sort((a, b) => a.beat - b.beat)
+        .forEach((bpmObject) => {
+        time += (bpmObject.beat - beats) * timePerBeat;
+        beats = bpmObject.beat;
+        timePerBeat = 60 / bpmObject.bpm;
+        timings.unshift({
+            beat: beats,
+            time,
+            timePerBeat,
+        });
+    });
+    const wrappedNoteEntities = [
+        {
+            entity: {
+                archetype: archetypes.initializationIndex,
+            },
+            time: Number.NEGATIVE_INFINITY,
+            lane: 0,
+        },
+        {
+            entity: {
+                archetype: archetypes.stageIndex,
+            },
+            time: Number.NEGATIVE_INFINITY,
+            lane: 0,
+        },
+    ];
+    const wrappedSliderEntities = [];
+    chartObjects.forEach((chartObject) => {
+        switch (chartObject.type) {
+            case 'Single': {
+                const time = beatToTime(chartObject.beat);
+                const lane = chartObject.lane - 3;
+                wrappedNoteEntities.push({
+                    entity: {
+                        archetype: chartObject.flick
+                            ? archetypes.flickNoteIndex
+                            : archetypes.tapNoteIndex,
+                        data: {
+                            index: 1,
+                            values: [time, lane],
+                        },
+                    },
+                    time,
+                    lane,
+                });
+                break;
+            }
+            case 'Directional': {
+                const time = beatToTime(chartObject.beat);
+                const lane = chartObject.lane - 3;
+                wrappedNoteEntities.push({
+                    entity: {
+                        archetype: archetypes.directionalFlickNoteIndex,
+                        data: {
+                            index: 1,
+                            values: [
+                                time,
+                                lane,
+                                chartObject.width - 1,
+                                chartObject.direction === 'Left' ? 1 : 0,
+                            ],
+                        },
+                    },
+                    time,
+                    lane,
+                });
+                break;
+            }
+            case 'Slide':
+            case 'Long': {
+                let segments = [];
+                const hasHidden = chartObject.connections.some((connection) => connection.hidden);
+                const canBeLong = chartObject.connections.length === 2 &&
+                    chartObject.connections[0].lane ===
+                        chartObject.connections[1].lane
+                    ? 1
+                    : 0;
+                chartObject.connections.forEach((connection, index) => {
+                    const time = beatToTime(connection.beat);
+                    const lane = connection.lane - 3;
+                    if (connection.hidden) {
+                        segments.push({
+                            time,
+                            lane,
+                        });
+                    }
+                    else {
+                        if (index === 0) {
+                            wrappedNoteEntities.push({
+                                entity: {
+                                    archetype: archetypes.slideStartNoteIndex,
+                                    data: {
+                                        index: 1,
+                                        values: [time, lane],
+                                    },
+                                },
+                                time,
+                                lane,
+                            });
+                        }
+                        else {
+                            const head = wrappedNoteEntities[wrappedNoteEntities.length - 1];
+                            if (index === chartObject.connections.length - 1) {
+                                wrappedNoteEntities.push({
+                                    entity: {
+                                        archetype: connection.flick
+                                            ? archetypes.slideFlickNoteIndex
+                                            : archetypes.slideEndNoteIndex,
+                                        data: {
+                                            index: 0,
+                                            values: [
+                                                0,
+                                                time,
+                                                lane,
+                                                0,
+                                                0,
+                                                canBeLong,
+                                            ],
+                                        },
+                                    },
+                                    time,
+                                    lane,
+                                    head,
+                                });
+                            }
+                            else {
+                                wrappedNoteEntities.push({
+                                    entity: {
+                                        archetype: archetypes.slideTickNoteIndex,
+                                        data: {
+                                            index: 0,
+                                            values: [0, time, lane],
+                                        },
+                                    },
+                                    time,
+                                    lane,
+                                    head,
+                                });
+                            }
+                            segments.push({
+                                time,
+                                lane,
+                            });
+                            const tail = wrappedNoteEntities[wrappedNoteEntities.length - 1];
+                            let prevSegment = {
+                                time: head.time,
+                                lane: head.lane,
+                            };
+                            segments.forEach((segment, index) => {
+                                wrappedSliderEntities.push({
+                                    entity: {
+                                        archetype: hasHidden
+                                            ? archetypes.curvedSliderIndex
+                                            : archetypes.straightSliderIndex,
+                                        data: {
+                                            index: 0,
+                                            values: [
+                                                0,
+                                                0,
+                                                prevSegment.time,
+                                                segment.time,
+                                                prevSegment.lane,
+                                                segment.lane,
+                                                index === 0 ? 1 : 0,
+                                            ],
+                                        },
+                                    },
+                                    head,
+                                    tail,
+                                });
+                                prevSegment = segment;
+                            });
+                            segments = [];
+                        }
+                    }
+                });
+                break;
+            }
+        }
+    });
+    return {
+        entities: [
+            ...wrappedNoteEntities
+                .sort((a, b) => a.time - b.time || Math.abs(b.lane) - Math.abs(a.lane))
+                .map((wrappedNoteEntity) => {
+                if (wrappedNoteEntity.head) {
+                    if (!wrappedNoteEntity.entity.data)
+                        throw 'Unexpected missing entity data';
+                    wrappedNoteEntity.entity.data.values[0] =
+                        wrappedNoteEntities.indexOf(wrappedNoteEntity.head);
+                }
+                return wrappedNoteEntity.entity;
+            }),
+            ...wrappedSliderEntities.map((wrappedSliderEntity) => {
+                if (!wrappedSliderEntity.entity.data)
+                    throw 'Unexpected missing entity data';
+                wrappedSliderEntity.entity.data.values[0] =
+                    wrappedNoteEntities.indexOf(wrappedSliderEntity.head);
+                wrappedSliderEntity.entity.data.values[1] =
+                    wrappedNoteEntities.indexOf(wrappedSliderEntity.tail);
+                return wrappedSliderEntity.entity;
+            }),
+        ],
+    };
+    function beatToTime(beat) {
+        for (const timing of timings) {
+            if (beat >= timing.beat) {
+                return timing.time + (beat - timing.beat) * timing.timePerBeat;
+            }
+        }
+        return 0;
+    }
+}
+exports.fromBestdori = fromBestdori;
+function repair(chartObjects) {
+    chartObjects.forEach((chartObject) => {
+        var _a, _b;
+        switch (chartObject.type) {
+            case 'Long':
+            case 'Slide': {
+                chartObject.connections.sort((a, b) => a.beat - b.beat);
+                const visibleConnections = chartObject.connections.filter((connection) => !connection.hidden);
+                switch (visibleConnections.length) {
+                    case 0:
+                        remove(chartObject);
+                        break;
+                    case 1: {
+                        const connection = visibleConnections[0];
+                        replace(chartObject, {
+                            type: 'Single',
+                            lane: connection.lane,
+                            beat: connection.beat,
+                            flick: connection.flick,
+                        });
+                        break;
+                    }
+                    default:
+                        while ((_a = chartObject.connections[0]) === null || _a === void 0 ? void 0 : _a.hidden) {
+                            chartObject.connections.shift();
+                        }
+                        while ((_b = chartObject.connections[chartObject.connections.length - 1]) === null || _b === void 0 ? void 0 : _b.hidden) {
+                            chartObject.connections.pop();
+                        }
+                        break;
+                }
+                break;
+            }
+        }
+    });
+    return chartObjects;
+    function replace(o, n) {
+        chartObjects.splice(chartObjects.indexOf(o), 1, n);
+    }
+    function remove(o) {
+        chartObjects.splice(chartObjects.indexOf(o), 1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { SLevelData } from 'sonolus.js';
+import { ChartObject } from './convert';
+import { Resource } from './Resource';
+export declare const version = "0.6.5";
+export declare const engineInfo: {
+    readonly name: "bandori";
+    readonly version: 4;
+    readonly title: {
+        readonly en: "BanG Dream!";
+        readonly ja: "バンドリ！";
+        readonly ko: "뱅드림!";
+        readonly 'zh-hans': "BanG Dream!";
+        readonly 'zh-hant': "BanG Dream!";
+    };
+    readonly subtitle: {
+        readonly en: "BanG Dream! Girls Band Party!";
+        readonly ja: "バンドリ！ ガールズバンドパーティ！";
+        readonly ko: "뱅드림! 걸즈 밴드 파티!";
+        readonly 'zh-hans': "BanG Dream! 少女乐团派对!";
+        readonly 'zh-hant': "BanG Dream! 少女樂團派對";
+    };
+    readonly author: {
+        readonly en: "Burrito";
+    };
+    readonly description: {
+        readonly en: string;
+    };
+};
+export declare const engineConfiguration: Resource;
+export declare const engineData: Resource;
+export declare const engineThumbnail: Resource;
+export declare function fromBestdori(chart: ChartObject[]): SLevelData;

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBestdori = exports.engineThumbnail = exports.engineData = exports.engineConfiguration = exports.engineInfo = exports.version = void 0;
+const convert_1 = require("./convert");
+const Resource_1 = require("./Resource");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const archetypes = require('./archetypes');
+exports.version = '0.6.5';
+exports.engineInfo = {
+    name: 'bandori',
+    version: 4,
+    title: {
+        en: 'BanG Dream!',
+        ja: 'バンドリ！',
+        ko: '뱅드림!',
+        'zh-hans': 'BanG Dream!',
+        'zh-hant': 'BanG Dream!',
+    },
+    subtitle: {
+        en: 'BanG Dream! Girls Band Party!',
+        ja: 'バンドリ！ ガールズバンドパーティ！',
+        ko: '뱅드림! 걸즈 밴드 파티!',
+        'zh-hans': 'BanG Dream! 少女乐团派对!',
+        'zh-hant': 'BanG Dream! 少女樂團派對',
+    },
+    author: {
+        en: 'Burrito',
+    },
+    description: {
+        en: [
+            'A recreation of BanG Dream! Girls Band Party engine in Sonolus.',
+            '',
+            'Version:',
+            exports.version,
+            '',
+            'GitHub Repository:',
+            'https://github.com/NonSpicyBurrito/sonolus-bandori-engine',
+        ].join('\n'),
+    },
+};
+exports.engineConfiguration = new Resource_1.Resource('EngineConfiguration');
+exports.engineData = new Resource_1.Resource('EngineData');
+exports.engineThumbnail = new Resource_1.Resource('thumbnail.png');
+function fromBestdori(chart) {
+    return convert_1.fromBestdori(chart, archetypes);
+}
+exports.fromBestdori = fromBestdori;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "sonolus-bandori-engine",
+  "version": "0.6.5",
+  "description": "A recreation of BanG Dream! Girls Band Party engine in Sonolus",
+  "author": "NonSpicyBurrito",
+  "repository": "github:NonSpicyBurrito/sonolus-bandori-engine",
+  "license": "MIT",
+  "keywords": [
+    "Sonolus"
+  ],
+  "main": "dist",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "lint": "eslint --ext .ts src/",
+    "serve": "nodemon",
+    "build": "ts-node ./src/build && tsc -p ./tsconfig.lib.json"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.12",
+    "@typescript-eslint/eslint-plugin": "^4.28.5",
+    "@typescript-eslint/parser": "^4.28.5",
+    "eslint": "^7.31.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "fs-extra": "^10.0.0",
+    "nodemon": "^2.0.12",
+    "prettier": "^2.3.2",
+    "sonolus.js": "^3.1.0",
+    "ts-node": "^10.1.0",
+    "typescript": "^4.3.5"
+  }
+}