sonolus-voez-engine 1.0.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 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,85 @@
+# Sonolus VOEZ Engine
+
+A recreation of VOEZ engine in [Sonolus](https://sonolus.com).
+
+## Links
+
+-   [Sonolus Website](https://sonolus.com)
+-   [Sonolus Wiki](https://github.com/NonSpicyBurrito/sonolus-wiki)
+
+## Installation
+
+```
+npm install sonolus-voez-engine
+```
+
+## Custom Resources
+
+### Skin Sprites
+
+| Name                           |
+| ------------------------------ |
+| `VOEZ Track Body 0`            |
+| `VOEZ Track Body 1`            |
+| `VOEZ Track Body 2`            |
+| `VOEZ Track Body 3`            |
+| `VOEZ Track Body 4`            |
+| `VOEZ Track Body 5`            |
+| `VOEZ Track Body 6`            |
+| `VOEZ Track Body 7`            |
+| `VOEZ Track Body 8`            |
+| `VOEZ Track Body 9`            |
+| `VOEZ Track Line`              |
+| `VOEZ Track Left Border`       |
+| `VOEZ Track Right Border`      |
+| `VOEZ Track Glow Body`         |
+| `VOEZ Track Glow Left Border`  |
+| `VOEZ Track Glow Right Border` |
+| `VOEZ Flick`                   |
+
+## 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.
+
+### `vsToVC(vs)`
+
+Converts VS (VOEZ Source) to VC (VOEZ Chart).
+
+-   `vs`: VOEZ source.
+
+### `vcToLevelData(vc, offset?)`
+
+Converts VC (VOEZ Chart) to Level Data.
+
+-   `vc`: VOEZ chart.
+-   `offset`: offset (default: `0`).

package/dist/Resource.cjs

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

package/dist/Resource.d.cts

@@ -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/index.cjs

@@ -0,0 +1,52 @@
+"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.engineThumbnail = exports.engineData = exports.engineConfiguration = exports.engineInfo = exports.version = exports.vsToVC = exports.vcToLevelData = void 0;
+const Resource_cjs_1 = require("./Resource.cjs");
+var convert_cjs_1 = require("./vc/convert.cjs");
+Object.defineProperty(exports, "vcToLevelData", { enumerable: true, get: function () { return convert_cjs_1.vcToLevelData; } });
+__exportStar(require("./vc/index.cjs"), exports);
+var convert_cjs_2 = require("./vs/convert.cjs");
+Object.defineProperty(exports, "vsToVC", { enumerable: true, get: function () { return convert_cjs_2.vsToVC; } });
+__exportStar(require("./vs/index.cjs"), exports);
+exports.version = '1.0.0';
+exports.engineInfo = {
+    name: 'voez',
+    version: 8,
+    title: {
+        en: 'VOEZ',
+    },
+    subtitle: {
+        en: 'VOEZ',
+    },
+    author: {
+        en: 'Burrito',
+    },
+    description: {
+        en: [
+            'A recreation of VOEZ engine in Sonolus.',
+            '',
+            'Version:',
+            exports.version,
+            '',
+            'GitHub Repository:',
+            'https://github.com/NonSpicyBurrito/sonolus-voez-engine',
+        ].join('\n'),
+    },
+};
+exports.engineConfiguration = new Resource_cjs_1.Resource('EngineConfiguration');
+exports.engineData = new Resource_cjs_1.Resource('EngineData');
+exports.engineThumbnail = new Resource_cjs_1.Resource('thumbnail.png');

package/dist/index.d.cts

@@ -0,0 +1,25 @@
+import { Resource } from './Resource.cjs';
+export { vcToLevelData } from './vc/convert.cjs';
+export * from './vc/index.cjs';
+export { vsToVC } from './vs/convert.cjs';
+export * from './vs/index.cjs';
+export declare const version = "1.0.0";
+export declare const engineInfo: {
+    readonly name: "voez";
+    readonly version: 8;
+    readonly title: {
+        readonly en: "VOEZ";
+    };
+    readonly subtitle: {
+        readonly en: "VOEZ";
+    };
+    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;

package/dist/vc/convert.cjs

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vcToLevelData = void 0;
+const sonolus_core_1 = require("sonolus-core");
+const ease = [
+    'InSine',
+    'OutSine',
+    'InOutSine',
+    'OutInSine',
+    'InQuad',
+    'OutQuad',
+    'InOutQuad',
+    'OutInQuad',
+    'InCubic',
+    'OutCubic',
+    'InOutCubic',
+    'OutInCubic',
+    'InQuart',
+    'OutQuart',
+    'InOutQuart',
+    'OutInQuart',
+    'InQuint',
+    'OutQuint',
+    'InOutQuint',
+    'OutInQuint',
+    'InExpo',
+    'OutExpo',
+    'InOutExpo',
+    'OutInExpo',
+    'InCirc',
+    'OutCirc',
+    'InOutCirc',
+    'OutInCirc',
+    'InBack',
+    'OutBack',
+    'InOutBack',
+    'OutInBack',
+    'InElastic',
+    'OutElastic',
+    'InOutElastic',
+    'OutInElastic',
+];
+const vcToLevelData = (vc, offset = 0) => {
+    const entities = [
+        {
+            archetype: 'Initialization',
+            data: [],
+        },
+        {
+            archetype: 'InputManager',
+            data: [],
+        },
+        {
+            archetype: 'Stage',
+            data: [],
+        },
+    ];
+    const add = (entity) => entities.push({
+        ...entity,
+        data: Object.entries(entity.data).map(([k, v]) => typeof v === 'number' ? { name: k, value: v } : { name: k, ref: v }),
+    });
+    let id = 0;
+    const next = () => `${id++}`;
+    for (const bpm of vc.bpms) {
+        add({
+            archetype: sonolus_core_1.EngineArchetypeName.BpmChange,
+            data: {
+                [sonolus_core_1.EngineArchetypeDataName.Beat]: bpm.beat,
+                [sonolus_core_1.EngineArchetypeDataName.Bpm]: bpm.bpm,
+            },
+        });
+    }
+    for (const track of vc.tracks) {
+        const ref = next();
+        add({
+            ref,
+            archetype: 'Track',
+            data: {
+                x: track.x,
+                w: track.w,
+                c: track.c,
+                startBeat: track.startBeat,
+                endBeat: track.endBeat,
+                animateStart: +track.animateStart,
+            },
+        });
+        const addCommand = (archetype, command) => add({
+            archetype,
+            data: {
+                trackRef: ref,
+                startBeat: command.startBeat,
+                startValue: command.startValue,
+                endBeat: command.endBeat,
+                endValue: command.endValue,
+                ease: ease.indexOf(command.ease),
+            },
+        });
+        for (const command of track.moveCommands) {
+            addCommand('TrackMoveCommand', command);
+        }
+        for (const command of track.scaleCommands) {
+            addCommand('TrackScaleCommand', command);
+        }
+        for (const command of track.colorCommands) {
+            addCommand('TrackColorCommand', command);
+        }
+        for (const note of track.notes) {
+            switch (note.type) {
+                case 'tap':
+                    add({
+                        archetype: 'TapNote',
+                        data: {
+                            trackRef: ref,
+                            [sonolus_core_1.EngineArchetypeDataName.Beat]: note.beat,
+                        },
+                    });
+                    break;
+                case 'slide':
+                    add({
+                        archetype: 'SlideNote',
+                        data: {
+                            trackRef: ref,
+                            [sonolus_core_1.EngineArchetypeDataName.Beat]: note.beat,
+                        },
+                    });
+                    break;
+                case 'flick':
+                    add({
+                        archetype: 'FlickNote',
+                        data: {
+                            trackRef: ref,
+                            [sonolus_core_1.EngineArchetypeDataName.Beat]: note.beat,
+                            direction: note.direction === 'left' ? -1 : 1,
+                        },
+                    });
+                    break;
+                case 'hold': {
+                    const headRef = next();
+                    const tailRef = next();
+                    add({
+                        ref: headRef,
+                        archetype: 'HoldStartNote',
+                        data: {
+                            trackRef: ref,
+                            [sonolus_core_1.EngineArchetypeDataName.Beat]: note.beat,
+                        },
+                    });
+                    add({
+                        ref: tailRef,
+                        archetype: 'HoldEndNote',
+                        data: {
+                            trackRef: ref,
+                            [sonolus_core_1.EngineArchetypeDataName.Beat]: note.toBeat,
+                            headRef,
+                        },
+                    });
+                    add({
+                        archetype: 'HoldConnector',
+                        data: {
+                            headRef,
+                            tailRef,
+                        },
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return {
+        bgmOffset: offset,
+        entities,
+    };
+};
+exports.vcToLevelData = vcToLevelData;

package/dist/vc/convert.d.cts

@@ -0,0 +1,3 @@
+import { LevelData } from 'sonolus-core';
+import { VC } from './index.cjs';
+export declare const vcToLevelData: (vc: VC, offset?: number) => LevelData;

package/dist/vc/index.cjs

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

package/dist/vc/index.d.cts

@@ -0,0 +1,46 @@
+export type VC = {
+    bpms: VCBpm[];
+    tracks: VCTrack[];
+};
+export type VCBpm = {
+    beat: number;
+    bpm: number;
+};
+export type VCTrack = {
+    x: number;
+    w: number;
+    c: number;
+    startBeat: number;
+    endBeat: number;
+    animateStart: boolean;
+    moveCommands: VCTrackCommand[];
+    scaleCommands: VCTrackCommand[];
+    colorCommands: VCTrackCommand[];
+    notes: VCNote[];
+};
+export type VCTrackCommand = {
+    startBeat: number;
+    startValue: number;
+    endBeat: number;
+    endValue: number;
+    ease: string;
+};
+export type VCNote = VCTapNote | VCSlideNote | VCFlickNote | VCHoldNote;
+type BaseVCNote = {
+    beat: number;
+};
+export type VCTapNote = BaseVCNote & {
+    type: 'tap';
+};
+export type VCSlideNote = BaseVCNote & {
+    type: 'slide';
+};
+export type VCFlickNote = BaseVCNote & {
+    type: 'flick';
+    direction: 'left' | 'right';
+};
+export type VCHoldNote = BaseVCNote & {
+    type: 'hold';
+    toBeat: number;
+};
+export {};

package/dist/vs/convert.cjs

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vsToVC = void 0;
+const easeMap = {
+    easeinsine: 'InSine',
+    easeoutsine: 'OutSine',
+    easeinoutsine: 'InOutSine',
+    easeoutinsine: 'OutInSine',
+    easeinquad: 'InQuad',
+    easeoutquad: 'OutQuad',
+    easeinoutquad: 'InOutQuad',
+    easeoutinquad: 'OutInQuad',
+    easeincubic: 'InCubic',
+    easeoutcubic: 'OutCubic',
+    easeinoutcubic: 'InOutCubic',
+    easeoutincubic: 'OutInCubic',
+    easeinquart: 'InQuart',
+    easeoutquart: 'OutQuart',
+    easeinoutquart: 'InOutQuart',
+    easeoutinquart: 'OutInQuart',
+    easeinquint: 'InQuint',
+    easeoutquint: 'OutQuint',
+    easeinoutquint: 'InOutQuint',
+    easeoutinquint: 'OutInQuint',
+    easeinexpo: 'InExpo',
+    easeoutexpo: 'OutExpo',
+    easeinoutexpo: 'InOutExpo',
+    easeoutinexpo: 'OutInExpo',
+    easeincirc: 'InCirc',
+    easeoutcirc: 'OutCirc',
+    easeinoutcirc: 'InOutCirc',
+    easeoutincirc: 'OutInCirc',
+    easeinback: 'InBack',
+    easeoutback: 'OutBack',
+    easeinoutback: 'InOutBack',
+    easeoutinback: 'OutInBack',
+    easeinelastic: 'InElastic',
+    easeintelastic: 'InElastic',
+    easeoutelastic: 'OutElastic',
+    easeinoutelastic: 'InOutElastic',
+    easeoutinelastic: 'OutInElastic',
+};
+const vsToVC = (vs) => {
+    const vc = {
+        bpms: [
+            {
+                beat: 0,
+                bpm: 60,
+            },
+        ],
+        tracks: [],
+    };
+    const x = (pos) => (pos * 2 - 1) * 7.29;
+    const w = (size) => size;
+    const c = (color) => color;
+    const ease = (ease) => easeMap[ease] ?? 'Linear';
+    for (const track of vs.tracks) {
+        let lastX = x(track.X);
+        let lastW = w(track.Size);
+        let lastC = c(track.Color);
+        vc.tracks.push({
+            x: lastX,
+            w: lastW,
+            c: lastC,
+            startBeat: track.Start,
+            endBeat: track.End,
+            animateStart: track.EntranceOn,
+            moveCommands: track.Move.map((command) => {
+                const startValue = lastX;
+                const endValue = x(command.To);
+                lastX = endValue;
+                return {
+                    startBeat: command.Start,
+                    startValue,
+                    endBeat: command.End,
+                    endValue,
+                    ease: ease(command.Ease),
+                };
+            }),
+            scaleCommands: track.Scale.map((command) => {
+                const startValue = lastW;
+                const endValue = w(command.To);
+                lastW = endValue;
+                return {
+                    startBeat: command.Start,
+                    startValue,
+                    endBeat: command.End,
+                    endValue,
+                    ease: ease(command.Ease),
+                };
+            }),
+            colorCommands: track.ColorChange.map((command) => {
+                const startValue = lastC;
+                const endValue = c(command.To);
+                lastC = endValue;
+                return {
+                    startBeat: command.Start,
+                    startValue,
+                    endBeat: command.End,
+                    endValue,
+                    ease: ease(command.Ease),
+                };
+            }),
+            notes: vs.notes
+                .filter((note) => note.Track === track.Id)
+                .map((note) => {
+                switch (note.Type) {
+                    case 'click':
+                        return {
+                            type: 'tap',
+                            beat: note.Time,
+                        };
+                    case 'slide':
+                        return {
+                            type: 'slide',
+                            beat: note.Time,
+                        };
+                    case 'swipe':
+                        return {
+                            type: 'flick',
+                            beat: note.Time,
+                            direction: note.Dir ? 'right' : 'left',
+                        };
+                    case 'hold':
+                        return {
+                            type: 'hold',
+                            beat: note.Time,
+                            toBeat: note.Time + note.Hold,
+                        };
+                }
+            }),
+        });
+    }
+    return vc;
+};
+exports.vsToVC = vsToVC;

package/dist/vs/convert.d.cts

@@ -0,0 +1,3 @@
+import { VC } from '../vc/index.cjs';
+import { VS } from './index.cjs';
+export declare const vsToVC: (vs: VS) => VC;

package/dist/vs/index.cjs

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

package/dist/vs/index.d.cts

@@ -0,0 +1,29 @@
+export type VS = {
+    notes: VSNote[];
+    tracks: VSTrack[];
+};
+export type VSTrack = {
+    Id: number;
+    EntranceOn: boolean;
+    X: number;
+    Size: number;
+    Start: number;
+    End: number;
+    Color: number;
+    Move: VSTrackCommand[];
+    Scale: VSTrackCommand[];
+    ColorChange: VSTrackCommand[];
+};
+export type VSTrackCommand = {
+    To: number;
+    Ease: string;
+    Start: number;
+    End: number;
+};
+export type VSNote = {
+    Type: 'click' | 'hold' | 'slide' | 'swipe';
+    Track: number;
+    Time: number;
+    Hold: number;
+    Dir: 0 | 1;
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "sonolus-voez-engine",
+  "version": "1.0.0",
+  "description": "A recreation of VOEZ engine in Sonolus",
+  "author": "NonSpicyBurrito",
+  "repository": "github:NonSpicyBurrito/sonolus-voez-engine",
+  "license": "MIT",
+  "keywords": [
+    "Sonolus"
+  ],
+  "main": "dist/index.cjs",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "sonolus-cli --dev",
+    "prebuild": "tsc -p . --noEmit && eslint --ext .mts ./src && eslint --ext .cts ./lib",
+    "build": "tsc -p ./lib/tsconfig.json && sonolus-cli --build && node ./lib/build.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^16.18.36",
+    "@typescript-eslint/eslint-plugin": "^5.59.11",
+    "@typescript-eslint/parser": "^5.59.11",
+    "eslint": "^8.42.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "prettier": "^2.8.8",
+    "prettier-plugin-organize-imports": "^3.2.2",
+    "sonolus-core": "~7.0.0",
+    "sonolus.js": "~9.0.0",
+    "typescript": "~5.1.3"
+  }
+}