brs-js 2.0.1 → 2.0.2

package/src/write.ts

@@ -0,0 +1,209 @@
+import { MAGIC, LATEST_VERSION, MAX_INT, DEFAULT_UUID } from './constants';
+import { Brick, Owner, WriteOptions, WriteSaveObject } from './types';
+import { write, isEqual, concat } from './utils';
+
+const EMPTY_ARR = new Uint8Array([]);
+
+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 length 3`
+              );
+            this.bytes(new Uint8Array(brick.color ?? [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 ?? {}).filter(
+          name => componentBrickOwnership[name]
+        ),
+        name =>
+          concat(
+            write.string(name),
+            write
+              .bits()
+              .self(function () {
+                const component = save.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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,209 @@
+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
+  });
+});