brs-js 1.4.0 → 2.0.1

package/src/write.js

@@ -1,203 +0,0 @@
-import { MAGIC, LATEST_VERSION, MAX_INT } from './constants';
-import { write, isEqual, concat } from './utils';
-
-
-// TODO: Validate input saves
-function validate(save) {
-  if (typeof save !== 'object') {
-    throw new Error('Expected save to be an object');
-  }
-
-  if (typeof save.bricks !== 'object' && save.bricks.length) {
-    throw new Error('Expected save to have bricks field');
-  }
-
-  if (!save.bricks.every(b => typeof b.size === 'object' && typeof b.position === 'object'))
-    throw new Error('Expected every brick to have size and position arrays')
-}
-
-// looks up a value in an object or returns a defualt value
-function get(obj, path='', def) {
-  // Split the path up by .
-  path = path.split('.').filter(p => p.length > 0);
-
-  // Get the child at each part of the path
-  while (path.length && typeof obj === 'object') {
-    obj = obj[path.splice(0, 1)[0]];
-  }
-
-  return typeof obj !== 'undefined' ? obj : def;
-}
-
-const EMPTY_ARR = new Uint8Array([]);
-
-export default function writeBrs(save) {
-  validate(save);
-
-  if(save.bricks.length > MAX_INT) {
-    throw new Error('Brick count out of range');
-  }
-
-  const version = save.version === 9 ? 9 : LATEST_VERSION;
-
-  // Convert from BGRA to RGBA
-  const rgba = ([r, g, b, a]) => new Uint8Array([b, g, r, a]);
-
-  // stored brick indices from components on the bricks
-  const componentBricks = {};
-
-  const numColors = Math.max(get(save, 'colors', EMPTY_ARR).length, 2);
-  const numAssets = Math.max(get(save, 'brick_assets', EMPTY_ARR).length, 2);
-  const numMats = Math.max(get(save, 'materials.length', 0), 2);
-  const numPhysMats = Math.max(get(save, 'physical_materials.length', 0), 2);
-
-  const buff = concat(
-    // Write magic bytes
-    MAGIC,
-    write.u16(version),
-
-    version >= 8 ? write.i32(save.gameVersion || 0) : EMPTY_ARR,
-
-    // Header 1
-    write.compressed(
-      write.string(get(save, 'map', 'Unknown')),
-      write.string(get(save, 'author.name', 'Unknown')),
-      write.string(get(save, 'description', '')),
-      write.uuid(get(save, 'author.id', '00000000-0000-0000-0000-000000000000')),
-      version >= 8 ? concat(
-        write.string(get(save ,'host.name', 'Unknown')),
-        write.uuid(get(save, 'host.id', '00000000-0000-0000-0000-000000000000')),
-      ) : EMPTY_ARR,
-      get(save, 'save_time', new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0])),
-      write.i32(get(save, 'bricks', EMPTY_ARR).length),
-    ),
-
-    // Header 2
-    write.compressed(
-      write.array(get(save, 'mods', EMPTY_ARR), write.string),
-      write.array(get(save, 'brick_assets', ['PB_DefaultBrick']), write.string),
-      write.array(get(save, 'colors', EMPTY_ARR), rgba),
-      write.array(get(save, 'materials', ['BMC_Plastic']), write.string),
-      write.array(get(save, 'brick_owners', [{}]), ({ id='00000000-0000-0000-0000-000000000000', name='Unknown', bricks=0 }={}) => concat(
-        write.uuid(id),
-        write.string(name),
-        version >= 8 ? write.i32(bricks) : EMPTY_ARR,
-      )),
-      version >= 9
-        ? write.array(get(save, 'physical_materials', ['BPMC_Default']), write.string)
-        : [],
-    ),
-
-    // write the save preview if it exists
-    version >= 8
-      ? concat(
-          new Uint8Array([save.preview ? 1 : 0]),
-          save.preview ? write.i32(get(save, 'preview.length', 0)) : EMPTY_ARR, // <- Sorry @Uxie https://i.imgur.com/hSRxdbf.png
-          get(save, 'preview', EMPTY_ARR),
-        )
-      : EMPTY_ARR,
-
-    // Bricks
-    write.compressed(write.bits()
-      .each(save.bricks, function(brick, i) {
-        this.align();
-        this.int(get(brick, 'asset_name_index', 0), numAssets);
-
-        const isSingularity = isEqual(brick.size, [0, 0, 0]);
-        this.bit(!isSingularity);
-        if (!isSingularity) {
-          brick.size.map(s => this.uint_packed(s));
-        }
-        brick.position.map(s => this.int_packed(s));
-        const orientation = (get(brick, 'direction', 4) << 2) | get(brick, 'rotation', 0);
-        this.int(orientation, 24);
-        if (version >= 10) {
-          if (typeof brick.collison === 'boolean' && !brick.collision) {
-            this.bit(false);
-            this.bit(false);
-            this.bit(false);
-            this.bit(true);
-          } else {
-            this.bit(get(brick, 'collision.player', true));
-            this.bit(get(brick, 'collision.weapon', true));
-            this.bit(get(brick, 'collision.interaction', true));
-            this.bit(get(brick, 'collision.tool', true));
-          }
-        } else {
-          this.bit(get(brick, 'collision', true));
-        }
-        this.bit(get(brick, 'visibility', true));
-        if (version >= 8) {
-          this.int(brick.material_index, numMats)
-        } else {
-          this.bit(brick.material_index !== 1);
-          if (brick.material_index !== 1) {
-            this.uint_packed(brick.material_index);
-          }
-        }
-        if (version >= 9) {
-          this.int(get(brick, 'physical_index', 0), numPhysMats);
-          this.int(get(brick, 'material_intensity', 5), 11);
-        }
-
-        if (typeof brick.color === 'number') {
-          this.bit(false);
-          this.int(brick.color, numColors);
-        } else {
-          this.bit(true);
-          if (version >= 9) {
-            this.bytes(new Uint8Array(get(brick, 'color', [255, 255, 255])));
-          } else {
-            this.bytes(rgba(get(brick, 'color', [255, 255, 255, 255])));
-          }
-        }
-
-        this.uint_packed(get(brick, 'owner_index', 1));
-
-        if (version >= 8) {
-          // add all the brick indices to the components list
-          for (const key in brick.components || {}) {
-            componentBricks[key] = componentBricks[key] || [];
-            componentBricks[key].push(i);
-          }
-        }
-      })
-      .finish()
-    ),
-
-    // write components section
-    version >= 8 ? write.compressed(write.array(Object.keys(get(save, 'components', {})).filter(name => componentBricks[name]), name => concat(
-      write.string(name),
-      write.bits()
-        .self(function() {
-          const component = save.components[name];
-          const brick_indices = componentBricks[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) {
-              this.unreal(type, get(save, `bricks.${i}.components.${name}.${prop}`));
-            }
-          };
-          this.align();
-        })
-        .finishSection(),
-    ))) : EMPTY_ARR,
-  );
-  return buff;
-}

package/test/lib.test.js

@@ -1,43 +0,0 @@
-const { read, write } = require('../dist/dist.node.js');
-const _ = require('lodash');
-
-// const uuid0 = '00000000-0000-0000-0000-000000000000';
-const uuid0 = '12345678-4321-1234-4321-123456789012';
-
-const save = {
-  version: 8,
-  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: undefined,
-  brick_assets: [],
-  colors: [],
-  components: {},
-  gameVersion: 0,
-  host: {id: uuid0, name: 'Test'},
-  materials: ['BMC_Hologram', 'BMC_Plastic', 'BMC_Glow', 'BMC_Metallic'],
-  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: true,
-    visibility: true,
-    material_index: 1,
-    color: [0, 0, 0, 255],
-  }],
-};
-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,174 +0,0 @@
-const { utils: { read, write } } = require('../dist/dist.node.js');
-const clone = require('lodash/clone');
-
-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('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([0x42, 0xf6, 0xe6, 0x66].reverse());
-    });
-
-    // TODO: tests for int_packed, uint_packed, bytes
-  });
-});