@etothepii/satisfactory-file-parser 0.4.20 → 0.4.22

package/build/parser/satisfactory/types/property/special/SpecialAnyProperty.d.ts

@@ -0,0 +1,54 @@
+import { ObjectReference } from '../../structs/ObjectReference';
+import { Transform } from '../../structs/Transform';
+import { vec2 } from '../../structs/vec2';
+import { vec3 } from '../../structs/vec3';
+export type SpecialAnyProperty = EmptySpecialProperty | PowerLineSpecialProperty | PlayerSpecialProperty | ConveyorChainActorSpecialProperty | BuildableSubsystemSpecialProperty;
+export type EmptySpecialProperty = {};
+export type PowerLineSpecialProperty = {
+    source: ObjectReference;
+    target: ObjectReference;
+    sourceTranslation?: vec3;
+    targetTranslation?: vec3;
+};
+export type PlayerSpecialProperty = {
+    flag: number;
+    eosData?: string;
+    steamPlayerData?: string;
+};
+export type ConveyorItemSpecialProperty = {
+    position: number;
+    itemName: string;
+};
+export type ConveyorChainSegmentSpecialProperty = {
+    chainActorRef: ObjectReference;
+    beltRef: ObjectReference;
+    someCount: number;
+    unknownUseBytes: number[];
+    firstItemIndex: number;
+    lastItemIndex: number;
+    beltIndexInChain: number;
+};
+export type ConveyorChainActorSpecialProperty = {
+    firstBelt: ObjectReference;
+    lastBelt: ObjectReference;
+    beltsInChain: ConveyorChainSegmentSpecialProperty[];
+    unknownInts: [number, number];
+    firstChainItemIndex: number;
+    lastChainItemIndex: number;
+    items: ConveyorItemSpecialProperty[];
+};
+export type BuildableTypeInstance = {
+    transform: Transform;
+    unknownUseNumbers: [vec2, vec3];
+    swatchSlotTypePath: string;
+    paintFinishPath: string;
+    recipeTypePath: string;
+    patternPath: string;
+    blueprintProxy: ObjectReference;
+};
+export type BuildableSubsystemSpecialProperty = {
+    buildables: {
+        typePath: string;
+        instances: BuildableTypeInstance[];
+    }[];
+};

package/build/parser/satisfactory/types/property/special/SpecialAnyProperty.js

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

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

