@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveComponent = exports.isSaveComponent = void 0;
+const SaveObject_1 = require("./SaveObject");
+const isSaveComponent = (obj) => {
+    return obj.type === 'SaveComponent';
+};
+exports.isSaveComponent = isSaveComponent;
+class SaveComponent extends SaveObject_1.SaveObject {
+    constructor(typePath, rootObject, instanceName, parentEntityName = '') {
+        super(typePath, rootObject, instanceName);
+        this.typePath = typePath;
+        this.rootObject = rootObject;
+        this.instanceName = instanceName;
+        this.parentEntityName = parentEntityName;
+        this.type = 'SaveComponent';
+    }
+    static ParseHeader(reader, obj) {
+        SaveObject_1.SaveObject.ParseHeader(reader, obj);
+        obj.parentEntityName = reader.readString();
+    }
+    static SerializeHeader(writer, component) {
+        SaveObject_1.SaveObject.SerializeHeader(writer, component);
+        writer.writeString(component.parentEntityName);
+    }
+    static ParseData(component, length, reader, buildVersion) {
+        SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion);
+    }
+}
+SaveComponent.TypeID = 0;
+exports.SaveComponent = SaveComponent;

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

@@ -0,0 +1,25 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { Transform } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+import { SaveObject } from "./SaveObject";
+export declare const isSaveEntity: (obj: any) => obj is SaveEntity;
+export declare class SaveEntity extends SaveObject {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    parentEntityName: string;
+    static readonly TypeID = 1;
+    readonly type = "SaveEntity";
+    needTransform: boolean;
+    transform: Transform;
+    wasPlacedInLevel: boolean;
+    parentObjectRoot: string;
+    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 SerializeHeader(writer: ByteWriter, entity: SaveEntity): void;
+    static SerializeData(writer: ByteWriter, entity: SaveEntity, buildVersion: number): void;
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveEntity = exports.isSaveEntity = void 0;
+const util_types_1 = require("../structs/util.types");
+const ObjectReference_1 = require("./ObjectReference");
+const SaveObject_1 = require("./SaveObject");
+const isSaveEntity = (obj) => {
+    return obj.type === 'SaveEntity';
+};
+exports.isSaveEntity = isSaveEntity;
+class SaveEntity extends SaveObject_1.SaveObject {
+    constructor(typePath, rootObject, instanceName, parentEntityName = '', needsTransform = false) {
+        super(typePath, rootObject, instanceName);
+        this.typePath = typePath;
+        this.rootObject = rootObject;
+        this.instanceName = instanceName;
+        this.parentEntityName = parentEntityName;
+        this.type = 'SaveEntity';
+        this.needTransform = needsTransform;
+        this.wasPlacedInLevel = false;
+        this.parentObjectRoot = '';
+        this.parentObjectName = '';
+        this.transform = {
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            translation: { x: 0, y: 0, z: 0 },
+            scale3d: { x: 1, y: 1, z: 1 }
+        };
+        this.components = [];
+    }
+    static ParseHeader(reader, obj) {
+        SaveObject_1.SaveObject.ParseHeader(reader, obj);
+        obj.needTransform = reader.readInt32() == 1;
+        obj.transform = (0, util_types_1.ParseTransform)(reader);
+        obj.wasPlacedInLevel = reader.readInt32() == 1;
+    }
+    static ParseData(entity, length, reader, buildVersion) {
+        var newLen = length - 12;
+        entity.parentObjectRoot = reader.readString();
+        if (entity.parentObjectRoot.length > 0)
+            newLen -= entity.parentObjectRoot.length + 1;
+        entity.parentObjectName = reader.readString();
+        if (entity.parentObjectName.length > 0)
+            newLen -= entity.parentObjectName.length + 1;
+        var componentCount = reader.readInt32();
+        for (let i = 0; i < componentCount; i++) {
+            var componentRef = ObjectReference_1.ObjectReference.Parse(reader);
+            entity.components.push(componentRef);
+            newLen -= 10 + componentRef.levelName.length + componentRef.pathName.length;
+        }
+        SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion);
+    }
+    static SerializeHeader(writer, entity) {
+        SaveObject_1.SaveObject.SerializeHeader(writer, entity);
+        writer.writeInt32(entity.needTransform ? 1 : 0);
+        (0, util_types_1.SerializeTransform)(writer, entity.transform);
+        writer.writeInt32(entity.wasPlacedInLevel ? 1 : 0);
+    }
+    static SerializeData(writer, entity, buildVersion) {
+        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);
+        }
+        SaveObject_1.SaveObject.SerializeData(writer, entity, buildVersion);
+    }
+}
+SaveEntity.TypeID = 1;
+exports.SaveEntity = SaveEntity;

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

