brs-js 2.0.12 → 2.0.14

package/src/uuid.ts

@@ -1,78 +0,0 @@
-// this code is modified from https://github.com/uuidjs/uuid
-
-import { Uuid } from './types';
-
-/*
-The MIT License (MIT)
-
-Copyright (c) 2010-2020 Robert Kieffer and other contributors
-
-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.
-*/
-const hexTable: string[] = Array.from({ length: 256 }).map((_, i) =>
-  (i + 0x100).toString(16).substr(1)
-);
-
-// stringify uuid
-export function uuidStringify(arr: number[]): Uuid {
-  return (
-    hexTable[arr[0]] +
-    hexTable[arr[1]] +
-    hexTable[arr[2]] +
-    hexTable[arr[3]] +
-    '-' +
-    hexTable[arr[4]] +
-    hexTable[arr[5]] +
-    '-' +
-    hexTable[arr[6]] +
-    hexTable[arr[7]] +
-    '-' +
-    hexTable[arr[8]] +
-    hexTable[arr[9]] +
-    '-' +
-    hexTable[arr[10]] +
-    hexTable[arr[11]] +
-    hexTable[arr[12]] +
-    hexTable[arr[13]] +
-    hexTable[arr[14]] +
-    hexTable[arr[15]]
-  ).toLowerCase();
-}
-
-export function uuidParse(uuid: Uuid): Uint8Array {
-  let v;
-  const arr = new Uint8Array(16);
-
-  // Parse ########-....-....-....-............
-  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
-  arr[1] = (v >>> 16) & 0xff;
-  arr[2] = (v >>> 8) & 0xff;
-  arr[3] = v & 0xff;
-
-  // Parse ........-####-....-....-............
-  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
-  arr[5] = v & 0xff;
-
-  // Parse ........-....-####-....-............
-  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
-  arr[7] = v & 0xff;
-
-  // Parse ........-....-....-####-............
-  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
-  arr[9] = v & 0xff;
-
-  // Parse ........-....-....-....-############
-  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
-  arr[10] = ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff;
-  arr[11] = (v / 0x100000000) & 0xff;
-  arr[12] = (v >>> 24) & 0xff;
-  arr[13] = (v >>> 16) & 0xff;
-  arr[14] = (v >>> 8) & 0xff;
-  arr[15] = v & 0xff;
-
-  return arr;
-}

package/src/write.ts

