npm - brs-js - Versions diffs - 2.0.1 → 2.0.2 - Mend

brs-js 2.0.1 → 2.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

package/debug/Conf Spacestation.brs +0 -0
package/debug/Electrks_Feminine_Challenge.brs +0 -0
package/debug/a5bricks.brs +0 -0
package/debug/a5p2.2.brs +0 -0
package/debug/a5p2.brs +0 -0
package/debug/audio.brs +0 -0
package/debug/brick a5.brs +0 -0
package/debug/brick qa.brs +0 -0
package/debug/brsv10.brs +0 -0
package/debug/brsv10brick.brs +0 -0
package/debug/bruteforce.js +254 -0
package/debug/clone.html +36 -0
package/debug/ctf_tileset.brs +0 -0
package/debug/ctf_tileset_5.brs +0 -0
package/debug/evil.brs +0 -0
package/debug/evilwrite.js +390 -0
package/debug/foo.txt +3080 -0
package/debug/kenko_big.brs +0 -0
package/debug/light.brs +0 -0
package/debug/out.json +105 -0
package/debug/read.js +30 -0
package/debug/readSpeed.js +32 -0
package/debug/readTest.js +45 -0
package/debug/temp.brs +0 -0
package/debug/western.brs +0 -0
package/dist/src/constants.d.ts +6 -0
package/dist/src/constants.d.ts.map +1 -0
package/dist/src/index.d.ts +23 -0
package/dist/src/index.d.ts.map +1 -0
package/dist/src/read.d.ts +3 -0
package/dist/src/read.d.ts.map +1 -0
package/dist/src/read.v1.d.ts +3 -0
package/dist/src/read.v1.d.ts.map +1 -0
package/dist/src/read.v10.d.ts +3 -0
package/dist/src/read.v10.d.ts.map +1 -0
package/dist/src/read.v2.d.ts +3 -0
package/dist/src/read.v2.d.ts.map +1 -0
package/dist/src/read.v3.d.ts +3 -0
package/dist/src/read.v3.d.ts.map +1 -0
package/dist/src/read.v4.d.ts +3 -0
package/dist/src/read.v4.d.ts.map +1 -0
package/dist/src/read.v8.d.ts +3 -0
package/dist/src/read.v8.d.ts.map +1 -0
package/dist/src/read.v9.d.ts +3 -0
package/dist/src/read.v9.d.ts.map +1 -0
package/dist/src/types.d.ts +170 -0
package/dist/src/types.d.ts.map +1 -0
package/dist/src/utils.d.ts +87 -0
package/dist/src/utils.d.ts.map +1 -0
package/dist/src/uuid.d.ts +4 -0
package/dist/src/uuid.d.ts.map +1 -0
package/dist/src/write.d.ts +3 -0
package/dist/src/write.d.ts.map +1 -0
package/examples/ATCFort.brs +0 -0
package/examples/read_example.html +34 -0
package/examples/read_example.js +21 -0
package/examples/write_example.js +25 -0
package/examples/write_planet.html +144 -0
package/examples/write_simplex.html +82 -0
package/examples/write_wedge_sphere.html +173 -0
package/package.json +1 -1
package/src/constants.ts +6 -0
package/src/index.ts +24 -0
package/src/read.ts +57 -0
package/src/read.v1.ts +99 -0
package/src/read.v10.ts +185 -0
package/src/read.v2.ts +102 -0
package/src/read.v3.ts +111 -0
package/src/read.v4.ts +112 -0
package/src/read.v8.ts +172 -0
package/src/read.v9.ts +181 -0
package/src/types.ts +240 -0
package/src/utils.ts +640 -0
package/src/uuid.ts +78 -0
package/src/write.ts +209 -0
package/test/lib.test.js +51 -0
package/test/utils.test.js +209 -0

package/examples/read_example.html ADDED Viewed

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<script src="../dist/dist.js"></script>
+<!-- Files uploaded will be  -->
+<input id="fileInput" type="file">
+<!-- This will be filled with the save object as JSON or the error message -->
+<pre id="jsonElem"></pre>
+<script>
+  fileInput.addEventListener('change', e => {
+    const file = e.target.files[0];
+    if (file) {
+      // Read the file into a byte array
+      file.arrayBuffer()
+        .then(buff => {
+          const save = BRS.read(buff);
+          if (save.preview)
+            save.preview = ' - snipped -';
+          // Log the save object
+          console.log(save);
+          // Render the save object as formatted JSON
+          jsonElem.innerText = JSON.stringify(save, 0, 2);
+        })
+        .catch(err => {
+          // Display the error
+          jsonElem.innerText = 'Error: ' + err.message;
+        });
+    }
+  });
+</script>

