@etothepii/satisfactory-file-parser 0.0.31 → 0.0.33

package/build/parser/satisfactory/objects/DataFields.js

@@ -4,20 +4,22 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Property"], factory);
+        define(["require", "exports", "../structs/util.types", "./Property"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DataFields = void 0;
+    const util_types_1 = require("../structs/util.types");
     const Property_1 = require("./Property");
     class DataFields {
         constructor() {
             this.properties = [];
+            this.specialProperties = {};
             this.trailingData = [];
             this.shouldBeNulled = false;
         }
-        static Parse(length, reader, buildVersion) {
+        static Parse(length, reader, buildVersion, typePath) {
             const start = reader.getBufferPosition();
             const fields = new DataFields();
             if (length === 0) {
@@ -33,11 +35,58 @@
             let int1 = reader.readInt32();
             if (int1 !== 0) {
             }
+            fields.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, start + length - reader.getBufferPosition() - 4);
             const end = reader.getBufferPosition();
             let remainingBytes = start + length - end;
             fields.trailingData = Array.from(reader.readBytes(remainingBytes));
             return fields;
         }
+        static ParseAdditionalSpecialProperties(reader, typePath, remainingLen) {
+            let 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/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':
+                    property = {};
+                    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: Property_1.ObjectProperty.ReadValue(reader),
+                        target: Property_1.ObjectProperty.ReadValue(reader)
+                    };
+                    if (remainingLen >= 24) {
+                        property.sourceTranslation = (0, util_types_1.ParseVec3)(reader);
+                        property.targetTranslation = (0, util_types_1.ParseVec3)(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;
+                default:
+                    property = {};
+                    break;
+            }
+            return property;
+        }
         static ParseProperty(reader, buildVersion, propertyName) {
             let currentProperty = {};
             if (currentProperty.name === 'None') {
@@ -131,15 +180,49 @@
             }
             return currentProperty;
         }
-        static Serialize(writer, fields, buildVersion) {
+        static Serialize(writer, fields, buildVersion, typePath) {
             for (const property of fields.properties) {
                 writer.writeString(property.name);
                 DataFields.SerializeProperty(writer, property, property.name, buildVersion);
             }
             writer.writeString('None');
             writer.writeInt32(0);
+            DataFields.SerializeAdditionalSpecialProperties(writer, typePath, fields.specialProperties);
             writer.writeBytesArray(fields.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/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':
+                    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_1.ObjectProperty.SerializeValue(writer, property.source);
+                    Property_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;
+            }
+        }
         static SerializeProperty(writer, property, propertyName, buildVersion) {
             writer.writeString(property.ueType);
             const lenIndicator = writer.getBufferPosition();

package/build/parser/satisfactory/objects/ObjectReference.d.ts

@@ -1,9 +1,9 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 export declare class ObjectReference {
     levelName: string;
     pathName: string;
     constructor(levelName: string, pathName: string);
-    static Parse(reader: ByteReader): ObjectReference;
+    static Parse(reader: BinaryReadable): ObjectReference;
     static Serialize(writer: ByteWriter, ref: ObjectReference): void;
 }

package/build/parser/satisfactory/objects/Property.d.ts

@@ -1,5 +1,5 @@
-import { ByteReader } from "../../byte/byte-reader.class";
-import { SaveWriter } from "../save/save-writer";
+import { ByteWriter } from "../../..";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { col4, vec3, vec4 } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
 export type Properties = {
@@ -20,19 +20,19 @@ export declare abstract class BasicProperty extends AbstractBaseProperty {
     constructor(type: string, ueType: string, guidInfo: GUID, index?: number);
 }
 export type GUID = undefined | Uint8Array;
-export declare const ParseGUID: (reader: ByteReader) => GUID;
-export declare const SerializeGUID: (writer: SaveWriter, guid: GUID) => void;
+export declare const ParseGUID: (reader: BinaryReadable) => GUID;
+export declare const SerializeGUID: (writer: ByteWriter, guid: GUID) => void;
 export type OverheadResult = {
     overhead: number;
 };
 export declare class BoolProperty extends BasicProperty {
     value: boolean;
     constructor(value: boolean, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): BoolProperty;
-    static ReadValue(reader: ByteReader): boolean;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): BoolProperty;
+    static ReadValue(reader: BinaryReadable): boolean;
     static CalcOverhead(property: BoolProperty): number;
-    static Serialize(writer: SaveWriter, property: BoolProperty): void;
-    static SerializeValue(writer: SaveWriter, value: boolean): void;
+    static Serialize(writer: ByteWriter, property: BoolProperty): void;
+    static SerializeValue(writer: ByteWriter, value: boolean): void;
 }
 export type BytePropertyValue = {
     type: string;
@@ -41,92 +41,92 @@ export type BytePropertyValue = {
 export declare class ByteProperty extends BasicProperty {
     value: BytePropertyValue;
     constructor(value: BytePropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ByteProperty;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ByteProperty;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: ByteProperty): number;
-    static Serialize(writer: SaveWriter, property: ByteProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: ByteProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int8Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int8Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int8Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Int8Property): number;
-    static Serialize(writer: SaveWriter, property: Int8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Int8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Uint8Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint8Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint8Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Uint8Property): number;
-    static Serialize(writer: SaveWriter, property: Uint8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Uint8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int32Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int32Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int32Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Int32Property): number;
-    static Serialize(writer: SaveWriter, property: Int32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Int32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Uint32Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint32Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint32Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Uint32Property): number;
-    static Serialize(writer: SaveWriter, property: Uint32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Uint32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int64Property extends BasicProperty {
     value: string;
     constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int64Property;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int64Property;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: Int64Property): number;
-    static Serialize(writer: SaveWriter, property: Int64Property): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: Int64Property): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export declare class FloatProperty extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): FloatProperty;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): FloatProperty;
     static CalcOverhead(property: FloatProperty): number;
-    static ReadValue(reader: ByteReader): number;
-    static Serialize(writer: SaveWriter, property: FloatProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static ReadValue(reader: BinaryReadable): number;
+    static Serialize(writer: ByteWriter, property: FloatProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class DoubleProperty extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): DoubleProperty;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): DoubleProperty;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: DoubleProperty): number;
-    static Serialize(writer: SaveWriter, property: DoubleProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: DoubleProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class StrProperty extends BasicProperty {
     value: string;
     constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): StrProperty;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): StrProperty;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: StrProperty): number;
-    static Serialize(writer: SaveWriter, property: StrProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: StrProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export declare class ObjectProperty extends BasicProperty {
     value: ObjectReference;
     constructor(value: ObjectReference, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ObjectProperty;
-    static ReadValue(reader: ByteReader): ObjectReference;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ObjectProperty;
+    static ReadValue(reader: BinaryReadable): ObjectReference;
     static CalcOverhead(property: ObjectProperty): number;
-    static Serialize(writer: SaveWriter, property: ObjectProperty): void;
-    static SerializeValue(writer: SaveWriter, value: {
+    static Serialize(writer: ByteWriter, property: ObjectProperty): void;
+    static SerializeValue(writer: ByteWriter, value: {
         levelName: string;
         pathName: string;
     }): void;
@@ -140,11 +140,11 @@ export declare class EnumProperty extends BasicProperty {
         name: string;
         value: string;
     }, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): EnumProperty;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): EnumProperty;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: EnumProperty): number;
-    static Serialize(writer: SaveWriter, property: EnumProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: EnumProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export type TextPropertyValue = {
     flags: number;
@@ -165,11 +165,11 @@ export type TextPropertyValue = {
 export declare class TextProperty extends BasicProperty {
     value: TextPropertyValue;
     constructor(value: TextPropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): TextProperty;
-    static ParseValue(reader: ByteReader): TextPropertyValue;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): TextProperty;
+    static ParseValue(reader: BinaryReadable): TextPropertyValue;
     static CalcOverhead(property: TextProperty): number;
-    static Serialize(writer: SaveWriter, property: TextProperty): void;
-    static SerializeValue(writer: SaveWriter, value: TextPropertyValue): void;
+    static Serialize(writer: ByteWriter, property: TextProperty): void;
+    static SerializeValue(writer: ByteWriter, value: TextPropertyValue): void;
 }
 export type BasicMultipleStructPropertyValue = {
     values: any;
@@ -213,11 +213,11 @@ export declare class StructProperty extends AbstractBaseProperty {
     unk3?: number;
     unk4?: number;
     constructor(subtype: string, ueType?: string, index?: number, guid?: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, size: number): StructProperty;
-    static ParseValue(reader: ByteReader, subtype: string, size: number): GENERIC_STRUCT_PROPERTY_VALUE;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, size: number): StructProperty;
+    static ParseValue(reader: BinaryReadable, subtype: string, size: number): GENERIC_STRUCT_PROPERTY_VALUE;
     static CalcOverhead(property: StructProperty): number;
-    static Serialize(writer: SaveWriter, property: StructProperty): void;
-    static SerializeValue(writer: SaveWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): void;
+    static Serialize(writer: ByteWriter, property: StructProperty): void;
+    static SerializeValue(writer: ByteWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): void;
 }
 export type ArrayPropertyStructValueFields = {
     allStructType: string;
@@ -233,17 +233,17 @@ export declare class ArrayProperty<T> extends BasicProperty {
     values: T[];
     structValueFields?: ArrayPropertyStructValueFields | undefined;
     constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
     static CalcOverhead(property: ArrayProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: ArrayProperty<any>, propertyName: string): void;
+    static Serialize(writer: ByteWriter, property: ArrayProperty<any>, propertyName: string): void;
 }
 export declare class SetProperty<T> extends BasicProperty {
     subtype: string;
     values: T[];
     constructor(subtype: string, values: T[], ueType: string, index: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): SetProperty<any>;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): SetProperty<any>;
     static CalcOverhead(property: SetProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: SetProperty<any>): void;
+    static Serialize(writer: ByteWriter, property: SetProperty<any>): void;
 }
 export declare class MapProperty extends BasicProperty {
     keyType: string;
@@ -258,13 +258,13 @@ export declare class MapProperty extends BasicProperty {
         value: any;
     }[];
     constructor(keyType: string, valueType: string, ueType: string, index: number);
-    static Parse(reader: ByteReader, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
+    static Parse(reader: BinaryReadable, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
     static CalcOverhead(property: MapProperty): number;
-    static Serialize(writer: SaveWriter, property: MapProperty): void;
+    static Serialize(writer: ByteWriter, property: MapProperty): void;
 }
-export declare const ParseDynamicStructData: (reader: ByteReader, buildVersion: number, type: string) => DynamicStructPropertyValue;
-export declare const SerializeDynamicStructData: (writer: SaveWriter, buildVersion: number, data: DynamicStructPropertyValue) => void;
-export declare const ReadFINNetworkTrace: (reader: ByteReader) => any;
-export declare const SerializeFINNetworkTrace: (writer: SaveWriter, obj: any) => void;
-export declare const ReadFINLuaProcessorStateStorage: (reader: ByteReader, size: number) => any;
-export declare const SerializeFINLuaProcessorStateStorage: (writer: SaveWriter, stateStorage: any) => void;
+export declare const ParseDynamicStructData: (reader: BinaryReadable, buildVersion: number, type: string) => DynamicStructPropertyValue;
+export declare const SerializeDynamicStructData: (writer: ByteWriter, buildVersion: number, data: DynamicStructPropertyValue) => void;
+export declare const ReadFINNetworkTrace: (reader: BinaryReadable) => any;
+export declare const SerializeFINNetworkTrace: (writer: ByteWriter, obj: any) => void;
+export declare const ReadFINLuaProcessorStateStorage: (reader: BinaryReadable, size: number) => any;
+export declare const SerializeFINLuaProcessorStateStorage: (writer: ByteWriter, stateStorage: any) => void;

package/build/parser/satisfactory/objects/Property.js

@@ -233,7 +233,7 @@
             return new Int64Property(value, ueType, guidInfo, index);
         }
         static ReadValue(reader) {
-            return reader.readLong().toString();
+            return reader.readInt64().toString();
         }
         static CalcOverhead(property) {
             return 1;
@@ -261,7 +261,7 @@
             return 1;
         }
         static ReadValue(reader) {
-            return reader.readFloat();
+            return reader.readFloat32();
         }
         static Serialize(writer, property) {
             (0, exports.SerializeGUID)(writer, property.guidInfo);
@@ -547,8 +547,8 @@
                     value = {
                         root: reader.readString(),
                         instanceName: reader.readString(),
-                        offset: reader.readFloat(),
-                        forward: reader.readFloat()
+                        offset: reader.readFloat32(),
+                        forward: reader.readFloat32()
                     };
                     break;
                 case 'TimerHandle':
@@ -568,14 +568,14 @@
                     break;
                 case 'FluidBox':
                     value = {
-                        value: reader.readFloat()
+                        value: reader.readFloat32()
                     };
                     break;
                 case 'SlateBrush':
                     value = reader.readString();
                     break;
                 case 'DateTime':
-                    value = reader.readLong().toString();
+                    value = reader.readInt64().toString();
                     break;
                 case 'FINNetworkTrace':
                     value = (0, exports.ReadFINNetworkTrace)(reader);
@@ -587,8 +587,8 @@
                     break;
                 case 'FICFrameRange':
                     value = {
-                        begin: reader.readLong().toString(),
-                        end: reader.readLong().toString(),
+                        begin: reader.readInt64().toString(),
+                        end: reader.readInt64().toString(),
                     };
                     break;
                 default:
@@ -704,35 +704,35 @@
             const elementCount = reader.readInt32();
             switch (subtype) {
                 case "FloatProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => FloatProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "BoolProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => BoolProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "IntProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
                     break;
                 case "Int64Property":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int64Property.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property.ReadValue(reader)), ueType, index);
                     break;
                 case "DoubleProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => DoubleProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "ByteProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ByteProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StrProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "EnumProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => EnumProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "TextProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => TextProperty.ParseValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty.ParseValue(reader)), ueType, index);
                     break;
                 case "InterfaceProperty":
                 case "ObjectProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StructProperty":
                     const name = reader.readString();
@@ -759,7 +759,7 @@
                         innerStructValueFields.allUnk4 = allUnk4;
                     }
                     const before = reader.getBufferPosition();
-                    const maArr = new Array(elementCount).fill(0).map(e => {
+                    const maArr = new Array(elementCount).fill(0).map(() => {
                         const struct = new StructProperty(allStructType, type, allIndex, allGuid);
                         struct.value = StructProperty.ParseValue(reader, allStructType, binarySize);
                         return struct;
@@ -852,17 +852,17 @@
             let property;
             switch (subtype) {
                 case "IntProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
                     break;
                 case "ObjectProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "NameProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StructProperty":
                     if (propertyName === 'mRemovalLocations') {
-                        property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => (0, util_types_1.ParseVec3)(reader)), ueType, index);
+                        property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => (0, util_types_1.ParseVec3)(reader)), ueType, index);
                     }
                     break;
                 default:
@@ -932,6 +932,7 @@
         const data = {
             type, properties: {}
         };
+        const pos = reader.getBufferPosition();
         let propertyName = reader.readString();
         while (propertyName !== 'None') {
             const property = DataFields_1.DataFields.ParseProperty(reader, buildVersion, propertyName);

package/build/parser/satisfactory/objects/SaveComponent.d.ts

@@ -1,8 +1,11 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
-import { SaveObject } from "./SaveObject";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
 export declare const isSaveComponent: (obj: any) => obj is SaveComponent;
-export declare class SaveComponent extends SaveObject {
+export interface SaveComponentHeader extends SaveObjectHeader {
+    parentEntityName: string;
+}
+export declare class SaveComponent extends SaveObject implements SaveComponentHeader {
     typePath: string;
     rootObject: string;
     instanceName: string;
@@ -10,7 +13,7 @@ export declare class SaveComponent extends SaveObject {
     static readonly TypeID = 0;
     readonly type = "SaveComponent";
     constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string);
-    static ParseHeader(reader: ByteReader, obj: SaveComponent): void;
+    static ParseHeader(reader: BinaryReadable, obj: SaveComponent): void;
     static SerializeHeader(writer: ByteWriter, component: SaveComponent): void;
-    static ParseData(component: SaveComponent, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseData(component: SaveComponent, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
 }

package/build/parser/satisfactory/objects/SaveComponent.js

@@ -32,8 +32,8 @@
             SaveObject_1.SaveObject.SerializeHeader(writer, component);
             writer.writeString(component.parentEntityName);
         }
-        static ParseData(component, length, reader, buildVersion) {
-            SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion);
+        static ParseData(component, length, reader, buildVersion, typePath) {
+            SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion, typePath);
         }
     }
     SaveComponent.TypeID = 0;

package/build/parser/satisfactory/objects/SaveEntity.d.ts

@@ -1,9 +1,14 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { Transform } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
-import { SaveObject } from "./SaveObject";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
 export declare const isSaveEntity: (obj: any) => obj is SaveEntity;
+export interface SaveEntityHeader extends SaveObjectHeader {
+    needTransform: boolean;
+    transform: Transform;
+    wasPlacedInLevel: boolean;
+}
 export declare class SaveEntity extends SaveObject {
     typePath: string;
     rootObject: string;
@@ -18,8 +23,8 @@ export declare class SaveEntity extends SaveObject {
     parentObjectName: string;
     components: ObjectReference[];
     constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string, needsTransform?: boolean);
-    static ParseHeader(reader: ByteReader, obj: SaveEntity): void;
-    static ParseData(entity: SaveEntity, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseHeader(reader: BinaryReadable, obj: SaveEntity): void;
+    static ParseData(entity: SaveEntity, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
     static SerializeHeader(writer: ByteWriter, entity: SaveEntity): void;
     static SerializeData(writer: ByteWriter, entity: SaveEntity, buildVersion: number): void;
 }

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

@@ -42,7 +42,7 @@
             obj.transform = (0, util_types_1.ParseTransform)(reader);
             obj.wasPlacedInLevel = reader.readInt32() == 1;
         }
-        static ParseData(entity, length, reader, buildVersion) {
+        static ParseData(entity, length, reader, buildVersion, typePath) {
             var newLen = length - 12;
             entity.parentObjectRoot = reader.readString();
             if (entity.parentObjectRoot.length > 0)
@@ -56,7 +56,7 @@
                 entity.components.push(componentRef);
                 newLen -= 10 + componentRef.levelName.length + componentRef.pathName.length;
             }
-            SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion);
+            return SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion, typePath);
         }
         static SerializeHeader(writer, entity) {
             SaveObject_1.SaveObject.SerializeHeader(writer, entity);