@divinevoxel/vlox 0.0.74 → 0.0.76

package/World/Archive/Functions/JSON/ExportArchivedAreaJSON.js

@@ -0,0 +1,100 @@
+import { BinaryBuffer, BinaryBufferCompresedTypes, } from "../../../../Util/BinaryBuffer";
+import { lightSegments } from "../Shared/LightSegments";
+async function ConvertSection(section, parentObject, parentObjectKey) {
+    const jsonSection = {
+        buffers: {},
+    };
+    if (section.flags)
+        jsonSection.flags = section.flags;
+    if (section.palettes) {
+        const palettes = {};
+        if (section.palettes.id)
+            palettes.id = await BinaryBuffer.ToJSON(section.palettes.id);
+        if (section.palettes.level)
+            palettes.level = await BinaryBuffer.ToJSON(section.palettes.level);
+        if (section.palettes.secondary)
+            palettes.secondary = await BinaryBuffer.ToJSON(section.palettes.secondary);
+        for (const segment of lightSegments) {
+            if (section.palettes?.light?.[segment]) {
+                palettes.light ??= {};
+                palettes.light[segment] = await BinaryBuffer.ToJSON(section.palettes.light[segment]);
+            }
+        }
+        jsonSection.palettes = palettes;
+    }
+    if (section.buffers.id) {
+        jsonSection.buffers.id = await BinaryBuffer.ToJSON(section.buffers.id, BinaryBufferCompresedTypes.Gzip);
+    }
+    if (section.buffers.level) {
+        jsonSection.buffers.level = await BinaryBuffer.ToJSON(section.buffers.level, BinaryBufferCompresedTypes.Gzip);
+    }
+    for (const segment of lightSegments) {
+        if (section.buffers.light?.[segment]) {
+            jsonSection.buffers.light ??= {};
+            jsonSection.buffers.light[segment] = await BinaryBuffer.ToJSON(section.buffers.light[segment], BinaryBufferCompresedTypes.Gzip);
+        }
+    }
+    if (section.buffers.secondary) {
+        jsonSection.buffers.secondary = await BinaryBuffer.ToJSON(section.buffers.secondary, BinaryBufferCompresedTypes.Gzip);
+    }
+    parentObject[parentObjectKey] = jsonSection;
+}
+async function ConvertSector(sector, sectorArray, index) {
+    const palettes = {
+        id: sector.palettes.id,
+        voxelPalette: await BinaryBuffer.ToJSON(sector.palettes.voxelPalette),
+        light: {},
+    };
+    if (sector.palettes.level) {
+        palettes.level = await BinaryBuffer.ToJSON(sector.palettes.level);
+    }
+    if (sector.palettes.light) {
+        palettes.light = {};
+        for (const segment of lightSegments) {
+            if (sector.palettes.light[segment]) {
+                palettes.light[segment] = await BinaryBuffer.ToJSON(sector.palettes.light[segment]);
+            }
+        }
+    }
+    const jsonSector = {
+        position: sector.position,
+        flags: sector.flags,
+        timestamps: sector.timestamps,
+        palettes,
+        sections: [],
+        duplicates: {
+            sections: {},
+        },
+    };
+    const proms = [];
+    for (let i = 0; i < sector.sections.length; i++) {
+        const section = sector.sections[i];
+        if (typeof section === "string") {
+            jsonSector.sections[i] = section;
+            continue;
+        }
+        proms.push(ConvertSection(section, jsonSector.sections, i));
+    }
+    for (const key in sector.duplicates.sections) {
+        const section = sector.duplicates.sections[key];
+        proms.push(ConvertSection(section, jsonSector.duplicates.sections, key));
+    }
+    await Promise.all(proms);
+    sectorArray[index] = jsonSector;
+}
+export default async function ExportArchivedAreaJSON(data) {
+    const archivedData = {
+        dimension: data.dimension,
+        engineVersion: data.engineVersion,
+        formatVersion: data.formatVersion,
+        dataKey: data.dataKey,
+        palettes: data.palettes,
+        sectors: [],
+    };
+    const proms = [];
+    for (let i = 0; i < data.sectors.length; i++) {
+        proms.push(ConvertSector(data.sectors[i], archivedData.sectors, i));
+    }
+    await Promise.all(proms);
+    return archivedData;
+}

package/World/Archive/Functions/JSON/ImportArchivedAreaJSON.d.ts

