brs-js 2.0.1 → 2.0.2

package/debug/evilwrite.js

@@ -0,0 +1,390 @@
+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) {
+  // Split the path up by .
+  path = path.split('.').filter(p => p.length > 0);
+
+  // Get the child at each part of the path
+  while (path.length && typeof obj === 'object') {
+    obj = obj[path.splice(0, 1)[0]];
+  }
+
+  return typeof obj !== 'undefined' ? obj : def;
+}
+
+const EMPTY_ARR = new Uint8Array([]);
+
+function writeSave(save) {
+  if (save.bricks.length > MAX_INT) {
+    throw new Error('Brick count out of range');
+  }
+
+  const version = typeof save.version !== 'undefined' ? save.version : LATEST_VERSION;
+
+  // Convert from BGRA to RGBA
+  const rgba = ([r, g, b, a]) => new Uint8Array([b, g, r, a]);
+
+  // stored brick indices from components on the bricks
+  const componentBricks = {};
+
+  const numColors = Math.max(get(save, 'colors', EMPTY_ARR).length, 2);
+  const numAssets = Math.max(get(save, 'brick_assets', EMPTY_ARR).length, 2);
+  const numMats = Math.max(get(save, 'materials.length', 0), 2);
+  const numPhysMats = Math.max(get(save, 'physical_materials.length', 0), 2);
+
+  const buff = concat(
+    // Write magic bytes
+    MAGIC,
+    write.u16(version),
+
+    version >= 8 ? write.i32(save.gameVersion || 0) : EMPTY_ARR,
+
+    // Header 1
+    write.compressed(
+      write.string(get(save, 'map', 'Unknown')),
+      write.string(get(save, 'author.name', 'Unknown')),
+      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.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])),
+      write.i32(get(save, 'bricks', EMPTY_ARR).length),
+    ),
+
+    // Header 2
+    write.compressed(
+      write.array(get(save, 'mods', EMPTY_ARR), write.string),
+      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.uuid(id),
+        write.string(name),
+        version >= 8 ? write.i32(bricks) : EMPTY_ARR,
+      )),
+      version >= 9
+        ? write.array(get(save, 'physical_materials', ['BPMC_Default']), write.string)
+        : [],
+    ),
+
+    // 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),
+      )
+      : EMPTY_ARR,
+
+    // Bricks
+    write.compressed(write.bits()
+      .each(save.bricks, function (brick, i) {
+        this.align();
+        this.int(get(brick, 'asset_name_index', 0), numAssets);
+
+        const isSingularity = isEqual(brick.size, [0, 0, 0]);
+        this.bit(!isSingularity);
+        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);
+        if (version >= 10) {
+          if (typeof brick.collison === 'boolean' && !brick.collision) {
+            this.bit(false);
+            this.bit(false);
+            this.bit(false);
+            this.bit(true);
+          } else {
+            this.bit(get(brick, 'collision.player', true));
+            this.bit(get(brick, 'collision.weapon', true));
+            this.bit(get(brick, 'collision.interaction', true));
+            this.bit(get(brick, 'collision.tool', true));
+          }
+        } else {
+          this.bit(get(brick, 'collision', true));
+        }
+        this.bit(get(brick, 'visibility', true));
+        if (version >= 8) {
+          this.int(brick.material_index, numMats)
+        } else {
+          this.bit(brick.material_index !== 1);
+          if (brick.material_index !== 1) {
+            this.uint_packed(brick.material_index);
+          }
+        }
+        if (version >= 9) {
+          this.int(get(brick, 'physical_index', 0), numPhysMats);
+          this.int(get(brick, 'material_intensity', 5), 11);
+        }
+
+        if (typeof brick.color === 'number') {
+          this.bit(false);
+          this.int(brick.color, numColors);
+        } else {
+          this.bit(true);
+          if (version >= 9) {
+            this.bytes(new Uint8Array(get(brick, 'color', [255, 255, 255])));
+          } else {
+            this.bytes(rgba(get(brick, 'color', [255, 255, 255, 255])));
+          }
+        }
+
+        this.uint_packed(get(brick, 'owner_index', 1));
+
+        if (version >= 8) {
+          // add all the brick indices to the components list
+          for (const key in brick.components || {}) {
+            componentBricks[key] = componentBricks[key] || [];
+            componentBricks[key].push(i);
+          }
+        }
+      })
+      .finish()
+    ),
+
+    // write components section
+    version >= 8 ? write.compressed(write.array(Object.keys(get(save, 'components', {})).filter(name => componentBricks[name]), name => concat(
+      write.string(name),
+      write.bits()
+        .self(function () {
+          const component = save.components[name];
+          const brick_indices = componentBricks[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) {
+              this.unreal(type, get(save, `bricks.${i}.components.${name}.${prop}`));
+            }
+          };
+          this.align();
+        })
+        .finishSection(),
+    ))) : 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"
+      }
+    }
+  }
+}));