@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

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

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFields = void 0;
+const Property_1 = require("./Property");
+class DataFields {
+    constructor() {
+        this.properties = [];
+        this.trailingData = [];
+        this.shouldBeNulled = false;
+    }
+    static Parse(length, reader, buildVersion) {
+        const start = reader.getBufferPosition();
+        const fields = new DataFields();
+        if (length === 0) {
+            //WARNING
+            fields.shouldBeNulled = true;
+            return fields;
+        }
+        let propertyName = reader.readString();
+        while (propertyName !== 'None') {
+            const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
+            fields.properties.push(property);
+            propertyName = reader.readString();
+        }
+        let int1 = reader.readInt32();
+        if (int1 !== 0) {
+            //WARNING
+        }
+        const end = reader.getBufferPosition();
+        let remainingBytes = start + length - end;
+        fields.trailingData = Array.from(reader.readBytes(remainingBytes));
+        return fields;
+    }
+    static ParseProperty(reader, buildVersion, propertyName) {
+        let currentProperty = {};
+        if (currentProperty.name === 'None') {
+            return null;
+        }
+        //TODO: What is this extra byte that is appearing sometime?
+        // i dont think there is an extra byte.
+        /*
+        let extraByteTest = reader.readByte();
+        if (extraByteTest !== 0) {
+            reader.currentByte -= 1;
+        }
+        else {
+            console.log('Property extra byte', currentProperty);
+        }
+        */
+        //TODO assign type and index after parsing.
+        const propertyType = reader.readString();
+        const binarySize = reader.readInt32();
+        const index = reader.readInt32();
+        const before = reader.getBufferPosition();
+        let overhead = 0;
+        switch (propertyType) {
+            case 'BoolProperty':
+                currentProperty = Property_1.BoolProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.BoolProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ByteProperty':
+                currentProperty = Property_1.ByteProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.ByteProperty.CalcOverhead(currentProperty);
+                break;
+            case 'Int8Property':
+                currentProperty = Property_1.Int8Property.Parse(reader, propertyType, index);
+                overhead = Property_1.Int8Property.CalcOverhead(currentProperty);
+                break;
+            case 'UInt8Property':
+                currentProperty = Property_1.Uint8Property.Parse(reader, propertyType, index);
+                overhead = Property_1.Uint8Property.CalcOverhead(currentProperty);
+                break;
+            case 'IntProperty':
+            case 'Int32Property':
+                currentProperty = Property_1.Int32Property.Parse(reader, propertyType, index);
+                overhead = Property_1.Int32Property.CalcOverhead(currentProperty);
+                break;
+            case 'UInt32Property':
+                currentProperty = Property_1.Uint32Property.Parse(reader, propertyType, index);
+                overhead = Property_1.Uint32Property.CalcOverhead(currentProperty);
+                break;
+            case 'Int64Property':
+                currentProperty = Property_1.Int64Property.Parse(reader, propertyType, index);
+                overhead = Property_1.Int64Property.CalcOverhead(currentProperty);
+                break;
+            // TODO
+            /*
+        case 'UInt64Property':
+            currentProperty = Int64Property.Parse(reader, propertyType, index);
+            break;
+            */
+            case 'SingleProperty':
+            case 'FloatProperty':
+                currentProperty = Property_1.FloatProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.FloatProperty.CalcOverhead(currentProperty);
+                break;
+            case 'DoubleProperty':
+                currentProperty = Property_1.DoubleProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.DoubleProperty.CalcOverhead(currentProperty);
+                break;
+            case 'StrProperty':
+            case 'NameProperty':
+                currentProperty = Property_1.StrProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.StrProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ObjectProperty':
+            case 'InterfaceProperty':
+                currentProperty = Property_1.ObjectProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.ObjectProperty.CalcOverhead(currentProperty);
+                break;
+            case 'EnumProperty':
+                currentProperty = Property_1.EnumProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.EnumProperty.CalcOverhead(currentProperty);
+                break;
+            case 'StructProperty':
+                currentProperty = Property_1.StructProperty.Parse(reader, propertyType, index, binarySize);
+                overhead = Property_1.StructProperty.CalcOverhead(currentProperty);
+                break;
+            case 'ArrayProperty':
+                currentProperty = Property_1.ArrayProperty.Parse(reader, propertyType, index, propertyName);
+                overhead = Property_1.ArrayProperty.CalcOverhead(currentProperty);
+                break;
+            case 'MapProperty':
+                //currentProperty = reader.readMapProperty(currentProperty, '');
+                currentProperty = Property_1.MapProperty.Parse(reader, propertyName, buildVersion, binarySize);
+                overhead = Property_1.MapProperty.CalcOverhead(currentProperty);
+                break;
+            case 'TextProperty':
+                currentProperty = Property_1.TextProperty.Parse(reader, propertyType, index);
+                overhead = Property_1.TextProperty.CalcOverhead(currentProperty);
+                break;
+            case 'SetProperty':
+                currentProperty = Property_1.SetProperty.Parse(reader, propertyType, index, propertyName);
+                overhead = Property_1.SetProperty.CalcOverhead(currentProperty);
+                break;
+            default:
+                throw new Error(`Unimplemented type ${propertyType}`);
+        }
+        currentProperty.name = propertyName;
+        const readBytes = reader.getBufferPosition() - before - overhead;
+        if (readBytes !== binarySize) {
+            throw new Error(`possibly corrupt. Read ${readBytes} for ${propertyType} ${propertyName}, but ${binarySize} were indicated.`);
+        }
+        return currentProperty;
+    }
+    static Serialize(writer, fields, buildVersion) {
+        for (const property of fields.properties) {
+            writer.writeString(property.name);
+            DataFields.SerializeProperty(writer, property, property.name, buildVersion);
+        }
+        writer.writeString('None');
+        writer.writeInt32(0);
+        writer.writeBytesArray(fields.trailingData);
+    }
+    static SerializeProperty(writer, property, propertyName, buildVersion) {
+        writer.writeString(property.ueType);
+        // binary length indicator
+        const lenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        // write index if it is not 0. Since it normally is.
+        writer.writeInt32(property.index ?? 0);
+        const start = writer.getBufferPosition();
+        let overhead = 0;
+        switch (property.ueType) {
+            case 'BoolProperty':
+                overhead = Property_1.BoolProperty.CalcOverhead(property);
+                Property_1.BoolProperty.Serialize(writer, property);
+                break;
+            case 'ByteProperty':
+                overhead = Property_1.ByteProperty.CalcOverhead(property);
+                Property_1.ByteProperty.Serialize(writer, property);
+                break;
+            case 'Int8Property':
+                overhead = Property_1.Int8Property.CalcOverhead(property);
+                Property_1.Int8Property.Serialize(writer, property);
+                break;
+            case 'UInt8Property':
+                overhead = Property_1.Uint8Property.CalcOverhead(property);
+                Property_1.Uint8Property.Serialize(writer, property);
+                break;
+            case 'IntProperty':
+            case 'Int32Property':
+                overhead = Property_1.Int32Property.CalcOverhead(property);
+                Property_1.Int32Property.Serialize(writer, property);
+                break;
+            case 'UInt32Property':
+                overhead = Property_1.Uint32Property.CalcOverhead(property);
+                Property_1.Uint32Property.Serialize(writer, property);
+                break;
+            case 'Int64Property':
+                overhead = Property_1.Int64Property.CalcOverhead(property);
+                Property_1.Int64Property.Serialize(writer, property);
+                break;
+            // TODO: uint64Property
+            case 'SingleProperty':
+            case 'FloatProperty':
+                overhead = Property_1.FloatProperty.CalcOverhead(property);
+                Property_1.FloatProperty.Serialize(writer, property);
+                break;
+            case 'DoubleProperty':
+                overhead = Property_1.DoubleProperty.CalcOverhead(property);
+                Property_1.DoubleProperty.Serialize(writer, property);
+                break;
+            case 'StrProperty':
+            case 'NameProperty':
+                overhead = Property_1.StrProperty.CalcOverhead(property);
+                Property_1.StrProperty.Serialize(writer, property);
+                break;
+            case 'ObjectProperty':
+            case 'InterfaceProperty':
+                overhead = Property_1.ObjectProperty.CalcOverhead(property);
+                Property_1.ObjectProperty.Serialize(writer, property);
+                break;
+            case 'EnumProperty':
+                overhead = Property_1.EnumProperty.CalcOverhead(property);
+                Property_1.EnumProperty.Serialize(writer, property);
+                break;
+            case 'ByteProperty':
+                overhead = Property_1.ByteProperty.CalcOverhead(property);
+                Property_1.ByteProperty.Serialize(writer, property);
+                break;
+            case 'StructProperty':
+                overhead = Property_1.StructProperty.CalcOverhead(property);
+                Property_1.StructProperty.Serialize(writer, property);
+                break;
+            case 'ArrayProperty':
+                overhead = Property_1.ArrayProperty.CalcOverhead(property);
+                Property_1.ArrayProperty.Serialize(writer, property, propertyName);
+                break;
+            case 'MapProperty':
+                overhead = Property_1.MapProperty.CalcOverhead(property);
+                Property_1.MapProperty.Serialize(writer, property);
+                break;
+            case 'TextProperty':
+                overhead = Property_1.TextProperty.CalcOverhead(property);
+                Property_1.TextProperty.Serialize(writer, property);
+                break;
+            case 'SetProperty':
+                overhead = Property_1.SetProperty.CalcOverhead(property);
+                Property_1.SetProperty.Serialize(writer, property);
+                break;
+            default:
+                throw new Error(`Unimplemented type ${property.type}`);
+        }
+        // replace len indicator.
+        writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
+    }
+}
+exports.DataFields = DataFields;

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

