@etothepii/satisfactory-file-parser/build/parser/satisfactory/save/asynchronous-level.class.js

A file parser for satisfactory files. Includes save files and blueprint files.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsynchronousLevel = void 0;
const SaveComponent_1 = require("../objects/SaveComponent");
const SaveEntity_1 = require("../objects/SaveEntity");
const level_class_1 = require("./level.class");
class AsynchronousLevel {
    static async StreamReadObjectContents(reader, objectsList, buildVersion, writer, onProgressCallback) {
        const binarySize = reader.readInt32();
        const posBefore = reader.getBufferPosition();
        await reader.allocate(binarySize);
        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}`);
        }
        let dynamicObjectBatch = [];
        for (let i = 0; i < countEntities; i++) {
            if (i % 1000 === 0) {
                console.log(`having some objects, writing ${i + 1}/${countEntities}.`);
                onProgressCallback(reader.getBufferProgress());
                await writer.writeObjects(...dynamicObjectBatch);
                dynamicObjectBatch = [];
            }
            const len = reader.readInt32();
            const before = reader.getBufferPosition();
            if (len < reader.getAmountAllocatedLeft()) {
                await reader.allocate(Math.max(before - binarySize, 300 * 1000 * 1000));
            }
            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);
            }
            dynamicObjectBatch.push(obj);
            const after = reader.getBufferPosition();
            if (after - before !== len) {
                console.warn('entity may be corrupt', this.name, i);
            }
        }
        await writer.writeObjects(...dynamicObjectBatch);
        const posAfter = reader.getBufferPosition();
        if (posAfter - posBefore !== binarySize) {
            console.warn('save seems corrupt.', this.name);
        }
    }
    static async StreamReadLevel(reader, levelName, buildVersion, writer) {
        const level = new level_class_1.Level(levelName);
        const binaryLength = reader.readInt32();
        await reader.allocate(binaryLength);
        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, 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, undefined);
        await writer.endLevel();
        return level;
    }
}
exports.AsynchronousLevel = AsynchronousLevel;