brs-js 2.0.0 → 2.0.3

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.__
 

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>