@divinevoxel/vlox 0.0.3 → 0.0.5

package/World/Archive/Functions/ArchiveSector.js

@@ -0,0 +1,355 @@
+import { StringPalette } from "../../../Util/StringPalette";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { VoxelPalette } from "../../../Voxels/Palettes/VoxelPalette";
+import { VoxelStruct } from "../../../Voxels/Structs/VoxelStruct";
+import { VoxelStructIds } from "../../../Voxels/Types/Voxel.types";
+import { Section, Sector } from "../../../World/index";
+import { convertToPaletteBuffer } from "../../../Data/Functions/Palettes";
+import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
+const getProcessedSection = (section) => {
+    return {
+        section,
+        palettes: getSectionPalettes(),
+        // ids
+        ids: new Uint16Array(section.ids.length),
+        idsAllTheSame: true,
+        remappedIds: false,
+        // light
+        light: new Uint16Array(section.light.length),
+        lightAllTheSame: true,
+        isLightPaletted: false,
+        remappedLight: false,
+        // level
+        level: new Uint8Array(section.level.length),
+        levelAllTheSame: true,
+        isLevelPaletted: false,
+        remappedLevel: false,
+        // state
+        state: new Uint16Array(section.state.length),
+        stateAllTheSame: true,
+        isStatePaletted: false,
+        remappedState: false,
+        // mod
+        mod: new Uint16Array(section.mod.length),
+        modAllTheSame: true,
+        isModPaletted: false,
+        remappedMod: false,
+        // secondary
+        secondary: new Uint16Array(section.secondary.length),
+        isSecondaryPaletted: false,
+        secondaryAllTheSame: true,
+        remappedSecondary: false,
+    };
+};
+let sectorStructInstance;
+let sectionStructInstance;
+function getSectionPalettes() {
+    return {
+        ids: new NumberPalette(),
+        level: new NumberPalette(),
+        light: new NumberPalette(),
+        state: new NumberPalette(),
+        mod: new NumberPalette(),
+        secondaryId: new NumberPalette(),
+        secondaryState: new NumberPalette(),
+    };
+}
+function getColumnPalettes() {
+    return {
+        ids: new StringPalette(),
+        level: new NumberPalette(),
+        light: new NumberPalette(),
+        stateIdMap: [],
+        state: new NumberPalette(),
+        modIdMap: [],
+        mod: new NumberPalette(),
+        secondaryId: new StringPalette(),
+        secondaryState: new NumberPalette(),
+    };
+}
+function GetArchivedSection(archiveSection, sectorPalettes) {
+    sectionStructInstance.setData(archiveSection.section.sectionState);
+    const palettes = {};
+    if (archiveSection.remappedIds)
+        palettes.id = Uint16Array.from(archiveSection.palettes.ids._palette);
+    if (archiveSection.remappedLevel)
+        palettes.level = Uint8Array.from(archiveSection.palettes.level._palette);
+    if (archiveSection.remappedLight)
+        palettes.light = Uint16Array.from(archiveSection.palettes.light._palette);
+    if (archiveSection.remappedState)
+        palettes.state = Uint16Array.from(archiveSection.palettes.state._palette);
+    if (archiveSection.remappedMod)
+        palettes.mod = Uint16Array.from(archiveSection.palettes.mod._palette);
+    if (archiveSection.remappedSecondary) {
+        palettes.secondaryId = Uint16Array.from(archiveSection.palettes.secondaryId._palette);
+        palettes.secondaryState = Uint16Array.from(archiveSection.palettes.secondaryState._palette);
+    }
+    return {
+        state: Object.values(sectionStructInstance.serialize()),
+        palettes,
+        buffers: {
+            id: archiveSection.idsAllTheSame
+                ? archiveSection.ids[0]
+                : convertToPaletteBuffer(archiveSection.remappedIds
+                    ? archiveSection.palettes.ids.size
+                    : sectorPalettes.ids.size, archiveSection.ids),
+            level: archiveSection.isLevelPaletted
+                ? archiveSection.level[0]
+                : archiveSection.isLevelPaletted
+                    ? convertToPaletteBuffer(archiveSection.remappedLevel
+                        ? archiveSection.palettes.level.size
+                        : sectorPalettes.level.size, archiveSection.level)
+                    : new Uint8Array(archiveSection.section.level.slice()),
+            light: archiveSection.lightAllTheSame
+                ? archiveSection.light[0]
+                : archiveSection.isLightPaletted
+                    ? convertToPaletteBuffer(archiveSection.remappedLight
+                        ? archiveSection.palettes.light.size
+                        : sectorPalettes.light.size, archiveSection.light)
+                    : new Uint16Array(archiveSection.section.light.slice()),
+            state: archiveSection.stateAllTheSame
+                ? archiveSection.state[0]
+                : archiveSection.isStatePaletted
+                    ? convertToPaletteBuffer(archiveSection.remappedState
+                        ? archiveSection.palettes.state.size
+                        : sectorPalettes.state.size, archiveSection.state)
+                    : new Uint16Array(archiveSection.section.state.slice()),
+            mod: archiveSection.modAllTheSame
+                ? archiveSection.mod[0]
+                : archiveSection.isModPaletted
+                    ? convertToPaletteBuffer(archiveSection.remappedMod
+                        ? archiveSection.palettes.mod.size
+                        : sectorPalettes.mod.size, archiveSection.mod)
+                    : new Uint16Array(archiveSection.section.mod.slice()),
+            secondary: archiveSection.secondaryAllTheSame
+                ? archiveSection.secondary[0]
+                : archiveSection.isSecondaryPaletted
+                    ? convertToPaletteBuffer(archiveSection.remappedSecondary
+                        ? Math.max(archiveSection.palettes.secondaryState.size, archiveSection.palettes.secondaryId.size)
+                        : Math.max(sectorPalettes.secondaryState.size, sectorPalettes.secondaryId.size), archiveSection.secondary)
+                    : new Uint16Array(archiveSection.secondary),
+        },
+    };
+}
+export default function ArchiveColumn(archiveData) {
+    WorldRegister.setDimension(archiveData.location[0]);
+    const sector = WorldRegister.sectors.get(archiveData.location[1], archiveData.location[2], archiveData.location[3]);
+    if (!sector)
+        throw new Error(`Column at location ${location} does not exist when trying to arhicve it.`);
+    if (!sectorStructInstance)
+        sectorStructInstance = Sector.StateStruct.instantiate();
+    if (!sectionStructInstance)
+        sectionStructInstance = Section.StateStruct.instantiate();
+    const sectorPalettes = getColumnPalettes();
+    sectorStructInstance.setData(sector.sectorState);
+    const sectorState = sectorStructInstance.serialize();
+    const processedSections = [];
+    for (const section of sector.sections) {
+        const length = section.ids.length;
+        let firstId = -1;
+        let firstLight = -1;
+        let firstLevel = -1;
+        let firstState = -1;
+        let firstMod = -1;
+        let firstSecondary = -1;
+        const processedSection = getProcessedSection(section);
+        for (let i = 0; i < length; i++) {
+            const stringId = VoxelPalette.ids.getStringId(section.ids[i]);
+            VoxelStruct.setStringVoxel(stringId);
+            const voxelId = !sectorPalettes.ids.isRegistered(stringId)
+                ? sectorPalettes.ids.register(stringId)
+                : sectorPalettes.ids.getNumberId(stringId);
+            if (!processedSection.palettes.ids.isRegistered(voxelId))
+                processedSection.palettes.ids.register(voxelId);
+            if (firstId == -1)
+                firstId = voxelId;
+            const secondaryId = VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1 &&
+                VoxelPalette.ids.getStringId(section.secondary[i]);
+            const voxelSecondary = secondaryId
+                ? !sectorPalettes.secondaryId.isRegistered(secondaryId)
+                    ? sectorPalettes.secondaryId.register(secondaryId)
+                    : sectorPalettes.secondaryId.getNumberId(secondaryId)
+                : !sectorPalettes.secondaryState.isRegistered(section.secondary[i])
+                    ? sectorPalettes.secondaryState.register(section.secondary[i])
+                    : sectorPalettes.secondaryState.getId(section.secondary[i]);
+            secondaryId
+                ? !processedSection.palettes.secondaryId.isRegistered(voxelSecondary) &&
+                    processedSection.palettes.secondaryId.register(voxelSecondary)
+                : !processedSection.palettes.secondaryState.isRegistered(voxelSecondary) &&
+                    processedSection.palettes.secondaryState.register(voxelSecondary);
+            if (firstSecondary == -1)
+                firstSecondary = section.secondary[i];
+            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]);
+            if (firstLevel == -1)
+                firstLevel = voxelLevel;
+            let voxelState = -1;
+            if (!sectorPalettes.state.isRegistered(section.state[i])) {
+                voxelState = sectorPalettes.state.register(section.state[i]);
+                sectorPalettes.stateIdMap[voxelState] = secondaryId
+                    ? section.secondary[i]
+                    : section.ids[i];
+            }
+            else {
+                voxelState = sectorPalettes.state.getId(section.state[i]);
+            }
+            if (!processedSection.palettes.state.isRegistered(voxelState))
+                processedSection.palettes.state.register(voxelState);
+            if (firstState == -1)
+                firstState = voxelState;
+            let voxelMod = -1;
+            if (!sectorPalettes.mod.isRegistered(section.mod[i])) {
+                voxelMod = sectorPalettes.mod.register(section.mod[i]);
+                sectorPalettes.stateIdMap[voxelMod] = secondaryId
+                    ? section.secondary[i]
+                    : section.ids[i];
+            }
+            else {
+                voxelMod = sectorPalettes.mod.getId(section.mod[i]);
+            }
+            if (!processedSection.palettes.mod.isRegistered(voxelMod))
+                processedSection.palettes.mod.register(voxelMod);
+            if (firstMod == -1)
+                firstMod = voxelMod;
+            const voxelLight = !sectorPalettes.light.isRegistered(section.light[i])
+                ? sectorPalettes.light.register(section.light[i])
+                : sectorPalettes.light.getId(section.light[i]);
+            if (!processedSection.palettes.light.isRegistered(section.light[i]))
+                processedSection.palettes.light.register(section.light[i]);
+            if (firstLight == -1)
+                firstLight = voxelLight;
+            if (voxelId != firstId)
+                processedSection.idsAllTheSame = false;
+            if (voxelLevel != firstLevel)
+                processedSection.levelAllTheSame = false;
+            if (voxelState != firstState)
+                processedSection.stateAllTheSame = false;
+            if (voxelMod != firstMod)
+                processedSection.modAllTheSame = false;
+            if (voxelLight != firstLight)
+                processedSection.lightAllTheSame = false;
+            if (voxelSecondary != firstSecondary)
+                processedSection.secondaryAllTheSame = false;
+            processedSection.ids[i] = voxelId;
+            processedSection.level[i] = voxelLevel;
+            processedSection.state[i] = voxelState;
+            processedSection.mod[i] = voxelMod;
+            processedSection.secondary[i] = voxelSecondary;
+            processedSection.light[i] = voxelLight;
+        }
+        processedSections.push(processedSection);
+    }
+    for (const section of processedSections) {
+        const reMapIds = section.palettes.ids.size < sectorPalettes.ids.size &&
+            section.palettes.ids.size <= 255 &&
+            !section.idsAllTheSame;
+        const reMapLevel = section.palettes.level.size < sectorPalettes.level.size &&
+            section.palettes.level.size <= 255 &&
+            !section.levelAllTheSame;
+        const reMapState = section.palettes.state.size < sectorPalettes.state.size &&
+            section.palettes.state.size <= 255 &&
+            !section.stateAllTheSame;
+        const reMapMod = section.palettes.mod.size < sectorPalettes.mod.size &&
+            section.palettes.mod.size <= 255 &&
+            !section.modAllTheSame;
+        const reMapLight = section.palettes.light.size < sectorPalettes.light.size &&
+            section.palettes.light.size <= 255 &&
+            !section.lightAllTheSame;
+        const reMapSecondary = Math.max(section.palettes.secondaryId.size, section.palettes.secondaryState.size) <
+            Math.max(sectorPalettes.secondaryState.size, sectorPalettes.secondaryId.size) &&
+            Math.max(section.palettes.secondaryId.size, section.palettes.secondaryState.size) <= 255 &&
+            !section.secondaryAllTheSame;
+        section.isLightPaletted =
+            sectorPalettes.light.size < 65_535 && section.palettes.light.size < 255;
+        section.isLevelPaletted =
+            sectorPalettes.level.size < 255 && section.palettes.level.size < 255;
+        section.isStatePaletted =
+            sectorPalettes.state.size < 65_535 && section.palettes.state.size < 255;
+        section.isModPaletted =
+            sectorPalettes.mod.size < 65_535 && section.palettes.mod.size < 255;
+        section.isSecondaryPaletted =
+            sectorPalettes.secondaryState.size < 65_535 &&
+                section.palettes.secondaryState.size < 255 &&
+                section.palettes.secondaryId.size < 255;
+        section.remappedIds = reMapIds;
+        section.remappedLight = reMapLight && section.isLightPaletted;
+        section.remappedState = reMapState && section.isStatePaletted;
+        section.remappedMod = reMapMod && section.isModPaletted;
+        section.remappedSecondary = reMapSecondary && section.isSecondaryPaletted;
+        if (!reMapIds && !reMapLight && !reMapSecondary && !reMapState)
+            continue;
+        const length = section.section.ids.length;
+        for (let i = 0; i < length; i++) {
+            VoxelStruct.setVoxel(section.ids[i]);
+            if (reMapIds)
+                section.ids[i] = section.palettes.ids.getId(section.ids[i]);
+            if (reMapLight)
+                section.light[i] = section.palettes.light.getId(section.section.light[i]);
+            if (reMapLevel)
+                section.level[i] = section.palettes.level.getId(section.section.level[i]);
+            if (reMapState)
+                section.state[i] = section.palettes.state.getId(sectorPalettes.state.getId(section.section.state[i]));
+            if (reMapMod)
+                section.mod[i] = section.palettes.mod.getId(sectorPalettes.mod.getId(section.section.mod[i]));
+            if (reMapSecondary)
+                section.secondary[i] =
+                    VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1
+                        ? section.palettes.secondaryId.getId(section.secondary[i])
+                        : section.palettes.secondaryState.getId(section.secondary[i]);
+        }
+    }
+    const stateMap = {};
+    for (let i = 0; i < sectorPalettes.state._palette.length; i++) {
+        const state = sectorPalettes.state._palette[i];
+        const voxelId = VoxelPalette.ids.getStringId(sectorPalettes.stateIdMap[i]);
+        if (!SchemaRegister.hasVoxelSchema(voxelId))
+            continue;
+        const schema = SchemaRegister.getVoxelSchemas(voxelId);
+        stateMap[i] = schema.state.getStateObject(state);
+    }
+    const modMap = {};
+    for (let i = 0; i < sectorPalettes.mod._palette.length; i++) {
+        const mod = sectorPalettes.mod._palette[i];
+        const voxelId = VoxelPalette.ids.getStringId(sectorPalettes.modIdMap[i]);
+        if (!SchemaRegister.hasVoxelSchema(voxelId))
+            continue;
+        const schema = SchemaRegister.getVoxelSchemas(voxelId);
+        modMap[i] = schema.mod.getStateObject(mod);
+    }
+    const sections = [];
+    for (const section of processedSections) {
+        sections.push(GetArchivedSection(section, sectorPalettes));
+    }
+    const palettes = {
+        id: sectorPalettes.ids._palette,
+        stateMap,
+        modMap,
+        state: new Uint16Array(sectorPalettes.state._palette),
+        mod: new Uint16Array(sectorPalettes.mod._palette),
+    };
+    if (sectorPalettes.light.size < 255)
+        palettes.light = new Uint16Array(sectorPalettes.light._palette);
+    if (sectorPalettes.level.size < 255)
+        palettes.level = new Uint8Array(sectorPalettes.level._palette);
+    if (sectorPalettes.light.size < 255)
+        palettes.light = new Uint16Array(sectorPalettes.light._palette);
+    if (sectorPalettes.secondaryId.size > 0)
+        palettes.secondaryId = sectorPalettes.secondaryId._palette;
+    if (sectorPalettes.secondaryState.size < 255)
+        palettes.secondaryState = new Uint16Array(sectorPalettes.secondaryState._palette);
+    return {
+        version: "",
+        location: [...archiveData.location],
+        sectorState,
+        buffers: {},
+        keys: {
+            sectionState: [...sectionStructInstance.getKeys()],
+        },
+        palettes,
+        sections,
+    };
+}