@@ -0,0 +1,7 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+export type GUID = [number, number, number, number];
+export declare namespace GUID {
+    const read: (reader: BinaryReadable) => GUID;
+    const write: (writer: ByteWriter, guid: GUID) => void;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GUID = void 0;
+var GUID;
+(function (GUID) {
+    GUID.read = (reader) => {
+        return [
+            reader.readUint32(),
+            reader.readUint32(),
+            reader.readUint32(),
+            reader.readUint32(),
+        ];
+    };
+    GUID.write = (writer, guid) => {
+        writer.writeUint32(guid[0]);
+        writer.writeUint32(guid[1]);
+        writer.writeUint32(guid[2]);
+        writer.writeUint32(guid[3]);
+    };
+})(GUID || (exports.GUID = GUID = {}));
+;

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

@@ -0,0 +1,8 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+import { GUID } from './GUID';
+export type GUIDInfo = undefined | GUID;
+export declare namespace GUIDInfo {
+    const read: (reader: BinaryReadable) => GUIDInfo;
+    const write: (writer: ByteWriter, guid: GUIDInfo) => void;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GUIDInfo = void 0;
+const GUID_1 = require("./GUID");
+var GUIDInfo;
+(function (GUIDInfo) {
+    GUIDInfo.read = (reader) => {
+        if (reader.readByte() === 1) {
+            return GUID_1.GUID.read(reader);
+        }
+        else {
+            return undefined;
+        }
+    };
+    GUIDInfo.write = (writer, guid) => {
+        if (guid === undefined) {
+            writer.writeByte(0);
+            return;
+        }
+        else {
+            writer.writeByte(1);
+            GUID_1.GUID.write(writer, guid);
+        }
+    };
+})(GUIDInfo || (exports.GUIDInfo = GUIDInfo = {}));
+;

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

@@ -0,0 +1,10 @@
+import { ByteReader } from '../../../byte/byte-reader.class';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+export type MD5Hash = {
+    isValid: boolean;
+    hash?: number[];
+};
+export declare namespace MD5Hash {
+    const read: (reader: ByteReader) => MD5Hash;
+    const write: (writer: ByteWriter, md5Hash: MD5Hash) => void;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MD5Hash = void 0;
+var MD5Hash;
+(function (MD5Hash) {
+    MD5Hash.read = (reader) => {
+        const md5Hash = { isValid: false };
+        md5Hash.isValid = reader.readInt32() === 1;
+        if (md5Hash.isValid) {
+            md5Hash.hash = Array.from(reader.readBytes(16));
+        }
+        return md5Hash;
+    };
+    MD5Hash.write = (writer, md5Hash) => {
+        writer.writeInt32(md5Hash.isValid ? 1 : 0);
+        if (md5Hash.isValid) {
+            writer.writeBytesArray(md5Hash.hash);
+        }
+    };
+})(MD5Hash || (exports.MD5Hash = MD5Hash = {}));
+;

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

@@ -0,0 +1,10 @@
+import { BinaryReadable } from "../../../byte/binary-readable.interface";
+import { ByteWriter } from "../../../byte/byte-writer.class";
+export type ObjectReference = {
+    levelName: string;
+    pathName: string;
+};
+export declare namespace ObjectReference {
+    const read: (reader: BinaryReadable) => ObjectReference;
+    const write: (writer: ByteWriter, ref: ObjectReference) => void;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectReference = void 0;
+var ObjectReference;
+(function (ObjectReference) {
+    ObjectReference.read = (reader) => {
+        return {
+            levelName: reader.readString(),
+            pathName: reader.readString()
+        };
+    };
+    ObjectReference.write = (writer, ref) => {
+        writer.writeString(ref.levelName);
+        writer.writeString(ref.pathName);
+    };
+})(ObjectReference || (exports.ObjectReference = ObjectReference = {}));
+;

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

@@ -0,0 +1,11 @@
+import { BinaryReadable } from "../../../byte/binary-readable.interface";
+import { ByteWriter } from "../../../byte/byte-writer.class";
+export type SoftObjectReference = {
+    instanceName: string;
+    pathName: string;
+    unk: number;
+};
+export declare namespace SoftObjectReference {
+    const read: (reader: BinaryReadable) => SoftObjectReference;
+    const write: (writer: ByteWriter, ref: SoftObjectReference) => void;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftObjectReference = void 0;
+var SoftObjectReference;
+(function (SoftObjectReference) {
+    SoftObjectReference.read = (reader) => {
+        return {
+            pathName: reader.readString(),
+            instanceName: reader.readString(),
+            unk: reader.readInt32()
+        };
+    };
+    SoftObjectReference.write = (writer, ref) => {
+        writer.writeString(ref.pathName);
+        writer.writeString(ref.instanceName);
+        writer.writeInt32(ref.unk);
+    };
+})(SoftObjectReference || (exports.SoftObjectReference = SoftObjectReference = {}));
+;

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

@@ -0,0 +1,15 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+import { vec3 } from './vec3';
+import { vec4 } from './vec4';
+export type Transform = {
+    rotation: vec4;
+    translation: vec3;
+    scale3d: vec3;
+};
+export declare namespace Transform {
+    const ParseF: (reader: BinaryReadable) => Transform;
+    const Parse: (reader: BinaryReadable) => Transform;
+    const Serialize: (writer: ByteWriter, transform: Transform) => void;
+    const SerializeF: (writer: ByteWriter, transform: Transform) => void;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transform = void 0;
+const vec3_1 = require("./vec3");
+const vec4_1 = require("./vec4");
+var Transform;
+(function (Transform) {
+    Transform.ParseF = (reader) => {
+        return {
+            rotation: vec4_1.vec4.ParseF(reader),
+            translation: vec3_1.vec3.ParseF(reader),
+            scale3d: vec3_1.vec3.ParseF(reader),
+        };
+    };
+    Transform.Parse = (reader) => {
+        return {
+            rotation: vec4_1.vec4.Parse(reader),
+            translation: vec3_1.vec3.Parse(reader),
+            scale3d: vec3_1.vec3.Parse(reader),
+        };
+    };
+    Transform.Serialize = (writer, transform) => {
+        vec4_1.vec4.Serialize(writer, transform.rotation);
+        vec3_1.vec3.Serialize(writer, transform.translation);
+        vec3_1.vec3.Serialize(writer, transform.scale3d);
+    };
+    Transform.SerializeF = (writer, transform) => {
+        vec4_1.vec4.SerializeF(writer, transform.rotation);
+        vec3_1.vec3.SerializeF(writer, transform.translation);
+        vec3_1.vec3.SerializeF(writer, transform.scale3d);
+    };
+})(Transform || (exports.Transform = Transform = {}));

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

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+export type col4 = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare namespace col4 {
+    const SerializeRGBA: (writer: ByteWriter, value: col4) => void;
+    const ParseRGBA: (reader: BinaryReadable) => col4;
+    const SerializeBGRA: (writer: ByteWriter, value: col4) => void;
+    const ParseBGRA: (reader: BinaryReadable) => col4;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.col4 = void 0;
+var col4;
+(function (col4) {
+    col4.SerializeRGBA = (writer, value) => {
+        writer.writeFloat32(value.r);
+        writer.writeFloat32(value.g);
+        writer.writeFloat32(value.b);
+        writer.writeFloat32(value.a);
+    };
+    col4.ParseRGBA = (reader) => {
+        return {
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32(),
+            a: reader.readFloat32(),
+        };
+    };
+    col4.SerializeBGRA = (writer, value) => {
+        writer.writeByte(value.b);
+        writer.writeByte(value.g);
+        writer.writeByte(value.r);
+        writer.writeByte(value.a);
+    };
+    col4.ParseBGRA = (reader) => {
+        return {
+            b: reader.readByte(),
+            g: reader.readByte(),
+            r: reader.readByte(),
+            a: reader.readByte(),
+        };
+    };
+})(col4 || (exports.col4 = col4 = {}));

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

@@ -0,0 +1,12 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+export type vec2 = {
+    x: number;
+    y: number;
+};
+export declare namespace vec2 {
+    const Parse: (reader: BinaryReadable) => vec2;
+    const Serialize: (writer: ByteWriter, vec: vec2) => void;
+    const ParseF: (reader: BinaryReadable) => vec2;
+    const SerializeF: (writer: ByteWriter, vec: vec2) => void;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vec2 = void 0;
+var vec2;
+(function (vec2) {
+    vec2.Parse = (reader) => {
+        return {
+            x: reader.readDouble(),
+            y: reader.readDouble(),
+        };
+    };
+    vec2.Serialize = (writer, vec) => {
+        writer.writeDouble(vec.x);
+        writer.writeDouble(vec.y);
+    };
+    vec2.ParseF = (reader) => {
+        return {
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
+        };
+    };
+    vec2.SerializeF = (writer, vec) => {
+        writer.writeFloat32(vec.x);
+        writer.writeFloat32(vec.y);
+    };
+})(vec2 || (exports.vec2 = vec2 = {}));

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

@@ -0,0 +1,19 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+import { vec2 } from './vec2';
+export type vec3 = vec2 & {
+    z: number;
+};
+export declare namespace vec3 {
+    const Parse: (reader: BinaryReadable) => vec3;
+    const Serialize: (writer: ByteWriter, vec: vec3) => void;
+    const ParseInt: (reader: BinaryReadable) => vec3;
+    const SerializeInt: (writer: ByteWriter, vec: vec3) => void;
+    const ParseF: (reader: BinaryReadable) => vec3;
+    const SerializeF: (writer: ByteWriter, vec: vec3) => void;
+    const sub: (other: vec3, vec: vec3) => vec3;
+    const add: (vec: vec3, other: vec3) => vec3;
+    const length: (vec: vec3) => number;
+    const mult: (vec: vec3, scale: number) => vec3;
+    const norm: (vec: vec3) => vec3;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vec3 = void 0;
+const vec2_1 = require("./vec2");
+var vec3;
+(function (vec3) {
+    vec3.Parse = (reader) => {
+        return {
+            ...(vec2_1.vec2.Parse(reader)),
+            z: reader.readDouble()
+        };
+    };
+    vec3.Serialize = (writer, vec) => {
+        vec2_1.vec2.Serialize(writer, vec);
+        writer.writeDouble(vec.z);
+    };
+    vec3.ParseInt = (reader) => {
+        return {
+            x: reader.readInt32(),
+            y: reader.readInt32(),
+            z: reader.readInt32()
+        };
+    };
+    vec3.SerializeInt = (writer, vec) => {
+        writer.writeInt32(vec.x);
+        writer.writeInt32(vec.y);
+        writer.writeInt32(vec.z);
+    };
+    vec3.ParseF = (reader) => {
+        return {
+            ...(vec2_1.vec2.ParseF(reader)),
+            z: reader.readFloat32()
+        };
+    };
+    vec3.SerializeF = (writer, vec) => {
+        vec2_1.vec2.SerializeF(writer, vec);
+        writer.writeFloat32(vec.z);
+    };
+    vec3.sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+    vec3.add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+    vec3.length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+    vec3.mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+    vec3.norm = (vec) => vec3.mult(vec, 1. / vec3.length(vec));
+})(vec3 || (exports.vec3 = vec3 = {}));

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

@@ -0,0 +1,12 @@
+import { BinaryReadable } from '../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../byte/byte-writer.class';
+import { vec3 } from './vec3';
+export type vec4 = vec3 & {
+    w: number;
+};
+export declare namespace vec4 {
+    const Parse: (reader: BinaryReadable) => vec4;
+    const Serialize: (writer: ByteWriter, vec: vec4) => void;
+    const ParseF: (reader: BinaryReadable) => vec4;
+    const SerializeF: (writer: ByteWriter, vec: vec4) => void;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vec4 = void 0;
+const vec3_1 = require("./vec3");
+var vec4;
+(function (vec4) {
+    vec4.Parse = (reader) => {
+        return {
+            ...(vec3_1.vec3.Parse(reader)),
+            w: reader.readDouble()
+        };
+    };
+    vec4.Serialize = (writer, vec) => {
+        vec3_1.vec3.Serialize(writer, vec);
+        writer.writeDouble(vec.w);
+    };
+    vec4.ParseF = (reader) => {
+        return {
+            ...(vec3_1.vec3.ParseF(reader)),
+            w: reader.readFloat32()
+        };
+    };
+    vec4.SerializeF = (writer, vec) => {
+        vec3_1.vec3.SerializeF(writer, vec);
+        writer.writeFloat32(vec.w);
+    };
+})(vec4 || (exports.vec4 = vec4 = {}));

package/build/parser/stream/reworked/readable-stream-parser.js

@@ -4,12 +4,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadableStreamParser = void 0;
 const web_1 = require("stream/web");
 const parser_error_1 = require("../../error/parser.error");
-const SaveComponent_1 = require("../../satisfactory/objects/SaveComponent");
-const SaveEntity_1 = require("../../satisfactory/objects/SaveEntity");
-const ObjectReference_1 = require("../../satisfactory/objects/values/ObjectReference");
 const level_class_1 = require("../../satisfactory/save/level.class");
 const satisfactory_save_1 = require("../../satisfactory/save/satisfactory-save");
 const save_reader_1 = require("../../satisfactory/save/save-reader");
+const SaveComponent_1 = require("../../satisfactory/types/objects/SaveComponent");
+const SaveEntity_1 = require("../../satisfactory/types/objects/SaveEntity");
+const ObjectReference_1 = require("../../satisfactory/types/structs/ObjectReference");
 const DEFAULT_BYTE_HIGHWATERMARK = 1024 * 1024 * 200;
 const createStringLengthQueuingStrategy = (highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => ({
     highWaterMark,

package/build/parser/stream/reworked/save-stream-writer.class.d.ts

@@ -1,9 +1,9 @@
 import { WritableStreamDefaultWriter } from "stream/web";
 import { ChunkCompressionInfo } from '../../file.types';
-import { SaveObject } from "../../satisfactory/objects/SaveObject";
-import { ObjectReference } from '../../satisfactory/objects/values/ObjectReference';
 import { ByteArray4, Grids } from '../../satisfactory/save/save-reader';
 import { SatisfactorySaveHeader } from '../../satisfactory/save/save.types';
+import { SaveObject } from "../../satisfactory/types/objects/SaveObject";
+import { ObjectReference } from '../../satisfactory/types/structs/ObjectReference';
 export declare class SaveStreamWriter {
     private writer;
     private mode;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.4.20",
+	"version": "0.4.22",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
 	"types": "./build/index.d.ts",
 	"main": "./build/index.js",