@@ -1,287 +0,0 @@
-import { DEFAULT_UUID, LATEST_VERSION, MAGIC, MAX_INT } from './constants';
-import {
-  Brick,
-  DefinedComponents,
-  KnownComponents,
-  Owner,
-  WriteOptions,
-  WriteSaveObject,
-} from './types';
-import { concat, isEqual, write } from './utils';
-
-const EMPTY_ARR = new Uint8Array([]);
-
-export const DEFAULT_COMPONENTS: DefinedComponents = {
-  BCD_SpotLight: {
-    version: 1,
-    properties: {
-      Rotation: 'Rotator',
-      InnerConeAngle: 'Float',
-      OuterConeAngle: 'Float',
-      Brightness: 'Float',
-      Radius: 'Float',
-      Color: 'Color',
-      bUseBrickColor: 'Boolean',
-      bCastShadows: 'Boolean',
-    },
-  },
-  BCD_PointLight: {
-    version: 1,
-    properties: {
-      bMatchBrickShape: 'Boolean',
-      Brightness: 'Float',
-      Radius: 'Float',
-      Color: 'Color',
-      bUseBrickColor: 'Boolean',
-      bCastShadows: 'Boolean',
-    },
-  },
-  BCD_ItemSpawn: {
-    version: 1,
-    properties: {
-      PickupClass: 'Class',
-      bPickupEnabled: 'Boolean',
-      bPickupRespawnOnMinigameReset: 'Boolean',
-      PickupMinigameResetRespawnDelay: 'Float',
-      bPickupAutoDisableOnPickup: 'Boolean',
-      PickupRespawnTime: 'Float',
-      PickupOffsetDirection: 'Byte',
-      PickupOffsetDistance: 'Float',
-      PickupRotation: 'Rotator',
-      PickupScale: 'Float',
-      bPickupAnimationEnabled: 'Boolean',
-      PickupAnimationAxis: 'Byte',
-      bPickupAnimationAxisLocal: 'Boolean',
-      PickupSpinSpeed: 'Float',
-      PickupBobSpeed: 'Float',
-      PickupBobHeight: 'Float',
-      PickupAnimationPhase: 'Float',
-    },
-  },
-  BCD_Interact: {
-    version: 1,
-    properties: {
-      bPlayInteractSound: 'Boolean',
-      Message: 'String',
-      ConsoleTag: 'String',
-    },
-  },
-  BCD_AudioEmitter: {
-    version: 1,
-    properties: {
-      AudioDescriptor: 'Object',
-      VolumeMultiplier: 'Float',
-      PitchMultiplier: 'Float',
-      InnerRadius: 'Float',
-      MaxDistance: 'Float',
-      bSpatialization: 'Boolean',
-    },
-  },
-};
-
-export default function writeBrs(
-  save: WriteSaveObject,
-  options: WriteOptions = {}
-) {
-  if (typeof save !== 'object') {
-    throw new Error('Expected save to be an object');
-  }
-
-  if (!Array.isArray(save.bricks) || save.bricks.length === 0) {
-    throw new Error('Expected save to have bricks field');
-  }
-
-  if (save.bricks.length > MAX_INT) {
-    throw new Error('Brick count out of range');
-  }
-
-  // compression is disabled by default
-  const compress = options.compress ? write.compressed : write.uncompressed;
-
-  // Convert from BGRA to RGBA
-  const rgba = ([r, g, b, a]: number[]) => new Uint8Array([b, g, r, a]);
-
-  // stored brick indices from components on the bricks
-  const componentBrickOwnership: { [component_name: string]: number[] } = {};
-
-  const numColors = Math.max(save.colors?.length ?? 0, 2);
-  const numAssets = Math.max(save.brick_assets?.length ?? 0, 2);
-  const numMats = Math.max(save.materials?.length ?? 0, 2);
-  const numPhysMats = Math.max(save.physical_materials?.length ?? 0, 2);
-
-  if (save.preview && !Array.isArray(save.preview))
-    throw new Error('Expected preview to be an array');
-
-  const buff = concat(
-    // Write magic bytes
-    MAGIC,
-    write.u16(LATEST_VERSION),
-    write.i32(save.game_version ?? 0),
-
-    // Header 1
-    compress(
-      write.string(save.map ?? 'Unknown'),
-      write.string(save.author?.name ?? 'Unknown'),
-      write.string(save.description ?? ''),
-      write.uuid(save.author?.id ?? DEFAULT_UUID),
-      concat(
-        write.string(save.host?.name ?? 'Unknown'),
-        write.uuid(save.host?.id ?? DEFAULT_UUID)
-      ),
-      new Uint8Array(
-        save.save_time &&
-        (Array.isArray(save.save_time) ||
-          save.save_time instanceof Uint8Array) &&
-        save.save_time.length === 8
-          ? save.save_time
-          : [0, 0, 0, 0, 0, 0, 0, 0]
-      ),
-      write.i32(save.bricks.length)
-    ),
-
-    // Header 2
-    compress(
-      write.array(save.mods ?? [], write.string),
-      write.array(save.brick_assets ?? ['PB_DefaultBrick'], write.string),
-      write.array(save.colors ?? [], rgba),
-      write.array(save.materials ?? ['BMC_Plastic'], write.string),
-      write.array(
-        save.brick_owners ?? [],
-        ({ id = DEFAULT_UUID, name = 'Unknown', bricks = 0 }: Partial<Owner>) =>
-          concat(write.uuid(id), write.string(name), write.i32(bricks))
-      ),
-      write.array(save.physical_materials ?? ['BPMC_Default'], write.string)
-    ),
-
-    // write the save preview if it exists
-    concat(
-      new Uint8Array([save.preview ? 1 : 0]),
-      save.preview ? write.i32(save.preview.length) : EMPTY_ARR, // <- Sorry @Uxie https://i.imgur.com/hSRxdbf.png
-      save.preview ?? EMPTY_ARR
-    ),
-
-    // Bricks
-    compress(
-      write
-        .bits()
-        .each(save.bricks, function (brick: Brick, i) {
-          if (typeof brick !== 'object')
-            throw new Error(`Expected save.bricks[${i}] to be an object`);
-
-          if (!Array.isArray(brick.size) || brick.size.length !== 3)
-            throw new Error(
-              `Expected save.bricks[${i}].size to be an array of length 3`
-            );
-
-          if (!Array.isArray(brick.position) || brick.position.length !== 3)
-            throw new Error(
-              `Expected save.bricks[${i}].position to be an array of length 3`
-            );
-
-          this.align();
-          this.int(brick.asset_name_index ?? 0, numAssets);
-
-          const isNonProcedural = isEqual(brick.size, [0, 0, 0]);
-          this.bit(!isNonProcedural);
-          if (!isNonProcedural) {
-            brick.size.map(s => this.uint_packed(s));
-          }
-          brick.position.map(s => this.int_packed(s));
-          this.int(((brick.direction ?? 4) << 2) | (brick.rotation ?? 0), 24);
-
-          if (typeof brick.collision === 'boolean') {
-            this.bit(brick.collision);
-            this.bit(brick.collision);
-            this.bit(brick.collision);
-            this.bit(true);
-          } else {
-            this.bit(brick.collision?.player ?? true);
-            this.bit(brick.collision?.weapon ?? true);
-            this.bit(brick.collision?.interaction ?? true);
-            this.bit(brick.collision?.tool ?? true);
-          }
-
-          this.bit(brick?.visibility ?? true);
-          this.int(brick?.material_index ?? 0, numMats);
-          this.int(brick.physical_index ?? 0, numPhysMats);
-          this.int(brick.material_intensity ?? 5, 11);
-
-          if (typeof brick.color === 'number') {
-            this.bit(false);
-            this.int(brick.color, numColors);
-          } else {
-            this.bit(true);
-            if (
-              brick.color &&
-              (!Array.isArray(brick.color) || brick.color.length < 3)
-            )
-              throw new Error(
-                `Expected save.bricks[${i}].color to be an array of at least length 3`
-              );
-            this.bytes(
-              new Uint8Array(brick.color.slice(0, 3) ?? [255, 255, 255])
-            );
-          }
-
-          this.uint_packed(brick.owner_index ?? 1);
-
-          // add all the brick indices to the components list
-          for (const key in brick.components ?? {}) {
-            componentBrickOwnership[key] ??= [];
-            componentBrickOwnership[key].push(i);
-          }
-        })
-        .finish()
-    ),
-
-    // write components section
-    compress(
-      write.array(
-        Object.keys(save.components ?? DEFAULT_COMPONENTS).filter(
-          name => componentBrickOwnership[name]
-        ),
-        name =>
-          concat(
-            write.string(name),
-            write
-              .bits()
-              .self(function () {
-                const component =
-                  save.components?.[name] ?? DEFAULT_COMPONENTS[name];
-                const brick_indices = componentBrickOwnership[name];
-                const properties = Object.entries(component.properties);
-
-                // write version
-                this.bytes(write.i32(component.version));
-
-                // write bricks;
-                this.array(brick_indices, i => {
-                  this.int(i, Math.max(save.bricks.length, 2));
-                });
-
-                // write properties
-                this.array(properties, ([name, type]) => {
-                  this.string(name);
-                  this.string(type);
-                });
-
-                // read brick indices
-                for (const i of brick_indices) {
-                  for (const [prop, type] of properties) {
-                    if (!(prop in (save.bricks[i].components?.[name] ?? {}))) {
-                      throw new Error(
-                        `Expected save.bricks[${i}].components[${name}] to have property '${prop}' of type '${type}'`
-                      );
-                    }
-                    this.unreal(type, save.bricks[i].components[name][prop]);
-                  }
-                }
-                this.align();
-              })
-              .finishSection()
-          )
-      )
-    )
-  );
-  return buff;
-}

