adofai-lib 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# ADOFAI Library
+
+A TypeScript library for working with ADOFAI level files. This library provides a simple interface for reading, modifying, and writing ADOFAI level files.
+
+## Installation
+
+```bash
+npm install adofai-lib
+```
+
+## Usage
+
+```typescript
+import { LevelDict } from 'adofai-lib';
+
+// Load an ADOFAI level file
+const level = new LevelDict('path/to/level.adofai');
+
+// Get all angles in the level
+const angles = level.getAngles();
+
+// Get relative angles (degrees between each pair of tiles)
+const relativeAngles = level.getAnglesRelative();
+
+// Get all actions in the level
+const actions = level.getActions();
+
+// Get all decorations in the level
+const decorations = level.getDecorations();
+
+// Modify the level...
+
+// Save the modified level
+level.writeToFile('path/to/output.adofai');
+```
+
+## Features
+
+- Read and write ADOFAI level files
+- Get and set tile angles
+- Get relative angles between tiles
+- Manage actions and decorations
+- Support for both angle-based and path-based level formats
+
+## API Reference
+
+### LevelDict
+
+The main class for working with ADOFAI level files.
+
+#### Constructor
+
+```typescript
+new LevelDict(filename?: string, encoding?: string)
+```
+
+- `filename`: Path to the ADOFAI level file (optional)
+- `encoding`: File encoding (default: 'utf-8')
+
+#### Methods
+
+- `getAngles()`: Returns an array of all tile angles
+- `setAngles(angles: number[])`: Sets the angles for all tiles
+- `getAnglesRelative(ignoreTwirls?: boolean, padMidspins?: boolean)`: Returns relative angles between tiles
+- `getActions(condition?: (action: Action) => boolean)`: Returns all actions matching the condition
+- `getDecorations(condition?: (decoration: Decoration) => boolean)`: Returns all decorations matching the condition
+- `writeToFile(filename?: string)`: Saves the level to a file
+
+## License
+
+MIT 

package/dist/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./types"), exports);
+__exportStar(require("./LevelDict"), exports);

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'js'],
+}; 

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "adofai-lib",
+  "version": "1.0.0",
+  "description": "A TypeScript library for working with ADOFAI level files",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "adofai",
+    "adofai-lib",
+    "adofai-lib-js",
+    "adofai-lib-js-v0w4n"
+  ],
+  "author": "V0W4N (original by M1n3c4rt)",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  }
+}

package/src/LevelDict.ts