@@ -0,0 +1,9 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+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 Serialize(writer: ByteWriter, ref: ObjectReference): void;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectReference = void 0;
+class ObjectReference {
+    constructor(levelName, pathName) {
+        this.levelName = levelName;
+        this.pathName = pathName;
+    }
+    static Parse(reader) {
+        return new ObjectReference(reader.readString(), reader.readString());
+    }
+    static Serialize(writer, ref) {
+        writer.writeString(ref.levelName);
+        writer.writeString(ref.pathName);
+    }
+}
+exports.ObjectReference = ObjectReference;

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

@@ -0,0 +1,270 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveWriter } from "../../save-writer";
+import { col4, vec3, vec4 } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+export type Properties = {
+    [key: string]: string | number | boolean | any;
+};
+export declare abstract class AbstractProperty {
+    type: string;
+    index?: number | undefined;
+    constructor(type: string, index?: number | undefined);
+}
+export declare abstract class AbstractBaseProperty extends AbstractProperty {
+    ueType: string;
+    name: string;
+    constructor(type: string, ueType: string, index: number);
+}
+export declare abstract class BasicProperty extends AbstractBaseProperty {
+    guidInfo: GUID;
+    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 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 CalcOverhead(property: BoolProperty): number;
+    static Serialize(writer: SaveWriter, property: BoolProperty): void;
+    static SerializeValue(writer: SaveWriter, value: boolean): void;
+}
+export type BytePropertyValue = {
+    type: string;
+    value: string | number;
+};
+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 CalcOverhead(property: ByteProperty): number;
+    static Serialize(writer: SaveWriter, property: ByteProperty): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: Int8Property): number;
+    static Serialize(writer: SaveWriter, property: Int8Property): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: Uint8Property): number;
+    static Serialize(writer: SaveWriter, property: Uint8Property): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: Int32Property): number;
+    static Serialize(writer: SaveWriter, property: Int32Property): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: Uint32Property): number;
+    static Serialize(writer: SaveWriter, property: Uint32Property): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: Int64Property): number;
+    static Serialize(writer: SaveWriter, property: Int64Property): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: FloatProperty): number;
+    static ReadValue(reader: ByteReader): number;
+    static Serialize(writer: SaveWriter, property: FloatProperty): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: DoubleProperty): number;
+    static Serialize(writer: SaveWriter, property: DoubleProperty): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: StrProperty): number;
+    static Serialize(writer: SaveWriter, property: StrProperty): void;
+    static SerializeValue(writer: SaveWriter, 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 CalcOverhead(property: ObjectProperty): number;
+    static Serialize(writer: SaveWriter, property: ObjectProperty): void;
+    static SerializeValue(writer: SaveWriter, value: {
+        levelName: string;
+        pathName: string;
+    }): void;
+}
+export declare class EnumProperty extends BasicProperty {
+    value: {
+        name: string;
+        value: string;
+    };
+    constructor(value: {
+        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 CalcOverhead(property: EnumProperty): number;
+    static Serialize(writer: SaveWriter, property: EnumProperty): void;
+    static SerializeValue(writer: SaveWriter, value: string): void;
+}
+export type TextPropertyValue = {
+    flags: number;
+    historyType: number;
+    namespace?: string;
+    key?: string;
+    value?: string;
+    sourceFmt?: TextPropertyValue;
+    arguments?: {
+        name: string;
+        valueType: number;
+        argumentValue: TextPropertyValue;
+    }[];
+    sourceText?: TextPropertyValue;
+    transformType?: number;
+    hasCultureInvariantString?: boolean;
+};
+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 CalcOverhead(property: TextProperty): number;
+    static Serialize(writer: SaveWriter, property: TextProperty): void;
+    static SerializeValue(writer: SaveWriter, value: TextPropertyValue): void;
+}
+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;
+    unk2: string;
+    unk3: string;
+    properties: any[];
+};
+export type FICFrameRangeStructPropertyValue = {
+    begin: string;
+    end: string;
+};
+export type DynamicStructPropertyValue = {
+    type: string;
+    properties: Properties;
+};
+export type GENERIC_STRUCT_PROPERTY_VALUE = BasicMultipleStructPropertyValue | BasicStructPropertyValue | BoxStructPropertyValue | RailroadTrackPositionStructPropertyValue | InventoryItemStructPropertyValue | FICFrameRangeStructPropertyValue | DynamicStructPropertyValue | col4 | vec3 | vec4 | string;
+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: ByteReader, ueType: string, index: number, size: number): StructProperty;
+    static ParseValue(reader: ByteReader, 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;
+}
+export type ArrayPropertyStructValueFields = {
+    allStructType: string;
+    allIndex: number;
+    allGuid: number;
+    allUnk1?: number;
+    allUnk2?: number;
+    allUnk3?: number;
+    allUnk4?: number;
+};
+export declare class ArrayProperty<T> extends BasicProperty {
+    subtype: string;
+    values: T[];
+    structValueFields?: ArrayPropertyStructValueFields | undefined;
+    constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
+    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
+    static CalcOverhead(property: ArrayProperty<any>): number;
+    static Serialize(writer: SaveWriter, 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 CalcOverhead(property: SetProperty<any>): number;
+    static Serialize(writer: SaveWriter, property: SetProperty<any>): void;
+}
+export declare class MapProperty extends BasicProperty {
+    keyType: string;
+    valueType: string;
+    modeType: number;
+    modeUnk1: string | undefined;
+    modeUnk2: string;
+    modeUnk3: string;
+    remainingData: number[];
+    values: {
+        key: any;
+        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 CalcOverhead(property: MapProperty): number;
+    static Serialize(writer: SaveWriter, 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;