@@ -0,0 +1,2 @@
+import { ArchivedAreaData, ArchivedAreaJSONData } from "../../Types/index";
+export default function ImportArchivedAreaJSON(data: ArchivedAreaJSONData): Promise<ArchivedAreaData>;

package/World/Archive/Functions/JSON/ImportArchivedAreaJSON.js

@@ -0,0 +1,100 @@
+import { BinaryBuffer } from "../../../../Util/BinaryBuffer";
+import { lightSegments } from "../Shared/LightSegments";
+async function ConvertSection(jsonSection, parentObject, parentObjectKey) {
+    const section = {
+        buffers: {},
+    };
+    if (jsonSection.flags)
+        section.flags = jsonSection.flags;
+    if (jsonSection.palettes) {
+        const palettes = {};
+        if (jsonSection.palettes.id)
+            palettes.id = await BinaryBuffer.FromJSON(jsonSection.palettes.id);
+        if (jsonSection.palettes.level)
+            palettes.level = await BinaryBuffer.FromJSON(jsonSection.palettes.level);
+        if (jsonSection.palettes.secondary)
+            palettes.secondary = await BinaryBuffer.FromJSON(jsonSection.palettes.secondary);
+        for (const segment of lightSegments) {
+            if (jsonSection.palettes?.light?.[segment]) {
+                palettes.light ??= {};
+                palettes.light[segment] = await BinaryBuffer.FromJSON(jsonSection.palettes.light[segment]);
+            }
+        }
+        section.palettes = palettes;
+    }
+    if (jsonSection.buffers.id) {
+        section.buffers.id = await BinaryBuffer.FromJSON(jsonSection.buffers.id);
+    }
+    if (jsonSection.buffers.level) {
+        section.buffers.level = await BinaryBuffer.FromJSON(jsonSection.buffers.level);
+    }
+    for (const segment of lightSegments) {
+        if (jsonSection.buffers.light?.[segment]) {
+            section.buffers.light ??= {};
+            section.buffers.light[segment] = await BinaryBuffer.FromJSON(jsonSection.buffers.light[segment]);
+        }
+    }
+    if (jsonSection.buffers.secondary) {
+        section.buffers.secondary = await BinaryBuffer.FromJSON(jsonSection.buffers.secondary);
+    }
+    parentObject[parentObjectKey] = section;
+}
+async function ConvertSector(jsonSector, sectorArray, index) {
+    const palettes = {
+        id: jsonSector.palettes.id,
+        voxelPalette: await BinaryBuffer.FromJSON(jsonSector.palettes.voxelPalette),
+        light: {},
+    };
+    if (jsonSector.palettes.level) {
+        palettes.level = await BinaryBuffer.FromJSON(jsonSector.palettes.level);
+    }
+    if (jsonSector.palettes.light) {
+        palettes.light = {};
+        for (const segment of lightSegments) {
+            if (jsonSector.palettes.light[segment]) {
+                palettes.light[segment] = await BinaryBuffer.FromJSON(jsonSector.palettes.light[segment]);
+            }
+        }
+    }
+    const sector = {
+        position: jsonSector.position,
+        flags: jsonSector.flags,
+        timestamps: jsonSector.timestamps,
+        palettes,
+        sections: [],
+        duplicates: {
+            sections: {},
+        },
+    };
+    const proms = [];
+    for (let i = 0; i < jsonSector.sections.length; i++) {
+        const section = jsonSector.sections[i];
+        if (typeof section === "string") {
+            sector.sections[i] = section;
+            continue;
+        }
+        proms.push(ConvertSection(section, sector.sections, i));
+    }
+    for (const key in jsonSector.duplicates.sections) {
+        const section = jsonSector.duplicates.sections[key];
+        proms.push(ConvertSection(section, sector.duplicates.sections, key));
+    }
+    await Promise.all(proms);
+    sectorArray[index] = sector;
+}
+export default async function ImportArchivedAreaJSON(data) {
+    const archivedData = {
+        dimension: data.dimension,
+        engineVersion: data.engineVersion,
+        formatVersion: data.formatVersion,
+        dataKey: data.dataKey,
+        palettes: data.palettes,
+        sectors: [],
+    };
+    const proms = [];
+    for (let i = 0; i < data.sectors.length; i++) {
+        proms.push(ConvertSector(data.sectors[i], archivedData.sectors, i));
+    }
+    await Promise.all(proms);
+    return archivedData;
+}

package/World/Archive/Functions/Sector/ArchiveSector.d.ts