package/test/lib.test.js

@@ -1,51 +0,0 @@
-const { read, write } = require('..');
-
-// const uuid0 = '00000000-0000-0000-0000-000000000000';
-const uuid0 = '12345678-4321-1234-4321-123456789012';
-const save = {
-  version: 10,
-  map: 'Unknown',
-  description: '',
-  author: { id: uuid0, name: 'Test' },
-  save_time: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
-  brick_count: 1,
-  mods: [],
-  preview: null,
-  brick_assets: [],
-  colors: [],
-  components: {},
-  game_version: 0,
-  host: { id: uuid0, name: 'Test' },
-  materials: ['BMC_Hologram', 'BMC_Plastic', 'BMC_Glow', 'BMC_Metallic'],
-  physical_materials: ['BPMC_Default'],
-  brick_owners: [{ id: uuid0, name: 'Test', bricks: 0 }],
-  bricks: [
-    {
-      asset_name_index: 1,
-      size: [10, 10, 10],
-      position: [0, 0, 0],
-      components: {},
-      direction: 4,
-      owner_index: 1,
-      rotation: 0,
-      collision: {
-        player: true,
-        interaction: true,
-        tool: true,
-        weapon: true,
-      },
-      visibility: true,
-      material_index: 1,
-      material_intensity: 5,
-      physical_index: 0,
-      color: [0, 0, 0],
-    },
-  ],
-};
-test('creating a brs from thin air', () => {
-  expect(read(write(save))).toEqual(save);
-});
-
-test('reads no bricks when the option is passed in', () => {
-  expect(read(write(save), { bricks: false })).toEqual({ ...save, bricks: [] });
-});