@@ -0,0 +1,171 @@
+import * as fs from 'fs';
+import { Action, Decoration, Settings, Tile, InvalidLevelDictException } from './types';
+
+export class LevelFile {
+  private filename: string;
+  private encoding: BufferEncoding;
+  private tiles: Tile[];
+  private nonFloorDecos: Decoration[];
+  private settings: Settings;
+
+  constructor(filename: string = '', encoding: BufferEncoding = 'utf-8') {
+    this.filename = filename;
+    this.encoding = encoding;
+    this.tiles = [];
+    this.nonFloorDecos = [];
+    this.settings = {};
+
+    const leveldict = this.getFileDict();
+    if (!leveldict.actions || !leveldict.settings || (!leveldict.angleData && !leveldict.pathData)) {
+      throw new InvalidLevelDictException(`The provided .adofai file is invalid. (missing: ${!leveldict.actions ? 'actions' : ''} ${!leveldict.settings ? 'settings' : ''} ${!leveldict.angleData && !leveldict.pathData ? 'angleData or pathData' : ''})`);
+    }
+
+    let angleData: number[];
+    if ('angleData' in leveldict) {
+      angleData = leveldict.angleData;
+    } else {
+      const pathchars: { [key: string]: number } = {
+        'R': 0, 'p': 15, 'J': 30, 'E': 45, 'T': 60, 'o': 75, 'U': 90,
+        'q': 105, 'G': 120, 'Q': 135, 'H': 150, 'W': 165, 'L': 180,
+        'x': 195, 'N': 210, 'Z': 225, 'F': 240, 'V': 255, 'D': 270,
+        'Y': 285, 'B': 300, 'C': 315, 'M': 330, 'A': 345, '!': 999
+      };
+      angleData = Array.from(leveldict.pathData as string).map(char => pathchars[char]);
+    }
+
+    angleData.push(angleData[angleData.length - 1] !== 999 ? angleData[angleData.length - 1] : (angleData[angleData.length - 2] + 180) % 360);
+    
+    const actions = leveldict.actions;
+    const decorations = leveldict.decorations || [];
+    
+    this.nonFloorDecos = decorations.filter((j: Decoration) => !('floor' in j)).map((j: Decoration) => ({ ...j }));
+    this.settings = filename !== '' ? { ...leveldict.settings } : {};
+    
+    // Initialize tiles
+    this.tiles = angleData.map(angle => ({
+      angle,
+      actions: [],
+      decorations: []
+    }));
+
+    // Add actions
+    actions.forEach((action: Action) => {
+      if (action.floor !== undefined && action.floor < this.tiles.length) {
+        this.tiles[action.floor].actions.push({ ...action });
+      }
+    });
+
+    // Add decorations
+    decorations.forEach((deco: Decoration) => {
+      if ('floor' in deco) {
+        if (deco.floor! >= this.tiles.length) {
+          this.tiles[this.tiles.length - 1].decorations.push({ ...deco });
+        } else {
+          this.tiles[deco.floor!].decorations.push({ ...deco });
+        }
+      }
+    });
+  }
+
+  private getFileString(): string {
+    if (!this.filename) return '';
+    return fs.readFileSync(this.filename, { encoding: this.encoding });
+  }
+
+  private getFileDict(): any {
+    if (!this.filename) {
+      return {
+        angleData: [0],
+        settings: {},
+        actions: [],
+        decorations: []
+      };
+    }
+
+    const content = this.getFileString();
+    return JSON.parse(content);
+  }
+
+  public getAngles(): number[] {
+    return this.tiles.map(tile => tile.angle);
+  }
+
+  public setAngles(angles: number[]): void {
+    if (angles.length > this.tiles.length) {
+      this.tiles.push({
+        angle: angles[angles.length - 1],
+        actions: [],
+        decorations: []
+      });
+    }
+    this.tiles = this.tiles.slice(0, angles.length);
+    this.tiles.forEach((tile, i) => {
+      tile.angle = angles[i];
+    });
+  }
+
+  public getAnglesRelative(ignoreTwirls: boolean = false, padMidspins: boolean = false): number[] {
+    const absangles = this.getAngles().slice(0, -1);
+
+    if (!ignoreTwirls) {
+      const twirls = this.getActions(action => action.eventType === 'Twirl')
+        .map(event => event.floor!);
+      
+      for (const twirl of twirls.reverse()) {
+        absangles.splice(twirl, absangles.length - twirl,
+          ...absangles.slice(twirl).map(angle => 
+            angle !== 999 ? (2 * absangles[twirl - 1] - angle) % 360 : 999
+          )
+        );
+      }
+    }
+
+    const midspins = absangles.map((angle, idx) => angle === 999 ? idx : -1).filter(idx => idx !== -1);
+    for (const midspin of midspins.reverse()) {
+      absangles.splice(midspin + 1, absangles.length - (midspin + 1),
+        ...absangles.slice(midspin + 1).map(angle =>
+          angle !== 999 ? (angle + 180) % 360 : 999
+        )
+      );
+    }
+
+    if (!padMidspins) {
+      absangles.splice(0, absangles.length, ...absangles.filter(angle => angle !== 999));
+    }
+
+    return absangles.map((angle, idx) => {
+      if (angle === 999) return 0;
+      if (idx === 0) return ((0 - angle + 180 - 1) % 360) + 1;
+      if (absangles[idx - 1] === 999) {
+        return ((absangles[idx - 2] - angle + 180 - 1) % 360) + 1;
+      }
+      return ((absangles[idx - 1] - angle + 180 - 1) % 360) + 1;
+    });
+  }
+
+  public getActions(condition: (action: Action) => boolean = () => true): Action[] {
+    return this.tiles.flatMap(tile => tile.actions.filter(condition));
+  }
+
+  public getDecorations(condition: (decoration: Decoration) => boolean = () => true): Decoration[] {
+    return [
+      ...this.tiles.flatMap(tile => tile.decorations.filter(condition)),
+      ...this.nonFloorDecos.filter(condition)
+    ];
+  }
+
+  public writeToFile(filename?: string): void {
+    const final = {
+      angleData: this.tiles.map(tile => tile.angle),
+      settings: { ...this.settings },
+      actions: this.tiles.flatMap(tile => tile.actions),
+      decorations: [
+        ...this.tiles.flatMap(tile => tile.decorations),
+        ...this.nonFloorDecos
+      ]
+    };
+
+    const outputFile = filename || this.filename;
+    fs.writeFileSync(outputFile, JSON.stringify(final, null, 4), { encoding: this.encoding });
+  }
+} 

