@etothepii/satisfactory-file-parser 0.4.20 → 0.4.22

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

@@ -0,0 +1,22 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { ObjectReference } from '../../structs/ObjectReference';
+import { BasicProperty } from './BasicProperty';
+import { GENERIC_STRUCT_PROPERTY_VALUE } from './StructProperty';
+export type MAP_STRUCT_KEY_PROXY = [number, number, number, number, number, number, number, number, number, number, number, number];
+export type GENERIC_MAP_KEY_TYPE = number | ObjectReference | boolean | GENERIC_STRUCT_PROPERTY_VALUE | MAP_STRUCT_KEY_PROXY;
+export type GENERIC_MAP_VALUE_TYPE = number | ObjectReference | boolean | GENERIC_STRUCT_PROPERTY_VALUE;
+export declare const isMapProperty: (property: BasicProperty) => property is MapProperty;
+export declare class MapProperty extends BasicProperty {
+    keyType: string;
+    valueType: string;
+    modeType: number;
+    modeUnk1: string | undefined;
+    modeUnk2: string;
+    modeUnk3: string;
+    values: [key: GENERIC_MAP_KEY_TYPE, value: GENERIC_MAP_VALUE_TYPE][];
+    constructor(keyType: string, valueType: string, ueType: string, index: number);
+    static Parse(reader: BinaryReadable, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
+    static CalcOverhead(property: MapProperty): number;
+    static Serialize(writer: ByteWriter, property: MapProperty): void;
+}

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapProperty = exports.isMapProperty = void 0;
+const BasicProperty_1 = require("./BasicProperty");
+const ByteProperty_1 = require("./ByteProperty");
+const EnumProperty_1 = require("./EnumProperty");
+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 {
+    constructor(keyType, valueType, ueType, index) {
+        super({ type: 'MapProperty', ueType, index });
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.modeType = 0;
+        this.modeUnk2 = '';
+        this.modeUnk3 = '';
+        this.values = [];
+    }
+    static Parse(reader, propertyName, buildVersion, size, ueType = 'MapProperty', index = 0) {
+        const start = reader.getBufferPosition();
+        const property = new MapProperty(reader.readString(), reader.readString(), ueType, index);
+        const unk = reader.readByte();
+        property.modeType = reader.readInt32();
+        const elementCount = reader.readInt32();
+        for (let i = 0; i < elementCount; i++) {
+            let key;
+            let value;
+            switch (property.keyType) {
+                case 'StructProperty':
+                    if (propertyName === 'mSaveData' || propertyName === 'mUnresolvedSaveData') {
+                        key = Array.from(reader.readBytes(12));
+                    }
+                    else {
+                        key = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.keyType);
+                    }
+                    break;
+                case 'ObjectProperty':
+                    key = ObjectProperty_1.ObjectProperty.ReadValue(reader);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    key = StrProperty_1.StrProperty.ReadValue(reader);
+                    break;
+                case 'EnumProperty':
+                    key = EnumProperty_1.EnumProperty.ReadValue(reader);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    key = Int32Property_1.Int32Property.ReadValue(reader);
+                    break;
+                case 'ByteProperty':
+                    key = ByteProperty_1.ByteProperty.ReadValue(reader);
+                    break;
+                default:
+                    throw new Error(`not implemented map key type ${property.keyType}`);
+            }
+            switch (property.valueType) {
+                case 'StructProperty':
+                    value = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.valueType);
+                    break;
+                case 'ObjectProperty':
+                    value = ObjectProperty_1.ObjectProperty.ReadValue(reader);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    value = StrProperty_1.StrProperty.ReadValue(reader);
+                    break;
+                case 'EnumProperty':
+                    value = EnumProperty_1.EnumProperty.ReadValue(reader);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    value = Int32Property_1.Int32Property.ReadValue(reader);
+                    break;
+                case 'Int64Property':
+                    value = Int64Property_1.Int64Property.ReadValue(reader);
+                    break;
+                case 'ByteProperty':
+                    value = ByteProperty_1.ByteProperty.ReadValue(reader);
+                    break;
+                default:
+                    throw new Error(`not implemented map value type ${property.valueType}`);
+            }
+            property.values.push([key, value]);
+        }
+        return property;
+    }
+    static CalcOverhead(property) {
+        return property.keyType.length + 5 + property.valueType.length + 5 + 1;
+    }
+    static Serialize(writer, property) {
+        writer.writeString(property.keyType);
+        writer.writeString(property.valueType);
+        writer.writeByte(0);
+        writer.writeInt32(property.modeType);
+        writer.writeInt32(property.values.length);
+        for (const entry of property.values) {
+            switch (property.keyType) {
+                case 'StructProperty':
+                    if (property.name === 'mSaveData' || property.name === 'mUnresolvedSaveData') {
+                        writer.writeBytesArray(entry[0]);
+                    }
+                    else {
+                        (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[0]);
+                    }
+                    break;
+                case 'ObjectProperty':
+                    ObjectProperty_1.ObjectProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    StrProperty_1.StrProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'EnumProperty':
+                    EnumProperty_1.EnumProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    Int32Property_1.Int32Property.SerializeValue(writer, entry[0]);
+                    break;
+                case 'ByteProperty':
+                    ByteProperty_1.ByteProperty.SerializeValue(writer, entry[0]);
+                    break;
+                default:
+                    throw new Error(`not implemented map key type ${property.valueType}`);
+            }
+            switch (property.valueType) {
+                case 'StructProperty':
+                    (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[1]);
+                    break;
+                case 'ObjectProperty':
+                    ObjectProperty_1.ObjectProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    StrProperty_1.StrProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'EnumProperty':
+                    EnumProperty_1.EnumProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    Int32Property_1.Int32Property.SerializeValue(writer, entry[1]);
+                    break;
+                case 'Int64Property':
+                    Int64Property_1.Int64Property.SerializeValue(writer, entry[1]);
+                    break;
+                case 'ByteProperty':
+                    ByteProperty_1.ByteProperty.SerializeValue(writer, entry[1]);
+                    break;
+                default:
+                    throw new Error(`not implemented map value type ${property.valueType}`);
+            }
+        }
+    }
+}
+exports.MapProperty = MapProperty;

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