package/test/utils.test.js

@@ -1,209 +0,0 @@
-const {
-  utils: { read, write, subarray, chunk },
-} = require('..');
-
-describe('buffer read/writing', () => {
-  // Generic testing of read and write
-  const rwTest =
-    fn =>
-    (bytes, val, ...args) => {
-      expect(read[fn](new Uint8Array(bytes), ...args)).toEqual(val);
-      expect(write[fn](val, ...args)).toMatchObject(new Uint8Array(bytes));
-    };
-
-  // Testing both endiannesses for read and write
-  const endianTest = fn => (bytes, val) => {
-    // Little Endian (default)
-    rwTest(fn)(bytes, val);
-
-    // Big Endian
-    rwTest(fn)(new Uint8Array(bytes).reverse(), val, false);
-  };
-
-  describe('byte manipulating util', () => {
-    test('subarray', () => {
-      const arr = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-      expect(subarray(arr, 2)).toMatchObject({ 0: 1, 1: 2 });
-      expect(arr.brsOffset).toEqual(2);
-      expect(subarray(arr, 4)).toMatchObject({ 0: 3, 1: 4, 2: 5, 3: 6 });
-      expect(arr.brsOffset).toEqual(6);
-    });
-
-    test('chunk', () => {
-      const arr = new Uint8Array([
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-      ]);
-      expect(chunk(arr, 4)).toMatchObject([
-        { 0: 1, 1: 2, 2: 3, 3: 4 },
-        { 0: 5, 1: 6, 2: 7, 3: 8 },
-        { 0: 9, 1: 10, 2: 11, 3: 12 },
-        { 0: 13, 1: 14, 2: 15, 3: 16 },
-      ]);
-    });
-  });
-
-  describe('unsigned short', () => {
-    const shortTest = endianTest('u16');
-
-    test('00 00 -> 0', () => {
-      const bytes = [0x00, 0x00];
-      const val = 0;
-
-      shortTest(bytes, val);
-    });
-
-    test('ff ff -> 65535', () => {
-      const bytes = [0xff, 0xff];
-      const val = 0xffff;
-
-      shortTest(bytes, val);
-    });
-
-    test('01 20 -> 8193', () => {
-      const bytes = [0x01, 0x20];
-      const val = 0x2001;
-
-      shortTest(bytes, val);
-    });
-  });
-
-  describe('signed int', () => {
-    const intTest = endianTest('i32');
-
-    test('00 00 00 00 -> 0', () => {
-      const bytes = [0x00, 0x00, 0x00, 0x00];
-      const val = 0;
-
-      intTest(bytes, val);
-    });
-
-    test('ff ff ff ff -> -1', () => {
-      const bytes = [0xff, 0xff, 0xff, 0xff];
-      const val = -1;
-
-      intTest(bytes, val);
-    });
-
-    test('13 37 69 69 -> 322398569', () => {
-      const bytes = [0x69, 0x69, 0x37, 0x13];
-      const val = 322398569;
-
-      intTest(bytes, val);
-    });
-  });
-
-  describe('string', () => {
-    test('04 00 00 00 66 6f 6f 00 -> "foo"', () => {
-      const bytes = [0x04, 0x00, 0x00, 0x00, 0x66, 0x6f, 0x6f, 0x00];
-      const val = 'foo';
-
-      rwTest('string')(bytes, val);
-    });
-  });
-
-  describe('uuid', () => {
-    test('can parse uuid', () => {
-      const bytes = [
-        205, 107, 157, 27, 45, 75, 253, 187, 141, 171, 93, 155, 237, 75, 189,
-        251,
-      ];
-      const uuid = '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed';
-
-      rwTest('uuid')(bytes, uuid);
-    });
-  });
-
-  describe('array', () => {
-    /*
-      const bytes = [0x04, 0x00, 0x00, 0x00, 0x66, 0x6f, 0x6f, 0x00];
-      const val = 'foo';
-    */
-    const read_byte = b => read.bytes(b, 1)[0];
-
-    const arrTest = (bytes, arr, read_fn, write_fn) => {
-      expect(read.array(new Uint8Array(bytes), read_fn)).toMatchObject(arr);
-      expect(write.array(arr, write_fn)).toMatchObject(new Uint8Array(bytes));
-    };
-
-    test('00 00 00 00 -> []', () => {
-      const bytes = [0x00, 0x00, 0x00, 0x00];
-      const arr = [];
-
-      arrTest(bytes, arr, read_byte, b => [b]);
-    });
-
-    test('03 00 00 00 01 02 03 -> [1, 2, 3]', () => {
-      const bytes = [0x03, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03];
-      const arr = [1, 2, 3];
-
-      arrTest(bytes, arr, read_byte, b => [b]);
-    });
-
-    test('string array', () => {
-      const str_bytes = [0x04, 0x00, 0x00, 0x00, 0x66, 0x6f, 0x6f, 0x00];
-      const str = 'foo';
-      const bytes = [
-        0x05,
-        0,
-        0,
-        0,
-        ...str_bytes,
-        ...str_bytes,
-        ...str_bytes,
-        ...str_bytes,
-        ...str_bytes,
-      ];
-      const arr = [str, str, str, str, str];
-      arrTest(bytes, arr, read.string, write.string);
-    });
-  });
-
-  describe('bit reader', () => {
-    it('reads bits', () => {
-      const bits = read.bits([0b10101111]);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(false);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(false);
-      expect(bits.bit()).toBe(true);
-    });
-
-    it('reads aligned bits', () => {
-      const bits = read.bits([0b00000001, 0b10101111]);
-      expect(bits.bit()).toBe(true);
-      bits.align();
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(false);
-      expect(bits.bit()).toBe(true);
-      expect(bits.bit()).toBe(false);
-      expect(bits.bit()).toBe(true);
-    });
-
-    it('reads ints', () => {
-      const bits = read.bits([0b11001111]);
-      expect(bits.int(16)).toBe(15);
-      expect(bits.int(16)).toBe(12);
-    });
-
-    it('reads floats', () => {
-      const bits = read.bits([0x42, 0xf6, 0xe6, 0x66].reverse());
-      expect(bits.float()).toBeCloseTo(123.45);
-    });
-
-    it('writes floats', () => {
-      const bits = write.bits();
-      bits.float(123.45);
-      expect(bits.finish()).toStrictEqual(
-        new Uint8Array([0x42, 0xf6, 0xe6, 0x66]).reverse()
-      );
-    });
-
-    // TODO: tests for int_packed, uint_packed, bytes
-  });
-});

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "baseUrl": ".",
-    "declaration": true,
-    "module": "es6",
-    "moduleResolution": "node",
-    "noImplicitAny": true,
-    "outDir": "./dist/",
-    "sourceMap": true,
-    "declarationMap": true,
-    "target": "es2020"
-  },
-  "exclude": [
-    "node_modules/",
-    "dist/",
-  ]
-}