@@ -0,0 +1,14 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { DataFields } from "./DataFields";
+export declare abstract class SaveObject {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    dataFields: DataFields;
+    constructor(typePath: string, rootObject: string, instanceName: string);
+    protected static ParseHeader(reader: ByteReader, obj: SaveObject): void;
+    protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
+    static ParseData(obj: SaveObject, length: number, reader: ByteReader, buildVersion: number): void;
+    static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveObject = void 0;
+const DataFields_1 = require("./DataFields");
+class SaveObject {
+    constructor(typePath, rootObject, instanceName) {
+        this.typePath = typePath;
+        this.rootObject = rootObject;
+        this.instanceName = instanceName;
+        this.dataFields = new DataFields_1.DataFields();
+    }
+    static ParseHeader(reader, obj) {
+        obj.typePath = reader.readString();
+        obj.rootObject = reader.readString();
+        obj.instanceName = reader.readString();
+    }
+    static SerializeHeader(writer, obj) {
+        writer.writeString(obj.typePath);
+        writer.writeString(obj.rootObject);
+        writer.writeString(obj.instanceName);
+    }
+    static ParseData(obj, length, reader, buildVersion) {
+        obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion);
+    }
+    static SerializeData(writer, obj, buildVersion) {
+        DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion);
+    }
+}
+exports.SaveObject = SaveObject;

package/build/parser/satisfactory/satisfactory-save.d.ts

