@etothepii/satisfactory-file-parser 0.4.20 → 0.4.22

package/build/parser/satisfactory/types/objects/SaveObject.d.ts

@@ -0,0 +1,24 @@
+import { BinaryReadable } from "../../../byte/binary-readable.interface";
+import { ByteWriter } from "../../../byte/byte-writer.class";
+import { PropertiesMap } from "../property/generic/BasicProperty";
+import { SpecialAnyProperty } from '../property/special/SpecialAnyProperty';
+export interface SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+}
+export declare abstract class SaveObject implements SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    properties: PropertiesMap;
+    specialProperties: SpecialAnyProperty;
+    trailingData: number[];
+    objectVersion: number;
+    unknownType2: number;
+    constructor(typePath: string, rootObject: string, instanceName: string);
+    protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
+    protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
+    static ParseData(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
+    static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
+}

package/build/parser/satisfactory/types/objects/SaveObject.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveObject = void 0;
+const DataFields_1 = require("../property/DataFields");
+class SaveObject {
+    constructor(typePath, rootObject, instanceName) {
+        this.typePath = typePath;
+        this.rootObject = rootObject;
+        this.instanceName = instanceName;
+        this.properties = {};
+        this.specialProperties = {};
+        this.trailingData = [];
+        this.objectVersion = 0;
+        this.unknownType2 = 0;
+    }
+    static ParseHeader(reader, obj) {
+        obj.typePath = reader.readString();
+        obj.rootObject = reader.readString();
+        obj.instanceName = reader.readString();
+    }
+    static SerializeHeader(writer, obj) {
+        writer.writeString(obj.typePath);
+        writer.writeString(obj.rootObject);
+        writer.writeString(obj.instanceName);
+    }
+    static ParseData(obj, length, reader, buildVersion, typePath) {
+        DataFields_1.DataFields.ParseProperties(obj, length, reader, buildVersion, typePath);
+    }
+    static SerializeData(writer, obj, buildVersion) {
+        DataFields_1.DataFields.Serialize(obj, writer, buildVersion, obj.typePath);
+    }
+}
+exports.SaveObject = SaveObject;

package/build/parser/satisfactory/types/property/DataFields.d.ts