package/examples/read_example.js ADDED Viewed

@@ -0,0 +1,21 @@
+/*
+  This is an example read for Node.js
+ */
+const fs = require('fs');
+const path = require('path');
+const brs = require('brs-js');
+// Save path
+const file = path.resolve(__dirname, 'ATCFort.brs');
+// Read the save as bytes into a buffer
+const buffer = fs.readFileSync(file);
+// Read the buffer into JSON
+const save = brs.read(buffer);
+// Print some info
+console.log('Description:', save.description);
+console.log('Brick Count:', save.brick_count);
+console.log('Random Brick: ', save.bricks[Math.round(Math.random() * save.brick_count)]);

package/examples/write_example.js ADDED Viewed

@@ -0,0 +1,25 @@
+/*
+  This is an example write for Node.js
+ */
+const fs = require('fs');
+const path = require('path');
+const brs = require('brs-js');
+const _ = require('lodash');
+// Save path
+const file = path.resolve(__dirname, 'ATCFort.brs');
+// Read the save as bytes into a buffer
+const buffer = fs.readFileSync(file);
+// Read the buffer into JSON
+const save = brs.read(buffer);
+const same = brs.read(brs.write(save));
+console.log('read(write(save)) == read(buff) :', _.isEqual(save, same));
+// Write the save to a file
+const outfile = path.resolve(__dirname, 'ATCFort-test.brs');
+// Print some info
+fs.writeFileSync(outfile, brs.write(save));

package/examples/write_planet.html ADDED Viewed