@@ -0,0 +1,57 @@
+import { Level } from "./level.class";
+import { ObjectReference } from "./objects/ObjectReference";
+export interface ModData {
+    Reference: string;
+    Name: string;
+    Version: string;
+}
+export interface SatisfactoryModMetadata {
+    Mods: ModData[];
+}
+export interface SatisfactorySaveHeader {
+    saveHeaderType: number;
+    saveVersion: number;
+    buildVersion: number;
+    mapName: string;
+    mapOptions: string;
+    sessionName: string;
+    playDurationSeconds: number;
+    saveDateTime: string;
+    sessionVisibility: number;
+    rawModMetadataString?: string;
+    modMetadata?: SatisfactoryModMetadata;
+    isModdedSave?: number;
+    saveIdentifier?: string;
+    fEditorObjectVersion?: number;
+}
+export type ResourceNodeEntry = {
+    purity: string;
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type CollectibleEntry = {
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type ChunkCompressionInfo = {
+    chunkHeaderSize: number;
+    packageFileTag: number;
+    maxChunkContentSize: number;
+};
+export declare class SatisfactorySave {
+    header: SatisfactorySaveHeader;
+    levels: Level[];
+    trailingCollectedObjects: ObjectReference[];
+    compressionInfo?: ChunkCompressionInfo;
+    constructor(header: SatisfactorySaveHeader);
+}

package/build/parser/satisfactory/satisfactory-save.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SatisfactorySave = void 0;
+class SatisfactorySave {
+    constructor(header) {
+        this.levels = [];
+        this.trailingCollectedObjects = [];
+        this.header = header;
+    }
+}
+exports.SatisfactorySave = SatisfactorySave;

package/build/parser/satisfactory/static-data.d.ts

@@ -0,0 +1,7 @@
+import { CollectibleEntry, ResourceNodeEntry } from "./satisfactory-save";
+export type StaticData = {
+    collectibles: CollectibleEntry[];
+    artifacts: CollectibleEntry[];
+    slugs: CollectibleEntry[];
+    resourceNodes: ResourceNodeEntry[];
+};

package/build/parser/satisfactory/static-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/parser/satisfactory/structs/util.types.d.ts

@@ -0,0 +1,40 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+export type col4 = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4RGBA: (reader: ByteReader) => col4;
+export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4BGRA: (reader: ByteReader) => col4;
+export type vec4 = vec3 & {
+    w: number;
+};
+export declare const ParseVec4: (reader: ByteReader) => vec4;
+export declare const SerializeVec4: (writer: ByteWriter, vec: vec4) => void;
+export declare const sub: (other: vec3, vec: vec3) => vec3;
+export declare const add: (vec: vec3, other: vec3) => vec3;
+export declare const length: (vec: vec3) => number;
+export declare const mult: (vec: vec3, scale: number) => vec3;
+export declare const norm: (vec: vec3) => vec3;
+export type vec3 = vec2 & {
+    z: number;
+};
+export declare const ParseVec3: (reader: ByteReader) => vec3;
+export declare const SerializeVec3: (writer: ByteWriter, vec: vec3) => void;
+export type vec2 = {
+    x: number;
+    y: number;
+};
+export declare const ParseVec2: (reader: ByteReader) => vec2;
+export declare const SerializeVec2: (writer: ByteWriter, vec: vec2) => void;
+export type Transform = {
+    rotation: vec4;
+    translation: vec3;
+    scale3d: vec3;
+};
+export declare const ParseTransform: (reader: ByteReader) => Transform;
+export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;

package/build/parser/satisfactory/structs/util.types.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeTransform = exports.ParseTransform = exports.SerializeVec2 = exports.ParseVec2 = exports.SerializeVec3 = exports.ParseVec3 = exports.norm = exports.mult = exports.length = exports.add = exports.sub = exports.SerializeVec4 = exports.ParseVec4 = exports.ParseCol4BGRA = exports.SerializeCol4BGRA = exports.ParseCol4RGBA = exports.SerializeCol4RGBA = void 0;
+const SerializeCol4RGBA = (writer, value) => {
+    writer.writeFloat(value.r);
+    writer.writeFloat(value.g);
+    writer.writeFloat(value.b);
+    writer.writeFloat(value.a);
+};
+exports.SerializeCol4RGBA = SerializeCol4RGBA;
+const ParseCol4RGBA = (reader) => {
+    return {
+        r: reader.readFloat(),
+        g: reader.readFloat(),
+        b: reader.readFloat(),
+        a: reader.readFloat(),
+    };
+};
+exports.ParseCol4RGBA = ParseCol4RGBA;
+const SerializeCol4BGRA = (writer, value) => {
+    writer.writeByte(value.b);
+    writer.writeByte(value.g);
+    writer.writeByte(value.r);
+    writer.writeByte(value.a);
+};
+exports.SerializeCol4BGRA = SerializeCol4BGRA;
+const ParseCol4BGRA = (reader) => {
+    return {
+        b: reader.readByte(),
+        g: reader.readByte(),
+        r: reader.readByte(),
+        a: reader.readByte(),
+    };
+};
+exports.ParseCol4BGRA = ParseCol4BGRA;
+const ParseVec4 = (reader) => {
+    return {
+        ...(0, exports.ParseVec3)(reader),
+        w: reader.readFloat()
+    };
+};
+exports.ParseVec4 = ParseVec4;
+const SerializeVec4 = (writer, vec) => {
+    (0, exports.SerializeVec3)(writer, vec);
+    writer.writeFloat(vec.w);
+};
+exports.SerializeVec4 = SerializeVec4;
+const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+exports.sub = sub;
+const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+exports.add = add;
+const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+exports.length = length;
+const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+exports.mult = mult;
+const norm = (vec) => (0, exports.mult)(vec, 1. / (0, exports.length)(vec));
+exports.norm = norm;
+const ParseVec3 = (reader) => {
+    return {
+        ...(0, exports.ParseVec2)(reader),
+        z: reader.readFloat()
+    };
+};
+exports.ParseVec3 = ParseVec3;
+const SerializeVec3 = (writer, vec) => {
+    (0, exports.SerializeVec2)(writer, vec);
+    writer.writeFloat(vec.z);
+};
+exports.SerializeVec3 = SerializeVec3;
+const ParseVec2 = (reader) => {
+    return {
+        x: reader.readFloat(),
+        y: reader.readFloat(),
+    };
+};
+exports.ParseVec2 = ParseVec2;
+const SerializeVec2 = (writer, vec) => {
+    writer.writeFloat(vec.x);
+    writer.writeFloat(vec.y);
+};
+exports.SerializeVec2 = SerializeVec2;
+const ParseTransform = (reader) => {
+    return {
+        rotation: (0, exports.ParseVec4)(reader),
+        translation: (0, exports.ParseVec3)(reader),
+        scale3d: (0, exports.ParseVec3)(reader),
+    };
+};
+exports.ParseTransform = ParseTransform;
+const SerializeTransform = (writer, transform) => {
+    (0, exports.SerializeVec4)(writer, transform.rotation);
+    (0, exports.SerializeVec3)(writer, transform.translation);
+    (0, exports.SerializeVec3)(writer, transform.scale3d);
+};
+exports.SerializeTransform = SerializeTransform;

package/build/parser/save-reader.d.ts

@@ -0,0 +1,43 @@
+import { ByteReader } from "./byte/byte-reader.class";
+import { Level } from "./satisfactory/level.class";
+import { ObjectReference } from "./satisfactory/objects/ObjectReference";
+import { SaveComponent } from "./satisfactory/objects/SaveComponent";
+import { SaveEntity } from "./satisfactory/objects/SaveEntity";
+import { SaveObject } from "./satisfactory/objects/SaveObject";
+import { ChunkCompressionInfo, SatisfactorySaveHeader } from "./satisfactory/satisfactory-save";
+export type EntityPathFilter = {
+    behavior: 'whitelist' | 'blacklist';
+    list: string[];
+};
+export type SaveProjectionConfig = {
+    entityPathFilter: EntityPathFilter;
+    includeComponents: boolean;
+};
+export declare const projectionFilterApplies: (config: SaveProjectionConfig, object: SaveComponent | SaveEntity) => boolean;
+export declare class SaveReader extends ByteReader {
+    onProgressCallback: (progress: number, msg?: string) => void;
+    header: SatisfactorySaveHeader | undefined;
+    levels: Level[];
+    trailingCollectedObjects: ObjectReference[];
+    compressionInfo: ChunkCompressionInfo;
+    static readonly EPOCH_TICKS = 621355968000000000n;
+    constructor(fileBuffer: ArrayBuffer, onProgressCallback?: (progress: number, msg?: string) => void);
+    readHeader(): SatisfactorySaveHeader;
+    inflateChunks(): {
+        concatenatedChunkLength: number;
+        numChunks: number;
+    };
+    readLevels(): Level[];
+}
+export declare class Conveyor {
+    static getConveyorBeltRegex(): RegExp;
+    static getConveyorLiftRegex(): RegExp;
+    static isAConveyorBelt(obj: SaveObject): boolean;
+    static isAConveyorLift(obj: SaveObject): boolean;
+    static get availableConnections(): string[];
+    static get availableConveyorBelts(): string[];
+    static get availableConveyorLifts(): string[];
+    static isConveyor(currentObject: any): boolean;
+    static isConveyorBelt(currentObject: any): boolean;
+    static isConveyorLift(currentObject: any): boolean;
+}