@@ -0,0 +1,15 @@
+import { BinaryReadable } from "../../../byte/binary-readable.interface";
+import { ByteWriter } from '../../../byte/byte-writer.class';
+import { SaveWriter } from "../../save/save-writer";
+import { SaveObject } from "../objects/SaveObject";
+import { AbstractBaseProperty } from "./generic/BasicProperty";
+import { SpecialAnyProperty } from './special/SpecialAnyProperty';
+export declare class DataFields {
+    constructor();
+    static ParseProperties(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
+    static ParseAdditionalSpecialProperties(reader: BinaryReadable, typePath: string, remainingLen: number): SpecialAnyProperty;
+    static ParseProperty(reader: BinaryReadable, buildVersion: number, propertyName: string): AbstractBaseProperty;
+    static Serialize(obj: SaveObject, writer: SaveWriter, buildVersion: number, typePath: string): void;
+    static SerializeAdditionalSpecialProperties(writer: ByteWriter, typePath: string, property: SpecialAnyProperty): void;
+    static SerializeProperty(writer: ByteWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
+}

package/build/parser/satisfactory/types/property/DataFields.js

@@ -0,0 +1,493 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFields = void 0;
+const parser_error_1 = require("../../../error/parser.error");
+const ObjectReference_1 = require("../structs/ObjectReference");
+const Transform_1 = require("../structs/Transform");
+const vec2_1 = require("../structs/vec2");
+const vec3_1 = require("../structs/vec3");
+const ArrayProperty_1 = require("./generic/ArrayProperty");
+const BoolProperty_1 = require("./generic/BoolProperty");
+const ByteProperty_1 = require("./generic/ByteProperty");
+const DoubleProperty_1 = require("./generic/DoubleProperty");
+const EnumProperty_1 = require("./generic/EnumProperty");
+const FloatProperty_1 = require("./generic/FloatProperty");
+const Int32Property_1 = require("./generic/Int32Property");
+const Int64Property_1 = require("./generic/Int64Property");
+const Int8Property_1 = require("./generic/Int8Property");
+const MapProperty_1 = require("./generic/MapProperty");
+const ObjectProperty_1 = require("./generic/ObjectProperty");
+const SetProperty_1 = require("./generic/SetProperty");
+const SoftObjectProperty_1 = require("./generic/SoftObjectProperty");
+const StrProperty_1 = require("./generic/StrProperty");
+const StructProperty_1 = require("./generic/StructProperty");
+const TextProperty_1 = require("./generic/TextProperty");
+const Uint32Property_1 = require("./generic/Uint32Property");
+const Uint64Property_1 = require("./generic/Uint64Property");
+const Uint8Property_1 = require("./generic/Uint8Property");
+class DataFields {
+    constructor() {
+    }
+    static ParseProperties(obj, length, reader, buildVersion, typePath) {
+        const start = reader.getBufferPosition();
+        obj.properties = {};
+        if (length === 0) {
+            console.warn(`properties length for object ${obj.instanceName} was indicated as 0. Which is suspicious. Skipping object properties.`);
+            return;
+        }
+        let propertyName = reader.readString();
+        while (propertyName !== 'None') {
+            const parsedProperty = DataFields.ParseProperty(reader, buildVersion, propertyName);
+            if (obj.properties[propertyName]) {
+                if (!Array.isArray(obj.properties[propertyName])) {
+                    obj.properties[propertyName] = [obj.properties[propertyName]];
+                }
+                obj.properties[propertyName].push(parsedProperty);
+            }
+            else {
+                obj.properties[propertyName] = parsedProperty;
+            }
+            propertyName = reader.readString();
+        }
+        reader.readInt32();
+        const remainingLen = length - (reader.getBufferPosition() - start);
+        obj.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, remainingLen);
+        const remainingSize = length - (reader.getBufferPosition() - start);
+        if (remainingSize > 0) {
+            obj.trailingData = Array.from(reader.readBytes(remainingSize));
+        }
+        else if (remainingSize < 0) {
+            throw new parser_error_1.ParserError('ParserError', `Unexpected. Read more bytes than are indicated for entity ${obj.instanceName}. bytes left to read is ${remainingSize}`);
+        }
+    }
+    static ParseAdditionalSpecialProperties(reader, typePath, remainingLen) {
+        let property;
+        const start = reader.getBufferPosition();
+        switch (typePath) {
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk6/Build_ConveyorBeltMk6.Build_ConveyorBeltMk6_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk6/Build_ConveyorLiftMk6.Build_ConveyorLiftMk6_C':
+                reader.readInt32();
+                property = {};
+                break;
+            case '/Script/FactoryGame.FGConveyorChainActor':
+                const lastBelt = ObjectReference_1.ObjectReference.read(reader);
+                const firstBelt = ObjectReference_1.ObjectReference.read(reader);
+                const countBeltsInChain = reader.readInt32();
+                const beltsInChain = [];
+                for (let i = 0; i < countBeltsInChain; i++) {
+                    const chainActorRef = ObjectReference_1.ObjectReference.read(reader);
+                    const beltRef = ObjectReference_1.ObjectReference.read(reader);
+                    const someCount = reader.readInt32();
+                    const unknownUseBytes = Array.from(reader.readBytes(someCount * 3 * 24 + 12));
+                    const firstItemIndex = reader.readInt32();
+                    const lastItemIndex = reader.readInt32();
+                    const beltIndexInChain = reader.readInt32();
+                    beltsInChain.push({
+                        chainActorRef,
+                        beltRef,
+                        someCount,
+                        unknownUseBytes,
+                        firstItemIndex,
+                        lastItemIndex,
+                        beltIndexInChain
+                    });
+                }
+                const unknownInts = [reader.readInt32(), reader.readInt32()];
+                const firstChainItemIndex = reader.readInt32();
+                const lastChainItemIndex = reader.readInt32();
+                const countItemsInChain = reader.readInt32();
+                const items = [];
+                for (let n = 0; n < countItemsInChain; n++) {
+                    reader.readInt32();
+                    const itemName = reader.readString();
+                    reader.readInt32();
+                    const position = reader.readInt32();
+                    items.push({ itemName, position });
+                }
+                property = {
+                    firstBelt: firstBelt,
+                    lastBelt: lastBelt,
+                    beltsInChain,
+                    unknownInts,
+                    firstChainItemIndex,
+                    lastChainItemIndex,
+                    items
+                };
+                break;
+            case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+            case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                property = {
+                    source: ObjectProperty_1.ObjectProperty.ReadValue(reader),
+                    target: ObjectProperty_1.ObjectProperty.ReadValue(reader)
+                };
+                if (remainingLen - (reader.getBufferPosition() - start) >= 24) {
+                    property.sourceTranslation = vec3_1.vec3.ParseF(reader);
+                    property.targetTranslation = vec3_1.vec3.ParseF(reader);
+                }
+                break;
+            case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                property = {};
+                property.flag = reader.readByte();
+                switch (property.flag) {
+                    case 248:
+                        const eos = reader.readString();
+                        property.eosData = reader.readString();
+                        break;
+                    case 25:
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case '/Script/FactoryGame.FGLightweightBuildableSubsystem':
+                property = { buildables: [] };
+                const entriesCount = reader.readInt32();
+                if (entriesCount > 0) {
+                    for (let i = 0; i < entriesCount; i++) {
+                        reader.readInt32();
+                        const typePath = reader.readString();
+                        const count = reader.readInt32();
+                        const instances = [];
+                        for (let j = 0; j < count; j++) {
+                            const transform = Transform_1.Transform.Parse(reader);
+                            reader.readInt32();
+                            const swatchSlotTypePath = reader.readString();
+                            reader.readInt32();
+                            reader.readInt64();
+                            const patternPath = reader.readString();
+                            const zeroes = vec2_1.vec2.Parse(reader);
+                            const oneZeroOne = vec3_1.vec3.Parse(reader);
+                            const unknownUseNumbers = [zeroes, oneZeroOne];
+                            reader.readInt32();
+                            const paintFinishPath = reader.readString();
+                            reader.readInt32();
+                            reader.readBytes(1);
+                            const recipeTypePath = reader.readString();
+                            const blueprintProxy = ObjectReference_1.ObjectReference.read(reader);
+                            instances.push({
+                                transform,
+                                unknownUseNumbers,
+                                swatchSlotTypePath,
+                                paintFinishPath,
+                                recipeTypePath,
+                                patternPath,
+                                blueprintProxy
+                            });
+                        }
+                        property.buildables.push({
+                            typePath,
+                            instances
+                        });
+                    }
+                }
+                break;
+            default:
+                property = {};
+                break;
+        }
+        return property;
+    }
+    static ParseProperty(reader, buildVersion, propertyName) {
+        let currentProperty = {};
+        const propertyType = reader.readString();
+        const binarySize = reader.readInt32();
+        const index = reader.readInt32();
+        const before = reader.getBufferPosition();
+        let overhead = 0;
+        switch (propertyType) {
+            case 'BoolProperty':
+                currentProperty = BoolProperty_1.BoolProperty.Parse(reader, propertyType, index);
+                overhead = BoolProperty_1.BoolProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ByteProperty':
+                currentProperty = ByteProperty_1.ByteProperty.Parse(reader, propertyType, index);
+                overhead = ByteProperty_1.ByteProperty.CalcOverhead(currentProperty);
+                break;
+            case 'Int8Property':
+                currentProperty = Int8Property_1.Int8Property.Parse(reader, propertyType, index);
+                overhead = Int8Property_1.Int8Property.CalcOverhead(currentProperty);
+                break;
+            case 'UInt8Property':
+                currentProperty = Uint8Property_1.Uint8Property.Parse(reader, propertyType, index);
+                overhead = Uint8Property_1.Uint8Property.CalcOverhead(currentProperty);
+                break;
+            case 'IntProperty':
+            case 'Int32Property':
+                currentProperty = Int32Property_1.Int32Property.Parse(reader, propertyType, index);
+                overhead = Int32Property_1.Int32Property.CalcOverhead(currentProperty);
+                break;
+            case 'UInt32Property':
+                currentProperty = Uint32Property_1.Uint32Property.Parse(reader, propertyType, index);
+                overhead = Uint32Property_1.Uint32Property.CalcOverhead(currentProperty);
+                break;
+            case 'Int64Property':
+                currentProperty = Int64Property_1.Int64Property.Parse(reader, propertyType, index);
+                overhead = Int64Property_1.Int64Property.CalcOverhead(currentProperty);
+                break;
+            case 'UInt64Property':
+                currentProperty = Uint64Property_1.Uint64Property.Parse(reader, propertyType, index);
+                break;
+            case 'SingleProperty':
+            case 'FloatProperty':
+                currentProperty = FloatProperty_1.FloatProperty.Parse(reader, propertyType, index);
+                overhead = FloatProperty_1.FloatProperty.CalcOverhead(currentProperty);
+                break;
+            case 'DoubleProperty':
+                currentProperty = DoubleProperty_1.DoubleProperty.Parse(reader, propertyType, index);
+                overhead = DoubleProperty_1.DoubleProperty.CalcOverhead(currentProperty);
+                break;
+            case 'StrProperty':
+            case 'NameProperty':
+                currentProperty = StrProperty_1.StrProperty.Parse(reader, propertyType, index);
+                overhead = StrProperty_1.StrProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ObjectProperty':
+            case 'InterfaceProperty':
+                currentProperty = ObjectProperty_1.ObjectProperty.Parse(reader, propertyType, index);
+                overhead = ObjectProperty_1.ObjectProperty.CalcOverhead(currentProperty);
+                break;
+            case 'SoftObjectProperty':
+                currentProperty = SoftObjectProperty_1.SoftObjectProperty.Parse(reader, propertyType, index);
+                overhead = SoftObjectProperty_1.SoftObjectProperty.CalcOverhead(currentProperty);
+                break;
+            case 'EnumProperty':
+                currentProperty = EnumProperty_1.EnumProperty.Parse(reader, propertyType, index);
+                overhead = EnumProperty_1.EnumProperty.CalcOverhead(currentProperty);
+                break;
+            case 'StructProperty':
+                currentProperty = StructProperty_1.StructProperty.Parse(reader, propertyType, index, binarySize);
+                overhead = StructProperty_1.StructProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ArrayProperty':
+                currentProperty = ArrayProperty_1.ArrayProperty.Parse(reader, propertyType, index, propertyName);
+                overhead = ArrayProperty_1.ArrayProperty.CalcOverhead(currentProperty);
+                break;
+            case 'MapProperty':
+                currentProperty = MapProperty_1.MapProperty.Parse(reader, propertyName, buildVersion, binarySize);
+                overhead = MapProperty_1.MapProperty.CalcOverhead(currentProperty);
+                break;
+            case 'TextProperty':
+                currentProperty = TextProperty_1.TextProperty.Parse(reader, propertyType, index);
+                overhead = TextProperty_1.TextProperty.CalcOverhead(currentProperty);
+                break;
+            case 'SetProperty':
+                currentProperty = SetProperty_1.SetProperty.Parse(reader, propertyType, index, propertyName);
+                overhead = SetProperty_1.SetProperty.CalcOverhead(currentProperty);
+                break;
+            default:
+                throw new Error(`Unimplemented type ${propertyType}`);
+        }
+        currentProperty.name = propertyName;
+        const readBytes = reader.getBufferPosition() - before - overhead;
+        if (readBytes !== binarySize) {
+            console.warn(`possibly corrupt. Read ${readBytes} for ${propertyType} ${propertyName}, but ${binarySize} were indicated.`);
+            throw new parser_error_1.ParserError('ParserError', `possibly corrupt. Read ${readBytes} bytes for ${propertyType} ${propertyName}, but ${binarySize} bytes were indicated.`);
+        }
+        return currentProperty;
+    }
+    static Serialize(obj, writer, buildVersion, typePath) {
+        for (const property of Object.values(obj.properties).flatMap(val => Array.isArray(val) ? val : [val])) {
+            writer.writeString(property.name);
+            DataFields.SerializeProperty(writer, property, property.name, buildVersion);
+        }
+        writer.writeString('None');
+        writer.writeInt32(0);
+        DataFields.SerializeAdditionalSpecialProperties(writer, typePath, obj.specialProperties);
+        writer.writeBytesArray(obj.trailingData);
+    }
+    static SerializeAdditionalSpecialProperties(writer, typePath, property) {
+        switch (typePath) {
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk6/Build_ConveyorBeltMk6.Build_ConveyorBeltMk6_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+            case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk6/Build_ConveyorLiftMk6.Build_ConveyorLiftMk6_C':
+                writer.writeInt32(0);
+                break;
+            case '/Script/FactoryGame.FGConveyorChainActor':
+                ObjectReference_1.ObjectReference.write(writer, property.lastBelt);
+                ObjectReference_1.ObjectReference.write(writer, property.firstBelt);
+                writer.writeInt32(property.beltsInChain.length);
+                for (const belt of property.beltsInChain) {
+                    ObjectReference_1.ObjectReference.write(writer, belt.chainActorRef);
+                    ObjectReference_1.ObjectReference.write(writer, belt.beltRef);
+                    writer.writeInt32(belt.someCount);
+                    writer.writeBytesArray(belt.unknownUseBytes);
+                    writer.writeInt32(belt.firstItemIndex);
+                    writer.writeInt32(belt.lastItemIndex);
+                    writer.writeInt32(belt.beltIndexInChain);
+                }
+                writer.writeInt32(property.unknownInts[0]);
+                writer.writeInt32(property.unknownInts[1]);
+                writer.writeInt32(property.firstChainItemIndex);
+                writer.writeInt32(property.lastChainItemIndex);
+                writer.writeInt32(property.items.length);
+                for (const item of property.items) {
+                    writer.writeInt32(0);
+                    writer.writeString(item.itemName);
+                    writer.writeInt32(0);
+                    writer.writeInt32(item.position);
+                }
+                break;
+            case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+            case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                ObjectProperty_1.ObjectProperty.SerializeValue(writer, property.source);
+                ObjectProperty_1.ObjectProperty.SerializeValue(writer, property.target);
+                break;
+            case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                writer.writeByte(property.flag);
+                switch (property.flag) {
+                    case 248:
+                        writer.writeString('EOS');
+                        writer.writeString(property.eosData);
+                        break;
+                    case 25:
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case '/Script/FactoryGame.FGLightweightBuildableSubsystem':
+                writer.writeInt32(property.buildables.length);
+                if (property.buildables.length > 0) {
+                    for (const buildable of property.buildables) {
+                        writer.writeInt32(0);
+                        writer.writeString(buildable.typePath);
+                        writer.writeInt32(buildable.instances.length);
+                        for (const instance of buildable.instances) {
+                            Transform_1.Transform.Serialize(writer, instance.transform);
+                            writer.writeInt32(0);
+                            writer.writeString(instance.swatchSlotTypePath);
+                            writer.writeInt32(0);
+                            writer.writeInt64(0n);
+                            writer.writeString(instance.patternPath);
+                            vec2_1.vec2.Serialize(writer, instance.unknownUseNumbers[0]);
+                            vec3_1.vec3.Serialize(writer, instance.unknownUseNumbers[1]);
+                            writer.writeInt32(0);
+                            writer.writeString(instance.paintFinishPath);
+                            writer.writeInt32(0);
+                            writer.writeByte(0);
+                            writer.writeString(instance.recipeTypePath);
+                            ObjectReference_1.ObjectReference.write(writer, instance.blueprintProxy);
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    static SerializeProperty(writer, property, propertyName, buildVersion) {
+        writer.writeString(property.ueType);
+        const lenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        writer.writeInt32(property.index ?? 0);
+        const start = writer.getBufferPosition();
+        let overhead = 0;
+        switch (property.ueType) {
+            case 'BoolProperty':
+                overhead = BoolProperty_1.BoolProperty.CalcOverhead(property);
+                BoolProperty_1.BoolProperty.Serialize(writer, property);
+                break;
+            case 'ByteProperty':
+                overhead = ByteProperty_1.ByteProperty.CalcOverhead(property);
+                ByteProperty_1.ByteProperty.Serialize(writer, property);
+                break;
+            case 'Int8Property':
+                overhead = Int8Property_1.Int8Property.CalcOverhead(property);
+                Int8Property_1.Int8Property.Serialize(writer, property);
+                break;
+            case 'UInt8Property':
+                overhead = Uint8Property_1.Uint8Property.CalcOverhead(property);
+                Uint8Property_1.Uint8Property.Serialize(writer, property);
+                break;
+            case 'IntProperty':
+            case 'Int32Property':
+                overhead = Int32Property_1.Int32Property.CalcOverhead(property);
+                Int32Property_1.Int32Property.Serialize(writer, property);
+                break;
+            case 'UInt32Property':
+                overhead = Uint32Property_1.Uint32Property.CalcOverhead(property);
+                Uint32Property_1.Uint32Property.Serialize(writer, property);
+                break;
+            case 'Int64Property':
+                overhead = Int64Property_1.Int64Property.CalcOverhead(property);
+                Int64Property_1.Int64Property.Serialize(writer, property);
+                break;
+            case 'UInt64PRoperty':
+                overhead = Uint64Property_1.Uint64Property.CalcOverhead(property);
+                Uint64Property_1.Uint64Property.Serialize(writer, property);
+                break;
+            case 'SingleProperty':
+            case 'FloatProperty':
+                overhead = FloatProperty_1.FloatProperty.CalcOverhead(property);
+                FloatProperty_1.FloatProperty.Serialize(writer, property);
+                break;
+            case 'DoubleProperty':
+                overhead = DoubleProperty_1.DoubleProperty.CalcOverhead(property);
+                DoubleProperty_1.DoubleProperty.Serialize(writer, property);
+                break;
+            case 'StrProperty':
+            case 'NameProperty':
+                overhead = StrProperty_1.StrProperty.CalcOverhead(property);
+                StrProperty_1.StrProperty.Serialize(writer, property);
+                break;
+            case 'ObjectProperty':
+            case 'InterfaceProperty':
+                overhead = ObjectProperty_1.ObjectProperty.CalcOverhead(property);
+                ObjectProperty_1.ObjectProperty.Serialize(writer, property);
+                break;
+            case 'SoftObjectProperty':
+                overhead = SoftObjectProperty_1.SoftObjectProperty.CalcOverhead(property);
+                SoftObjectProperty_1.SoftObjectProperty.Serialize(writer, property);
+                break;
+            case 'EnumProperty':
+                overhead = EnumProperty_1.EnumProperty.CalcOverhead(property);
+                EnumProperty_1.EnumProperty.Serialize(writer, property);
+                break;
+            case 'ByteProperty':
+                overhead = ByteProperty_1.ByteProperty.CalcOverhead(property);
+                ByteProperty_1.ByteProperty.Serialize(writer, property);
+                break;
+            case 'StructProperty':
+                overhead = StructProperty_1.StructProperty.CalcOverhead(property);
+                StructProperty_1.StructProperty.Serialize(writer, property);
+                break;
+            case 'ArrayProperty':
+                overhead = ArrayProperty_1.ArrayProperty.CalcOverhead(property);
+                ArrayProperty_1.ArrayProperty.Serialize(writer, property, propertyName);
+                break;
+            case 'MapProperty':
+                overhead = MapProperty_1.MapProperty.CalcOverhead(property);
+                MapProperty_1.MapProperty.Serialize(writer, property);
+                break;
+            case 'TextProperty':
+                overhead = TextProperty_1.TextProperty.CalcOverhead(property);
+                TextProperty_1.TextProperty.Serialize(writer, property);
+                break;
+            case 'SetProperty':
+                overhead = SetProperty_1.SetProperty.CalcOverhead(property);
+                SetProperty_1.SetProperty.Serialize(writer, property);
+                break;
+            default:
+                throw new Error(`Unimplemented type ${property.type}`);
+        }
+        writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
+    }
+}
+exports.DataFields = DataFields;

package/build/parser/satisfactory/types/property/generic/ArrayProperty.d.ts

@@ -0,0 +1,22 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { BasicProperty } from './BasicProperty';
+export type ArrayPropertyStructValueFields = {
+    allStructType: string;
+    allIndex: number;
+    allGuid: number;
+    allUnk1?: number;
+    allUnk2?: number;
+    allUnk3?: number;
+    allUnk4?: number;
+};
+export declare const isArrayProperty: (property: BasicProperty) => property is ArrayProperty<any>;
+export declare class ArrayProperty<T> extends BasicProperty {
+    subtype: string;
+    values: T[];
+    structValueFields?: ArrayPropertyStructValueFields | undefined;
+    constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
+    static CalcOverhead(property: ArrayProperty<any>): number;
+    static Serialize(writer: ByteWriter, property: ArrayProperty<any>, propertyName: string): void;
+}