package/World/Archive/Functions/ImportSector.d.ts

@@ -0,0 +1,9 @@
+import { VoxelDataArrays, SectorData } from "../../index";
+import { ArchivedSectorData } from "../Archive.types";
+type RunData = {
+    version?: number;
+    loadColumnState?: (data: Record<string, any>, sector: SectorData) => void;
+    loadSectionState?: (keys: string[], data: any[], section: VoxelDataArrays) => void;
+};
+export default function ImportSector(sector: ArchivedSectorData, archiveData: RunData): SectorData;
+export {};

package/World/Archive/Functions/ImportSector.js

@@ -0,0 +1,234 @@
+import { VoxelPalette } from "../../../Voxels/Palettes/VoxelPalette";
+import { Section, Sector } from "../../index";
+import { VoxelStruct } from "../../../Voxels/Structs/VoxelStruct";
+import { VoxelStructIds } from "../../../Voxels/Types/Voxel.types";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { StringPalette } from "../../../Util/StringPalette";
+import { getPaletteArray } from "../../../Data/Functions/Palettes";
+import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
+let sectorStructInstance;
+let sectionStructInstance;
+const updateSectionBuffers = (sector, section) => {
+    if ((sector.palettes.id.length <= 15 ||
+        (section.palettes.id && section.palettes.id.length <= 15)) &&
+        ArrayBuffer.isView(section.buffers.id)) {
+        section.buffers.id = getPaletteArray(Math.min(section.palettes.id?.length || Infinity, sector.palettes.id?.length || 0), section.buffers.id);
+    }
+    if (((section.palettes.light && section.palettes.light.length <= 15) ||
+        (sector.palettes.light && sector.palettes.light.length <= 15)) &&
+        ArrayBuffer.isView(section.buffers.light)) {
+        section.buffers.light = getPaletteArray(Math.min(section.palettes.light?.length || Infinity, sector.palettes.light?.length || 0), section.buffers.light);
+    }
+    if (((section.palettes.state && section.palettes.state.length <= 15) ||
+        (sector.palettes.state && sector.palettes.state.length <= 15)) &&
+        ArrayBuffer.isView(section.buffers.state)) {
+        section.buffers.state = getPaletteArray(Math.min(section.palettes.state?.length || Infinity, sector.palettes.state?.length || 0), section.buffers.state);
+    }
+    if (((section.palettes.mod && section.palettes.mod.length <= 15) ||
+        (sector.palettes.mod && sector.palettes.mod.length <= 15)) &&
+        ArrayBuffer.isView(section.buffers.mod)) {
+        section.buffers.mod = getPaletteArray(Math.min(section.palettes.mod?.length || Infinity, sector.palettes.mod?.length || 0), section.buffers.mod);
+    }
+    if (((section.palettes.secondaryState &&
+        section.palettes.secondaryState.length <= 15) ||
+        (sector.palettes.secondaryState &&
+            sector.palettes.secondaryState.length <= 15)) &&
+        ((section.palettes.secondaryId && section.palettes.secondaryId.length <= 15) ||
+            (sector.palettes.secondaryId &&
+                sector.palettes.secondaryId.length <= 15)) &&
+        ArrayBuffer.isView(section.buffers.secondary)) {
+        section.buffers.secondary = getPaletteArray(Math.max(Math.min(section.palettes.secondaryId?.length || Infinity, sector.palettes.secondaryId?.length || 0), Math.min(section.palettes.secondaryState?.length || Infinity, sector.palettes.secondaryState?.length || 0)), section.buffers.secondary);
+    }
+};
+const getImportedColumnData = (sector) => {
+    return {
+        sector,
+        idPalette: new StringPalette(sector.palettes.id),
+        secondaryId: sector.palettes.secondaryId
+            ? new StringPalette(sector.palettes.secondaryId)
+            : undefined,
+        lightPalette: sector.palettes.light
+            ? new NumberPalette(sector.palettes.light)
+            : undefined,
+        statePalette: sector.palettes.state
+            ? new NumberPalette(sector.palettes.state)
+            : undefined,
+        modPalette: sector.palettes.mod
+            ? new NumberPalette(sector.palettes.mod)
+            : undefined,
+        secondaryState: sector.palettes.secondaryState
+            ? new NumberPalette(sector.palettes.secondaryState)
+            : undefined,
+    };
+};
+const getImportedSectionData = (section) => {
+    return {
+        section,
+        idPalette: section.palettes.id
+            ? new NumberPalette(section.palettes.id)
+            : undefined,
+        lightPalette: section.palettes.light
+            ? new NumberPalette(section.palettes.light)
+            : undefined,
+        statePalette: section.palettes.state
+            ? new NumberPalette(section.palettes.state)
+            : undefined,
+        modPalette: section.palettes.mod
+            ? new NumberPalette(section.palettes.mod)
+            : undefined,
+        secondaryState: section.palettes.secondaryState
+            ? new NumberPalette(section.palettes.secondaryState)
+            : undefined,
+        secondaryId: section.palettes.secondaryId
+            ? new NumberPalette(section.palettes.secondaryId)
+            : undefined,
+    };
+};
+const getId = (value, importedColumn, importedSection) => {
+    if (importedSection.section.buffers.state instanceof Uint16Array)
+        return value;
+    if (typeof importedSection.section.buffers.id == "number") {
+        return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.id[importedSection.section.buffers.id]);
+    }
+    if (importedSection.idPalette) {
+        return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(importedSection.idPalette.getValue(value)));
+    }
+    return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(value));
+};
+const getLight = (value, importedColumn, importedSection) => {
+    if (importedSection.section.buffers.light instanceof Uint16Array)
+        return value;
+    if (typeof importedSection.section.buffers.light == "number") {
+        return value;
+    }
+    if (importedSection.lightPalette) {
+        return importedSection.lightPalette.getValue(value);
+    }
+    if (importedColumn.lightPalette) {
+        return importedColumn.lightPalette.getValue(value);
+    }
+    return value;
+};
+const getState = (voxelId, value, processedState, importedColumn, importedSection) => {
+    const voxelStringId = VoxelPalette.ids.getStringId(voxelId);
+    if (!SchemaRegister.hasVoxelSchema(voxelStringId))
+        return value;
+    let stateId = -1;
+    if (importedSection.section.buffers.state instanceof Uint16Array ||
+        typeof importedSection.section.buffers.state == "number") {
+        stateId = value;
+    }
+    if (importedSection.statePalette) {
+        stateId = importedSection.statePalette.getValue(value);
+    }
+    else if (importedColumn.statePalette) {
+        stateId = value;
+    }
+    if (processedState[stateId] !== undefined)
+        return processedState[stateId];
+    value = SchemaRegister.getVoxelSchemas(voxelStringId).state.fromStateObject(importedColumn.sector.palettes.stateMap[stateId]);
+    processedState[stateId] = value;
+    return value;
+};
+const getMod = (voxelId, value, processedMod, importedColumn, importedSection) => {
+    const voxelStringId = VoxelPalette.ids.getStringId(voxelId);
+    if (!SchemaRegister.hasVoxelSchema(voxelStringId))
+        return value;
+    let modId = -1;
+    if (importedSection.section.buffers.state instanceof Uint16Array ||
+        typeof importedSection.section.buffers.state == "number") {
+        modId = value;
+    }
+    if (importedSection.modPalette) {
+        modId = importedSection.modPalette.getValue(value);
+    }
+    else if (importedColumn.modPalette) {
+        modId = value;
+    }
+    if (processedMod[modId] !== undefined)
+        return processedMod[modId];
+    value = SchemaRegister.getVoxelSchemas(voxelStringId).mod.fromStateObject(importedColumn.sector.palettes.modMap[modId]);
+    processedMod[modId] = value;
+    return value;
+};
+const getSecondary = (voxelId, value, importedColumn, importedSection) => {
+    VoxelStruct.setVoxel(voxelId);
+    if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
+        if (typeof importedSection.section.buffers.secondary == "number") {
+            return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.secondaryId[importedSection.section.buffers.secondary]);
+        }
+        if (importedSection.secondaryId) {
+            return VoxelPalette.ids.getNumberId(importedColumn.secondaryId.getStringId(importedSection.secondaryId.getValue(value)));
+        }
+        return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.secondaryId[value]);
+    }
+    if (typeof importedSection.section.buffers.secondary == "number") {
+        return value;
+    }
+    if (importedSection.secondaryState && importedColumn.secondaryState) {
+        return importedColumn.secondaryState.getValue(importedSection.secondaryState.getValue(value));
+    }
+    if (importedColumn.secondaryState) {
+        return importedColumn.secondaryState.getId(value);
+    }
+    return value;
+};
+export default function ImportSector(sector, archiveData) {
+    if (!sectorStructInstance)
+        sectorStructInstance = Sector.StateStruct.instantiate();
+    if (!sectionStructInstance)
+        sectionStructInstance = Section.StateStruct.instantiate();
+    const newSector = new Sector(Sector.CreateNew());
+    newSector.position[0] = sector.location[1];
+    newSector.position[1] = sector.location[2];
+    newSector.position[2] = sector.location[3];
+    if (!archiveData.loadColumnState) {
+        sectorStructInstance.setData(newSector.sectorState);
+        sectorStructInstance.deserialize(sector.sectorState);
+    }
+    else {
+        archiveData.loadColumnState(sector.sectorState, newSector);
+    }
+    const importedSector = getImportedColumnData(sector);
+    const processedState = {};
+    const processedMod = {};
+    for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
+        const section = sector.sections[sectionIndex];
+        const importedSection = getImportedSectionData(section);
+        const newSection = newSector.sections[sectionIndex];
+        const sectionState = {};
+        for (let i = 0; i < sector.keys.sectionState.length; i++) {
+            sectionState[sector.keys.sectionState[i]] = section.state[i];
+        }
+        updateSectionBuffers(sector, section);
+        if (!archiveData.loadSectionState) {
+            sectionStructInstance.setData(newSection.sectionState);
+            sectionStructInstance.deserialize(sectionState);
+        }
+        else {
+            archiveData.loadSectionState(sector.keys.sectionState, section.state, newSection);
+        }
+        for (let i = 0; i < newSection.ids.length; i++) {
+            newSection.ids[i] = getId(typeof section.buffers.id == "number"
+                ? section.buffers.id
+                : section.buffers.id[i], importedSector, importedSection);
+            newSection.light[i] = getLight(typeof section.buffers.light == "number"
+                ? section.buffers.light
+                : section.buffers.light[i], importedSector, importedSection);
+            newSection.secondary[i] = getSecondary(newSection.ids[i], typeof section.buffers.secondary == "number"
+                ? section.buffers.secondary
+                : section.buffers.secondary[i], importedSector, importedSection);
+            VoxelStruct.setVoxel(newSection.ids[i]);
+            let secondary = VoxelStruct.instance[VoxelStructIds.canHaveSecondary] &&
+                newSection.secondary[i] > 0;
+            newSection.state[i] = getState(secondary ? newSection.secondary[i] : newSection.ids[i], typeof section.buffers.state == "number"
+                ? section.buffers.state
+                : section.buffers.state[i], processedState, importedSector, importedSection);
+            newSection.mod[i] = getMod(secondary ? newSection.secondary[i] : newSection.ids[i], typeof section.buffers.mod == "number"
+                ? section.buffers.mod
+                : section.buffers.mod[i], processedMod, importedSector, importedSection);
+        }
+        newSector.sections[sectionIndex] = newSection;
+    }
+    return newSector;
+}

package/World/Archive/Functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ArchiveArea";
+export * from "./ArchiveSector";
+export * from "./ImportSector";

package/World/Archive/Functions/index.js

@@ -0,0 +1,3 @@
+export * from "./ArchiveArea";
+export * from "./ArchiveSector";
+export * from "./ImportSector";

package/World/Archive/InitTasks.d.ts

@@ -0,0 +1,4 @@
+import { Thread } from "@amodx/threads";
+export default function InitTasks(props: {
+    worldThread: Thread;
+}): void;