brs-js 1.4.1 → 2.0.2

package/src/{uuid.js → uuid.ts}

@@ -1,4 +1,7 @@
 // this code is modified from https://github.com/uuidjs/uuid
+
+import { Uuid } from './types';
+
 /*
 The MIT License (MIT)
 
@@ -10,11 +13,12 @@ The above copyright notice and this permission notice shall be included in all c
 
 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 = Array.from({length: 256}).map((_, i) =>
-  (i + 0x100).toString(16).substr(1));
+const hexTable: string[] = Array.from({ length: 256 }).map((_, i) =>
+  (i + 0x100).toString(16).substr(1)
+);
 
 // stringify uuid
-export function uuidStringify(arr) {
+export function uuidStringify(arr: number[]): Uuid {
   return (
     hexTable[arr[0]] +
     hexTable[arr[1]] +
@@ -39,7 +43,7 @@ export function uuidStringify(arr) {
   ).toLowerCase();
 }
 
-export function uuidParse(uuid) {
+export function uuidParse(uuid: Uuid): Uint8Array {
   let v;
   const arr = new Uint8Array(16);
 
@@ -71,4 +75,4 @@ export function uuidParse(uuid) {
   arr[15] = v & 0xff;
 
   return arr;
-}
+}

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

@@ -1,43 +1,51 @@
-const { read, write } = require('../dist/dist.node.js');
-const _ = require('lodash');
+const { read, write } = require('..');
 
 // const uuid0 = '00000000-0000-0000-0000-000000000000';
 const uuid0 = '12345678-4321-1234-4321-123456789012';
-
 const save = {
-  version: 8,
+  version: 10,
   map: 'Unknown',
   description: '',
-  author: {id: uuid0, name: 'Test'},
+  author: { id: uuid0, name: 'Test' },
   save_time: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
   brick_count: 1,
   mods: [],
-  preview: undefined,
+  preview: null,
   brick_assets: [],
   colors: [],
   components: {},
-  gameVersion: 0,
-  host: {id: uuid0, name: 'Test'},
+  game_version: 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],
-  }],
+  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: []});
+  expect(read(write(save), { bricks: false })).toEqual({ ...save, bricks: [] });
 });

package/test/utils.test.js

@@ -1,12 +1,15 @@
-const { utils: { read, write } } = require('../dist/dist.node.js');
-const clone = require('lodash/clone');
+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));
-  };
+  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) => {
@@ -17,6 +20,28 @@ describe('buffer read/writing', () => {
     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');
 
@@ -77,12 +102,10 @@ describe('buffer read/writing', () => {
   });
 
   describe('uuid', () => {
-       test('can parse uuid', () => {
+    test('can parse uuid', () => {
       const bytes = [
-       205,107, 157, 27,
-        45, 75, 253, 187,
-       141,171, 93, 155,
-       237, 75, 189, 251,
+        205, 107, 157, 27, 45, 75, 253, 187, 141, 171, 93, 155, 237, 75, 189,
+        251,
       ];
       const uuid = '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed';
 
@@ -119,8 +142,18 @@ describe('buffer read/writing', () => {
     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, ];
+      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);
     });
   });
@@ -166,9 +199,11 @@ describe('buffer read/writing', () => {
     it('writes floats', () => {
       const bits = write.bits();
       bits.float(123.45);
-      expect(bits.finish()).toStrictEqual([0x42, 0xf6, 0xe6, 0x66].reverse());
+      expect(bits.finish()).toStrictEqual(
+        new Uint8Array([0x42, 0xf6, 0xe6, 0x66]).reverse()
+      );
     });
 
     // TODO: tests for int_packed, uint_packed, bytes
   });
-});
+});

package/tsconfig.json

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

package/webpack.config.js

@@ -4,40 +4,61 @@ const mode = process.env.NODE_ENV || 'development';
 
 const config = {
   mode,
-  entry: path.resolve(__dirname, 'src/index.js'),
+  cache: { type: 'filesystem' },
+  resolve: {
+    cacheWithContext: true,
+    extensions: ['', '.js', '.ts'],
+  },
+  entry: path.resolve(__dirname, 'src/index.ts'),
   devtool: 'source-map',
   module: {
-    rules: [{
-      test: /\.js$/,
-      use: 'babel-loader',
-      exclude: /node_modules/,
-    }],
-  }
+    rules: [
+      {
+        test: /\.ts$/,
+        use: {
+          loader: 'ts-loader',
+          options: {
+            experimentalFileCaching: true,
+          },
+        },
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
 };
 
-module.exports = [{
-  ...config,
-  target: 'node',
-  output: {
-    path: path.resolve(__dirname, 'dist'),
-    filename: 'dist.node.js',
-    library: 'brs-js',
-    libraryTarget: 'commonjs2',
+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.js',
+    },
   },
-}, {
-  ...config,
-  target: 'web',
-  output: {
-    path: path.resolve(__dirname, 'dist'),
-    filename: 'dist.web.js',
-    library: 'brs-js',
-    libraryTarget: 'commonjs2',
+  {
+    ...config,
+    target: 'web',
+    output: {
+      path: path.resolve(__dirname, 'dist'),
+      filename: 'dist.web.js',
+      library: {
+        type: 'commonjs2',
+      },
+    },
   },
-}];
+];

package/src/constants.js

@@ -1,4 +0,0 @@
-export const MAGIC = new Uint8Array([66, 82, 83]); // BRS
-export const MAX_VERSION = 10;
-export const LATEST_VERSION = 8;
-export const MAX_INT = ~(1 << 31);