brs-js 1.4.1 → 2.0.2

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "printWidth": 80,
+  "semi": true,
+  "singleQuote": true
+}

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Isaac Hirschfeld
+Copyright (c) 2021 Isaac Hirschfeld
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,7 +2,7 @@
 
 Read and write Brickadia save files (.brs)
 
-Currently supports save versions <= 8
+Currently supports save versions <= 10
 
 **Warning:** __Unreal Engine uses numbers potentially larger than Javascript can handle.__
 
@@ -116,7 +116,7 @@ Unsigned ints, while unlikely, may overflow.
 | field                       | type   | default                              | optional | description                      |
 |-----------------------------|--------|--------------------------------------|----------|----------------------------------|
 | version                     | short  | Latest Save Version                  | auto     | Save file version                |
-| gameVersion                 | int    | Game Version                         | &#9745;  | Saving version of the game       |
+| game_version                | int    | Game Version                         | &#9745;  | Saving version of the game       |
 | map                         | string | 'Unknown'                            | &#9745;  | Map where the save was generated |
 | author.id                   | uuid   | 00000000-0000-0000-0000-000000000000 | &#9745;  | Save author UUID                 |
 | author.name                 | string | 'Unknown'                            | &#9745;  | Save author name                 |

package/debug/bruteforce.js

