Add LogicGateReceiver component

Author: mdingena

docs/LogicGateReceiverComponent.md

@@ -0,0 +1,147 @@
+# Class: `LogicGateReceiverComponent`
+
+- [Types](#types)
+  - [`<ComponentProps>`](#componentprops)
+  - [`<LogicGateReceiverComponentProps>`](#logicgatereceivercomponentprops)
+- [Constructors](#constructors)
+  - [`new LogicGateReceiverComponent(props)`](#new-logicgatereceivercomponentprops)
+  - [`LogicGateReceiverComponent.fromBinary(reader, version)`](#logicgatereceivercomponentfrombinaryreader-version)
+- [Properties](#properties)
+  - [`hash`](#hash)
+  - [`name`](#name)
+  - [`version`](#version)
+  - [`senders`](#senders)
+  - [`operationType`](#operationtype)
+  - [`isInversedOutputSaved`](#isinversedoutputsaved)
+- [Methods](#methods)
+  - [`toBinary(version?)`](#tobinaryversion)
+  - [`write(writer, version?)`](#writewriter-version)
+
+## Types
+
+### `<ComponentProps>`
+
+See [`<ComponentProps>`](./Component.md#componentprops)
+
+---
+
+### `<LogicGateReceiverComponentProps>`
+
+A portion of the configuration object to pass to the `LogicGateReceiverComponent` constructor.
+
+```ts
+type LogicGateReceiverComponentPropsV2 = {
+  senders?: number[] | undefined;
+  operationType?: LogicOperator | undefined;
+  isInversedOutputSaved?: boolean | undefined;
+};
+
+type LogicGateReceiverComponentProps = LogicGateReceiverComponentPropsV2;
+```
+
+#### Since v2
+
+- `senders` (optional, default `[]`) `<Array<number>>`
+- `operationType` (optional, default `0`) [`<LogicOperator>`](../src/types/LogicOperator.ts)
+- `isInversedOutputSaved` (optional, default `false`) `<boolean>`
+
+## Constructors
+
+### `new LogicGateReceiverComponent(props)`
+
+Creates a versioned `LogicGateReceiver` component.
+
+- `props` [`<ComponentProps & LogicGateReceiverComponentProps>`](#types) Configuration of the component to create.
+- Returns: `<LogicGateReceiverComponent>`
+
+```ts
+import { LogicGateReceiverComponent } from 'att-string-transcoder';
+
+const componentVersion = 2;
+const component = new LogicGateReceiverComponent({ version: componentVersion });
+```
+
+---
+
+### `LogicGateReceiverComponent.fromBinary(reader, version)`
+
+See [`Component.fromBinary(reader, version)`](./Component.md#componentfrombinaryreader-version)
+
+## Properties
+
+Note that the following properties are sorted in order of appearance when decoding component binary data.
+
+### `hash`
+
+See [`Component.hash`](./Component.md#hash)
+
+---
+
+### `name`
+
+See [`Component.name`](./Component.md#name)
+
+---
+
+### `version`
+
+See [`Component.version`](./Component.md#version)
+
+---
+
+### `senders`
+
+The identifiers of the `Logic*Sender` components that are connected to this `LogicGateReceiver`.
+
+- Since: `v2`
+- `<Array<number>>`
+
+---
+
+### `operationType`
+
+The type of operation to perform on the received inputs.
+
+- Since: `v2`
+- [`<LogicOperator>`](../src/types/LogicOperator.ts)
+
+```ts
+import { LogicGateReceiverComponent } from 'att-string-transcoder';
+
+const componentVersion = 2;
+const component = new LogicGateReceiverComponent({ version: componentVersion });
+
+const operationType = component.operationType;
+// `operationType` is `0` (AND)
+```
+
+---
+
+### `isInversedOutputSaved`
+
+Whether to inverse the output of this gate.
+
+- Since: `v2`
+- `<boolean>`
+
+```ts
+import { LogicGateReceiverComponent } from 'att-string-transcoder';
+
+const componentVersion = 2;
+const component = new LogicGateReceiverComponent({ version: componentVersion });
+
+const isInversedOutputSaved = component.isInversedOutputSaved;
+// `isInversedOutputSaved` is `false`
+```
+
+## Methods
+
+### `toBinary(version?)`
+
+See [`Component.toBinary(version?)`](./Component.md#tobinaryversion)
+
+---
+
+### `write(writer, version?)`
+
+See [`Component.write(writer, version?)`](./Component.md#writewriter-version)

docs/README.md

@@ -20,6 +20,7 @@
   - [`LiquidContainerComponent`](./LiquidContainerComponent.md)
   - [`LogicBoolReceiverComponent`](./LogicBoolReceiverComponent.md)
   - [`LogicFloatReceiverComponent`](./LogicFloatReceiverComponent.md)
+  - [`LogicGateReceiverComponent`](./LogicGateReceiverComponent.md)
   - [`LogicIntReceiverComponent`](./LogicIntReceiverComponent.md)
   - [`NetworkRigidbodyComponent`](./NetworkRigidbodyComponent.md)
   - [`PhysicalMaterialPartComponent`](./PhysicalMaterialPartComponent.md)

src/components/LogicGateReceiverComponent.test.ts

@@ -0,0 +1,143 @@
+import { BinaryData } from '../BinaryData.js';
+import { BinaryReader } from '../BinaryReader.js';
+import { BinaryWriter } from '../BinaryWriter.js';
+import { Prefab } from '../Prefab.js';
+import { ComponentHash } from '../types/ComponentHash.js';
+import { LogicOperator } from '../types/LogicOperator.js';
+
+import { LogicGateReceiverComponent } from './LogicGateReceiverComponent.js';
+
+const componentHash = ComponentHash.LogicGateReceiver;
+const componentName = 'LogicGateReceiver';
+const componentVersion = 2;
+const componentProps = {
+  senders: [69, 420, 1337],
+  operationType: LogicOperator.Xor,
+  isInversedOutputSaved: true
+};
+
+describe('new LogicGateReceiverComponent()', () => {
+  describe('when given the required props', () => {
+    it('returns an instance of the LogicGateReceiverComponent class', () => {
+      const component = new LogicGateReceiverComponent({ version: componentVersion });
+
+      expect(component).toBeInstanceOf(LogicGateReceiverComponent);
+      expect(component.hash).toStrictEqual(componentHash);
+      expect(component.name).toStrictEqual(componentName);
+      expect(component.version).toStrictEqual(componentVersion);
+    });
+  });
+
+  describe('when given additional props', () => {
+    it('returns an instance of the LogicGateReceiverComponent class', () => {
+      const component = new LogicGateReceiverComponent({ version: componentVersion, ...componentProps });
+
+      expect(component).toBeInstanceOf(LogicGateReceiverComponent);
+      expect(component.hash).toStrictEqual(componentHash);
+      expect(component.name).toStrictEqual(componentName);
+      expect(component.version).toStrictEqual(componentVersion);
+      expect(component.senders).toStrictEqual(componentProps.senders);
+      expect(component.operationType).toStrictEqual(componentProps.operationType);
+      expect(component.isInversedOutputSaved).toStrictEqual(componentProps.isInversedOutputSaved);
+    });
+  });
+});
+
+describe('LogicGateReceiverComponent.fromBinary()', () => {
+  let fastForwardedReader: BinaryReader;
+
+  const prefab = new Prefab('MRK_Small_Lever', {
+    components: {
+      LogicGateReceiver: new LogicGateReceiverComponent({ version: componentVersion, ...componentProps })
+    }
+  });
+
+  beforeEach(() => {
+    const saveString = prefab.toSaveString();
+    const [dataString] = saveString.split('|');
+
+    if (typeof dataString === 'undefined') {
+      throw new Error('Invalid test data.');
+    }
+
+    const unsignedIntegers = dataString.split(',').map(Number);
+
+    const data = BinaryData.fromUnsignedIntegerArray(unsignedIntegers);
+    const reader = new BinaryReader(data.toBinaryString());
+
+    reader.readUnsignedInteger(); // Root prefab hash.
+    reader.readUnsignedInteger(); // SaveString bytes.
+    reader.readUnsignedInteger(); // Parent prefab hash.
+    reader.readFloat(); // Parent position X.
+    reader.readFloat(); // Parent position Y.
+    reader.readFloat(); // Parent position Z.
+    reader.readFloat(); // Parent rotation X.
+    reader.readFloat(); // Parent rotation Y.
+    reader.readFloat(); // Parent rotation Z.
+    reader.readFloat(); // Parent rotation W.
+    reader.readFloat(); // Parent scale.
+    reader.readUnsignedInteger(); // LogicGateReceiverComponent hash.
+    reader.readUnsignedInteger(); // LogicGateReceiverComponent data length.
+
+    fastForwardedReader = reader;
+  });
+
+  it('returns an instance of the LogicGateReceiverComponent class', () => {
+    const component = LogicGateReceiverComponent.fromBinary(fastForwardedReader, componentVersion);
+
+    expect(component).toBeInstanceOf(LogicGateReceiverComponent);
+    expect(component.hash).toStrictEqual(componentHash);
+    expect(component.name).toStrictEqual(componentName);
+    expect(component.version).toStrictEqual(componentVersion);
+    expect(component.senders).toStrictEqual(componentProps.senders);
+    expect(component.operationType).toStrictEqual(componentProps.operationType);
+    expect(component.isInversedOutputSaved).toStrictEqual(componentProps.isInversedOutputSaved);
+  });
+});
+
+describe('LogicGateReceiverComponent.toBinary()', () => {
+  it('returns a BinaryString representation of the component', () => {
+    const component = new LogicGateReceiverComponent({ version: componentVersion, ...componentProps });
+
+    const data = component.toBinary();
+
+    const expectedData =
+      '00000000000000000000000000000011000000000000000000000000010001010000000000000000000000011010010000000000000000000000010100111001100000000000000000000000000000101';
+
+    expect(data).toStrictEqual(expectedData);
+  });
+});
+
+describe('LogicGateReceiverComponent.write()', () => {
+  it('writes a BinaryString representation of the component to the given BinaryWriter, including component hash and data length', () => {
+    const component = new LogicGateReceiverComponent({ version: componentVersion, ...componentProps });
+
+    const writer = new BinaryWriter();
+    component.write(writer);
+
+    const data = writer.flush();
+
+    const expectedData =
+      '010100101111001111111000000011100000000000000000000000001010000100000000000000000000000000000011000000000000000000000000010001010000000000000000000000011010010000000000000000000000010100111001100000000000000000000000000000101';
+
+    expect(data).toStrictEqual(expectedData);
+
+    const reader = new BinaryReader(data);
+
+    const hash = reader.readUnsignedInteger();
+    reader.readUnsignedInteger(); // LogicGateReceiverComponent data length.
+    reader.readUnsignedInteger(); // Senders array length.
+    const sender1 = reader.readUnsignedInteger();
+    const sender2 = reader.readUnsignedInteger();
+    const sender3 = reader.readUnsignedInteger();
+    const operationType = reader.readSignedInteger();
+    const isInversedOutputSaved = reader.readBoolean();
+
+    expect(hash).toStrictEqual(componentHash);
+    expect(sender1).toStrictEqual(componentProps.senders[0]);
+    expect(sender2).toStrictEqual(componentProps.senders[1]);
+    expect(sender3).toStrictEqual(componentProps.senders[2]);
+    expect(operationType).toStrictEqual(componentProps.operationType);
+    expect(isInversedOutputSaved).toStrictEqual(componentProps.isInversedOutputSaved);
+  });
+});