@@ -0,0 +1,15 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { ObjectReference } from '../../structs/ObjectReference';
+import { BasicProperty } from './BasicProperty';
+export declare const isObjectProperty: (property: BasicProperty) => property is ObjectProperty;
+export declare class ObjectProperty extends BasicProperty {
+    value: ObjectReference;
+    constructor(value: ObjectReference, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ObjectProperty;
+    static ReadValue(reader: BinaryReadable): ObjectReference;
+    static CalcOverhead(property: ObjectProperty): number;
+    static Serialize(writer: ByteWriter, property: ObjectProperty): void;
+    static SerializeValue(writer: ByteWriter, value: ObjectReference): void;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectProperty = exports.isObjectProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isObjectProperty = (property) => property.type === 'ObjectProperty';
+exports.isObjectProperty = isObjectProperty;
+class ObjectProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'ObjectProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'ObjectProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = ObjectProperty.ReadValue(reader);
+        return new ObjectProperty(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        const x = {
+            levelName: reader.readString(),
+            pathName: reader.readString()
+        };
+        return x;
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        ObjectProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value.levelName);
+        writer.writeString(value.pathName);
+    }
+}
+exports.ObjectProperty = ObjectProperty;

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

@@ -0,0 +1,12 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { BasicProperty } from './BasicProperty';
+export declare const isSetProperty: (property: BasicProperty) => property is SetProperty<any>;
+export declare class SetProperty<T> extends BasicProperty {
+    subtype: string;
+    values: T[];
+    constructor(subtype: string, values: T[], ueType: string, index: number);
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): SetProperty<any>;
+    static CalcOverhead(property: SetProperty<any>): number;
+    static Serialize(writer: ByteWriter, property: SetProperty<any>): void;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetProperty = exports.isSetProperty = void 0;
+const GUID_1 = require("../../structs/GUID");
+const vec3_1 = require("../../structs/vec3");
+const BasicProperty_1 = require("./BasicProperty");
+const Int32Property_1 = require("./Int32Property");
+const ObjectProperty_1 = require("./ObjectProperty");
+const StrProperty_1 = require("./StrProperty");
+const Uint32Property_1 = require("./Uint32Property");
+const isSetProperty = (property) => property.type === 'SetProperty';
+exports.isSetProperty = isSetProperty;
+class SetProperty extends BasicProperty_1.BasicProperty {
+    constructor(subtype, values, ueType, index) {
+        super({ type: 'SetProperty', ueType, index });
+        this.subtype = subtype;
+        this.values = values;
+    }
+    static Parse(reader, ueType, index, propertyName) {
+        const subtype = reader.readString();
+        const unk2 = reader.skipBytes(1);
+        const unk3 = reader.skipBytes(4);
+        const elementCount = reader.readInt32();
+        let property;
+        switch (subtype) {
+            case "UInt32Property":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Uint32Property_1.Uint32Property.ReadValue(reader)), ueType, index);
+                break;
+            case "IntProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property_1.Int32Property.ReadValue(reader)), ueType, index);
+                break;
+            case "ObjectProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "NameProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty_1.StrProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "StructProperty":
+                if (propertyName === 'mRemovalLocations') {
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => vec3_1.vec3.ParseF(reader)), ueType, index);
+                }
+                if (propertyName === 'mDestroyedPickups' || propertyName === 'mLootedDropPods') {
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => GUID_1.GUID.read(reader)), ueType, index);
+                }
+                else {
+                    throw new Error(`Not Implemented SetProperty of StructProperty for property ${propertyName}.`);
+                }
+                break;
+            default:
+                throw new Error(`Not Implemented SetProperty of ${subtype}.`);
+        }
+        return property;
+    }
+    static CalcOverhead(property) {
+        return property.subtype.length + 5 + 1;
+    }
+    static Serialize(writer, property) {
+        writer.writeString(property.subtype);
+        writer.writeByte(0);
+        writer.writeInt32(0);
+        writer.writeInt32(property.values.length);
+        switch (property.subtype) {
+            case "IntProperty":
+            case "Int32Property":
+                property.values.forEach(v => Int32Property_1.Int32Property.SerializeValue(writer, v));
+                break;
+            case "UIntProperty":
+            case "UInt32Property":
+                property.values.forEach(v => Uint32Property_1.Uint32Property.SerializeValue(writer, v));
+                break;
+            case "ObjectProperty":
+                property.values.forEach(v => ObjectProperty_1.ObjectProperty.SerializeValue(writer, v));
+                break;
+            case "NameProperty":
+                property.values.forEach(v => StrProperty_1.StrProperty.SerializeValue(writer, v));
+                break;
+            case "StructProperty":
+                if (property.name === 'mRemovalLocations') {
+                    console.warn('serializing mRemovalLocations, this is still under investigation.');
+                    property.values.forEach(v => vec3_1.vec3.SerializeF(writer, v));
+                }
+                else if (property.name === 'mDestroyedPickups' || property.name === 'mLootedDropPods') {
+                    property.values.forEach(v => GUID_1.GUID.write(writer, v));
+                }
+                else {
+                    throw new Error(`Not Implemented serializing SetProperty of StructProperty for property ${property.name}.`);
+                }
+                break;
+            default:
+                throw new Error(`Not Implemented SetProperty of ${property.subtype}.`);
+        }
+    }
+}
+exports.SetProperty = SetProperty;

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