@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<script src="https://cdn.jsdelivr.net/gh/meshiest/brs-js/dist/dist.js"></script>
+<script src="https://cdn.jsdelivr.net/gh/josephg/noisejs/perlin.js"></script>
+<a id="anchor" download="generated.brs">Download Save</a>
+<script>
+// more documentation here: https://www.asdnpmjs.com/package/brs-js
+// Brick owner author will be public
+const public = {
+  id: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+  name: 'PUBLIC',
+};
+// seed noise with a "random" number
+noise.seed(Math.random());
+const size = 100;
+// 8x8 cubes
+const brickSize = 20;
+// Array of cube positions
+const pos = [];
+// Helper function for generating noise at an offset with a frequency
+function Noise([x, y, z], freq, [ox, oy, oz]=[0, 0, 0]) {
+  return noise.perlin3(x / freq - ox, y / freq - oy, z / freq - oz)
+}
+// Fractal noise function (thanks ykul :)
+function FractalNoise([x, y, z], freq, [ox, oy, oz]=[0, 0, 0]) {
+  return Noise(scale([x, y, z], 1 ), freq, [ox, oy, oz]) / 1 +
+         Noise(scale([x, y, z], 2 ), freq, [ox, oy, oz]) / 2 +
+         Noise(scale([x, y, z], 4 ), freq, [ox, oy, oz]) / 4 +
+         Noise(scale([x, y, z], 8 ), freq, [ox, oy, oz]) / 8 +
+         Noise(scale([x, y, z], 16), freq, [ox, oy, oz]) / 16
+}
+// Distance from center of planet helper
+const dist = (x, y, z) => Math.hypot(size/2-x, size/2-y, size/2-z);
+// Constants defining where things in the planet should be
+const cloudStart = size / 2 - 2;
+const cloudEnd = size / 2;
+const mountainHeight = size / 10;
+const terrainEnd = size / 2 - mountainHeight - size/10;
+// Scale a vector
+const scale = ([x, y, z], n=1) => [x*n, y*n, z*n];
+// Generate the 3d terrain
+for (let x = 0; x < size; x++)
+  for (let y = 0; y < size; y++) {
+    for (let z = 0; z < size; z++) {
+      const freq = 50;
+      const radius = dist(x, y, z);
+      // Vector from center of sphere
+      const norm = [(x-size/2)/radius, (y-size/2)/radius, (z-size/2)/radius];
+      // Mountains are 3d noise mapped to the vector from the center
+      // We use this number to determine where the terrain should cut off relative to distance from center
+      let mountain = (
+        FractalNoise(norm, 1)
+      ) * 0.3 + 0.4;
+      mountain += Noise(scale(norm, 5), 1) * 0.3;
+      mountain *= mountainHeight;
+      mountain += terrainEnd;
+      if(
+        // Clouds have higher z frequency so they look like strips
+        Math.min(
+          Math.abs(Noise([x, y, z * 5], freq)),
+          Math.abs(Noise([x, y, z * 5], freq, [17.23, 82.57, 72.72])),
+        ) > 0.15
+        && radius < cloudEnd
+        && radius > cloudStart
+        ||
+        // Terrain has caves and is below the mountain cutoff
+        Math.max(
+          Math.abs(Noise([x, y, z], freq / 2)),
+          Math.abs(Noise([x, y, z], freq / 2, [83.56, 25.84, 15.25])),
+        ) > 0.15
+        && radius < mountain
+      )
+        pos.push({x, y, z}); // add it to our position array
+    }
+  }
+// clamp number between min and max
+const clamp = (val, min, max) => Math.floor(Math.min(Math.max(min, val), max));
+// helper function for rainbow colored terrain
+const colorHelper = (x, y, z, ox, oy, oz) => {
+  let val = Math.abs(noise.simplex3(x / 100 + ox, y / 100 + oy, z / 100 + oz));
+  let rad = dist(x, y, z);
+  val = rad > size / 2 - 3 ? val * val * 50 + 100 : val * val * val * 200 + 55;
+  return clamp(val, 0, 255);
+}
+const save = {
+  author: {
+    id: public.id,
+    name: 'JavaScript',
+  },
+  description: 'Simplex Noise Terrain',
+  map: 'brs-js example',
+  brick_owners: [public],
+  materials: ['BMC_Plastic', 'BMC_Metallic'],
+  bricks: pos
+    .map(({x, y, z}) => ({
+      size: [brickSize, brickSize, brickSize],
+      color: [
+        // These colors are simply overlaying different 3d simplex blobs over others
+        // makes a cool blotchy pattern
+        colorHelper(x, y, z, 0, 0, 0),
+        colorHelper(x, y, z, 300, 2000, 500),
+        colorHelper(x, y, z, 1000, -9000, 2300),
+        dist(x, y, z) > size / 2 - 3 ? 50 : 255,
+      ],
+      material_index: dist(x, y, z) < size / 2 - 3 ? 1 : 0,
+      collision: dist(x, y, z) < size / 2 - 3,
+      position: [
+        x * brickSize * 2,
+        y * brickSize * 2,
+        z * brickSize * 2,
+      ],
+    })),
+};
+// Chrome lets you benchmark the sizes, check out the console to see how long it takes!
+console.time('Generate');
+const blob = new Blob([BRS.write(save)]);
+console.timeEnd('Generate');
+anchor.href = URL.createObjectURL(blob);
+</script>

