@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

package/build/parser/save-reader.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conveyor = exports.SaveReader = exports.projectionFilterApplies = void 0;
+const pako_1 = __importDefault(require("pako"));
+const alignment_enum_1 = require("./byte/alignment.enum");
+const byte_reader_class_1 = require("./byte/byte-reader.class");
+const parser_error_1 = require("./error/parser.error");
+const level_class_1 = require("./satisfactory/level.class");
+const SaveComponent_1 = require("./satisfactory/objects/SaveComponent");
+const SaveEntity_1 = require("./satisfactory/objects/SaveEntity");
+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;
+class SaveReader extends byte_reader_class_1.ByteReader {
+    constructor(fileBuffer, onProgressCallback = () => { }) {
+        super(fileBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.onProgressCallback = onProgressCallback;
+        this.levels = [];
+        this.trailingCollectedObjects = [];
+        this.compressionInfo = {
+            packageFileTag: 0,
+            maxChunkContentSize: 0,
+            chunkHeaderSize: 48
+        };
+    }
+    readHeader() {
+        this.header = {
+            saveHeaderType: 0,
+            saveVersion: 0,
+            buildVersion: 0,
+            mapName: "DEFAULT",
+            mapOptions: "",
+            sessionName: "",
+            playDurationSeconds: 0,
+            saveDateTime: "0",
+            sessionVisibility: 0
+        };
+        this.header.saveHeaderType = this.readInt32();
+        this.header.saveVersion = this.readInt32();
+        this.header.buildVersion = this.readInt32();
+        this.header.mapName = this.readString();
+        this.header.mapOptions = this.readString();
+        this.header.sessionName = this.readString();
+        this.header.playDurationSeconds = this.readInt32();
+        const rawSaveDateTimeInTicks = this.readLong();
+        const unixMilliseconds = (rawSaveDateTimeInTicks - SaveReader.EPOCH_TICKS) / 10000n;
+        this.header.saveDateTime = unixMilliseconds.toString();
+        this.header.sessionVisibility = this.readByte();
+        if (this.header.saveHeaderType >= 7) {
+            this.header.fEditorObjectVersion = this.readInt32();
+        }
+        if (this.header.saveHeaderType >= 8) {
+            this.header.rawModMetadataString = this.readString();
+            try {
+                this.header.modMetadata = JSON.parse(this.header.rawModMetadataString);
+            }
+            catch (error) {
+                //
+            }
+            this.header.isModdedSave = this.readInt32();
+        }
+        if (this.header.saveHeaderType >= 10) {
+            this.header.saveIdentifier = this.readString();
+        }
+        if (this.header.saveVersion >= 21) {
+            // all good, ready to read chunks now.
+        }
+        else {
+            throw new parser_error_1.UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
+        }
+        return this.header;
+    }
+    inflateChunks() {
+        // free memory
+        this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+        this.handledByte = 0;
+        this.currentByte = 0;
+        this.maxByte = this.fileBuffer.byteLength;
+        let currentChunks = [];
+        let totalUncompressedBodySize = 0;
+        // read while we can handle
+        while (this.handledByte < this.maxByte) {
+            // Read chunk info size...
+            let chunkHeader = new DataView(this.fileBuffer.slice(0, this.compressionInfo.chunkHeaderSize));
+            this.currentByte = this.compressionInfo.chunkHeaderSize;
+            this.handledByte += this.compressionInfo.chunkHeaderSize;
+            if (this.compressionInfo.packageFileTag <= 0) {
+                this.compressionInfo.packageFileTag = chunkHeader.getInt32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            totalUncompressedBodySize += chunkUncompressedLength;
+            const currentChunkSize = chunkCompressedLength;
+            let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);
+            this.handledByte += currentChunkSize;
+            this.currentByte += currentChunkSize;
+            // Free memory from previous chunk...
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.currentByte = 0;
+            // Unzip!
+            try {
+                // Inflate current chunk
+                let currentInflatedChunk = null;
+                currentInflatedChunk = pako_1.default.inflate(currentChunk);
+                currentChunks.push(currentInflatedChunk);
+            }
+            catch (err) {
+                throw new parser_error_1.CompressionLibraryError("Failed to inflate compressed save data. " + err);
+            }
+        }
+        //TODO we can get rid of file buffer here.
+        // Create one big chunk out of the little chunks
+        let newChunkLength = currentChunks.map(cc => cc.length).reduce((prev, cur) => prev + cur);
+        const bigWholeChunk = new Uint8Array(newChunkLength);
+        let currentLength = 0;
+        for (let i = 0; i < currentChunks.length; i++) {
+            bigWholeChunk.set(currentChunks[i], currentLength);
+            currentLength += currentChunks[i].length;
+        }
+        this.currentByte = 0;
+        this.maxByte = bigWholeChunk.buffer.byteLength;
+        this.bufferView = new DataView(bigWholeChunk.buffer);
+        const dataLength = this.readInt32();
+        if (totalUncompressedBodySize !== dataLength + 4) {
+            throw new parser_error_1.CorruptSaveError(`Possibly corrupt. Indicated size of total save body (${dataLength}) does not match the uncompressed real size of ${totalUncompressedBodySize}.`);
+        }
+        return {
+            concatenatedChunkLength: newChunkLength,
+            numChunks: currentChunks.length
+        };
+    }
+    readLevels() {
+        if (!this.header) {
+            throw new parser_error_1.ParserError('ParserError', 'Header must be set before objects can be read.');
+        }
+        if (this.header.saveVersion < 29) {
+            throw new parser_error_1.UnsupportedVersionError('Support for < U6 is not yet implemented.');
+        }
+        const numSubLevels = this.readInt32();
+        this.levels = new Array(numSubLevels + 1);
+        // read levels
+        for (let j = 0; j <= numSubLevels; j++) {
+            let levelName = (j === numSubLevels) ? '' + this.header.mapName : this.readString();
+            this.onProgressCallback(this.getBufferProgress(), `reading level [${(j + 1)}/${(numSubLevels + 1)}] ${levelName}`);
+            this.levels[j] = level_class_1.Level.ReadLevel(this, levelName, this.header.buildVersion);
+        }
+        // in U6/U7 there were more collectibles added that do not belong to a particular level
+        if (this.getBufferPosition() < this.bufferView.byteLength) {
+            this.trailingCollectedObjects = level_class_1.Level.ReadCollectablesList(this);
+        }
+        return this.levels;
+    }
+}
+// the number of .net ticks at the unix epoch
+SaveReader.EPOCH_TICKS = 621355968000000000n;
+exports.SaveReader = SaveReader;
+class Conveyor {
+    static getConveyorBeltRegex() {
+        return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorBeltMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
+    }
+    ;
+    static getConveyorLiftRegex() {
+        return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorLiftMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
+    }
+    ;
+    static isAConveyorBelt(obj) {
+        return obj.typePath.match(this.getConveyorBeltRegex()) !== null;
+    }
+    static isAConveyorLift(obj) {
+        return obj.typePath.match(this.getConveyorLiftRegex()) !== null;
+    }
+    static get availableConnections() { return ['.ConveyorAny0', '.ConveyorAny1', '.Input0', '.Input1', '.Input2', '.Input3', '.InPut3', '.Input4', '.Input5', '.Input6', '.Output0', '.Output1', '.Output2', '.Output3']; }
+    static get availableConveyorBelts() {
+        return [
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C'
+        ];
+    }
+    static get availableConveyorLifts() {
+        return [
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C'
+        ];
+    }
+    /*
+     * BELT/LIFT LOOKUP, includes mods to avoid finding them everywhere
+     */
+    static isConveyor(currentObject) {
+        return Conveyor.isConveyorBelt(currentObject) || Conveyor.isConveyorLift(currentObject);
+    }
+    static isConveyorBelt(currentObject) {
+        if (Conveyor.availableConveyorBelts.includes(currentObject.className)) {
+            return true;
+        }
+        // Belts Mod
+        if (currentObject.className.startsWith('/Conveyors_Mod/Build_BeltMk')
+            || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_BeltMk')
+            || currentObject.className.startsWith('/UltraFastLogistics/Buildable/build_conveyorbeltMK')
+            || currentObject.className.startsWith('/FlexSplines/Conveyor/Build_Belt')
+            || currentObject.className.startsWith('/conveyorbeltmod/Belt/mk')
+            || currentObject.className.startsWith('/minerplus/content/buildable/Factory/belt_')
+            || currentObject.className.startsWith('/bamfp/content/buildable/Factory/belt_')) {
+            return true;
+        }
+        return false;
+    }
+    static isConveyorLift(currentObject) {
+        if (Conveyor.availableConveyorLifts.includes(currentObject.className)) {
+            return true;
+        }
+        // Lifts Mod
+        if (currentObject.className.startsWith('/minerplus/content/buildable/Factory/lift')
+            || currentObject.className.startsWith('/bamfp/content/buildable/Factory/lift')
+            || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_LiftMk')
+            || currentObject.className.startsWith('/Conveyors_Mod/Build_LiftMk')
+            || currentObject.className.startsWith('/Game/CoveredConveyor')
+            || currentObject.className.startsWith('/CoveredConveyor')
+            || currentObject.className.startsWith('/conveyorbeltmod/lift/')) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.Conveyor = Conveyor;

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

@@ -0,0 +1,22 @@
+import { Alignment } from "./byte/alignment.enum";
+import { ByteWriter } from "./byte/byte-writer.class";
+import { ChunkCompressionInfo, SatisfactorySave, SatisfactorySaveHeader } from "./satisfactory/satisfactory-save";
+export declare class SaveWriter extends ByteWriter {
+    constructor();
+    static WriteHeader(writer: ByteWriter, header: SatisfactorySaveHeader): void;
+    static WriteLevels(writer: ByteWriter, save: SatisfactorySave, buildVersion: number): void;
+    static GenerateCompressedChunksFromData(bufferArray: ArrayBuffer, compressionInfo: ChunkCompressionInfo, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void, alignment?: Alignment): void;
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void): void;
+}

package/build/parser/save-writer.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveWriter = void 0;
+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 level_class_1 = require("./satisfactory/level.class");
+class SaveWriter extends byte_writer_class_1.ByteWriter {
+    constructor() {
+        super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+    }
+    static WriteHeader(writer, header) {
+        writer.writeInt32(header.saveHeaderType);
+        writer.writeInt32(header.saveVersion);
+        writer.writeInt32(header.buildVersion);
+        writer.writeString(header.mapName);
+        writer.writeString(header.mapOptions);
+        writer.writeString(header.sessionName);
+        writer.writeInt32(header.playDurationSeconds);
+        writer.writeInt64(BigInt(header.saveDateTime));
+        writer.writeByte(header.sessionVisibility);
+        if (header.saveHeaderType >= 7) {
+            writer.writeInt32(header.fEditorObjectVersion);
+        }
+        if (header.saveHeaderType >= 8) {
+            if (header.modMetadata) {
+                writer.writeString(JSON.stringify(header.modMetadata));
+            }
+            else {
+                writer.writeString(header.rawModMetadataString);
+            }
+            writer.writeInt32(header.isModdedSave);
+        }
+        if (header.saveHeaderType >= 10) {
+            writer.writeString(header.saveIdentifier);
+        }
+        if (header.saveVersion >= 21) {
+            // ready to write levels now.
+        }
+        else {
+            throw new parser_error_1.UnsupportedVersionError("The save version is too old to be supported currently.");
+        }
+    }
+    static WriteLevels(writer, save, buildVersion) {
+        writer.writeInt32(save.levels.length - 1);
+        for (const level of save.levels) {
+            if (level.name !== save.header.mapName) {
+                writer.writeString(level.name);
+            }
+            level_class_1.Level.WriteLevel(writer, level, buildVersion);
+        }
+        level_class_1.Level.SerializeCollectablesList(writer, save.trailingCollectedObjects);
+    }
+    static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
+        const errors = [];
+        const totalUncompressedSize = bufferArray.byteLength;
+        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);
+        onBinaryBeforeCompressing(saveBody.buffer);
+        // collect slices of chunks with help of compression info for max chunk size
+        let handledByte = 0;
+        const chunkSummary = [];
+        while (handledByte < saveBody.byteLength) {
+            // create uncompressed chunk.
+            const uncompressedContentSize = Math.min(compressionInfo.maxChunkContentSize, saveBody.byteLength - handledByte);
+            const uncompressedChunk = saveBody.buffer.slice(handledByte, handledByte + uncompressedContentSize);
+            // deflate chunk while we're at it.
+            let compressedChunk = new Uint8Array(0);
+            try {
+                compressedChunk = pako_1.default.deflate(uncompressedChunk);
+            }
+            catch (err) {
+                errors.push("An error occurred while calling pako deflate. -> " + err);
+            }
+            const chunk = new Uint8Array(compressionInfo.chunkHeaderSize + compressedChunk.byteLength);
+            chunk.set(compressedChunk, compressionInfo.chunkHeaderSize);
+            // write header
+            const view = new DataView(chunk.buffer);
+            view.setInt32(0, compressionInfo.packageFileTag, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(4, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            view.setInt32(8, compressionInfo.maxChunkContentSize, 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);
+            onChunk(chunk);
+            chunkSummary.push({
+                uncompressedSize: uncompressedContentSize + compressionInfo.chunkHeaderSize,
+                compressedSize: compressedChunk.byteLength + compressionInfo.chunkHeaderSize
+            });
+            handledByte += uncompressedContentSize;
+        }
+        onFinish({
+            errors,
+            chunkSummary
+        });
+    }
+    generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
+        if (posAfterHeader <= 0) {
+            throw new parser_error_1.ParserError('ParserError', 'Seems like this buffer has no header. Please write the header first before you can generate chunks.');
+        }
+        // send plain header first.
+        const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
+        onHeader(header);
+        // create save body
+        this.bufferArray = this.bufferArray.slice(posAfterHeader);
+        SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, this.alignment);
+    }
+}
+exports.SaveWriter = SaveWriter;

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.0.10",
+	"version": "0.0.12",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
-	"main": "index.js",
+	"main": "build/index.js",
 	"keywords": [
 		"satisfactory",
 		"save",
@@ -15,7 +15,7 @@
 	"scripts": {
 		"test": "jest --config=jest.config.json",
 		"build": "tsc",
-		"prepublish": "rollup -c && npm version patch"
+		"prepublish": "npm version patch"
 	},
 	"repository": {
 		"type": "git",