@@ -0,0 +1,13 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { SoftObjectReference } from '../../structs/SoftObjectReference';
+import { BasicProperty } from './BasicProperty';
+export declare const isSoftObjectProperty: (property: BasicProperty) => property is SoftObjectProperty;
+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 CalcOverhead(property: SoftObjectProperty): number;
+    static Serialize(writer: ByteWriter, property: SoftObjectProperty): void;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftObjectProperty = exports.isSoftObjectProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const SoftObjectReference_1 = require("../../structs/SoftObjectReference");
+const BasicProperty_1 = require("./BasicProperty");
+const isSoftObjectProperty = (property) => property.type === 'SoftObjectProperty';
+exports.isSoftObjectProperty = isSoftObjectProperty;
+class SoftObjectProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'SoftObjectProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'SoftObjectProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = SoftObjectReference_1.SoftObjectReference.read(reader);
+        return new SoftObjectProperty(value, ueType, guidInfo, index);
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        SoftObjectReference_1.SoftObjectReference.write(writer, property.value);
+    }
+}
+exports.SoftObjectProperty = SoftObjectProperty;

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

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isStrProperty: (property: BasicProperty) => property is StrProperty;
+export declare class StrProperty extends BasicProperty {
+    value: string;
+    constructor(value: string, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): StrProperty;
+    static ReadValue(reader: BinaryReadable): string;
+    static CalcOverhead(property: StrProperty): number;
+    static Serialize(writer: ByteWriter, property: StrProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrProperty = exports.isStrProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isStrProperty = (property) => property.type === 'StrProperty';
+exports.isStrProperty = isStrProperty;
+class StrProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'StrProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'StrProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = StrProperty.ReadValue(reader);
+        return new StrProperty(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readString();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        StrProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value);
+    }
+}
+exports.StrProperty = StrProperty;

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

