@etothepii/satisfactory-file-parser 0.1.16 → 0.1.18

package/README.md

@@ -13,13 +13,11 @@ The version support of the packages is indicated below.
 
 Game Version Files of U5 and below are NOT supported.
 
-U8 has read and write support for blueprints, but only read support for saves. More coming soon.
-
 | Game Version   |      Package                 |
 |:--------------:|:-----------------------------|
 | <= U5          |  ❌                          |
-| U6 + U7        |  ✅ 0.0.1 - 0.0.34              |
-| U8             |  ⚠️ >= 0.1.16  (readig for both saves and blueprints, writing only for blueprints) |
+| U6 + U7        |  ✅ 0.0.1 - 0.0.34           |
+| U8             |  ✅ >= 0.1.18                |
 
 
 ## Installation via npm
@@ -96,7 +94,7 @@ fs.writeFileSync('./MyModifiedSave.sbpcfg', Buffer.from(summary.configFileBinary
 ## License 
 MIT License
 
-Copyright (c) 2023 etotheepii
+Copyright (c) 2023 etothepii
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/build/parser/byte/byte-reader.class.d.ts

@@ -13,7 +13,8 @@ export declare abstract class ByteReader implements BinaryReadable {
     skipBytes(byteLength?: number): void;
     readByte(): number;
     readBytes(count: number): Uint8Array;
-    readHex(hexLength: number): string;
+    private uint8ToHexRepresentation;
+    readHex(byteLength: number, hexSeparator?: string): string;
     readInt8(): number;
     readUint8(): number;
     readInt16(): number;

package/build/parser/byte/byte-reader.class.js

@@ -34,13 +34,11 @@ class ByteReader {
     readBytes(count) {
         return new Uint8Array(new Array(count).fill(0).map(pl => this.bufferView.getUint8(this.currentByte++)));
     }
-    readHex(hexLength) {
-        let hexPart = [];
-        for (let i = 0; i < hexLength; i++) {
-            let currentHex = String.fromCharCode(this.bufferView.getUint8(this.currentByte++));
-            hexPart.push(currentHex);
-        }
-        return hexPart.join('');
+    uint8ToHexRepresentation(byte) {
+        return ('0' + byte.toString(16)).slice(-2);
+    }
+    readHex(byteLength, hexSeparator = '') {
+        return Array.from(this.readBytes(byteLength)).map(byte => this.uint8ToHexRepresentation(byte)).join(hexSeparator);
     }
     readInt8() {
         let data = this.bufferView.getInt8(this.currentByte++);

package/build/parser/file.types.d.ts

@@ -1,7 +1,11 @@
+export declare enum CompressionAlgorithmCode {
+    ZLIB = 3
+}
 export type ChunkCompressionInfo = {
+    compressionAlgorithm?: CompressionAlgorithmCode;
     chunkHeaderSize: number;
     packageFileTag: number;
-    maxChunkContentSize: number;
+    maxUncompressedChunkContentSize: number;
 };
 export type ChunkSummary = {
     uncompressedSize: number;

package/build/parser/file.types.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionAlgorithmCode = void 0;
+var CompressionAlgorithmCode;
+(function (CompressionAlgorithmCode) {
+    CompressionAlgorithmCode[CompressionAlgorithmCode["ZLIB"] = 3] = "ZLIB";
+})(CompressionAlgorithmCode = exports.CompressionAlgorithmCode || (exports.CompressionAlgorithmCode = {}));

package/build/parser/parser.js

@@ -11,6 +11,8 @@ class Parser {
         const writer = new save_writer_1.SaveWriter();
         save_writer_1.SaveWriter.WriteHeader(writer, save.header);
         const posAfterHeader = writer.getBufferPosition();
+        save_writer_1.SaveWriter.WriteSaveBodyHash(writer, save.gridHash);
+        save_writer_1.SaveWriter.WriteGrids(writer, save.grids);
         save_writer_1.SaveWriter.WriteLevels(writer, save, save.header.buildVersion);
         writer.endWriting();
         const chunkSummary = writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk);
@@ -22,7 +24,10 @@ class Parser {
         const save = new satisfactory_save_1.SatisfactorySave(header);
         const inflateResult = reader.inflateChunks();
         onDecompressedSaveBody(reader.getBuffer());
+        const gridHash = reader.readSaveBodyHash();
+        save.gridHash = gridHash;
         const grids = reader.readGrids();
+        save.grids = grids;
         save.levels = reader.readLevels();
         save.compressionInfo = reader.compressionInfo;
         save.trailingCollectedObjects = reader.trailingCollectedObjects;

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

@@ -18,14 +18,14 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
         super(bluePrintBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
         this.compressionInfo = {
             packageFileTag: 0,
-            maxChunkContentSize: 0,
+            maxUncompressedChunkContentSize: 0,
             chunkHeaderSize: save_reader_1.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
         };
     }
     static ReadHeader(reader) {
         const blueprintTypeOrWhat = reader.readBytes(4);
         const versionThing = reader.readBytes(2 * 4);
-        const probablyDimensions = (0, util_types_1.ParseVec3f)(reader);
+        const dimensions = (0, util_types_1.ParseVec3f)(reader);
         let itemTypeCount = reader.readInt32();
         const itemCosts = new Array(itemTypeCount).fill(['', 0]);
         for (let i = 0; i < itemTypeCount; i++) {
@@ -42,6 +42,7 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
             recipeRefs[i] = recipeName;
         }
         return {
+            designerDimension: dimensions,
             recipeReferences: recipeRefs,
             itemCosts
         };
@@ -60,11 +61,11 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
             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);
+            if (this.compressionInfo.maxUncompressedChunkContentSize <= 0) {
+                this.compressionInfo.maxUncompressedChunkContentSize = 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(24, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkCompressedLength = chunkHeader.getInt32(33, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(25, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
             totalUncompressedBodySize += chunkUncompressedLength;
             const currentChunkSize = chunkCompressedLength;
             let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);

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

@@ -1,13 +1,14 @@
 import { ChunkCompressionInfo } from "../../file.types";
 import { SaveComponent } from "../objects/SaveComponent";
 import { SaveEntity } from "../objects/SaveEntity";
-import { col4 } from "../structs/util.types";
+import { col4, vec3 } from "../structs/util.types";
 export interface BlueprintConfig {
     description: string;
     color: col4;
     iconID: number;
 }
 export type BlueprintHeader = {
+    designerDimension?: vec3;
     itemCosts: [string, number][];
     recipeReferences: string[];
 };

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

@@ -126,10 +126,7 @@ export declare class ObjectProperty extends BasicProperty {
     static ReadValue(reader: BinaryReadable): ObjectReference;
     static CalcOverhead(property: ObjectProperty): number;
     static Serialize(writer: ByteWriter, property: ObjectProperty): void;
-    static SerializeValue(writer: ByteWriter, value: {
-        levelName: string;
-        pathName: string;
-    }): void;
+    static SerializeValue(writer: ByteWriter, value: ObjectReference): void;
 }
 export declare class EnumProperty extends BasicProperty {
     value: {
@@ -245,16 +242,17 @@ export declare class SetProperty<T> extends BasicProperty {
     static CalcOverhead(property: SetProperty<any>): number;
     static Serialize(writer: ByteWriter, property: SetProperty<any>): void;
 }
-export type GENERIC_MAP_KEY_TYPE = number | ObjectReference | boolean | GENERIC_STRUCT_PROPERTY_VALUE;
+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 class MapProperty extends BasicProperty {
     keyType: string;
     valueType: string;
+    structKeyProxy: MAP_STRUCT_KEY_PROXY;
     modeType: number;
     modeUnk1: string | undefined;
     modeUnk2: string;
     modeUnk3: string;
-    remainingData: number[];
     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;

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

@@ -858,7 +858,7 @@ class SetProperty extends BasicProperty {
                 property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
                 break;
             default:
-                throw new Error('Not Implemented.');
+                throw new Error(`Not Implemented SetProperty of ${subtype}.`);
         }
         return property;
     }
@@ -872,8 +872,13 @@ class SetProperty extends BasicProperty {
         writer.writeInt32(property.values.length);
         switch (property.subtype) {
             case "IntProperty":
+            case "Int32Property":
                 property.values.forEach(v => Int32Property.SerializeValue(writer, v));
                 break;
+            case "UIntProperty":
+            case "UInt32Property":
+                property.values.forEach(v => Uint32Property.SerializeValue(writer, v));
+                break;
             case "ObjectProperty":
                 property.values.forEach(v => ObjectProperty.SerializeValue(writer, v));
                 break;
@@ -884,7 +889,7 @@ class SetProperty extends BasicProperty {
                 property.values.forEach(v => (0, util_types_1.SerializeVec3f)(writer, v));
                 break;
             default:
-                throw new Error('Not Implemented.');
+                throw new Error(`Not Implemented SetProperty of ${property.subtype}.`);
         }
     }
 }
@@ -894,10 +899,10 @@ class MapProperty extends BasicProperty {
         super('MapProperty', ueType, undefined, index);
         this.keyType = keyType;
         this.valueType = valueType;
+        this.structKeyProxy = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         this.modeType = 0;
         this.modeUnk2 = '';
         this.modeUnk3 = '';
-        this.remainingData = [];
         this.values = [];
     }
     static Parse(reader, propertyName, buildVersion, size, ueType = 'MapProperty', index = 0) {
@@ -913,7 +918,7 @@ class MapProperty extends BasicProperty {
                 case 'StructProperty':
                     if (propertyName === 'mSaveData' || propertyName === 'mUnresolvedSaveData') {
                         key = propertyName;
-                        reader.skipBytes(12);
+                        property.structKeyProxy = Array.from(reader.readBytes(12));
                     }
                     else {
                         key = (0, exports.ParseDynamicStructData)(reader, 0, property.keyType);
@@ -975,7 +980,62 @@ class MapProperty extends BasicProperty {
         writer.writeString(property.valueType);
         writer.writeByte(0);
         writer.writeInt32(property.modeType);
-        writer.writeBytesArray(property.remainingData);
+        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(property.structKeyProxy);
+                    }
+                    else {
+                        (0, exports.SerializeDynamicStructData)(writer, 0, entry[0]);
+                    }
+                    break;
+                case 'ObjectProperty':
+                    ObjectProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    StrProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'EnumProperty':
+                    EnumProperty.SerializeValue(writer, entry[0]);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    Int32Property.SerializeValue(writer, entry[0]);
+                    break;
+                case 'ByteProperty':
+                    ByteProperty.SerializeValue(writer, entry[0]);
+                    break;
+                default:
+                    throw new Error(`not implemented map key type ${property.valueType}`);
+            }
+            switch (property.valueType) {
+                case 'StructProperty':
+                    (0, exports.SerializeDynamicStructData)(writer, 0, entry[1]);
+                    break;
+                case 'ObjectProperty':
+                    ObjectProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    StrProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'EnumProperty':
+                    EnumProperty.SerializeValue(writer, entry[1]);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    Int32Property.SerializeValue(writer, entry[1]);
+                    break;
+                case 'ByteProperty':
+                    ByteProperty.SerializeValue(writer, entry[1]);
+                    break;
+                default:
+                    throw new Error(`not implemented map value type ${property.valueType}`);
+            }
+        }
     }
 }
 exports.MapProperty = MapProperty;

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

@@ -14,7 +14,7 @@ export declare abstract class SaveObject implements SaveObjectHeader {
     properties: PropertiesMap;
     specialProperties: SpecialAnyProperty;
     trailingData: number[];
-    unknownType1: number;
+    saveOrBlueprintIndicator: number;
     unknownType2: number;
     constructor(typePath: string, rootObject: string, instanceName: string);
     protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;

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

@@ -10,7 +10,7 @@ class SaveObject {
         this.properties = {};
         this.specialProperties = {};
         this.trailingData = [];
-        this.unknownType1 = 0;
+        this.saveOrBlueprintIndicator = 0;
         this.unknownType2 = 0;
     }
     static ParseHeader(reader, obj) {

package/build/parser/satisfactory/objects/ue/FMD5Hash.d.ts

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

package/build/parser/satisfactory/objects/ue/FMD5Hash.js

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

package/build/parser/satisfactory/save/asynchronous-level.class.js

@@ -52,13 +52,13 @@ class AsynchronousLevel {
         await writer.openLevel(levelName);
         level_class_1.Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
         reader.onProgressCallback(reader.getBufferProgress());
-        level.collectables = level_class_1.Level.ReadCollectablesList(reader);
+        level.collectables = level_class_1.Level.ReadCollectablesList(reader, undefined);
         console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
         await AsynchronousLevel.StreamReadObjectContents(reader, level.objects, buildVersion, writer, reader.onProgressCallback);
         await writer.switchInLevelToCollectables();
         await writer.writeCollectables(...level.collectables);
         reader.onProgressCallback(reader.getBufferProgress());
-        level_class_1.Level.ReadCollectablesList(reader);
+        level_class_1.Level.ReadCollectablesList(reader, undefined);
         await writer.endLevel();
         return level;
     }

package/build/parser/satisfactory/save/level.class.d.ts

@@ -9,6 +9,7 @@ export declare class Level {
     name: string;
     objects: (SaveEntity | SaveComponent)[];
     collectables: ObjectReference[];
+    remainingStuffAfterHeaders: Uint8Array;
     constructor(name: string);
     static SerializeObjectHeaders(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
     static WriteLevel(writer: ByteWriter, level: Level, buildVersion: number): void;
@@ -17,5 +18,5 @@ export declare class Level {
     static ReadObjectContents(levelName: string, reader: BinaryReadable, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
     static ReadLevel(reader: SaveReader, levelName: string, buildVersion: number): Level;
     static SerializeCollectablesList(writer: ByteWriter, collectables: ObjectReference[]): void;
-    static ReadCollectablesList(reader: BinaryReadable): ObjectReference[];
+    static ReadCollectablesList(reader: BinaryReadable, printSmthWhenItsCollectables?: string | undefined): ObjectReference[];
 }

package/build/parser/satisfactory/save/level.class.js

@@ -9,6 +9,7 @@ class Level {
         this.name = name;
         this.objects = [];
         this.collectables = [];
+        this.remainingStuffAfterHeaders = new Uint8Array();
     }
     static SerializeObjectHeaders(writer, objects) {
         writer.writeInt32(objects.length);
@@ -31,17 +32,21 @@ class Level {
     static WriteLevel(writer, level, buildVersion) {
         const lenIndicatorHeaderAndCollectableSize = writer.getBufferPosition();
         writer.writeInt32(0);
+        writer.writeInt32(0);
         Level.SerializeObjectHeaders(writer, level.objects);
         Level.SerializeCollectablesList(writer, level.collectables);
-        writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
+        writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 8);
         Level.SerializeObjectContents(writer, level.objects, buildVersion, level.name);
         Level.SerializeCollectablesList(writer, level.collectables);
     }
     static SerializeObjectContents(writer, objects, buildVersion, levelName) {
         const lenIndicatorEntities = writer.getBufferPosition();
         writer.writeInt32(0);
+        writer.writeInt32(0);
         writer.writeInt32(objects.length);
         for (const obj of objects) {
+            writer.writeInt32(obj.saveOrBlueprintIndicator);
+            writer.writeInt32(obj.unknownType2);
             const lenReplacementPosition = writer.getBufferPosition();
             writer.writeInt32(0);
             if ((0, SaveEntity_1.isSaveEntity)(obj)) {
@@ -52,7 +57,7 @@ class Level {
             }
             writer.writeBinarySizeFromPosition(lenReplacementPosition, lenReplacementPosition + 4);
         }
-        writer.writeBinarySizeFromPosition(lenIndicatorEntities, lenIndicatorEntities + 4);
+        writer.writeBinarySizeFromPosition(lenIndicatorEntities, lenIndicatorEntities + 8);
     }
     static ReadObjectHeaders(reader, objectsList, onProgressCallback) {
         let countObjectHeaders = reader.readInt32();
@@ -88,7 +93,7 @@ class Level {
                 onProgressCallback(reader.getBufferProgress());
             }
             const obj = objectsList[i];
-            obj.unknownType1 = reader.readInt32();
+            obj.saveOrBlueprintIndicator = reader.readInt32();
             obj.unknownType2 = reader.readInt32();
             const binarySize = reader.readInt32();
             const before = reader.getBufferPosition();
@@ -106,18 +111,23 @@ class Level {
     }
     static ReadLevel(reader, levelName, buildVersion) {
         const level = new Level(levelName);
-        const levelStartPos = reader.getBufferPosition();
         const headersBinLen = reader.readInt32();
         const unk = reader.readInt32();
         const posBeforeHeaders = reader.getBufferPosition();
         Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
-        const remainingSize = headersBinLen - (reader.getBufferPosition() - posBeforeHeaders);
+        let remainingSize = headersBinLen - (reader.getBufferPosition() - posBeforeHeaders);
         if (remainingSize > 0) {
-            reader.readBytes(remainingSize);
+            const doubledCollectablesIgnored = Level.ReadCollectablesList(reader, 'collectables at the header section! ' + levelName);
+        }
+        else {
+        }
+        remainingSize = headersBinLen - (reader.getBufferPosition() - posBeforeHeaders);
+        if (remainingSize !== 0) {
+            console.warn('remaining size not 0. Save may be corrupt.', remainingSize, levelName);
         }
         const objectContentsBinLen = reader.readInt32();
+        const unk2 = reader.readInt32();
         reader.onProgressCallback(reader.getBufferProgress());
-        level.collectables = Level.ReadCollectablesList(reader);
         const posBeforeContents = reader.getBufferPosition();
         Level.ReadObjectContents(levelName, reader, level.objects, buildVersion, reader.onProgressCallback);
         const posAfterContents = reader.getBufferPosition();
@@ -125,7 +135,7 @@ class Level {
             console.warn('save seems corrupt.', this.name);
         }
         reader.onProgressCallback(reader.getBufferProgress());
-        level.collectables = Level.ReadCollectablesList(reader);
+        level.collectables = Level.ReadCollectablesList(reader, 'collectables 2! ' + levelName);
         return level;
     }
     static SerializeCollectablesList(writer, collectables) {
@@ -134,19 +144,17 @@ class Level {
             ObjectReference_1.ObjectReference.Serialize(writer, collectable);
         }
     }
-    static ReadCollectablesList(reader) {
+    static ReadCollectablesList(reader, printSmthWhenItsCollectables) {
         const collected = [];
         let countSmthing = reader.readInt32();
         if (countSmthing > 0) {
-            const lookahead = reader.readInt32();
-            if (lookahead === 0) {
-                return collected;
-            }
-            reader.skipBytes(-4);
             for (let i = 0; i < countSmthing; i++) {
                 const collectable = ObjectReference_1.ObjectReference.Parse(reader);
                 collected.push(collectable);
             }
+            if (process.env.NODE_ENV === 'debug' && countSmthing > 0) {
+                console.log(printSmthWhenItsCollectables, countSmthing, collected.map(coll => coll.pathName).join(', '));
+            }
         }
         return collected;
     }

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

@@ -1,10 +1,11 @@
 import { ChunkCompressionInfo } from "../../file.types";
 import { ObjectReference } from "../objects/ObjectReference";
 import { Level } from "./level.class";
-import { Grids } from "./save-reader";
+import { ByteArray4, Grids } from "./save-reader";
 import { SatisfactorySaveHeader } from "./save.types";
 export declare class SatisfactorySave {
     header: SatisfactorySaveHeader;
+    gridHash: ByteArray4;
     grids: Grids;
     levels: Level[];
     trailingCollectedObjects: ObjectReference[];

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SatisfactorySave = void 0;
 class SatisfactorySave {
     constructor(header) {
+        this.gridHash = [0, 0, 0, 0];
         this.grids = {};
         this.levels = [];
         this.trailingCollectedObjects = [];

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

@@ -6,12 +6,15 @@ import { Level } from "./level.class";
 import { RoughSaveVersion, SatisfactorySaveHeader } from "./save.types";
 export type ReadMode = 'stream' | 'whole';
 export declare const DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 49;
+export type ByteArray4 = [number, number, number, number];
 export type Grids = {
     [parentName: string]: {
-        [level: number]: {
-            name: string;
-            size: number;
-        }[];
+        checksum: number;
+        cellSize: number;
+        gridHash: number;
+        children: {
+            [name: string]: number;
+        };
     };
 };
 export declare class SaveReader extends ByteReader {
@@ -28,6 +31,7 @@ export declare class SaveReader extends ByteReader {
         concatenatedChunkLength: number;
         numChunks: number;
     };
+    readSaveBodyHash: () => ByteArray4;
     readGrids: () => Grids;
     readLevels(): Level[];
     readLevelsAsynchronously(writer: SaveStreamWriter): Promise<Level[]>;

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

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,6 +31,7 @@ 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 FMD5Hash = __importStar(require("../objects/ue/FMD5Hash"));
 const asynchronous_level_class_1 = require("./asynchronous-level.class");
 const level_class_1 = require("./level.class");
 exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 49;
@@ -19,43 +43,38 @@ class SaveReader extends byte_reader_class_1.ByteReader {
         this.trailingCollectedObjects = [];
         this.compressionInfo = {
             packageFileTag: 0,
-            maxChunkContentSize: 0,
+            maxUncompressedChunkContentSize: 0,
             chunkHeaderSize: exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
         };
-        this.readGrids = () => {
+        this.readSaveBodyHash = () => {
             const unk = this.readInt32();
             const cannotBeLevelCountWhatIsIt = this.readInt32();
             const noneString = this.readString();
             const unk2 = this.readInt32();
-            const hm1 = this.readInt32();
+            const gridValidationHash = Array.from(this.readBytes(4));
             const unk3 = this.readInt32();
             const noneString2 = this.readString();
+            return gridValidationHash;
+        };
+        this.readGrids = () => {
             const grids = {};
-            const readLevelsList = (childrenCount) => {
-                const hmm = this.readInt32();
+            const readGrid = (childrenCount) => {
+                const parentChecksumIdOrSmth = this.readUint32();
                 const parentName = this.readString();
-                const whatever1 = this.readInt32();
-                const whatever2 = this.readInt32();
-                grids[parentName] = {};
+                const cellSize = this.readInt32();
+                const gridHash = this.readUint32();
+                grids[parentName] = { checksum: parentChecksumIdOrSmth, children: {}, cellSize, gridHash };
                 for (let i = 0; i < childrenCount; i++) {
-                    const binaryLenIGuess = this.readUint32();
+                    const cellHash = this.readUint32();
                     const levelInstanceName = this.readString();
-                    const lod = /\_L([0-9]+)\_/.exec(levelInstanceName)[1];
-                    const arr = grids[parentName][Number(lod)];
-                    if (!arr) {
-                        grids[parentName][Number(lod)] = [];
-                    }
-                    grids[parentName][Number(lod)].push({
-                        name: levelInstanceName,
-                        size: binaryLenIGuess
-                    });
+                    grids[parentName].children[levelInstanceName] = cellHash;
                 }
             };
-            readLevelsList(1379);
-            readLevelsList(0);
-            readLevelsList(972);
-            readLevelsList(0);
-            readLevelsList(0);
+            readGrid(1379);
+            readGrid(0);
+            readGrid(972);
+            readGrid(0);
+            readGrid(0);
             const unk5 = this.readInt32();
             return grids;
         };
@@ -98,10 +117,17 @@ class SaveReader extends byte_reader_class_1.ByteReader {
         if (this.header.saveHeaderType >= 10) {
             this.header.saveIdentifier = this.readString();
         }
+        if (this.header.saveHeaderType >= 11) {
+            this.header.partitionEnabledFlag = this.readInt32() === 1;
+        }
+        if (this.header.saveHeaderType >= 12) {
+            this.header.consistencyHashBytes = FMD5Hash.readMD5Hash(this);
+        }
         if (this.header.saveHeaderType >= 13) {
-            this.header.unknownStuff = Array.from(this.readBytes(28));
+            this.header.creativeModeEnabled = this.readInt32() == 1;
         }
         if (this.header.saveVersion >= 21) {
+            console.log('save version', this.header.saveVersion, 'header type', this.header.saveHeaderType, 'buildversion', this.header.buildVersion);
         }
         else {
             throw new parser_error_1.UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
@@ -122,8 +148,8 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             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);
+            if (this.compressionInfo.maxUncompressedChunkContentSize <= 0) {
+                this.compressionInfo.maxUncompressedChunkContentSize = chunkHeader.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
             }
             const chunkCompressedLength = chunkHeader.getInt32(33, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
             const chunkUncompressedLength = chunkHeader.getInt32(25, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
@@ -179,18 +205,8 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             let levelSingleName = this.readString();
             levels.push(level_class_1.Level.ReadLevel(this, levelSingleName, this.header.buildVersion));
         }
-        level_class_1.Level.ReadCollectablesList(this);
-        this.onProgressCallback(this.getBufferProgress(), `finished reading levels pack of ${levelCount}.`);
-        if (this.getBufferPosition() < this.getBufferLength()) {
-            const appendedLevel = new level_class_1.Level(this.header.mapName);
-            levels.push(appendedLevel);
-            level_class_1.Level.ReadObjectHeaders(this, appendedLevel.objects, this.onProgressCallback);
-            const unk = this.readInt32();
-            appendedLevel.collectables = level_class_1.Level.ReadCollectablesList(this);
-            level_class_1.Level.ReadObjectContents(appendedLevel.name, this, appendedLevel.objects, this.header.buildVersion, this.onProgressCallback);
-            level_class_1.Level.ReadCollectablesList(this);
-            level_class_1.Level.ReadCollectablesList(this);
-        }
+        levels.push(level_class_1.Level.ReadLevel(this, this.header.mapName, this.header.buildVersion));
+        const trailingStuffToIgnore = level_class_1.Level.ReadCollectablesList(this, 'collectables 6!');
         this.onProgressCallback(this.getBufferProgress(), 'finished parsing.');
         return levels;
     }

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

@@ -2,11 +2,12 @@ import { Alignment } from "../../byte/alignment.enum";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { ChunkCompressionInfo, ChunkSummary } from "../../file.types";
 import { SatisfactorySave } from "./satisfactory-save";
-import { Grids } from "./save-reader";
+import { ByteArray4, Grids } from "./save-reader";
 import { SatisfactorySaveHeader } from "./save.types";
 export declare class SaveWriter extends ByteWriter {
     constructor();
     static WriteHeader(writer: ByteWriter, header: SatisfactorySaveHeader): void;
+    static WriteSaveBodyHash: (writer: ByteWriter, hash: ByteArray4) => void;
     static WriteGrids: (writer: ByteWriter, grids: Grids) => void;
     static WriteLevels(writer: ByteWriter, save: SatisfactorySave, buildVersion: number): void;
     static GenerateCompressedChunksFromData(bufferArray: ArrayBuffer, compressionInfo: ChunkCompressionInfo, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onChunk: (chunk: Uint8Array) => void, alignment?: Alignment): ChunkSummary[];

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

@@ -8,7 +8,10 @@ const pako_1 = __importDefault(require("pako"));
 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 file_types_1 = require("../../file.types");
+const FMD5Hash_1 = require("../objects/ue/FMD5Hash");
 const level_class_1 = require("./level.class");
+const save_reader_1 = require("./save-reader");
 class SaveWriter extends byte_writer_class_1.ByteWriter {
     constructor() {
         super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
@@ -21,7 +24,7 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
         writer.writeString(header.mapOptions);
         writer.writeString(header.sessionName);
         writer.writeInt32(header.playDurationSeconds);
-        writer.writeInt64(BigInt(header.saveDateTime));
+        writer.writeInt64(BigInt(header.saveDateTime) * 10000n + save_reader_1.SaveReader.EPOCH_TICKS);
         writer.writeByte(header.sessionVisibility);
         if (header.saveHeaderType >= 7) {
             writer.writeInt32(header.fEditorObjectVersion);
@@ -38,8 +41,14 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
         if (header.saveHeaderType >= 10) {
             writer.writeString(header.saveIdentifier);
         }
+        if (header.saveHeaderType >= 11) {
+            writer.writeInt32(header.partitionEnabledFlag ? 1 : 0);
+        }
+        if (header.saveHeaderType >= 12) {
+            (0, FMD5Hash_1.writeMD5Hash)(writer, header.consistencyHashBytes);
+        }
         if (header.saveHeaderType >= 13) {
-            writer.writeBytesArray(header.unknownStuff);
+            writer.writeInt32(header.creativeModeEnabled ? 1 : 0);
         }
         if (header.saveVersion >= 21) {
         }
@@ -55,7 +64,7 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
             }
             level_class_1.Level.WriteLevel(writer, level, buildVersion);
         }
-        level_class_1.Level.SerializeCollectablesList(writer, save.trailingCollectedObjects);
+        level_class_1.Level.SerializeCollectablesList(writer, save.trailingCollectedObjects ?? []);
     }
     static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
         const errors = [];
@@ -63,12 +72,12 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
         const saveBody = new Uint8Array(bufferArray.byteLength + 4);
         saveBody.set(new Uint8Array(bufferArray), 4);
         const miniView = new DataView(saveBody.buffer);
-        miniView.setInt32(0, totalUncompressedSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        miniView.setInt32(0, totalUncompressedSize - 4, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
         onBinaryBeforeCompressing(saveBody.buffer);
         let handledByte = 0;
         const chunkSummary = [];
         while (handledByte < saveBody.byteLength) {
-            const uncompressedContentSize = Math.min(compressionInfo.maxChunkContentSize, saveBody.byteLength - handledByte);
+            const uncompressedContentSize = Math.min(compressionInfo.maxUncompressedChunkContentSize, saveBody.byteLength - handledByte);
             const uncompressedChunk = saveBody.buffer.slice(handledByte, handledByte + uncompressedContentSize);
             let compressedChunk = new Uint8Array(0);
             try {
@@ -81,17 +90,18 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
             chunk.set(compressedChunk, compressionInfo.chunkHeaderSize);
             const view = new DataView(chunk.buffer);
             view.setInt32(0, compressionInfo.packageFileTag, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(4, 572662306, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(8, compressionInfo.maxChunkContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(4, 0x22222222, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(8, compressionInfo.maxUncompressedChunkContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
             view.setInt32(12, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(16, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(20, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(24, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(28, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(32, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(36, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(40, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            view.setInt32(44, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setUint8(16, file_types_1.CompressionAlgorithmCode.ZLIB);
+            view.setInt32(17, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(21, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(25, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(29, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(33, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(37, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(41, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(45, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
             onChunk(chunk);
             chunkSummary.push({
                 uncompressedSize: uncompressedContentSize + compressionInfo.chunkHeaderSize,
@@ -112,23 +122,26 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
         return chunkSummary;
     }
 }
-SaveWriter.WriteGrids = (writer, grids) => {
-    writer.writeInt32(0);
+SaveWriter.WriteSaveBodyHash = (writer, hash) => {
     writer.writeInt32(0);
+    writer.writeInt32(6);
     writer.writeString('None');
     writer.writeInt32(0);
-    writer.writeInt32(0);
-    writer.writeInt32(0);
+    writer.writeBytesArray(hash);
+    writer.writeInt32(1);
     writer.writeString('None');
+};
+SaveWriter.WriteGrids = (writer, grids) => {
     for (const parentEntry of Object.entries(grids)) {
-        writer.writeInt32(0);
+        writer.writeInt32(parentEntry[1].checksum);
         writer.writeString(parentEntry[0]);
-        writer.writeInt32(0);
-        writer.writeInt32(0);
-        for (const child of Object.entries(parentEntry[1]).flatMap(entry => entry[1])) {
-            writer.writeUint32(child.size);
-            writer.writeString(child.name);
+        writer.writeInt32(parentEntry[1].cellSize);
+        writer.writeUint32(parentEntry[1].gridHash);
+        for (const child of Object.entries(parentEntry[1].children)) {
+            writer.writeUint32(child[1]);
+            writer.writeString(child[0]);
         }
     }
+    writer.writeInt32(0);
 };
 exports.SaveWriter = SaveWriter;

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

@@ -1,3 +1,4 @@
+import { MD5Hash } from '../objects/ue/FMD5Hash';
 export interface ModData {
     Reference: string;
     Name: string;
@@ -21,7 +22,9 @@ export interface SatisfactorySaveHeader {
     isModdedSave?: number;
     saveIdentifier?: string;
     fEditorObjectVersion?: number;
-    unknownStuff?: number[];
+    partitionEnabledFlag?: boolean;
+    consistencyHashBytes?: MD5Hash;
+    creativeModeEnabled?: boolean;
 }
 export type RoughSaveVersion = '<U6' | 'U6/U7' | 'U8+';
 export type ResourceNodeEntry = {

package/build/parser/stream/save-stream-json-stringifier.js

@@ -10,6 +10,8 @@ class SaveStreamJsonStringifier {
         if (save.compressionInfo) {
             await writer.writeCompressionInfo(save.compressionInfo);
         }
+        await writer.writeGridHash(save.gridHash);
+        await writer.writeGrids(save.grids);
         await writer.openLevels();
         const objectBatchSize = 10000;
         for (const level of save.levels) {

package/build/parser/stream/save-stream-reader.class.js

@@ -14,7 +14,7 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
         super(reader, onCloseCallback, 30000, maxBufferThreshold, alignment_enum_1.Alignment.LITTLE_ENDIAN);
         this.compressionInfo = {
             packageFileTag: 0,
-            maxChunkContentSize: 0,
+            maxUncompressedChunkContentSize: 0,
             chunkHeaderSize: SaveStreamReader.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
         };
     }
@@ -73,8 +73,8 @@ class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
         if (this.compressionInfo.packageFileTag <= 0) {
             this.compressionInfo.packageFileTag = this.operatingDataView.getInt32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
         }
-        if (this.compressionInfo.maxChunkContentSize <= 0) {
-            this.compressionInfo.maxChunkContentSize = this.operatingDataView.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        if (this.compressionInfo.maxUncompressedChunkContentSize <= 0) {
+            this.compressionInfo.maxUncompressedChunkContentSize = this.operatingDataView.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
         }
         const chunkCompressedLength = this.operatingDataView.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
         const chunkUncompressedLength = this.operatingDataView.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);

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

@@ -2,6 +2,7 @@
 import { WritableStreamDefaultWriter } from "stream/web";
 import { ChunkCompressionInfo, ObjectReference, SatisfactorySaveHeader } from "../..";
 import { SaveObject } from "../satisfactory/objects/SaveObject";
+import { ByteArray4, Grids } from '../satisfactory/save/save-reader';
 export declare class SaveStreamWriter {
     private writer;
     private mode;
@@ -10,6 +11,8 @@ export declare class SaveStreamWriter {
     beginSave(): Promise<void>;
     writeHeader(header: SatisfactorySaveHeader): Promise<void>;
     writeCompressionInfo(compressionInfo: ChunkCompressionInfo): Promise<void>;
+    writeGridHash(gridHash: ByteArray4): Promise<void>;
+    writeGrids(grids: Grids): Promise<void>;
     openLevels(): Promise<void>;
     openLevel(levelName: string): Promise<void>;
     writeObjects(...objects: SaveObject[]): Promise<void>;

package/build/parser/stream/save-stream-writer.class.js

@@ -30,9 +30,23 @@ class SaveStreamWriter {
         await this.writer.write(`, "compressionInfo": ${JSON.stringify(compressionInfo)}`);
         this.mode = 'WROTE_COMPRESSION_INFO';
     }
-    async openLevels() {
+    async writeGridHash(gridHash) {
         if (this.mode !== 'WROTE_COMPRESSION_INFO') {
-            throw new Error(`Wrong order of commands. Levels have to come after compression info. mode is ${this.mode}.`);
+            throw new Error(`Wrong order of commands. Save hbody hash has to come after compression info. mode is ${this.mode}.`);
+        }
+        await this.writer.write(`, "gridHash": ${JSON.stringify(gridHash)}`);
+        this.mode = 'WROTE_GRID_HASH';
+    }
+    async writeGrids(grids) {
+        if (this.mode !== 'WROTE_GRID_HASH') {
+            throw new Error(`Wrong order of commands. Grids have to come after save body hash info. mode is ${this.mode}.`);
+        }
+        await this.writer.write(`, "grids": ${JSON.stringify(grids)}`);
+        this.mode = 'WROTE_GRIDS';
+    }
+    async openLevels() {
+        if (this.mode !== 'WROTE_GRIDS') {
+            throw new Error(`Wrong order of commands. Levels have to come after grids info. mode is ${this.mode}.`);
         }
         await this.writer.write(`, "levels": [`);
         this.mode = 'OPENED_LEVELS';

package/package.json

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