@@ -0,0 +1,7 @@
+import { LocationData } from "../../../../Math";
+import { ArchivedSectorData } from "../../Types/index";
+type ArchiveSectorProps = {
+    location: LocationData;
+};
+export default function ArchiveSector(archiveData: ArchiveSectorProps): ArchivedSectorData;
+export {};

package/World/Archive/Functions/Sector/ArchiveSector.js

@@ -0,0 +1,209 @@
+import { WorldRegister } from "../../../../World/WorldRegister";
+import { VoxelTagsRegister } from "../../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
+import { BinaryBuffer, BinaryBufferConstants, BinaryBufferFormat, } from "../../../../Util/BinaryBuffer/index";
+import { getBaseData, lightSegments, lightSemgnetGet } from "../Shared/index";
+import { ProcessedSection, SectorPalette } from "../../Classes/ArchiveClasses";
+import { CreateArchivedSection } from "./CreateArchivedSection";
+import { RemoveDuplicateSections } from "./RemoveDuplicateSections";
+import { VoxelPalettesRegister } from "../../../../Voxels/Data/VoxelPalettesRegister";
+const lightData = new VoxelLightData();
+export default function ArchiveSector(archiveData) {
+    const sector = WorldRegister.sectors.get(archiveData.location[0], archiveData.location[1], archiveData.location[2], archiveData.location[3]);
+    if (!sector)
+        throw new Error(`Sector at location ${location} does not exist when trying to arhicve it.`);
+    const sectorPalettes = new SectorPalette();
+    const processedSections = [];
+    for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
+        const section = sector.sections[sectionIndex];
+        const processedSection = new ProcessedSection(section);
+        const firstId = section.ids[0];
+        const firstLight = section.light[0];
+        const firstLevel = section.level[0];
+        const firstSecondary = section.secondary[0];
+        const firstLightLevels = {
+            sun: lightData.getS(firstLight),
+            red: lightData.getR(firstLight),
+            green: lightData.getG(firstLight),
+            blue: lightData.getB(firstLight),
+        };
+        const length = section.ids.length;
+        for (let i = 0; i < length; i++) {
+            const voxelId = sectorPalettes.voxels.register(section.ids[i]);
+            processedSection.voxels.value = voxelId;
+            if (!processedSection.palettes.voxels.isRegistered(voxelId))
+                processedSection.palettes.voxels.register(voxelId);
+            let voxelSecondary = 0;
+            if (VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxels[section.ids[i]][0]]["dve_can_have_secondary"]) {
+                voxelSecondary = sectorPalettes.voxels.register(section.secondary[i]);
+                if (!processedSection.palettes.secondaryVoxels.isRegistered(voxelSecondary))
+                    processedSection.palettes.secondaryVoxels.register(voxelSecondary);
+            }
+            const voxelLevel = !sectorPalettes.level.isRegistered(section.level[i])
+                ? sectorPalettes.level.register(section.level[i])
+                : sectorPalettes.level.getId(section.level[i]);
+            if (!processedSection.palettes.level.isRegistered(section.level[i]))
+                processedSection.palettes.level.register(section.level[i]);
+            for (let l = 0; l < lightSegments.length; l++) {
+                const segment = lightSegments[l];
+                const light = lightSemgnetGet[segment](section.light[i]);
+                if (light != firstLightLevels[segment])
+                    processedSection.light[segment].allTheSame = false;
+                processedSection.light[segment].value = light;
+                const voxelLight = !sectorPalettes.light[segment].isRegistered(light)
+                    ? sectorPalettes.light[segment].register(light)
+                    : sectorPalettes.light[segment].getId(light);
+                if (!processedSection.palettes.light[segment].isRegistered(light))
+                    processedSection.palettes.light[segment].register(light);
+                processedSection.light[segment].buffer[i] = voxelLight;
+            }
+            if (section.ids[i] != firstId)
+                processedSection.voxels.allTheSame = false;
+            if (section.level[i] != firstLevel)
+                processedSection.level.allTheSame = false;
+            if (section.secondary[i] != firstSecondary)
+                processedSection.secondaryVoxels.allTheSame = false;
+            processedSection.voxels.buffer[i] = voxelId;
+            processedSection.level.buffer[i] = voxelLevel;
+            processedSection.secondaryVoxels.buffer[i] = voxelSecondary;
+        }
+        processedSections[sectionIndex] = processedSection;
+    }
+    let neededPalettes = {
+        level: false,
+        light: {
+            sun: false,
+            red: false,
+            green: false,
+            blue: false,
+        },
+    };
+    for (const archivedSection of processedSections) {
+        //ids
+        archivedSection.voxels.isPaletted =
+            sectorPalettes.voxels.size <= BinaryBufferConstants.ByteArrayMax ||
+                archivedSection.palettes.voxels.size <=
+                    BinaryBufferConstants.ByteArrayMax;
+        archivedSection.voxels.remapped =
+            sectorPalettes.voxels.size > BinaryBufferConstants.ByteArrayMax &&
+                archivedSection.palettes.voxels.size <=
+                    BinaryBufferConstants.ByteArrayMax &&
+                !archivedSection.voxels.allTheSame;
+        //level
+        archivedSection.level.isPaletted =
+            sectorPalettes.level.size <= BinaryBufferConstants.NibbleArrayMax &&
+                archivedSection.palettes.level.size <=
+                    BinaryBufferConstants.NibbleArrayMax;
+        archivedSection.level.remapped =
+            sectorPalettes.level.size > BinaryBufferConstants.NibbleArrayMax &&
+                archivedSection.palettes.level.size <=
+                    BinaryBufferConstants.NibbleArrayMax &&
+                !archivedSection.level.allTheSame;
+        if (archivedSection.level.isPaletted && !archivedSection.level.remapped) {
+            neededPalettes.level = true;
+        }
+        for (const semgnet of lightSegments) {
+            archivedSection.light[semgnet].isPaletted =
+                sectorPalettes.light[semgnet].size <=
+                    BinaryBufferConstants.HalfNibbleArrayMax ||
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBufferConstants.HalfNibbleArrayMax;
+            archivedSection.light[semgnet].remapped =
+                sectorPalettes.light[semgnet].size >
+                    BinaryBufferConstants.HalfNibbleArrayMax &&
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBufferConstants.HalfNibbleArrayMax &&
+                    !archivedSection.light[semgnet].allTheSame;
+            if (archivedSection.light[semgnet].isPaletted &&
+                !archivedSection.light[semgnet].remapped) {
+                neededPalettes.light[semgnet] = true;
+            }
+        }
+        //secondary
+        archivedSection.secondaryVoxels.isPaletted =
+            sectorPalettes.voxels.size <= BinaryBufferConstants.ByteArrayMax ||
+                archivedSection.palettes.secondaryVoxels.size <=
+                    BinaryBufferConstants.ByteArrayMax;
+        archivedSection.secondaryVoxels.remapped =
+            sectorPalettes.voxels.size > BinaryBufferConstants.ByteArrayMax &&
+                archivedSection.palettes.secondaryVoxels.size <=
+                    BinaryBufferConstants.ByteArrayMax &&
+                !archivedSection.secondaryVoxels.allTheSame;
+        if (!archivedSection.voxels.remapped &&
+            !archivedSection.light.sun.remapped &&
+            !archivedSection.light.red.remapped &&
+            !archivedSection.light.green.remapped &&
+            !archivedSection.light.blue.remapped &&
+            !archivedSection.secondaryVoxels.remapped &&
+            !archivedSection.level.remapped)
+            continue;
+        const length = archivedSection.original.ids.length;
+        for (let i = 0; i < length; i++) {
+            let secondary = false;
+            if (VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxels[archivedSection.original.ids[i]][0]]["dve_can_have_secondary"] &&
+                archivedSection.original.secondary[i] !== 0) {
+                secondary = true;
+            }
+            let voxelId = archivedSection.voxels.buffer[i];
+            if (archivedSection.voxels.remapped)
+                archivedSection.voxels.buffer[i] =
+                    archivedSection.palettes.voxels.getId(voxelId);
+            for (let l = 0; l < lightSegments.length; l++) {
+                const segment = lightSegments[l];
+                if (archivedSection.light[segment].remapped) {
+                    archivedSection.light[segment].buffer[i] =
+                        archivedSection.palettes.light[segment].getId(lightSemgnetGet[segment](archivedSection.original.light[i]));
+                }
+            }
+            if (archivedSection.level.remapped)
+                archivedSection.level.buffer[i] = archivedSection.palettes.level.getId(archivedSection.original.level[i]);
+            if (archivedSection.secondaryVoxels.remapped) {
+                if (secondary) {
+                    archivedSection.secondaryVoxels.buffer[i] =
+                        archivedSection.palettes.secondaryVoxels.getId(voxelId);
+                }
+            }
+        }
+    }
+    const palettes = {
+        ...sectorPalettes.voxels.toJSON(),
+    };
+    const sections = [];
+    for (let sectionIndex = 0; sectionIndex < processedSections.length; sectionIndex++) {
+        sections[sectionIndex] = CreateArchivedSection(processedSections[sectionIndex], sectorPalettes);
+    }
+    if (neededPalettes.level &&
+        !(sectorPalettes.level.size == 1 && sectorPalettes.level._palette[0] == 0)) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            buffer: new Uint8Array(sectorPalettes.level._palette).buffer,
+        });
+    }
+    for (const segment of lightSegments) {
+        if (neededPalettes.light[segment]) {
+            if (sectorPalettes.light[segment].size == 1 &&
+                sectorPalettes.light[segment]._palette[0] == 0)
+                continue;
+            palettes.light ??= {};
+            palettes.light[segment] = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                buffer: new Uint8Array(sectorPalettes.light[segment]._palette).buffer,
+            });
+        }
+    }
+    const archivedSector = {
+        ...getBaseData(WorldRegister.dimensions.get(archiveData.location[0]).id || "main"),
+        position: {
+            x: archiveData.location[1],
+            y: archiveData.location[2],
+            z: archiveData.location[3],
+        },
+        flags: sector.storeFlags(),
+        timestamps: sector.storeTimestamps(),
+        palettes,
+        duplicates: {},
+        sections,
+    };
+    RemoveDuplicateSections(archivedSector);
+    return archivedSector;
+}