@@ -0,0 +1,69 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { col4 } from '../../structs/col4';
+import { vec3 } from '../../structs/vec3';
+import { vec4 } from '../../structs/vec4';
+import { AbstractBaseProperty, PropertiesMap } from './BasicProperty';
+export type BasicMultipleStructPropertyValue = {
+    values: any;
+};
+export type BasicStructPropertyValue = {
+    value: any;
+};
+export type BoxStructPropertyValue = {
+    min: vec3;
+    max: vec3;
+    isValid: boolean;
+};
+export type RailroadTrackPositionStructPropertyValue = {
+    root: string;
+    instanceName: string;
+    offset: number;
+    forward: number;
+};
+export type InventoryItemStructPropertyValue = {
+    unk1: number;
+    itemName: string;
+    hasItemState: number;
+    itemState?: {
+        unk: number;
+        pathName: string;
+        binarySize: number;
+        itemStateRaw: number[];
+    };
+};
+export type FICFrameRangeStructPropertyValue = {
+    begin: string;
+    end: string;
+};
+export type DynamicStructPropertyValue = {
+    type: string;
+    properties: PropertiesMap;
+};
+export type ClientIdentityInfo = {
+    offlineId: string;
+    accountIds: Record<number, number[]>;
+};
+export type GENERIC_STRUCT_PROPERTY_VALUE = BasicMultipleStructPropertyValue | BasicStructPropertyValue | BoxStructPropertyValue | RailroadTrackPositionStructPropertyValue | InventoryItemStructPropertyValue | FICFrameRangeStructPropertyValue | ClientIdentityInfo | DynamicStructPropertyValue | col4 | vec3 | vec4 | string;
+export declare const isStructProperty: (property: AbstractBaseProperty) => property is StructProperty;
+export declare class StructProperty extends AbstractBaseProperty {
+    subtype: string;
+    guid: number;
+    value: GENERIC_STRUCT_PROPERTY_VALUE;
+    unk1?: number;
+    unk2?: number;
+    unk3?: number;
+    unk4?: number;
+    constructor(subtype: string, ueType?: string, index?: number, guid?: number);
+    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: ByteWriter, property: StructProperty): void;
+    static SerializeValue(writer: ByteWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): 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;