brs-js 2.0.1 → 2.0.2

package/src/read.v9.ts

@@ -0,0 +1,181 @@
+import {
+  BRSBytes,
+  ReadOptions,
+  BrsV9,
+  User,
+  UnrealColor,
+  BrickV9,
+  Vector,
+  ColorRgb,
+  AppliedComponent,
+} from './types';
+import { bgra, read } from './utils';
+
+// Reads in a byte array to build a brs object
+export default function readBrsV9(
+  brsData: BRSBytes,
+  options: ReadOptions = {}
+): BrsV9 {
+  // game version is included in saves >= v8
+  const game_version = read.i32(brsData);
+
+  // 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 host: User = {
+    name: read.string(header1Data),
+    id: read.uuid(header1Data),
+  };
+  const save_time = read.bytes(header1Data, 8);
+
+  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
+  );
+  const materials = read.array(header2Data, read.string);
+  const brick_owners = read.array(header2Data, data => ({
+    id: read.uuid(data),
+    name: read.string(data),
+    bricks: read.i32(data),
+  }));
+
+  const physical_materials = read.array(header2Data, read.string);
+
+  // check for preview byte
+  let preview = null;
+  if (read.bytes(brsData, 1)[0]) {
+    const len = read.i32(brsData);
+    if (options.preview) {
+      preview = read.bytes(brsData, len);
+    } else {
+      brsData.brsOffset += len;
+    }
+  }
+
+  // Read in bricks
+  let bricks: BrickV9[] = [];
+  const components: BrsV9['components'] = {};
+
+  const numPhysMats = Math.max(physical_materials.length, 2);
+  const numMats = Math.max(materials.length, 2);
+  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 material_index = brickBits.int(numMats);
+      const physical_index = brickBits.int(numPhysMats);
+      const material_intensity = brickBits.int(11);
+
+      const color = brickBits.bit()
+        ? (brickBits.bytesArr(3) as [number, number, number])
+        : brickBits.int(colors.length);
+
+      const owner_index = brickBits.uint_packed();
+
+      bricks[i] = {
+        asset_name_index,
+        size,
+        position,
+        direction,
+        rotation,
+        collision,
+        visibility,
+        material_index,
+        physical_index,
+        material_intensity,
+        color: color as ColorRgb | number,
+        owner_index,
+        components: {},
+      };
+    }
+
+    const componentData = read.compressed(brsData);
+    const numBricks = Math.max(bricks.length, 2);
+
+    read.each(componentData, data => {
+      // read component name
+      const name = read.string(data);
+
+      // read component body
+      const bits = read.bits(read.bytes(data, read.i32(data)));
+
+      const version = read.i32(bits.bytes(4));
+      // list of bricks
+      const brick_indices = bits.array(() => bits.int(numBricks));
+
+      // list of name, type properties
+      const properties = bits.array(() => [bits.string(), bits.string()]);
+
+      // read components for each brick
+      for (const i of brick_indices) {
+        const props: AppliedComponent = {};
+        for (const [name, type] of properties) props[name] = bits.unreal(type);
+        bricks[i].components[name] = props;
+      }
+
+      components[name] = {
+        version,
+        brick_indices,
+        properties: Object.fromEntries(properties),
+      };
+    });
+  }
+
+  return {
+    version: 9,
+    game_version,
+    map,
+    description,
+    author: {
+      id: author_id,
+      name: author_name,
+    },
+    host,
+    mods,
+    brick_assets,
+    colors,
+    materials,
+    brick_owners,
+    physical_materials,
+    preview,
+    bricks,
+    brick_count,
+    save_time,
+    components,
+  };
+}

package/src/types.ts