package/src/__tests__/LevelFile.test.ts

@@ -0,0 +1,83 @@
+import { LevelFile } from '../LevelDict';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock fs module
+jest.mock('fs');
+
+describe('LevelFile', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create an empty level file when no filename is provided', () => {
+    const level = new LevelFile();
+    expect(level.getAngles()).toEqual([0,0]);
+    expect(level.getActions()).toEqual([]);
+    expect(level.getDecorations()).toEqual([]);
+  });
+
+  it('should throw InvalidLevelDictException for invalid file', () => {
+    (fs.readFileSync as jest.Mock).mockReturnValue('{}');
+    
+    expect(() => {
+      new LevelFile('invalid.adofai');
+    }).toThrow('The provided .adofai file is invalid');
+  });
+
+  it('should load a valid level file', () => {
+    const mockLevelData = {
+      angleData: [0, 90, 180],
+      settings: { bpm: 120 },
+      actions: [],
+      decorations: []
+    };
+
+    (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockLevelData));
+
+    const level = new LevelFile('test.adofai');
+    expect(level.getAngles()).toEqual([0, 90, 180, 180]);
+  });
+
+  it('should write level file correctly', () => {
+    const level = new LevelFile();
+    level.setAngles([0, 90, 180]);
+    
+    level.writeToFile('output.adofai');
+    
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      'output.adofai',
+      expect.stringMatching(/"angleData"\s*:\s*\[\s*0\s*,\s*90\s*,\s*180\s*\]/),
+      { encoding: 'utf-8' }
+    );
+  });
+
+  it('should handle path-based level data', () => {
+    const mockLevelData = {
+      pathData: 'RUL',
+      settings: { bpm: 120 },
+      actions: [],
+      decorations: []
+    };
+
+    (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockLevelData));
+
+    const level = new LevelFile('test.adofai');
+    expect(level.getAngles()).toEqual([0, 90, 180, 180]);
+  });
+
+  it('should get relative angles correctly', () => {
+    const mockLevelData = {
+      angleData: [0, 90, 180, 180],
+      settings: { bpm: 120 },
+      actions: [],
+      decorations: []
+    };
+
+    (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockLevelData));
+
+    const level = new LevelFile('test.adofai');
+    const relativeAngles = level.getAnglesRelative();
+    expect(relativeAngles).toEqual([180, 90, 90, 180]);
+  });
+}); 

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './LevelDict'; 

package/src/types/index.ts

@@ -0,0 +1,28 @@
+export interface Action {
+  [key: string]: any;
+  floor?: number;
+  eventType?: string;
+  angleOffset?: number;
+}
+
+export interface Decoration {
+  [key: string]: any;
+  floor?: number;
+}
+
+export interface Settings {
+  [key: string]: any;
+}
+
+export interface Tile {
+  angle: number;
+  actions: Action[];
+  decorations: Decoration[];
+}
+
+export class InvalidLevelDictException extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidLevelDictException';
+  }
+} 

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "lib": ["es2019", "dom"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}