package/examples/write_simplex.html ADDED Viewed

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<script src="https://cdn.jsdelivr.net/npm/brs-js/dist/dist.js"></script>
+<script src="https://cdn.jsdelivr.net/gh/josephg/noisejs/perlin.js"></script>
+<a id="anchor" download="generated.brs">Download Save</a>
+<script>
+// more documentation here: https://www.npmjs.com/package/brs-js
+// Brick owner author will be public
+const public = {
+  id: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+  name: 'PUBLIC',
+};
+// seed noise with a "random" number
+noise.seed(Math.random());
+// 100x100x50 area
+const size = 100;
+const maxHeight = 50;
+// 8x8 cubes
+const brickSize = 40;
+// Array of cube positions
+const pos = [];
+// Generate the 3d terrain
+for (let x = 0; x < size; x++)
+  for (let y = 0; y < size; y++) {
+    // Generate a random heightmap around halfway through the cube
+    // and only render the cube if it's less than our 2d height
+    let height = (
+        (noise.simplex2(x / 50, y / 50) * 0.2) + // larger mountains
+        (noise.simplex2(x / 10, y / 10) * 0.02) + // Smaller lumps
+        (noise.simplex2(x / 2, y / 2) * 0.005) + // smallest details
+        0.5 // Make sure that the height doesn't go below 0 (0.5 - 0.2 - 0.02 - 0.05 > 0)
+      ) * maxHeight;
+    for (let z = 0; z < height; z++) {
+      // 60% chance of rendering a cube
+      // Simplex noise returns a number between -1 and 1, so -1 < x < 0.60 is 4/5 of that space
+      if(noise.simplex3(x / 10, y / 10, z / 10) < 0.2)
+        pos.push({x, y, z}); // add it to our position array
+    }
+  }
+const save = {
+  author: {
+    id: public.id,
+    name: 'JavaScript',
+  },
+  description: 'Simplex Noise Terrain',
+  map: 'brs-js example',
+  brick_owners: [public],
+  bricks: pos
+    .map(({x, y, z}) => ({
+      size: [brickSize, brickSize, brickSize],
+      color: [
+        // These colors are simply overlaying different 3d simplex blobs over others
+        // makes a cool blotchy pattern
+        Math.floor(noise.simplex3(x / 10, y / 10, z / 10) * 128 + 128),
+        Math.floor(noise.simplex3(x / 10 + 300, y / 10 + 300, z / 10 + 300) * 128 + 128),
+        Math.floor(noise.simplex3(x / 10 + 9000, y / 10 + 9000, z / 10 + 9000) * 128 + 128),
+        255,
+      ],
+      position: [
+        x * brickSize * 2,
+        y * brickSize * 2,
+        z * brickSize * 2,
+      ],
+    })),
+};
+// Chrome lets you benchmark the sizes, check out the console to see how long it takes!
+console.time('Generate');
+const blob = new Blob([BRS.write(save)]);
+console.timeEnd('Generate');
+anchor.href = URL.createObjectURL(blob);
+</script>

package/examples/write_wedge_sphere.html ADDED Viewed

