@etothepii/satisfactory-file-parser 0.0.15 → 0.0.17

package/build/parser/satisfactory/blueprint/blueprint-reader.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueprintConfigReader = exports.BlueprintReader = void 0;
+const pako_1 = __importDefault(require("pako"));
+const alignment_enum_1 = require("../../byte/alignment.enum");
+const byte_reader_class_1 = require("../../byte/byte-reader.class");
+const parser_error_1 = require("../../error/parser.error");
+const level_class_1 = require("../save/level.class");
+const util_types_1 = require("../structs/util.types");
+class BlueprintReader extends byte_reader_class_1.ByteReader {
+    constructor(bluePrintBuffer) {
+        super(bluePrintBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.compressionInfo = {
+            packageFileTag: 0,
+            maxChunkContentSize: 0,
+            chunkHeaderSize: 48
+        };
+    }
+    static ReadHeader(reader) {
+        const unk = reader.readBytes(3 * 4);
+        const positionThingOrWhat = (0, util_types_1.ParseVec3)(reader);
+        let itemTypeCount = reader.readInt32();
+        const itemCosts = new Array(itemTypeCount).fill(['', 0]);
+        for (let i = 0; i < itemTypeCount; i++) {
+            let indexOrWhat = reader.readInt32();
+            let itemPathName = reader.readString();
+            let itemCount = reader.readInt32();
+            itemCosts[i] = [itemPathName, itemCount];
+        }
+        let recipeCount = reader.readInt32();
+        const recipeRefs = new Array(recipeCount).fill('');
+        for (let i = 0; i < recipeCount; i++) {
+            let indexOrWhat = reader.readInt32();
+            const recipeName = reader.readString();
+            recipeRefs[i] = recipeName;
+        }
+        return {
+            recipeReferences: recipeRefs,
+            itemCosts
+        };
+    }
+    inflateChunks() {
+        this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+        this.handledByte = 0;
+        this.currentByte = 0;
+        this.maxByte = this.fileBuffer.byteLength;
+        let currentChunks = [];
+        let totalUncompressedBodySize = 0;
+        while (this.handledByte < this.maxByte) {
+            let chunkHeader = new DataView(this.fileBuffer.slice(0, this.compressionInfo.chunkHeaderSize));
+            this.currentByte = this.compressionInfo.chunkHeaderSize;
+            this.handledByte += this.compressionInfo.chunkHeaderSize;
+            if (this.compressionInfo.packageFileTag <= 0) {
+                this.compressionInfo.packageFileTag = chunkHeader.getUint32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            totalUncompressedBodySize += chunkUncompressedLength;
+            const currentChunkSize = chunkCompressedLength;
+            let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);
+            this.handledByte += currentChunkSize;
+            this.currentByte += currentChunkSize;
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.currentByte = 0;
+            try {
+                let currentInflatedChunk = null;
+                currentInflatedChunk = pako_1.default.inflate(currentChunk);
+                currentChunks.push(currentInflatedChunk);
+            }
+            catch (err) {
+                throw new parser_error_1.ParserError('ParserError', 'An error occurred while calling pako inflate.' + err);
+            }
+        }
+        let newChunkLength = currentChunks.map(cc => cc.length).reduce((prev, cur) => prev + cur);
+        const bigWholeChunk = new Uint8Array(newChunkLength);
+        let currentLength = 0;
+        for (let i = 0; i < currentChunks.length; i++) {
+            bigWholeChunk.set(currentChunks[i], currentLength);
+            currentLength += currentChunks[i].length;
+        }
+        this.currentByte = 0;
+        this.maxByte = bigWholeChunk.buffer.byteLength;
+        this.bufferView = new DataView(bigWholeChunk.buffer);
+        return {
+            newChunkLength,
+            numChunks: currentChunks.length,
+            inflatedData: bigWholeChunk
+        };
+    }
+    static ParseObjects(reader) {
+        const totalBodyRestSize = reader.readInt32();
+        const objectHeadersBinarySize = reader.readInt32();
+        let objects = [];
+        level_class_1.Level.ReadObjectHeaders(reader, objects, () => { });
+        level_class_1.Level.ReadObjectContents(reader, objects, 0, () => { });
+        return objects;
+    }
+}
+exports.BlueprintReader = BlueprintReader;
+class BlueprintConfigReader extends byte_reader_class_1.ByteReader {
+    constructor(bluePrintConfigBuffer) {
+        super(bluePrintConfigBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.bluePrintConfigBuffer = bluePrintConfigBuffer;
+        this.parse = () => BlueprintConfigReader.ParseConfig(this);
+    }
+    static ParseConfig(reader) {
+        const unk = reader.readInt32();
+        const description = reader.readString();
+        const unk3 = reader.readInt32();
+        const colorMaybe = (0, util_types_1.ParseCol4RGBA)(reader);
+        return {
+            description,
+            color: colorMaybe,
+            iconID: unk3
+        };
+    }
+}
+exports.BlueprintConfigReader = BlueprintConfigReader;

package/build/parser/satisfactory/blueprint/blueprint-writer.d.ts

@@ -0,0 +1,15 @@
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { ChunkCompressionInfo, ChunkSummary } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
+export declare class BlueprintWriter extends ByteWriter {
+    constructor();
+    static SerializeHeader(writer: ByteWriter, header: BlueprintHeader): void;
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
+    static SerializeObjects(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+}
+export declare class BlueprintConfigWriter extends ByteWriter {
+    constructor();
+    static SerializeConfig(writer: ByteWriter, config: BlueprintConfig): void;
+}

package/build/parser/satisfactory/blueprint/blueprint-writer.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueprintConfigWriter = exports.BlueprintWriter = void 0;
+const alignment_enum_1 = require("../../byte/alignment.enum");
+const byte_writer_class_1 = require("../../byte/byte-writer.class");
+const parser_error_1 = require("../../error/parser.error");
+const level_class_1 = require("../save/level.class");
+const save_writer_1 = require("../save/save-writer");
+const util_types_1 = require("../structs/util.types");
+class BlueprintWriter extends byte_writer_class_1.ByteWriter {
+    constructor() {
+        super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+    }
+    static SerializeHeader(writer, header) {
+        writer.writeInt32(2);
+        writer.writeInt32(36);
+        writer.writeInt32(211839);
+        writer.writeInt32(4);
+        writer.writeInt32(4);
+        writer.writeInt32(4);
+        writer.writeInt32(header.itemCosts.length);
+        for (const itemCost of header.itemCosts) {
+            writer.writeInt32(0);
+            writer.writeString(itemCost[0]);
+            writer.writeInt32(itemCost[1]);
+        }
+        writer.writeInt32(header.recipeReferences.length);
+        for (const recipeReference of header.recipeReferences) {
+            writer.writeInt32(0);
+            writer.writeString(recipeReference);
+        }
+    }
+    generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk) {
+        if (posAfterHeader <= 0) {
+            throw new parser_error_1.ParserError('ParserError', 'seems like this buffer has no header. Please write the header first before you can generate chunks.');
+        }
+        const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
+        onHeader(header);
+        this.bufferArray = this.bufferArray.slice(posAfterHeader);
+        const chunkSummary = save_writer_1.SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, this.alignment);
+        return chunkSummary;
+    }
+    static SerializeObjects(writer, objects) {
+        const headersLenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        level_class_1.Level.SerializeObjectHeaders(writer, objects);
+        writer.writeBinarySizeFromPosition(headersLenIndicator, headersLenIndicator + 4);
+        level_class_1.Level.SerializeObjectContents(writer, objects, 0);
+    }
+}
+exports.BlueprintWriter = BlueprintWriter;
+class BlueprintConfigWriter extends byte_writer_class_1.ByteWriter {
+    constructor() {
+        super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+    }
+    static SerializeConfig(writer, config) {
+        writer.writeInt32(2);
+        writer.writeString(config.description);
+        writer.writeInt32(config.iconID);
+        (0, util_types_1.SerializeCol4RGBA)(writer, config.color);
+    }
+}
+exports.BlueprintConfigWriter = BlueprintConfigWriter;

package/build/parser/satisfactory/blueprint/blueprint.types.d.ts

@@ -0,0 +1,20 @@
+import { ChunkCompressionInfo } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { col4 } from "../structs/util.types";
+export interface BlueprintConfig {
+    description: string;
+    color: col4;
+    iconID: number;
+}
+export type BlueprintHeader = {
+    itemCosts: [string, number][];
+    recipeReferences: string[];
+};
+export interface Blueprint {
+    name: string;
+    compressionInfo: ChunkCompressionInfo;
+    header: BlueprintHeader;
+    config: BlueprintConfig;
+    objects: (SaveEntity | SaveComponent)[];
+}

package/build/parser/satisfactory/blueprint/blueprint.types.js

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

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

@@ -1,5 +1,5 @@
 import { ByteReader } from "../../byte/byte-reader.class";
-import { SaveWriter } from "../../save-writer";
+import { SaveWriter } from "../save/save-writer";
 import { AbstractBaseProperty } from "./Property";
 export declare class DataFields {
     properties: any[];

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

@@ -12,7 +12,6 @@ class DataFields {
         const start = reader.getBufferPosition();
         const fields = new DataFields();
         if (length === 0) {
-            //WARNING
             fields.shouldBeNulled = true;
             return fields;
         }
@@ -24,7 +23,6 @@ class DataFields {
         }
         let int1 = reader.readInt32();
         if (int1 !== 0) {
-            //WARNING
         }
         const end = reader.getBufferPosition();
         let remainingBytes = start + length - end;
@@ -36,18 +34,6 @@ class DataFields {
         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();
@@ -83,12 +69,6 @@ class DataFields {
                 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);
@@ -121,7 +101,6 @@ class DataFields {
                 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;
@@ -154,10 +133,8 @@ class DataFields {
     }
     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;
@@ -191,7 +168,6 @@ class DataFields {
                 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);
@@ -242,7 +218,6 @@ class DataFields {
             default:
                 throw new Error(`Unimplemented type ${property.type}`);
         }
-        // replace len indicator.
         writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
     }
 }

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

@@ -1,5 +1,5 @@
 import { ByteReader } from "../../byte/byte-reader.class";
-import { SaveWriter } from "../../save-writer";
+import { SaveWriter } from "../save/save-writer";
 import { col4, vec3, vec4 } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
 export type Properties = {