@@ -0,0 +1,240 @@
+export interface BRSBytes extends Uint8Array {
+  brsOffset: number;
+}
+
+type Modify<T, R> = Omit<T, keyof R> & R;
+
+export type Bytes = Uint8Array | BRSBytes;
+export type Uuid = string;
+
+export type UnrealClass = string;
+export type UnrealObject = string;
+export type UnrealBoolean = boolean;
+export type UnrealFloat = number;
+export type UnrealColor = [number, number, number, number];
+export type UnrealByte = number;
+export type UnrealRotator = [number, number, number];
+export type UnrealType =
+  | UnrealClass
+  | UnrealObject
+  | UnrealBoolean
+  | UnrealFloat
+  | UnrealColor
+  | UnrealByte
+  | UnrealRotator;
+
+export interface User {
+  id: Uuid;
+  name: string;
+}
+
+export interface Owner extends User {
+  bricks: number;
+}
+
+export enum Direction {
+  XPositive,
+  XNegative,
+  YPositive,
+  YNegative,
+  ZPositive,
+  ZNegative,
+}
+
+export enum Rotation {
+  Deg0,
+  Deg90,
+  Deg180,
+  Deg270,
+}
+
+export type ColorRgb = [number, number, number];
+
+export interface Collision {
+  player: boolean;
+  weapon: boolean;
+  interaction: boolean;
+  tool: boolean;
+}
+
+export interface AppliedComponent {
+  [property: string]: UnrealType;
+}
+
+export interface DefinedComponents {
+  [component_name: string]: {
+    version: number;
+    brick_indices: number[];
+    properties: { [property: string]: string };
+  };
+}
+
+export interface Components {
+  [component_name: string]: AppliedComponent;
+}
+
+export type Vector = [number, number, number];
+
+export interface BrickV1 {
+  asset_name_index: number;
+  size: Vector;
+  position: Vector;
+  direction: Direction;
+  rotation: Rotation;
+  collision: boolean;
+  visibility: boolean;
+  color: UnrealColor | number;
+}
+
+export interface BrickV2 extends BrickV1 {
+  material_index: number;
+}
+
+export interface BrickV3 extends BrickV2 {
+  owner_index: number;
+}
+
+export interface BrickV8 extends BrickV3 {
+  components: Components;
+}
+
+export type BrickV9 = Modify<
+  BrickV8,
+  {
+    physical_index: number;
+    material_intensity: number;
+    color: ColorRgb | number;
+  }
+>;
+
+export type BrickV10 = Modify<
+  BrickV9,
+  {
+    collision: Collision;
+  }
+>;
+
+export interface BrsV1 {
+  version: 1;
+  map: string;
+  author: User;
+  description: string;
+  brick_count: number;
+  mods: string[];
+  brick_assets: string[];
+  colors: UnrealColor[];
+  bricks: BrickV1[];
+}
+
+export type BrsV2 = Modify<
+  BrsV1,
+  {
+    version: 2;
+    materials: string[];
+    bricks: BrickV2[];
+  }
+>;
+
+export type BrsV3 = Modify<
+  BrsV2,
+  {
+    version: 3;
+    brick_owners: User[];
+    bricks: BrickV3[];
+  }
+>;
+
+export type BrsV4 = Modify<
+  BrsV3,
+  {
+    version: 4;
+    save_time: Uint8Array;
+  }
+>;
+
+// not sure what part of 8 makes up 5-7 but nobody should have any saves in those versions
+
+export type BrsV8 = Modify<
+  BrsV4,
+  {
+    version: 8;
+    host: User;
+    brick_owners: Owner[];
+    preview?: Bytes;
+    game_version: number;
+    bricks: BrickV8[];
+    components: DefinedComponents;
+  }
+>;
+
+export type BrsV9 = Modify<
+  BrsV8,
+  {
+    version: 9;
+    physical_materials: string[];
+    bricks: BrickV9[];
+  }
+>;
+
+export type BrsV10 = Modify<
+  BrsV9,
+  {
+    version: 10;
+    bricks: BrickV10[];
+  }
+>;
+
+// a save read from a file
+export type ReadSaveObject =
+  | BrsV1
+  | BrsV2
+  | BrsV3
+  | BrsV4
+  | BrsV8
+  | BrsV9
+  | BrsV10;
+
+// a brick a user provides
+export interface Brick {
+  asset_name_index?: number;
+  size: Vector;
+  position: Vector;
+  direction?: Direction;
+  rotation?: Rotation;
+  collision?: boolean | Partial<Collision>;
+  visibility?: boolean;
+  material_index?: number;
+  physical_index?: number;
+  material_intensity?: number;
+  color?: ColorRgb | number;
+  owner_index?: number;
+  components?: Components;
+}
+
+// save a user can write
+export interface WriteSaveObject {
+  game_version?: number;
+  map?: string;
+  description?: string;
+  author?: Partial<User>;
+  host?: Partial<User>;
+  mods?: string[];
+  brick_assets?: string[];
+  colors?: UnrealColor[];
+  materials?: string[];
+  brick_owners?: Partial<Owner>[];
+  physical_materials?: string[];
+  preview?: Bytes;
+  bricks: Brick[];
+  save_time?: ArrayLike<number>;
+  components?: DefinedComponents;
+}
+
+export interface ReadOptions {
+  bricks?: boolean;
+  preview?: boolean;
+}
+
+export interface WriteOptions {
+  compress?: boolean;
+}