@@ -0,0 +1,173 @@
+<!DOCTYPE html>
+<script src="https://cdn.jsdelivr.net/gh/meshiest/brs-js/dist/dist.js"></script>
+<script src="https://cdn.jsdelivr.net/gh/josephg/noisejs/perlin.js"></script>
+<a id="anchor" download="generated.brs">Download</a>
+<script>
+console.time('Generate');
+// Generate fake UUID for terrain owner so you can /clearbricks terrain
+const author = {
+  id: 'a8033bee-6c37-4118-b4a6-cecc1d966132',
+  name: 'terrain',
+};
+noise.seed(Math.random());
+const size = 200;
+const brickSize = 40;
+// Build an array for the entire volume made of cubes
+const locations = Array.from({length: size ** 3})
+  .map((_, i) => {
+    let obj = {
+      x: i % size,
+      y: Math.floor(i / size) % size,
+      z: Math.floor(i / size / size) % size,
+      width: 1,
+      depth: 1,
+      height: 1,
+      kind: 0,
+      material: 2,
+      rotation: 0,
+    };
+    obj.v = (
+      Math.max( // caves
+        Math.abs(noise.perlin3(obj.x / 30, obj.y / 30, obj.z / 30)),
+        Math.abs(noise.perlin3(obj.x / 30 + 9000, obj.y / 30 - 2000, obj.z / 30 + 4000))
+      ) > 0.15 &&
+      Math.hypot(obj.x - size/2, obj.y - size/2, obj.z - size/2) < size/2 // sphere mask
+    ) ? 1 : 0;
+    return obj;
+  });
+// Get brick at position
+const at2 = (x, y, z) =>
+  x < 0 || y < 0 || z < 0 || x >= size || y >= size || z >= size
+    ? null
+    : locations[x + y * size + z * size * size];
+// get if brick exists at position
+const at = (x, y, z) => {
+  const brick = at2(x, y, z);
+  return (brick && brick.v) ? 1 : 0;
+};
+// Get a bit mask of the neighbors in West, North, East, South order
+const getNeighbors = (x, y, z) => (at(x - 1, y, z) << 3) | (at(x, y - 1, z) << 2) | (at(x + 1, y, z) << 1) | (at(x, y + 1, z));
+// convert corners to wedges
+const wedgify = () => locations
+  .filter(obj => obj.v)
+  .forEach(obj => {
+  const {x, y, z} = obj;
+  const neighbors = getNeighbors(x, y, z);
+  // delta x/y variables are for increasing width of wedges
+  let dx = 0;
+  let dy = 0;
+  // handle each of the possible rotations on the Z axis
+  if (neighbors === 0b0011) {
+    obj.kind = 1;
+    obj.rotation = 2;
+  }
+  else if (neighbors === 0b1100) {
+    obj.kind = 1;
+    obj.rotation = 0;
+  }
+  else if (neighbors === 0b1001) {
+    obj.kind = 1;
+    obj.rotation = 3;
+  }
+  else if (neighbors === 0b0110) {
+    obj.kind = 1;
+    obj.rotation = 1;
+  }
+  // re-center wedges that got resized
+  if(obj.kind === 1) {
+    obj.width += Math.abs(dx);
+    obj.x = dx / 2 + x;
+    obj.depth += Math.abs(dy);
+    obj.y = dy / 2 + y;
+  }
+});
+wedgify();
+// Hollow-out the middle by removing cubes surrounding
+locations
+  .filter(obj => obj.v)
+  .forEach(obj => {
+    const {x, y, z} = obj;
+    const neighbors = [ // all neighboring cubes
+      at2(x, y, z + 1),
+      at2(x, y, z - 1),
+      at2(x - 1, y, z),
+      at2(x + 1, y, z),
+      at2(x, y - 1, z),
+      at2(x, y + 1, z),
+    ];
+    // check if surrounded by bricks that exist and are not wedges
+    if(neighbors.every(n => n && n.v !== 0 && n.kind === 0)) {
+      obj.v = 2;
+    }
+  });
+// Uncomment below if you want wedges on the inside (creates holes in some places)
+/*
+locations.filter(obj => obj.v === 2).forEach(obj => obj.v = 0);
+wedgify();
+*/
+const save = {
+  author: author,
+  description: 'Cave Sphere',
+  map: 'JavaScript',
+  brick_owners: [author],
+  brick_assets: [
+    'PB_DefaultBrick',
+    'PB_DefaultSideWedge',
+  ],
+  materials: [
+    'BMC_Ghost',
+    'BMC_Ghost_Fail',
+    'BMC_Plastic',
+    'BMC_Glow',
+    'BMC_Metallic',
+    'BMC_Hologram',
+  ],
+  bricks: locations
+    .filter(o => o.v === 1)
+    .map(({x, y, z, kind, rotation, material, width, height, depth}) => ({
+      // give multiple dimensions in case we resize wedges
+      size: [brickSize * width, brickSize * depth, brickSize * height],
+      asset_name_index: kind,
+      material_index: material,
+      rotation,
+      // 3d color blobs that are kinda grey-ish
+      color: [
+        Math.floor(noise.perlin3(x / 50, y / 50, z / 50) * 80 + 100),
+        Math.floor(noise.perlin3(x / 50 - 3000, y / 50 - 3000, z / 50 + 200) * 80 + 100),
+        Math.floor(noise.perlin3(x / 50 + 2000, y / 50 + 2000, z / 50 - 2000) * 80 + 100),
+        255,
+      ],
+      position: [
+        x * brickSize * 2,
+        y * brickSize * 2,
+        z * brickSize * 2,
+      ],
+    })),
+};
+const blob = new Blob([new Uint8Array(BRS.write(save))]);
+console.timeEnd('Generate');
+anchor.href = URL.createObjectURL(blob);
+</script>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "brs-js",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Brickadia Save Read/Writing",
   "main": "index.js",
   "scripts": {

package/src/constants.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { Uuid } from './types';
+export const MAGIC = new Uint8Array([66, 82, 83]); // BRS
+export const LATEST_VERSION = 10;
+export const MAX_INT = ~(1 << 31);
+export const DEFAULT_UUID: Uuid = '00000000-0000-0000-0000-000000000000';

package/src/index.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import read from './read';
+import write from './write';
+import * as utils from './utils';
+import * as constants from './constants';
+// https://i.imgur.com/cv1fDWs.png
+const brs = { read, write, utils, constants };
+export { read, write, utils, constants };
+export default brs;
+declare global {
+  interface Window {
+    BRS: {
+      read: typeof read;
+      write: typeof write;
+      utils: typeof utils;
+      constants: typeof constants;
+    };
+  }
+}
+if (typeof window !== 'undefined') {
+  window.BRS = brs;
+}

package/src/read.ts ADDED Viewed

@@ -0,0 +1,57 @@
+import { MAGIC } from './constants';
+import readBrsV1 from './read.v1';
+import readBrsV10 from './read.v10';
+import readBrsV2 from './read.v2';
+import readBrsV3 from './read.v3';
+import readBrsV4 from './read.v4';
+import readBrsV8 from './read.v8';
+import readBrsV9 from './read.v9';
+import { BRSBytes, ReadOptions, ReadSaveObject } from './types';
+import { read } from './utils';
+// Reads in a byte array to build a brs object
+export default function readBrs(
+  rawBytes: Uint8Array,
+  options: ReadOptions = {}
+): ReadSaveObject {
+  if (typeof options !== 'object') throw new Error('Invalid options');
+  // default enable brick reading
+  if (typeof options.bricks !== 'boolean') options.bricks = true;
+  // default disable preview (a5 only)
+  if (typeof options.preview !== 'boolean') options.preview = false;
+  // Determine if the first 3 bytes are equal to the Brickadia save magic bytes
+  if (
+    rawBytes[0] !== MAGIC[0] ||
+    rawBytes[1] !== MAGIC[1] ||
+    rawBytes[2] !== MAGIC[2]
+  ) {
+    throw new Error('Invalid starting bytes');
+  }
+  const brsData = rawBytes as BRSBytes;
+  brsData.brsOffset = 3;
+  // Determine if the file version supported
+  const version = read.u16(brsData);
+  switch (version) {
+    case 1:
+      return readBrsV1(brsData, options);
+    case 2:
+      return readBrsV2(brsData, options);
+    case 3:
+      return readBrsV3(brsData, options);
+    case 4:
+      return readBrsV4(brsData, options);
+    case 8:
+      return readBrsV8(brsData, options);
+    case 9:
+      return readBrsV9(brsData, options);
+    case 10:
+      return readBrsV10(brsData, options);
+    default:
+      throw new Error('Unsupported version ' + version);
+  }
+}

package/src/read.v1.ts ADDED Viewed

@@ -0,0 +1,99 @@
+import {
+  BRSBytes,
+  ReadOptions,
+  BrsV1,
+  UnrealColor,
+  BrickV1,
+  Vector,
+} from './types';
+import { bgra, read } from './utils';
+// Reads in a byte array to build a brs object
+export default function readBrsV1(
+  brsData: BRSBytes,
+  options: ReadOptions = {}
+): BrsV1 {
+  // Read in Headers
+  const header1Data = read.compressed(brsData);
+  const header2Data = read.compressed(brsData);
+  const map = read.string(header1Data);
+  const author_name = read.string(header1Data);
+  const description = read.string(header1Data);
+  const author_id = read.uuid(header1Data);
+  const brick_count = read.i32(header1Data);
+  const mods = read.array(header2Data, read.string);
+  const brick_assets = read.array(header2Data, read.string);
+  const colors = read.array(
+    header2Data,
+    data => bgra(Array.from(read.bytes(data, 4))) as UnrealColor
+  );
+  // Read in bricks
+  let bricks: BrickV1[] = [];
+  const numAssets = Math.max(brick_assets.length, 2);
+  if (options.bricks) {
+    bricks = Array(brick_count);
+    const brickData = read.compressed(brsData);
+    const brickBits = read.bits(brickData);
+    // Brick reader
+    for (let i = 0; !brickBits.empty() && i < brick_count; i++) {
+      brickBits.align();
+      const asset_name_index = brickBits.int(numAssets);
+      const size: Vector = brickBits.bit()
+        ? [
+            brickBits.uint_packed(),
+            brickBits.uint_packed(),
+            brickBits.uint_packed(),
+          ]
+        : [0, 0, 0];
+      const position: Vector = [
+        brickBits.int_packed(),
+        brickBits.int_packed(),
+        brickBits.int_packed(),
+      ];
+      const orientation = brickBits.int(24);
+      const direction = (orientation >> 2) % 6;
+      const rotation = orientation & 3;
+      const collision = brickBits.bit();
+      const visibility = brickBits.bit();
+      const color = brickBits.bit()
+        ? bgra(brickBits.bytesArr(4) as [number, number, number, number])
+        : brickBits.int(colors.length);
+      bricks[i] = {
+        asset_name_index,
+        size,
+        collision,
+        position,
+        direction,
+        rotation,
+        visibility,
+        color,
+      };
+    }
+  }
+  return {
+    version: 1,
+    map,
+    description,
+    author: {
+      id: author_id,
+      name: author_name,
+    },
+    mods,
+    brick_assets,
+    colors,
+    bricks,
+    brick_count,
+  };
+}