package/World/Archive/Functions/Sector/CreateArchivedSection.d.ts

@@ -0,0 +1,3 @@
+import { ArchivedSectionData } from "../../Types/index";
+import { ProcessedSection, SectorPalette } from "../../Classes/ArchiveClasses";
+export declare function CreateArchivedSection(archiveSection: ProcessedSection, sectorPalettes: SectorPalette): ArchivedSectionData;

package/World/Archive/Functions/Sector/CreateArchivedSection.js

@@ -0,0 +1,147 @@
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../../Util/BinaryBuffer/index";
+import { getLightBuffer, lightSegments } from "../Shared/LightSegments";
+export function CreateArchivedSection(archiveSection, sectorPalettes) {
+    const palettes = {};
+    if (archiveSection.voxels.remapped) {
+        palettes.id = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: Uint16Array.from(archiveSection.palettes.voxels._palette).buffer,
+        });
+    }
+    if (archiveSection.level.remapped) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            buffer: Uint8Array.from(archiveSection.palettes.level._palette).buffer,
+        });
+    }
+    for (const segment of lightSegments) {
+        if (archiveSection.light[segment].remapped) {
+            palettes.light ??= {};
+            palettes.light[segment] = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                buffer: Uint8Array.from(archiveSection.palettes.light[segment]._palette)
+                    .buffer,
+            });
+        }
+    }
+    if (archiveSection.secondaryVoxels.remapped) {
+        palettes.secondary = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: Uint16Array.from(archiveSection.palettes.secondaryVoxels._palette)
+                .buffer,
+        });
+    }
+    const buffers = {};
+    //id
+    if (archiveSection.voxels.allTheSame) {
+        if (archiveSection.voxels.buffer[0] !== 0) {
+            buffers.id = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: archiveSection.original.ids.length,
+                buffer: archiveSection.voxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.voxels.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.voxels.remapped
+            ? archiveSection.palettes.voxels.size
+            : sectorPalettes.voxels.size);
+        buffers.id = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.voxels.buffer, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.id = BinaryBuffer.Create({
+            buffer: archiveSection.voxels.buffer.buffer,
+            format: BinaryBufferFormat.Uint16,
+        });
+    }
+    //level
+    if (archiveSection.level.allTheSame) {
+        if (archiveSection.level.buffer[0] !== 0) {
+            buffers.level = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: archiveSection.original.level.length,
+                buffer: archiveSection.voxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.level.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.level.remapped
+            ? archiveSection.palettes.level.size
+            : sectorPalettes.level.size);
+        buffers.level = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.level.buffer, BinaryBufferFormat.Uint8, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.level = BinaryBuffer.Create({
+            buffer: archiveSection.original.level.slice().buffer,
+            byteLength: archiveSection.original.level.length,
+            format: BinaryBufferFormat.Uint8,
+        });
+    }
+    for (const semgnet of lightSegments) {
+        if (archiveSection.light[semgnet].allTheSame) {
+            if (archiveSection.light[semgnet].value !== 0) {
+                buffers.light ??= {};
+                buffers.light[semgnet] = BinaryBuffer.Create({
+                    format: BinaryBufferFormat.NibbleArray,
+                    buffer: archiveSection.light[semgnet].value,
+                    byteLength: archiveSection.original.light.length,
+                });
+            }
+        }
+        else if (archiveSection.light[semgnet].isPaletted) {
+            const type = BinaryBuffer.DetermineSubByteArray(archiveSection.light[semgnet].remapped
+                ? archiveSection.palettes.light[semgnet].size
+                : sectorPalettes.light[semgnet].size);
+            buffers.light ??= {};
+            buffers.light[semgnet] = BinaryBuffer.Create({
+                buffer: BinaryBuffer.Convert(archiveSection.light[semgnet].buffer, BinaryBufferFormat.Uint8, type).buffer,
+                format: type,
+            });
+        }
+        else {
+            buffers.light ??= {};
+            buffers.light[semgnet] = BinaryBuffer.Create({
+                buffer: getLightBuffer(semgnet, archiveSection.original.light).buffer,
+                format: BinaryBufferFormat.NibbleArray,
+                byteLength: archiveSection.original.light.length,
+            });
+        }
+    }
+    if (archiveSection.secondaryVoxels.allTheSame) {
+        if (archiveSection.secondaryVoxels.buffer[0] !== 0) {
+            buffers.secondary = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: archiveSection.original.level.length,
+                buffer: archiveSection.secondaryVoxels.buffer[0],
+            });
+        }
+    }
+    else if (archiveSection.secondaryVoxels.isPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.secondaryVoxels.remapped
+            ? archiveSection.palettes.secondaryVoxels.size
+            : sectorPalettes.voxels.size);
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.secondaryVoxels.buffer, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: archiveSection.secondaryVoxels.buffer.buffer,
+            format: BinaryBufferFormat.Uint16,
+            byteLength: archiveSection.original.secondary.length,
+        });
+    }
+    const flags = archiveSection.original.storeFlags();
+    return {
+        ...(Object.keys(flags).length ? { flags } : {}),
+        ...(Object.keys(palettes).length ? { palettes } : {}),
+        buffers,
+    };
+}

