@etothepii/satisfactory-file-parser 0.1.1 → 0.1.4

package/README.md

@@ -19,7 +19,7 @@ U8 has only read support so far and only for save files, not for blueprint files
 |:--------------:|:-----------------------------|
 | <= U5          |  ❌                          |
 | U6 + U7        |  ✅ 0.0.1 - 0.0.34              |
-| U8             |  ⚠️ >= 0.1.0  ( .sav file Reading only so far) |
+| U8             |  ⚠️ >= 0.1.3  (Reading only) |
 
 
 ## Installation via npm

package/build/parser/parser.d.ts

@@ -2,7 +2,6 @@
 import { ChunkSummary } from "./file.types";
 import { Blueprint } from "./satisfactory/blueprint/blueprint.types";
 import { SatisfactorySave } from "./satisfactory/save/satisfactory-save";
-import { SaveProjectionConfig } from "./satisfactory/save/save-reader";
 export declare class Parser {
     static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
     static ParseSaveFile(file: Buffer, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
@@ -11,6 +10,5 @@ export declare class Parser {
         configFileBinary: ArrayBuffer;
     };
     static ParseBlueprintFiles(name: string, blueprintFile: Buffer, blueprintConfigFile: Buffer, onDecompressedBlueprintBody?: (buffer: ArrayBuffer) => void): Blueprint;
-    static ProjectSave(save: SatisfactorySave, config: SaveProjectionConfig): SatisfactorySave;
     static JSONStringifyModified: (obj: any, indent?: number) => string;
 }

package/build/parser/parser.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const blueprint_reader_1 = require("./satisfactory/blueprint/blueprint-reader");
 const blueprint_writer_1 = require("./satisfactory/blueprint/blueprint-writer");
-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 save_writer_1 = require("./satisfactory/save/save-writer");
@@ -23,7 +22,8 @@ class Parser {
         const save = new satisfactory_save_1.SatisfactorySave(header);
         const inflateResult = reader.inflateChunks();
         onDecompressedSaveBody(reader.getBuffer());
-        save.levels = reader.readLevelsU8();
+        reader.readGrids();
+        save.levels = reader.readLevels();
         save.compressionInfo = reader.compressionInfo;
         save.trailingCollectedObjects = reader.trailingCollectedObjects;
         return save;
@@ -62,18 +62,6 @@ class Parser {
         };
         return blueprint;
     }
-    static ProjectSave(save, config) {
-        return {
-            header: save.header,
-            trailingCollectedObjects: save.trailingCollectedObjects,
-            levels: save.levels.map(level => {
-                const lvl = new level_class_1.Level(level.name);
-                lvl.collectables = level.collectables;
-                lvl.objects = level.objects.filter(obj => (0, save_reader_1.projectionFilterApplies)(config, obj));
-                return lvl;
-            })
-        };
-    }
 }
 Parser.JSONStringifyModified = (obj, indent = 0) => JSON.stringify(obj, (key, value) => {
     if (typeof value === 'bigint') {

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

@@ -10,6 +10,7 @@ export declare class BlueprintReader extends ByteReader {
     static ReadHeader(reader: BinaryReadable): BlueprintHeader;
     inflateChunks(): any;
     static ParseObjects(reader: ByteReader): (SaveEntity | SaveComponent)[];
+    private static ReadBlueprintObjectContents;
 }
 export declare class BlueprintConfigReader extends ByteReader {
     bluePrintConfigBuffer: ArrayBuffer;

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

@@ -8,7 +8,10 @@ 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 SaveComponent_1 = require("../objects/SaveComponent");
+const SaveEntity_1 = require("../objects/SaveEntity");
 const level_class_1 = require("../save/level.class");
+const save_reader_1 = require("../save/save-reader");
 const util_types_1 = require("../structs/util.types");
 class BlueprintReader extends byte_reader_class_1.ByteReader {
     constructor(bluePrintBuffer) {
@@ -16,7 +19,7 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
         this.compressionInfo = {
             packageFileTag: 0,
             maxChunkContentSize: 0,
-            chunkHeaderSize: 48
+            chunkHeaderSize: save_reader_1.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
         };
     }
     static ReadHeader(reader) {
@@ -59,8 +62,8 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
             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);
+            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);
@@ -98,9 +101,28 @@ class BlueprintReader extends byte_reader_class_1.ByteReader {
         const objectHeadersBinarySize = reader.readInt32();
         let objects = [];
         level_class_1.Level.ReadObjectHeaders(reader, objects, () => { });
-        level_class_1.Level.ReadObjectContents('', reader, objects, 0, () => { });
+        const suomeChecksumThing = reader.readInt32();
+        BlueprintReader.ReadBlueprintObjectContents('', reader, objects, 0);
+        const pos = reader.getBufferPosition();
+        console.log(pos, reader.getBufferLength(), reader.getBufferProgress());
         return objects;
     }
+    static ReadBlueprintObjectContents(levelName, reader, objectsList, buildVersion) {
+        const countEntities = reader.readInt32();
+        for (let i = 0; i < countEntities; i++) {
+            const len = reader.readInt32();
+            if (len === 0) {
+                throw new parser_error_1.CorruptSaveError(`check number is a wrong value (${len}). This normally indicates a corrupt entity or save.`);
+            }
+            const obj = objectsList[i];
+            if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+            }
+            else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
+            }
+        }
+    }
 }
 exports.BlueprintReader = BlueprintReader;
 class BlueprintConfigReader extends byte_reader_class_1.ByteReader {

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

@@ -4,6 +4,7 @@ import { SaveWriter } from "../save/save-writer";
 import { vec3 } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
 import { AbstractBaseProperty } from "./Property";
+import { SaveObject } from "./SaveObject";
 export type SpecialAnyProperty = {} | PowerLineSpecialProperty;
 export type PowerLineSpecialProperty = {
     num: number;
@@ -27,15 +28,11 @@ export type ConveyorSpecialProperty = {
     items: ItemSpecialProperty[];
 };
 export declare class DataFields {
-    properties: AbstractBaseProperty[];
-    specialProperties: SpecialAnyProperty;
-    trailingData: number[];
-    shouldBeNulled: boolean;
     constructor();
-    static Parse(length: number, reader: BinaryReadable, buildVersion: number, typePath: string): DataFields;
+    static ParseProperties(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
     static ParseAdditionalSpecialProperties(reader: BinaryReadable, typePath: string, remainingLen: number): SpecialAnyProperty;
     static ParseProperty(reader: BinaryReadable, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
-    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number, typePath: string): void;
+    static Serialize(obj: SaveObject, writer: SaveWriter, buildVersion: number, typePath: string): void;
     static SerializeAdditionalSpecialProperties(writer: ByteWriter, typePath: string, property: SpecialAnyProperty): void;
     static SerializeProperty(writer: ByteWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
 }

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

@@ -5,39 +5,32 @@ const util_types_1 = require("../structs/util.types");
 const Property_1 = require("./Property");
 class DataFields {
     constructor() {
-        this.properties = [];
-        this.specialProperties = {};
-        this.trailingData = [];
-        this.shouldBeNulled = false;
     }
-    static Parse(length, reader, buildVersion, typePath) {
+    static ParseProperties(obj, length, reader, buildVersion, typePath) {
         const start = reader.getBufferPosition();
-        const fields = new DataFields();
+        obj.properties = {};
         if (length === 0) {
-            fields.shouldBeNulled = true;
-            return fields;
+            return;
         }
         let propertyName = reader.readString();
         while (propertyName !== 'None') {
             const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
-            fields.properties.push(property);
+            obj.properties[property.name] = property;
             propertyName = reader.readString();
         }
-        let int1 = reader.readInt32();
-        if (int1 !== 0) {
+        let padding = reader.readInt32();
+        if (padding !== 0) {
         }
         const remainingLen = length - (reader.getBufferPosition() - start);
-        const oldRemainingLen = start + length - reader.getBufferPosition() - 4;
-        fields.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, remainingLen);
+        obj.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, remainingLen);
         const end = reader.getBufferPosition();
         const newWayOfCalculatingReminingSize = length - (end - start);
         if (newWayOfCalculatingReminingSize > 0) {
-            reader.readBytes(newWayOfCalculatingReminingSize);
+            obj.trailingData = Array.from(reader.readBytes(newWayOfCalculatingReminingSize));
         }
         else if (newWayOfCalculatingReminingSize < 0) {
-            console.warn(`Unexpected. Did i read too much or is save corrupt !? bytes left to read is ${newWayOfCalculatingReminingSize}`);
+            throw new Error(`Unexpected. Read more bytes than are indicated for this etity. bytes left to read is ${newWayOfCalculatingReminingSize}`);
         }
-        return fields;
     }
     static ParseAdditionalSpecialProperties(reader, typePath, remainingLen) {
         let property;
@@ -180,15 +173,15 @@ class DataFields {
         }
         return currentProperty;
     }
-    static Serialize(writer, fields, buildVersion, typePath) {
-        for (const property of fields.properties) {
+    static Serialize(obj, writer, buildVersion, typePath) {
+        for (const property of Object.values(obj.properties)) {
             writer.writeString(property.name);
             DataFields.SerializeProperty(writer, property, property.name, buildVersion);
         }
         writer.writeString('None');
         writer.writeInt32(0);
-        DataFields.SerializeAdditionalSpecialProperties(writer, typePath, fields.specialProperties);
-        writer.writeBytesArray(fields.trailingData);
+        DataFields.SerializeAdditionalSpecialProperties(writer, typePath, obj.specialProperties);
+        writer.writeBytesArray(obj.trailingData);
     }
     static SerializeAdditionalSpecialProperties(writer, typePath, property) {
         switch (typePath) {

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

@@ -34,23 +34,15 @@ class SaveEntity extends SaveObject_1.SaveObject {
         obj.wasPlacedInLevel = reader.readInt32() == 1;
     }
     static ParseData(entity, length, reader, buildVersion, typePath) {
-        const typeOrWhat = reader.readInt32();
-        const something = reader.readInt32();
         const afterSizeIndicator = reader.getBufferPosition();
-        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;
         }
-        const remainingSize = something - (reader.getBufferPosition() - afterSizeIndicator);
+        const remainingSize = length - (reader.getBufferPosition() - afterSizeIndicator);
         return SaveObject_1.SaveObject.ParseData(entity, remainingSize, reader, buildVersion, typePath);
     }
     static SerializeHeader(writer, entity) {

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

@@ -1,6 +1,7 @@
 import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
-import { DataFields } from "./DataFields";
+import { SpecialAnyProperty } from "./DataFields";
+import { AbstractBaseProperty } from "./Property";
 export interface SaveObjectHeader {
     typePath: string;
     rootObject: string;
@@ -10,7 +11,13 @@ export declare abstract class SaveObject implements SaveObjectHeader {
     typePath: string;
     rootObject: string;
     instanceName: string;
-    dataFields: DataFields;
+    properties: {
+        [name: string]: AbstractBaseProperty;
+    };
+    specialProperties: SpecialAnyProperty;
+    trailingData: number[];
+    unknownType1: number;
+    unknownType2: number;
     constructor(typePath: string, rootObject: string, instanceName: string);
     protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
     protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;

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

@@ -7,7 +7,11 @@ class SaveObject {
         this.typePath = typePath;
         this.rootObject = rootObject;
         this.instanceName = instanceName;
-        this.dataFields = new DataFields_1.DataFields();
+        this.properties = {};
+        this.specialProperties = {};
+        this.trailingData = [];
+        this.unknownType1 = 0;
+        this.unknownType2 = 0;
     }
     static ParseHeader(reader, obj) {
         obj.typePath = reader.readString();
@@ -20,10 +24,10 @@ class SaveObject {
         writer.writeString(obj.instanceName);
     }
     static ParseData(obj, length, reader, buildVersion, typePath) {
-        obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion, typePath);
+        DataFields_1.DataFields.ParseProperties(obj, length, reader, buildVersion, typePath);
     }
     static SerializeData(writer, obj, buildVersion) {
-        DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion, obj.typePath);
+        DataFields_1.DataFields.Serialize(obj, writer, buildVersion, obj.typePath);
     }
 }
 exports.SaveObject = SaveObject;

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

@@ -77,10 +77,8 @@ class Level {
                     break;
             }
         }
-        const unk = reader.readInt32();
     }
     static async ReadObjectContents(levelName, reader, objectsList, buildVersion, onProgressCallback) {
-        const posBefore = reader.getBufferPosition();
         const countEntities = reader.readInt32();
         if (countEntities !== objectsList.length) {
             throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
@@ -89,56 +87,45 @@ class Level {
             if (i % 1000 === 0) {
                 onProgressCallback(reader.getBufferProgress());
             }
-            const len = reader.readInt32();
-            if (len === 0) {
-                throw new Error(`check number is a wrong value (${len}). This normally indicates a corrupt entity or save.`);
-            }
-            const before = reader.getBufferPosition();
             const obj = objectsList[i];
+            obj.unknownType1 = reader.readInt32();
+            obj.unknownType2 = reader.readInt32();
+            const binarySize = reader.readInt32();
+            const before = reader.getBufferPosition();
             if ((0, SaveEntity_1.isSaveEntity)(obj)) {
-                SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                SaveEntity_1.SaveEntity.ParseData(obj, binarySize, reader, buildVersion, obj.typePath);
             }
             else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
-                const wtf1 = reader.readInt32();
-                const wtf2 = reader.readInt32();
-                SaveComponent_1.SaveComponent.ParseData(obj, wtf2, reader, buildVersion, obj.typePath);
+                SaveComponent_1.SaveComponent.ParseData(obj, binarySize, reader, buildVersion, obj.typePath);
             }
             const after = reader.getBufferPosition();
-            if (after - before !== len) {
+            if (after - before !== binarySize) {
+                console.warn('entity may be corrupt', obj.instanceName);
             }
         }
-        const posAfter = reader.getBufferPosition();
     }
     static ReadLevel(reader, levelName, buildVersion) {
         const level = new Level(levelName);
         const levelStartPos = reader.getBufferPosition();
-        const placeholderHead = reader.readInt32();
-        if (placeholderHead === 8) {
-            const morePlaceholder = reader.readBytes(28);
-        }
-        else {
-            reader.skipBytes(-4);
-        }
-        const lookahead1 = reader.readInt32();
-        const lookahead2 = reader.readInt32();
-        if (lookahead1 !== 0 && lookahead2 !== 0) {
-            reader.skipBytes(-8);
-            return level;
-        }
-        else if (lookahead1 !== 0 && lookahead2 === 0) {
-            reader.skipBytes(-8);
-        }
-        else {
-            throw new Error('Unexpected. what now? TODO FIXME');
-        }
-        const binLen = reader.readInt32();
+        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);
+        if (remainingSize > 0) {
+            reader.readBytes(remainingSize);
+        }
+        const objectContentsBinLen = 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();
+        if (posAfterContents - posBeforeContents !== objectContentsBinLen) {
+            console.warn('save seems corrupt.', this.name);
+        }
         reader.onProgressCallback(reader.getBufferProgress());
-        Level.ReadCollectablesList(reader);
+        level.collectables = Level.ReadCollectablesList(reader);
         return level;
     }
     static SerializeCollectablesList(writer, collectables) {

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

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

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.grids = {};
         this.levels = [];
         this.trailingCollectedObjects = [];
         this.header = header;

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

@@ -2,21 +2,15 @@ import { ByteReader } from "../../byte/byte-reader.class";
 import { ChunkCompressionInfo } from "../../file.types";
 import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
 import { ObjectReference } from "../objects/ObjectReference";
-import { SaveComponent } from "../objects/SaveComponent";
-import { SaveEntity } from "../objects/SaveEntity";
 import { Level } from "./level.class";
-import { SatisfactorySaveHeader } from "./save.types";
-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;
+import { RoughSaveVersion, SatisfactorySaveHeader } from "./save.types";
 export type ReadMode = 'stream' | 'whole';
 export declare const DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 49;
+export type Grids = {
+    [parentName: string]: {
+        [level: number]: string[];
+    };
+};
 export declare class SaveReader extends ByteReader {
     onProgressCallback: (progress: number, msg?: string) => void;
     header: SatisfactorySaveHeader | undefined;
@@ -26,10 +20,12 @@ export declare class SaveReader extends ByteReader {
     static readonly EPOCH_TICKS = 621355968000000000n;
     constructor(fileBuffer: ArrayBuffer, onProgressCallback?: (progress: number, msg?: string) => void);
     readHeader(): SatisfactorySaveHeader;
+    static getRoughSaveVersion: (saveVersion: number, headerTypeVersion: number) => RoughSaveVersion;
     inflateChunks(): {
         concatenatedChunkLength: number;
         numChunks: number;
     };
-    readLevelsU8(): Level[];
+    readGrids: () => Grids;
+    readLevels(): Level[];
     readLevelsAsynchronously(writer: SaveStreamWriter): Promise<Level[]>;
 }

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

@@ -3,33 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveReader = exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = exports.projectionFilterApplies = void 0;
+exports.SaveReader = exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 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 SaveComponent_1 = require("../objects/SaveComponent");
-const SaveEntity_1 = require("../objects/SaveEntity");
 const asynchronous_level_class_1 = require("./asynchronous-level.class");
 const level_class_1 = require("./level.class");
-const projectionFilterApplies = (config, object) => {
-    let cond1 = false;
-    if ((0, SaveEntity_1.isSaveEntity)(object) || (config.includeComponents && (0, SaveComponent_1.isSaveComponent)(object))) {
-        cond1 = true;
-    }
-    let cond2 = true;
-    if ((0, SaveEntity_1.isSaveEntity)(object)) {
-        cond2 = false;
-        if (config.entityPathFilter.behavior === 'whitelist') {
-            cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) !== undefined;
-        }
-        else if (config.entityPathFilter.behavior === 'blacklist') {
-            cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) === undefined;
-        }
-    }
-    return cond1 && cond2;
-};
-exports.projectionFilterApplies = projectionFilterApplies;
 exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 49;
 class SaveReader extends byte_reader_class_1.ByteReader {
     constructor(fileBuffer, onProgressCallback = () => { }) {
@@ -42,6 +22,40 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             maxChunkContentSize: 0,
             chunkHeaderSize: exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
         };
+        this.readGrids = () => {
+            const unk = this.readInt32();
+            const cannotBeLevelCountWhatIsIt = this.readInt32();
+            const noneString = this.readString();
+            const unk2 = this.readInt32();
+            const hm1 = this.readInt32();
+            const unk3 = this.readInt32();
+            const noneString2 = this.readString();
+            const grids = {};
+            const readLevelsList = (childrenCount) => {
+                const hmm = this.readInt32();
+                const parentName = this.readString();
+                const whatever1 = this.readInt32();
+                const whatever2 = this.readInt32();
+                grids[parentName] = {};
+                for (let i = 0; i < childrenCount; i++) {
+                    const binaryLenIGuess = this.readInt32();
+                    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(levelInstanceName);
+                }
+            };
+            readLevelsList(1379);
+            readLevelsList(0);
+            readLevelsList(972);
+            readLevelsList(0);
+            readLevelsList(0);
+            const unk5 = this.readInt32();
+            return grids;
+        };
     }
     readHeader() {
         this.header = {
@@ -82,10 +96,7 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             this.header.saveIdentifier = this.readString();
         }
         if (this.header.saveHeaderType >= 13) {
-            const unk1 = this.readInt32();
-            const unk2 = this.readInt32();
-            const unk3 = this.readBytes(16);
-            const unk4 = this.readInt32();
+            this.header.unknownStuff = Array.from(this.readBytes(28));
         }
         if (this.header.saveVersion >= 21) {
         }
@@ -148,7 +159,7 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             numChunks: currentChunks.length
         };
     }
-    readLevelsU8() {
+    readLevels() {
         if (!this.header) {
             throw new parser_error_1.ParserError('ParserError', 'Header must be set before objects can be read.');
         }
@@ -158,36 +169,6 @@ class SaveReader extends byte_reader_class_1.ByteReader {
         if (this.header.saveHeaderType < 13) {
             throw new parser_error_1.UnsupportedVersionError('Game Version < U8 is not supported in this package version. Consider downgrading to the latest package version supporting it, which is 0.0.34');
         }
-        const unk = this.readInt32();
-        const cannotBeLevelCountWhatIsIt = this.readInt32();
-        const noneString = this.readString();
-        const unk2 = this.readInt32();
-        const hm1 = this.readInt32();
-        const unk3 = this.readInt32();
-        const noneString2 = this.readString();
-        const grids = {};
-        const readLevelsList = (childrenCount) => {
-            const hmm = this.readInt32();
-            const parentName = this.readString();
-            const whatever = this.readBytes(8);
-            grids[parentName] = {};
-            for (let i = 0; i < childrenCount; i++) {
-                const binaryLenIGuess = this.readInt32();
-                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(levelInstanceName);
-            }
-        };
-        readLevelsList(1379);
-        readLevelsList(0);
-        readLevelsList(972);
-        readLevelsList(0);
-        readLevelsList(0);
-        const unk5 = this.readInt32();
         const levels = [];
         const levelCount = this.readInt32();
         this.onProgressCallback(this.getBufferProgress(), `reading pack of ${levelCount} levels.`);
@@ -201,6 +182,7 @@ class SaveReader extends byte_reader_class_1.ByteReader {
             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);
@@ -223,4 +205,15 @@ class SaveReader extends byte_reader_class_1.ByteReader {
     }
 }
 SaveReader.EPOCH_TICKS = 621355968000000000n;
+SaveReader.getRoughSaveVersion = (saveVersion, headerTypeVersion) => {
+    if (headerTypeVersion >= 13) {
+        return 'U8+';
+    }
+    else if (saveVersion >= 29) {
+        return 'U6/U7';
+    }
+    else {
+        return '<U6';
+    }
+};
 exports.SaveReader = SaveReader;

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

@@ -38,6 +38,9 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
         if (header.saveHeaderType >= 10) {
             writer.writeString(header.saveIdentifier);
         }
+        if (header.saveHeaderType >= 13) {
+            writer.writeBytesArray(header.unknownStuff);
+        }
         if (header.saveVersion >= 21) {
         }
         else {

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

@@ -21,7 +21,9 @@ export interface SatisfactorySaveHeader {
     isModdedSave?: number;
     saveIdentifier?: string;
     fEditorObjectVersion?: number;
+    unknownStuff?: number[];
 }
+export type RoughSaveVersion = '<U6' | 'U6/U7' | 'U8+';
 export type ResourceNodeEntry = {
     purity: string;
     pathName: string;

package/build/parser/stream/stream-parser.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { Alignment } from "../byte/alignment.enum";
+export declare class StreamParserReader {
+    minBufferSize: number;
+    private buffer;
+    view: DataView;
+    private hasInputStreamEnded;
+    currentByte: number;
+    alignment: Alignment;
+    private inputBuffer;
+    private input;
+    hasDataToRead: boolean;
+    private onInputDataAvailableCallback;
+    constructor(minBufferSize: number);
+    getAmountLeftToRead: () => number;
+    parseLogic: () => Promise<void>;
+    private allocate;
+    private waitForAmountLeftToRead;
+    private wait;
+    private shiftBufferIntoOperatingDataView;
+    private readTilBufferFullOrInputEmpty;
+    startReading(input: Readable): void;
+    skipBytes(byteLength?: number): void;
+    readByte(): number;
+    readBytes(count: number): Uint8Array;
+    readHex(hexLength: number): string;
+    readInt8(): number;
+    readUint8(): number;
+    readInt16(): number;
+    readUint16(): number;
+    readInt32(): number;
+    readUint32(): number;
+    readLong(): bigint;
+    readInt64(): bigint;
+    readUint64(): bigint;
+    readFloat32(): number;
+    readDouble(): number;
+    readString(): string;
+}

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

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamParserReader = void 0;
+const alignment_enum_1 = require("../byte/alignment.enum");
+class StreamParserReader {
+    constructor(minBufferSize) {
+        this.minBufferSize = minBufferSize;
+        this.alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN;
+        this.getAmountLeftToRead = () => {
+            return this.view.byteLength - this.currentByte;
+        };
+        this.parseLogic = async () => {
+            console.log('before allocate 1', this.getAmountLeftToRead(), this.inputBuffer.length);
+            await this.allocate(100000);
+            const unknownStuff = [
+                this.readInt32(),
+                this.readInt32(),
+                this.readString(),
+                this.readInt32(),
+                this.readInt32(),
+                this.readInt32(),
+                this.readString()
+            ];
+            console.log('before allocate 2', unknownStuff, this.getAmountLeftToRead(), this.inputBuffer.length);
+            await this.allocate(10000);
+        };
+        this.allocate = async (amount) => {
+            if (amount > this.minBufferSize) {
+                throw new Error(`Can not attempt to allocate (${amount}) more than the size of the buffer (${this.minBufferSize}) is.`);
+            }
+            if (this.getAmountLeftToRead() >= amount) {
+                return Promise.resolve();
+            }
+            return new Promise((resolve, reject) => {
+                console.log('Waiting for allocate', amount, this.getAmountLeftToRead());
+                this.readTilBufferFullOrInputEmpty();
+                console.log('shift?', this.inputBuffer.length);
+                if (this.inputBuffer.length > 0 && this.inputBuffer.length + this.getAmountLeftToRead() >= amount) {
+                    this.shiftBufferIntoOperatingDataView();
+                    return resolve();
+                }
+                this.onInputDataAvailableCallback = () => {
+                    console.log('on available callback.', this.inputBuffer.length, this.getAmountLeftToRead(), amount);
+                    if (this.inputBuffer.length > 0 && this.inputBuffer.length + this.getAmountLeftToRead() >= amount) {
+                        this.shiftBufferIntoOperatingDataView();
+                        console.log(this.getAmountLeftToRead());
+                        this.onInputDataAvailableCallback = undefined;
+                        return resolve();
+                    }
+                };
+            });
+        };
+        this.waitForAmountLeftToRead = async (amount, callback = () => { }) => {
+            while (this.getAmountLeftToRead() < amount) {
+                if (this.hasInputStreamEnded) {
+                    throw new Error(`Unexpected end of stream. Waited to read ${amount} but stream ended prematurely.`);
+                }
+                console.log('###waiting... for ', amount);
+                this.readTilBufferFullOrInputEmpty();
+                if (this.inputBuffer.length > 0) {
+                    console.log('###shift.');
+                    this.shiftBufferIntoOperatingDataView();
+                }
+                await this.wait(20);
+            }
+            console.log('amount left to read is no longer smaller than', amount, this.getAmountLeftToRead());
+            callback();
+        };
+        this.wait = (ms) => new Promise((resolve, reject) => {
+            setTimeout(() => {
+                return resolve(ms);
+            }, ms);
+        });
+        this.shiftBufferIntoOperatingDataView = (amountOfTrailingBytesToKeep = 300) => {
+            const resultingTrailingBytes = Math.min(this.currentByte, amountOfTrailingBytesToKeep);
+            const trailingPlusLeftToRead = new Uint8Array(this.buffer.slice(this.currentByte - resultingTrailingBytes));
+            const { length, ...chunks } = this.inputBuffer;
+            const inBuffer = new Uint8Array(Buffer.concat(Object.values(chunks)));
+            this.inputBuffer = { length: 0 };
+            this.buffer = new Uint8Array(trailingPlusLeftToRead.byteLength + inBuffer.byteLength);
+            this.buffer.set(trailingPlusLeftToRead, 0);
+            this.buffer.set(inBuffer, trailingPlusLeftToRead.byteLength);
+            this.currentByte = resultingTrailingBytes;
+            this.view = new DataView(this.buffer.buffer);
+        };
+        this.readTilBufferFullOrInputEmpty = () => {
+            let chunk;
+            console.log(this.hasDataToRead, this.inputBuffer.length, this.minBufferSize);
+            while (this.hasDataToRead && this.inputBuffer.length < this.minBufferSize && (chunk = this.input.read()) != null) {
+                console.log('reading chunk', chunk);
+                this.inputBuffer[chunk.byteLength] = chunk;
+                this.inputBuffer.length += chunk.length;
+            }
+            if (chunk === null) {
+                console.log('chunk is null, input empty for now.');
+                this.hasDataToRead = false;
+            }
+            else if (this.inputBuffer.length >= this.minBufferSize) {
+                console.log('buffer is full, ignoring for now.', this.inputBuffer.length);
+            }
+            console.log('data available callback?', this.onInputDataAvailableCallback);
+            if (this.onInputDataAvailableCallback) {
+                this.onInputDataAvailableCallback();
+            }
+        };
+        this.buffer = new Uint8Array(0);
+        this.view = new DataView(this.buffer.buffer);
+        this.currentByte = 0;
+        this.hasInputStreamEnded = false;
+        this.inputBuffer = { length: 0 };
+        this.hasDataToRead = false;
+    }
+    startReading(input) {
+        this.input = input;
+        this.input.pause();
+        this.input.on('readable', () => {
+            console.log('on readable. Reading til buffer full or input empty.');
+            this.hasDataToRead = true;
+            this.readTilBufferFullOrInputEmpty();
+        });
+        this.input.on('end', () => {
+            this.hasDataToRead = false;
+            this.hasInputStreamEnded = true;
+        });
+        this.input.on('close', () => {
+            this.hasDataToRead = false;
+            this.hasInputStreamEnded = true;
+        });
+    }
+    skipBytes(byteLength = 1) {
+        this.currentByte += byteLength;
+        return;
+    }
+    readByte() {
+        return parseInt(this.view.getUint8(this.currentByte++).toString());
+    }
+    readBytes(count) {
+        return new Uint8Array(new Array(count).fill(0).map(pl => this.view.getUint8(this.currentByte++)));
+    }
+    readHex(hexLength) {
+        let hexPart = [];
+        for (let i = 0; i < hexLength; i++) {
+            let currentHex = String.fromCharCode(this.view.getUint8(this.currentByte++));
+            hexPart.push(currentHex);
+        }
+        return hexPart.join('');
+    }
+    readInt8() {
+        let data = this.view.getInt8(this.currentByte++);
+        return data;
+    }
+    readUint8() {
+        let data = this.view.getUint8(this.currentByte++);
+        return data;
+    }
+    readInt16() {
+        let data = this.view.getInt16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readUint16() {
+        let data = this.view.getUint16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readInt32() {
+        let data = this.view.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readUint32() {
+        let data = this.view.getUint32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readLong() {
+        let data = this.view.getBigInt64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readInt64() {
+        return this.readLong();
+    }
+    readUint64() {
+        let data = this.view.getBigUint64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readFloat32() {
+        let data = this.view.getFloat32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readDouble() {
+        let data = this.view.getFloat64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readString() {
+        let strLength = this.readInt32();
+        if (strLength === 0) {
+            return '';
+        }
+        if (strLength > (this.view.buffer.byteLength - this.currentByte)) {
+            let errorMessage = `Cannot read string of length ${strLength} at position ${this.currentByte} as it exceeds the end at ${this.view.buffer.byteLength}`;
+            throw new Error(errorMessage);
+        }
+        if (strLength < 0) {
+            const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
+            this.currentByte += 2;
+            return string.join('');
+        }
+        try {
+            const string = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.readUint8()));
+            this.currentByte += 1;
+            return string.join('');
+        }
+        catch (error) {
+            let errorMessage = `Cannot read UTF8 string of length ${strLength} at position ${this.currentByte}.`;
+            console.log(errorMessage, error);
+            throw error;
+        }
+    }
+}
+exports.StreamParserReader = StreamParserReader;

package/package.json

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