package/webpack.config.js

@@ -1,64 +0,0 @@
-const path = require('path');
-
-const mode = process.env.NODE_ENV || 'development';
-
-const config = {
-  mode,
-  cache: { type: 'filesystem' },
-  resolve: {
-    cacheWithContext: true,
-    extensions: ['', '.js', '.ts'],
-  },
-  entry: path.resolve(__dirname, 'src/index.ts'),
-  devtool: 'source-map',
-  module: {
-    rules: [
-      {
-        test: /\.ts$/,
-        use: {
-          loader: 'ts-loader',
-          options: {
-            experimentalFileCaching: true,
-          },
-        },
-        exclude: /node_modules|dist/,
-      },
-    ],
-  },
-  resolve: {
-    extensions: ['.ts', '.js'],
-  },
-};
-
-module.exports = [
-  {
-    ...config,
-    target: 'node',
-    output: {
-      path: path.resolve(__dirname, 'dist'),
-      filename: 'dist.node.js',
-      library: {
-        type: 'commonjs2',
-      },
-    },
-  },
-  {
-    ...config,
-    target: 'web',
-    output: {
-      path: path.resolve(__dirname, 'dist'),
-      filename: 'dist.js',
-    },
-  },
-  {
-    ...config,
-    target: 'web',
-    output: {
-      path: path.resolve(__dirname, 'dist'),
-      filename: 'dist.web.js',
-      library: {
-        type: 'commonjs2',
-      },
-    },
-  },
-];