package/World/Archive/Functions/{ImportSector.d.ts → Sector/ImportSector.d.ts}

@@ -1,5 +1,5 @@
-import { SectorData } from "../../index";
-import { ArchivedSectorData } from "../Archive.types";
+import { SectorData } from "../../../index";
+import { ArchivedSectorData } from "../../Types/index";
 type RunData = {
     version?: number;
 };

package/World/Archive/Functions/Sector/ImportSector.js

@@ -0,0 +1,32 @@
+import { WorldSpaces } from "../../../WorldSpaces";
+import { Sector } from "../../../index";
+import { ImportedSector } from "../../Classes/ImportedSector";
+import { Vector3Like } from "@amodx/math";
+export default function ImportSector(archivedSector, archiveData) {
+    const sector = new Sector();
+    sector.setBuffer(Sector.CreateNewBuffer());
+    sector.position[0] = archivedSector.position.x;
+    sector.position[1] = archivedSector.position.y;
+    sector.position[2] = archivedSector.position.z;
+    sector.loadFlags(archivedSector.flags);
+    sector.loadTimestamps(archivedSector.timestamps);
+    const importedSector = new ImportedSector(archivedSector);
+    const position = Vector3Like.Create();
+    for (const importedSection of importedSector.sections) {
+        const archivedSection = importedSection.section;
+        const section = sector.sections[importedSection.sectionIndex];
+        archivedSection.flags && section.loadFlags(archivedSection.flags);
+        section.dirtyMap.fill(0xff);
+        for (let i = 0; i < section.ids.length; i++) {
+            section.ids[i] = importedSection.getId(i);
+            section.level[i] = importedSection.getLevel(i);
+            section.light[i] = importedSection.getLight(i);
+            section.secondary[i] = importedSection.getSecondary(i);
+            if (section.ids[i] !== 0 || section.secondary[i] !== 0) {
+                section.setHasVoxel(WorldSpaces.voxel.getPositionFromIndex(i, position).y - 1, true);
+            }
+        }
+    }
+    sector.setBitFlag(Sector.FlagIds.stored, true);
+    return sector;
+}

package/World/Archive/Functions/Sector/RemoveDuplicateSections.d.ts

@@ -0,0 +1,2 @@
+import { ArchivedSectorData } from "../../Types/index";
+export declare function RemoveDuplicateSections(sector: ArchivedSectorData): void;