@etothepii/satisfactory-file-parser 0.4.22 → 0.5.1

package/README.md

@@ -140,7 +140,25 @@ fs.writeFileSync('./MyModifiedBlueprint.sbpcfg', Buffer.from(summary.configFileB
 So far this was just a private hobby project. But i figure some people actually use it.
 If you find a bug or have feedback about the parser, you can just open an issue on the github repo or hit me up on the satisfactory discord `etothepii`.
 
+# Explicitly Supported/Tested Mods (No guarantee for other mods)
+### Ficsit-Cam (`FicsItCam`)
+### Structural Solutions (`SS_Mod`)
+### Linear Motion (`LinearMotion`)
+### Container Screens (`ContainerScreen`)
+### Conveyor Wall Hole (`WallHoleConveyor`)
+### X3-Signs (`x3_signs`)
+### X3-Roads (`x3_roads`)
+
 # Changelog
+### [0.5.1] (2024-10-15)
+#### Added Mod Support
+#### Internal Renamings
+* `DynamicStructPropertyValue` extracted to own file.
+* Parsing of object data partially moved to `SaveObject`.
+* Renamed `DataFields` class to `PropertiesList`.
+* Moved parsing of class-specific properties into own namespace.
+* `ObjectProperty` and `SoftObjectProperty` now reuse the correct method for parsing/serializing the reference value.
+
 ### [0.4.22] (2024-10-07)
 #### compatibility fix
 * referenced icon libraries in blueprints are now optional when being parsed.
@@ -189,7 +207,7 @@ If you find a bug or have feedback about the parser, you can just open an issue
 # License 
 MIT License
 
-Copyright (c) 2024 etothepii
+Copyright (c) 2021-2024 etothepii
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/build/index.d.ts

@@ -4,7 +4,6 @@ export * from './parser/satisfactory/save/satisfactory-save';
 export * from './parser/satisfactory/save/save.types';
 export * from './parser/satisfactory/types/objects/SaveComponent';
 export * from './parser/satisfactory/types/objects/SaveEntity';
-export * from './parser/satisfactory/types/property/DataFields';
 export * from './parser/satisfactory/types/property/generic/ArrayProperty';
 export * from './parser/satisfactory/types/property/generic/BasicProperty';
 export * from './parser/satisfactory/types/property/generic/BoolProperty';
@@ -24,11 +23,15 @@ export * from './parser/satisfactory/types/property/generic/TextProperty';
 export * from './parser/satisfactory/types/property/generic/Uint32Property';
 export * from './parser/satisfactory/types/property/generic/Uint64Property';
 export * from './parser/satisfactory/types/property/generic/Uint8Property';
-export * from './parser/satisfactory/types/property/special/SpecialAnyProperty';
+export * from './parser/satisfactory/types/property/PropertiesList';
+export * from './parser/satisfactory/types/property/special/SpecialAnyProperties';
+export * from './parser/satisfactory/types/property/special/SpecialProperties';
 export * from './parser/satisfactory/types/structs/col4';
+export * from './parser/satisfactory/types/structs/DynamicStructPropertyValue';
 export * from './parser/satisfactory/types/structs/GUID';
 export * from './parser/satisfactory/types/structs/GUIDInfo';
 export * from './parser/satisfactory/types/structs/MD5Hash';
+export * from './parser/satisfactory/types/structs/mods/FicsItCam/FICFrameRange';
 export * from './parser/satisfactory/types/structs/ObjectReference';
 export * from './parser/satisfactory/types/structs/SoftObjectReference';
 export * from './parser/satisfactory/types/structs/Transform';

package/build/index.js

@@ -21,7 +21,6 @@ __exportStar(require("./parser/satisfactory/save/satisfactory-save"), exports);
 __exportStar(require("./parser/satisfactory/save/save.types"), exports);
 __exportStar(require("./parser/satisfactory/types/objects/SaveComponent"), exports);
 __exportStar(require("./parser/satisfactory/types/objects/SaveEntity"), exports);
-__exportStar(require("./parser/satisfactory/types/property/DataFields"), exports);
 __exportStar(require("./parser/satisfactory/types/property/generic/ArrayProperty"), exports);
 __exportStar(require("./parser/satisfactory/types/property/generic/BasicProperty"), exports);
 __exportStar(require("./parser/satisfactory/types/property/generic/BoolProperty"), exports);
@@ -41,11 +40,15 @@ __exportStar(require("./parser/satisfactory/types/property/generic/TextProperty"
 __exportStar(require("./parser/satisfactory/types/property/generic/Uint32Property"), exports);
 __exportStar(require("./parser/satisfactory/types/property/generic/Uint64Property"), exports);
 __exportStar(require("./parser/satisfactory/types/property/generic/Uint8Property"), exports);
-__exportStar(require("./parser/satisfactory/types/property/special/SpecialAnyProperty"), exports);
+__exportStar(require("./parser/satisfactory/types/property/PropertiesList"), exports);
+__exportStar(require("./parser/satisfactory/types/property/special/SpecialAnyProperties"), exports);
+__exportStar(require("./parser/satisfactory/types/property/special/SpecialProperties"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/col4"), exports);
+__exportStar(require("./parser/satisfactory/types/structs/DynamicStructPropertyValue"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/GUID"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/GUIDInfo"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/MD5Hash"), exports);
+__exportStar(require("./parser/satisfactory/types/structs/mods/FicsItCam/FICFrameRange"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/ObjectReference"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/SoftObjectReference"), exports);
 __exportStar(require("./parser/satisfactory/types/structs/Transform"), exports);

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

@@ -34,7 +34,7 @@ class SaveEntity extends SaveObject_1.SaveObject {
         obj.wasPlacedInLevel = reader.readInt32() == 1;
     }
     static ParseData(entity, length, reader, buildVersion, typePath) {
-        const afterSizeIndicator = reader.getBufferPosition();
+        const start = reader.getBufferPosition();
         entity.parentObjectRoot = reader.readString();
         entity.parentObjectName = reader.readString();
         var componentCount = reader.readInt32();
@@ -42,7 +42,7 @@ class SaveEntity extends SaveObject_1.SaveObject {
             var componentRef = ObjectReference_1.ObjectReference.read(reader);
             entity.components.push(componentRef);
         }
-        const remainingSize = length - (reader.getBufferPosition() - afterSizeIndicator);
+        const remainingSize = length - (reader.getBufferPosition() - start);
         return SaveObject_1.SaveObject.ParseData(entity, remainingSize, reader, buildVersion, typePath);
     }
     static SerializeHeader(writer, entity) {
@@ -55,9 +55,9 @@ class SaveEntity extends SaveObject_1.SaveObject {
         writer.writeString(entity.parentObjectRoot);
         writer.writeString(entity.parentObjectName);
         writer.writeInt32(entity.components.length);
-        for (const com of entity.components) {
-            writer.writeString(com.levelName);
-            writer.writeString(com.pathName);
+        for (const component of entity.components) {
+            writer.writeString(component.levelName);
+            writer.writeString(component.pathName);
         }
         SaveObject_1.SaveObject.SerializeData(writer, entity, buildVersion);
     }

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

@@ -1,7 +1,7 @@
 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';
+import { SpecialAnyProperties } from '../property/special/SpecialAnyProperties';
 export interface SaveObjectHeader {
     typePath: string;
     rootObject: string;
@@ -12,7 +12,7 @@ export declare abstract class SaveObject implements SaveObjectHeader {
     rootObject: string;
     instanceName: string;
     properties: PropertiesMap;
-    specialProperties: SpecialAnyProperty;
+    specialProperties: SpecialAnyProperties;
     trailingData: number[];
     objectVersion: number;
     unknownType2: number;

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SaveObject = void 0;
-const DataFields_1 = require("../property/DataFields");
+const parser_error_1 = require("../../../error/parser.error");
+const PropertiesList_1 = require("../property/PropertiesList");
+const SpecialProperties_1 = require("../property/special/SpecialProperties");
 class SaveObject {
     constructor(typePath, rootObject, instanceName) {
         this.typePath = typePath;
@@ -24,10 +26,24 @@ class SaveObject {
         writer.writeString(obj.instanceName);
     }
     static ParseData(obj, length, reader, buildVersion, typePath) {
-        DataFields_1.DataFields.ParseProperties(obj, length, reader, buildVersion, typePath);
+        const start = reader.getBufferPosition();
+        PropertiesList_1.PropertiesList.ParseList(obj, length, reader, buildVersion, typePath);
+        reader.readInt32();
+        let remainingSize = length - (reader.getBufferPosition() - start);
+        obj.specialProperties = SpecialProperties_1.SpecialProperties.ParseClassSpecificSpecialProperties(reader, typePath, remainingSize);
+        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 SerializeData(writer, obj, buildVersion) {
-        DataFields_1.DataFields.Serialize(obj, writer, buildVersion, obj.typePath);
+        PropertiesList_1.PropertiesList.SerializeList(obj, writer, buildVersion, obj.typePath);
+        writer.writeInt32(0);
+        SpecialProperties_1.SpecialProperties.SerializeClassSpecificSpecialProperties(writer, obj.typePath, obj.specialProperties);
+        writer.writeBytesArray(obj.trailingData);
     }
 }
 exports.SaveObject = SaveObject;

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

@@ -0,0 +1,11 @@
+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';
+export declare namespace PropertiesList {
+    const ParseList: (obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string) => void;
+    const SerializeList: (obj: SaveObject, writer: SaveWriter, buildVersion: number, typePath: string) => void;
+    const ParseSingleProperty: (reader: BinaryReadable, buildVersion: number, propertyName: string) => AbstractBaseProperty;
+    const SerializeSingleProperty: (writer: ByteWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number) => void;
+}

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

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertiesList = void 0;
+const parser_error_1 = require("../../../error/parser.error");
+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");
+var PropertiesList;
+(function (PropertiesList) {
+    PropertiesList.ParseList = (obj, length, reader, buildVersion, typePath) => {
+        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 = PropertiesList.ParseSingleProperty(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();
+        }
+    };
+    PropertiesList.SerializeList = (obj, writer, buildVersion, typePath) => {
+        for (const property of Object.values(obj.properties).flatMap(val => Array.isArray(val) ? val : [val])) {
+            writer.writeString(property.name);
+            PropertiesList.SerializeSingleProperty(writer, property, property.name, buildVersion);
+        }
+        writer.writeString('None');
+    };
+    PropertiesList.ParseSingleProperty = (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;
+    };
+    PropertiesList.SerializeSingleProperty = (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);
+    };
+})(PropertiesList || (exports.PropertiesList = PropertiesList = {}));

package/build/parser/satisfactory/types/property/generic/ArrayProperty.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayProperty = exports.isArrayProperty = void 0;
-const SoftObjectReference_1 = require("../../structs/SoftObjectReference");
 const BasicProperty_1 = require("./BasicProperty");
 const BoolProperty_1 = require("./BoolProperty");
 const ByteProperty_1 = require("./ByteProperty");
@@ -11,6 +10,7 @@ const FloatProperty_1 = require("./FloatProperty");
 const Int32Property_1 = require("./Int32Property");
 const Int64Property_1 = require("./Int64Property");
 const ObjectProperty_1 = require("./ObjectProperty");
+const SoftObjectProperty_1 = require("./SoftObjectProperty");
 const StrProperty_1 = require("./StrProperty");
 const StructProperty_1 = require("./StructProperty");
 const TextProperty_1 = require("./TextProperty");
@@ -54,14 +54,14 @@ class ArrayProperty extends BasicProperty_1.BasicProperty {
                 property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty_1.EnumProperty.ReadValue(reader)), ueType, index);
                 break;
             case "TextProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty_1.TextProperty.ParseValue(reader)), ueType, index);
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty_1.TextProperty.ReadValue(reader)), ueType, index);
                 break;
             case "InterfaceProperty":
             case "ObjectProperty":
                 property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader)), ueType, index);
                 break;
             case "SoftObjectProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => SoftObjectReference_1.SoftObjectReference.read(reader)), ueType, index);
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => SoftObjectProperty_1.SoftObjectProperty.ReadValue(reader)), ueType, index);
                 break;
             case "StructProperty":
                 const name = reader.readString();
@@ -145,7 +145,7 @@ class ArrayProperty extends BasicProperty_1.BasicProperty {
                 property.values.forEach(v => ObjectProperty_1.ObjectProperty.SerializeValue(writer, v));
                 break;
             case "SoftObjectProperty":
-                property.values.forEach(v => SoftObjectReference_1.SoftObjectReference.write(writer, v));
+                property.values.forEach(v => SoftObjectProperty_1.SoftObjectProperty.SerializeValue(writer, v));
                 break;
             case "StructProperty":
                 writer.writeString(propertyName);

package/build/parser/satisfactory/types/property/generic/BoolProperty.js

@@ -19,7 +19,7 @@ class BoolProperty extends BasicProperty_1.BasicProperty {
         return reader.readByte() > 0;
     }
     static CalcOverhead(property) {
-        return 2;
+        return 1 + 1;
     }
     static Serialize(writer, property) {
         BoolProperty.SerializeValue(writer, property.value);

package/build/parser/satisfactory/types/property/generic/EnumProperty.js

@@ -21,7 +21,7 @@ class EnumProperty extends BasicProperty_1.BasicProperty {
         return reader.readString();
     }
     static CalcOverhead(property) {
-        return property.value.name.length + 6;
+        return property.value.name.length + 5 + 1;
     }
     static Serialize(writer, property) {
         writer.writeString(property.value.name);

package/build/parser/satisfactory/types/property/generic/MapProperty.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapProperty = exports.isMapProperty = void 0;
+const DynamicStructPropertyValue_1 = require("../../structs/DynamicStructPropertyValue");
 const BasicProperty_1 = require("./BasicProperty");
 const ByteProperty_1 = require("./ByteProperty");
 const EnumProperty_1 = require("./EnumProperty");
@@ -8,7 +9,6 @@ const Int32Property_1 = require("./Int32Property");
 const Int64Property_1 = require("./Int64Property");
 const ObjectProperty_1 = require("./ObjectProperty");
 const StrProperty_1 = require("./StrProperty");
-const StructProperty_1 = require("./StructProperty");
 const isMapProperty = (property) => property.type === 'MapProperty';
 exports.isMapProperty = isMapProperty;
 class MapProperty extends BasicProperty_1.BasicProperty {
@@ -36,7 +36,7 @@ class MapProperty extends BasicProperty_1.BasicProperty {
                         key = Array.from(reader.readBytes(12));
                     }
                     else {
-                        key = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.keyType);
+                        key = DynamicStructPropertyValue_1.DynamicStructPropertyValue.read(reader, 0, property.keyType);
                     }
                     break;
                 case 'ObjectProperty':
@@ -53,6 +53,9 @@ class MapProperty extends BasicProperty_1.BasicProperty {
                 case 'Int32Property':
                     key = Int32Property_1.Int32Property.ReadValue(reader);
                     break;
+                case 'Int64Property':
+                    key = Int64Property_1.Int64Property.ReadValue(reader);
+                    break;
                 case 'ByteProperty':
                     key = ByteProperty_1.ByteProperty.ReadValue(reader);
                     break;
@@ -61,7 +64,7 @@ class MapProperty extends BasicProperty_1.BasicProperty {
             }
             switch (property.valueType) {
                 case 'StructProperty':
-                    value = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.valueType);
+                    value = DynamicStructPropertyValue_1.DynamicStructPropertyValue.read(reader, 0, property.valueType);
                     break;
                 case 'ObjectProperty':
                     value = ObjectProperty_1.ObjectProperty.ReadValue(reader);
@@ -106,7 +109,7 @@ class MapProperty extends BasicProperty_1.BasicProperty {
                         writer.writeBytesArray(entry[0]);
                     }
                     else {
-                        (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[0]);
+                        DynamicStructPropertyValue_1.DynamicStructPropertyValue.write(writer, 0, entry[0]);
                     }
                     break;
                 case 'ObjectProperty':
@@ -123,6 +126,9 @@ class MapProperty extends BasicProperty_1.BasicProperty {
                 case 'Int32Property':
                     Int32Property_1.Int32Property.SerializeValue(writer, entry[0]);
                     break;
+                case 'Int64Property':
+                    Int64Property_1.Int64Property.SerializeValue(writer, entry[0]);
+                    break;
                 case 'ByteProperty':
                     ByteProperty_1.ByteProperty.SerializeValue(writer, entry[0]);
                     break;
@@ -131,7 +137,7 @@ class MapProperty extends BasicProperty_1.BasicProperty {
             }
             switch (property.valueType) {
                 case 'StructProperty':
-                    (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[1]);
+                    DynamicStructPropertyValue_1.DynamicStructPropertyValue.write(writer, 0, entry[1]);
                     break;
                 case 'ObjectProperty':
                     ObjectProperty_1.ObjectProperty.SerializeValue(writer, entry[1]);

package/build/parser/satisfactory/types/property/generic/ObjectProperty.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectProperty = exports.isObjectProperty = void 0;
 const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const ObjectReference_1 = require("../../structs/ObjectReference");
 const BasicProperty_1 = require("./BasicProperty");
 const isObjectProperty = (property) => property.type === 'ObjectProperty';
 exports.isObjectProperty = isObjectProperty;
@@ -16,11 +17,7 @@ class ObjectProperty extends BasicProperty_1.BasicProperty {
         return new ObjectProperty(value, ueType, guidInfo, index);
     }
     static ReadValue(reader) {
-        const x = {
-            levelName: reader.readString(),
-            pathName: reader.readString()
-        };
-        return x;
+        return ObjectReference_1.ObjectReference.read(reader);
     }
     static CalcOverhead(property) {
         return 1;
@@ -30,8 +27,7 @@ class ObjectProperty extends BasicProperty_1.BasicProperty {
         ObjectProperty.SerializeValue(writer, property.value);
     }
     static SerializeValue(writer, value) {
-        writer.writeString(value.levelName);
-        writer.writeString(value.pathName);
+        ObjectReference_1.ObjectReference.write(writer, value);
     }
 }
 exports.ObjectProperty = ObjectProperty;

package/build/parser/satisfactory/types/property/generic/SetProperty.js

@@ -18,8 +18,8 @@ class SetProperty extends BasicProperty_1.BasicProperty {
     }
     static Parse(reader, ueType, index, propertyName) {
         const subtype = reader.readString();
-        const unk2 = reader.skipBytes(1);
-        const unk3 = reader.skipBytes(4);
+        reader.skipBytes(1);
+        reader.skipBytes(4);
         const elementCount = reader.readInt32();
         let property;
         switch (subtype) {

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

@@ -8,6 +8,8 @@ export declare class SoftObjectProperty extends BasicProperty {
     value: SoftObjectReference;
     constructor(value: SoftObjectReference, ueType?: string, guidInfo?: GUIDInfo, index?: number);
     static Parse(reader: BinaryReadable, ueType: string, index?: number): SoftObjectProperty;
+    static ReadValue(reader: BinaryReadable): SoftObjectReference;
     static CalcOverhead(property: SoftObjectProperty): number;
     static Serialize(writer: ByteWriter, property: SoftObjectProperty): void;
+    static SerializeValue(writer: ByteWriter, value: SoftObjectReference): void;
 }

package/build/parser/satisfactory/types/property/generic/SoftObjectProperty.js

@@ -16,6 +16,9 @@ class SoftObjectProperty extends BasicProperty_1.BasicProperty {
         const value = SoftObjectReference_1.SoftObjectReference.read(reader);
         return new SoftObjectProperty(value, ueType, guidInfo, index);
     }
+    static ReadValue(reader) {
+        return SoftObjectReference_1.SoftObjectReference.read(reader);
+    }
     static CalcOverhead(property) {
         return 1;
     }
@@ -23,5 +26,8 @@ class SoftObjectProperty extends BasicProperty_1.BasicProperty {
         GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
         SoftObjectReference_1.SoftObjectReference.write(writer, property.value);
     }
+    static SerializeValue(writer, value) {
+        SoftObjectReference_1.SoftObjectReference.write(writer, value);
+    }
 }
 exports.SoftObjectProperty = SoftObjectProperty;