@@ -0,0 +1,254 @@
+const fs = require('fs');
+
+const {utils: {read, isEqual}, constants: {MAGIC}} = require('../dist/dist.node.js');
+
+// arg parsing
+const file = process.argv.find(f => f.endsWith('brs'));
+if (!file) {
+  console.error('missing save argument');
+  process.exit(1);
+}
+if (!fs.existsSync(file)) {
+  console.error('file does not exist');
+  process.exit(1);
+}
+
+// read the file
+const data = Array.from(fs.readFileSync(file));
+const copyData = () => data.slice();
+
+const bgra = ([b, g, r, a]) => [r, g, b, a];
+const PNG_MAGIC = [137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82];
+let quiet = false;
+
+function tryRead(data, type, fn, results) {
+  try {
+    if (typeof type === 'function')
+      return type(data, results);
+
+    switch(type) {
+    case 'magic': return isEqual(data.splice(0, MAGIC.length), MAGIC);
+    case 'pngmagic': return isEqual(data.splice(0, PNG_MAGIC.length), PNG_MAGIC);
+    case 'compressed': return read.compressed(data);
+    case 'compressed.array': return read.array(read.compressed(data), data => fn(data, results));
+    case 'string': return read.string(data);
+    case 'uuid': return read.uuid(data);
+    case 'byte': return data.splice(0, 1)[0];
+    case 'u16': return read.u16(data);
+    case 'i32': return read.i32(data);
+    case 'time': return data.splice(0, 8);
+    case 'word': return data.splice(0, 4);
+    case 'bits': return read.bits(data);
+    case 'array': return read.array(data, data => fn(data, results));
+    case 'rest': return data.splice(0, data.length);
+    case 'bricks':
+      const brickData = read.compressed(data);
+      // console.log(brickData.map(d => d.toString(2).padStart(8, '0')).join(''));
+      const brickBits = read.bits(brickData);
+      const bricks = [];
+
+      try {
+        while(!brickBits.empty() && bricks.length < results.header1.brickCount) {
+          brickBits.align();
+          const start = brickBits.pos;
+          const brick = fn(brickBits, results);
+          brick.bitsize = (brickBits.pos - start);
+          bricks.push(brick);
+        }
+      } catch (e) {
+        console.error(e)
+        return bricks;
+      }
+
+      return bricks;
+    }
+  } catch (e) {
+    console.log(e);
+    return ';;badvalue;;';
+  }
+}
+
+function bruteforce(data, steps, indent=0) {
+  let i = 0;
+  const results = {};
+  for (let step of steps) {
+    i ++;
+
+    // convert string and arrays into objects
+    if (typeof step === 'string')
+      step = {name: step, bin: false, type: step};
+    if (typeof step === 'object' && typeof step.length === 'number')
+      step = {name: 'scan', attempt: step};
+
+    // check if ther's any data left
+    if (data.length === 0) {
+      if(!quiet) console.log(''.padStart(indent * 2, ' '), i, ')', step.name || '?', '[no bytes left]');
+      break;
+    }
+
+    let type = step.type;
+
+    // if this is a conditional step, assign the next steps based on this one
+    if (step.test) {
+      const test = step.test(tryRead(data, step.type));
+      if(!quiet) console.log(''.padStart(indent * 2, ' '), i, '-', step.name || '?', 'test', test);
+      step.contains = test ? step.yes : step.no;
+      step.type = 'rest';
+    } else if (!type) {
+      // scan for a matching type
+      type = step.attempt.find(t => tryRead(data.slice(), typeof t === 'object' ? t.name : t, t.fn) !== ';;badvalue;;');
+    }
+
+
+    const val = step.test ? 'test' : tryRead(data, type, step.fn, results);
+    if(!quiet) console.log(''.padStart(indent * 2, '.'), i, ')', step.name || '?', '=', step.bin ? val.length + ' bytes' : val);
+    results[step.name] = step.contains
+      ? bruteforce(step.test ? data : val, step.contains, indent+1, results)
+      : val;
+  }
+
+  return results;
+}
+
+const go = (before, after) => bruteforce(copyData(), [
+  {name: 'BRS', type: 'magic'},
+  {name: 'version', type: 'u16'},
+  {name: 'game version', type: 'i32'},
+  {
+    name: 'header1', type: 'compressed', bin: true,
+    contains: [
+      {name: 'map', type: 'string'},
+      {name: 'saverName', type: 'string'},
+      {name: 'description', type: 'string'},
+      {name: 'saverId', type: 'uuid'},
+      {name: 'hostName', type: 'string'},
+      {name: 'hostId', type: 'uuid'},
+      {name: 'saveDate', type: 'time'},
+      {name: 'brickCount', type: 'i32'},
+    ],
+  },
+  {
+    name: 'header2', type: 'compressed', bin: true,
+    contains: [
+      {name: 'mods', type: 'array', fn: read.string},
+      {name: 'assets', type: 'array', fn: read.string},
+      {name: 'colors', type: 'array', fn: data => bgra(data.splice(0, 4))},
+      {name: 'materials', type: 'array', fn: read.string},
+      {name: 'owners', type: 'array', fn: data => ({
+        id: read.uuid(data),
+        name: read.string(data),
+        count: read.i32(data)
+      })},
+    ],
+  },
+  {
+    name: 'preview',
+    test: v => v, type: 'byte',
+    yes: [
+      {name: 'data', type: data => {
+        const len = read.i32(data);
+        const png = data.splice(0, len);
+        return len + ' bytes';
+      }},
+    ],
+    no: [],
+  },
+  {
+    name: 'bricks',
+    type: 'bricks',
+    fn: (bits, parent) => ({
+      asset_index: bits.int(Math.max(parent.header2.assets.length, 2)),
+      size: bits.bit() ? [bits.uint_packed(), bits.uint_packed(), bits.uint_packed()] : [0, 0, 0],
+      position: [bits.int_packed(), bits.int_packed(), bits.int_packed()],
+      ...(orientation => ({
+        direction: (orientation >> 2) % 6,
+        rotation: orientation & 3,
+      }))(bits.int(24)),
+      collision: bits.bit(),
+      visibility: bits.bit(),
+      material_index: bits.bit() ? bits.uint_packed() : 1,
+      // material_index: bits.int(Math.max(parent.header2.materials.length, 2)),
+      color: bits.bit() ? bgra(bits.bytes(4)) : bits.int(parent.header2.colors.length),
+      owner_index: bits.uint_packed(true),
+    }),
+  },
+  {
+    name: 'components', type: 'compressed.array', fn: (data, parent) => {
+      const name = read.string(data);
+      const bits = read.bits(data.splice(0, read.i32(data)));
+      const version = read.i32(bits.bytes(4));
+      const brick_indices = bits.array(() => bits.int(Math.max(parent.header1.brickCount, 2)));
+      const properties = bits.array(() => [bits.string(), bits.string()]);
+
+      const bricks = brick_indices.map(i => ({
+        index: i,
+        props: Object.fromEntries(properties.map(([name, type]) => {
+          let val;
+          switch(type) {
+          case 'Class':
+            val = bits.string();
+            break;
+          case 'Boolean':
+            val = !!read.i32(bits.bytes(4));
+            break;
+          case 'Float':
+            val = bits.float();
+            break;
+          case 'Color':
+            val = bgra(bits.bytes(4));
+            break;
+          case 'Rotator':
+            val = [bits.float(), bits.float(), bits.float()];
+            break;
+          }
+          return [name, val];
+        })),
+      }));
+      return {
+        name,
+        version,
+        brick_indices,
+        properties: Object.fromEntries(properties),
+        bricks,
+      }
+    },
+  },
+]);
+
+      /*
+for each component type used in the build, it will
+  write the component type name [done]
+  write the version [done]
+  write an array of brick indices to attach to [done]
+  write the data layout
+      write an array of property infos
+          write the name of the property
+          write the type of the property
+  write the size of the following data section
+    write the data
+        write each component instance
+            write each property
+
+        */
+
+// console.log(go(1).bricks.bricks.slice(0, 2))
+
+quiet = true;
+for (let before = 0; before < 1; before++) {
+  for (let after = 0; after < 1; after++) {
+    const res = go(before, after);
+    // return;
+    // const colorOk = res.bricks.every(b => b.color === 0);
+    const bricksOk = res.bricks.length === res.header1.brickCount && res.bricks.every(b => b.owner_index <= res.header2.owners.length );
+    // const ownerOk = res.bricks.some(b => b.owner_index !== 1) && res.bricks.some(b => b.owner_index === 0);
+    // const materialOk = res.bricks.every(b => b.color === 0);
+    if (true) {
+      const bin = arr => arr.map(a => a?'1':'0').join('');
+      res.components.map(c => console.log(c, ...c.bricks))
+      console.log(
+        res,
+        {bricks: res.bricks.length, before, after},
+      );
+    }
+  }
+}

