brs-js 2.0.12 → 2.0.14

package/package.json

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

package/.babelrc

@@ -1,5 +0,0 @@
-{
-  "presets": [
-    "@babel/preset-env",
-  ]
-}

package/.prettierrc

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

package/debug/bruteforce.js

@@ -1,254 +0,0 @@
-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

@@ -1,36 +0,0 @@
-<!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>