package/debug/clone.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<script src="../dist/dist.js"></script>
+
+<!-- Files uploaded will be  -->
+<input id="fileInput" type="file">
+
+<a id="anchor" download="cloned.brs">Download</a>
+
+<!-- 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);
+
+          // Log the save object
+          console.log(save);
+
+          // Render the save object as formatted JSON
+          jsonElem.innerText = '';
+
+          const blob = new Blob([new Uint8Array(BRS.write(save))]);
+          anchor.href = URL.createObjectURL(blob);
+        })
+        .catch(err => {
+          // Display the error
+          jsonElem.innerText = 'Error: ' + err.message;
+        });
+    }
+  });
+</script>

package/{src/write.js → debug/evilwrite.js}

@@ -1,23 +1,10 @@
-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')
-}
+const {
+  utils: { write, isEqual, concat },
+  constants: { MAGIC, LATEST_VERSION, MAX_INT },
+} = require('../dist/dist.node.js');
 
 // looks up a value in an object or returns a defualt value
-function get(obj, path='', def) {
+function get(obj, path = '', def) {
   // Split the path up by .
   path = path.split('.').filter(p => p.length > 0);
 
@@ -31,10 +18,8 @@ function get(obj, path='', def) {
 
 const EMPTY_ARR = new Uint8Array([]);
 
-export default function writeBrs(save) {
-  validate(save);
-
-  if(save.bricks.length > MAX_INT) {
+function writeSave(save) {
+  if (save.bricks.length > MAX_INT) {
     throw new Error('Brick count out of range');
   }
 
@@ -65,7 +50,7 @@ export default function writeBrs(save) {
       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.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])),
@@ -78,7 +63,7 @@ export default function writeBrs(save) {
       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.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,
@@ -91,15 +76,15 @@ export default function writeBrs(save) {
     // 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),
-        )
+        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) {
+      .each(save.bricks, function (brick, i) {
         this.align();
         this.int(get(brick, 'asset_name_index', 0), numAssets);
 
@@ -108,6 +93,7 @@ export default function writeBrs(save) {
         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);
@@ -169,7 +155,7 @@ export default function writeBrs(save) {
     version >= 8 ? write.compressed(write.array(Object.keys(get(save, 'components', {})).filter(name => componentBricks[name]), name => concat(
       write.string(name),
       write.bits()
-        .self(function() {
+        .self(function () {
           const component = save.components[name];
           const brick_indices = componentBricks[name];
           const properties = Object.entries(component.properties);
@@ -200,4 +186,205 @@ export default function writeBrs(save) {
     ))) : EMPTY_ARR,
   );
   return buff;
-}
+}
+
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+
+// Write the save to a file
+const outfile = path.resolve('/mnt/c/Users/ISAAC/AppData/Local/Brickadia/Saved/Builds', 'evil.brs');
+
+// Print some info
+fs.writeFileSync(outfile, writeSave({
+  "version": 10,
+  "bricks": [
+    {
+      "asset_name_index": 0,
+      "size": [ 5, 5, 6 ],
+      "position": [0, 0, 0],
+      "direction": 4,
+      "rotation": 0,
+      "collision": {
+        "player": true,
+        "weapon": true,
+        "interaction": true,
+        "tool": true
+      },
+      "visibility": true,
+      "material_index": 3,
+      "physical_index": 0,
+      "material_intensity": 5,
+      "color": 0,
+      "owner_index": 1,
+      "components": {
+        "BCD_AudioEmitter": {
+          "AudioDescriptor": "BA_AMB_Component_Fires_Fireplace_1",
+          "VolumeMultiplier": 1,
+          "PitchMultiplier": 1,
+          "InnerRadius": 15,
+          "MaxDistance": 400,
+          "bSpatialization": true
+        },
+        "BCD_ItemSpawn": {
+          "PickupClass": "BP_ItemPickup_StickGrenade",
+          "bPickupEnabled": true,
+          "bPickupRespawnOnMinigameReset": true,
+          "PickupMinigameResetRespawnDelay": 0,
+          "bPickupAutoDisableOnPickup": true,
+          "PickupRespawnTime": 0.1,
+          "PickupOffsetDirection": 4,
+          "PickupOffsetDistance": 5,
+          "PickupRotation": [ 0, 0, 5 ],
+          "PickupScale": 1,
+          "bPickupAnimationEnabled": true,
+          "PickupAnimationAxis": 2,
+          "bPickupAnimationAxisLocal": false,
+          "PickupSpinSpeed": 0.1,
+          "PickupBobSpeed": 0.1,
+          "PickupBobHeight": 4,
+          "PickupAnimationPhase": 0.1515854299068451
+        },
+        "BCD_PointLight": {
+          "bMatchBrickShape": true,
+          "Brightness": 15,
+          "Radius": 500,
+          "Color": [
+            255,
+            255,
+            255,
+            255
+          ],
+          "bUseBrickColor": true,
+          "bCastShadows": true
+        },
+        "BCD_SpotLight": {
+          "Rotation": [
+            270,
+            0,
+            0
+          ],
+          "InnerConeAngle": 30,
+          "OuterConeAngle": 0,
+          "Brightness": 15,
+          "Radius": 150,
+          "Color": [
+            0,
+            255,
+            255,
+            255
+          ],
+          "bUseBrickColor": true,
+          "bCastShadows": true
+        }
+      }
+    },
+  ],
+  "map": "Plate",
+  "author": {
+    "name": "cake",
+    "id": "60eab7e7-9aa9-4647-83e4-6ce4ec66ae7d"
+  },
+  "description": "a".repeat(5),
+  "host": {
+    "name": "cake",
+    "id": "60eab7e7-9aa9-4647-83e4-6ce4ec66ae7d"
+  },
+  "mods": [],
+  "brick_assets": ["PB_DefaultBrick"],
+  "colors": [
+    [255, 255, 255, 255],
+  ],
+  "materials": [
+    "BMC_Hidden",
+    "BMC_Ghost",
+    "BMC_Ghost_Fail",
+    "BMC_Plastic",
+    "BMC_Glass",
+    "BMC_Glow",
+    "BMC_Metallic",
+    "BMC_Hologram"
+  ],
+  "brick_owners": [
+    {
+      "id": "60eab7e7-9aa9-4647-83e4-6ce4ec66ae7d",
+      "name": "cake",
+      "bricks": 69
+    },
+  ],
+  "physical_materials": [
+    "BPMC_Default"
+  ],
+  "gameVersion": 6880,
+  "components": {
+    "BCD_AudioEmitter": {
+      "version": 1,
+      "brick_indices": [
+        0
+      ],
+      "properties": {
+        "AudioDescriptor": "Object",
+        "VolumeMultiplier": "Float",
+        "PitchMultiplier": "Float",
+        "InnerRadius": "Float",
+        "MaxDistance": "Float",
+        "bSpatialization": "Boolean"
+      }
+    },
+    "BCD_ItemSpawn": {
+      "version": -1,
+      "brick_indices": [
+        0
+      ],
+      "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_PointLight": {
+      "version": 1,
+      "brick_indices": [
+        0
+      ],
+      "properties": {
+        "bMatchBrickShape": "Boolean",
+        "Brightness": "Float",
+        "Radius": "Float",
+        "Color": "Color",
+        "bUseBrickColor": "Boolean",
+        "bCastShadows": "Boolean"
+      }
+    },
+    "BCD_SpotLight": {
+      "version": 1,
+      "brick_indices": [
+        0
+      ],
+      "properties": {
+        "Rotation": "Rotator",
+        "InnerConeAngle": "Float",
+        "OuterConeAngle": "Float",
+        "Brightness": "Float",
+        "Radius": "Float",
+        "Color": "Color",
+        "bUseBrickColor": "Boolean",
+        "bCastShadows": "Boolean"
+      }
+    }
+  }
+}));