@divinevoxel/vlox 0.0.72 → 0.0.74

package/World/Archive/Functions/ArchiveSector.js

@@ -1,340 +1,431 @@
-import { StringPalette } from "../../../Util/StringPalette";
-import { NumberPalette } from "../../../Util/NumberPalette";
 import { WorldRegister } from "../../../World/WorldRegister";
-import { convertToPaletteBuffer } from "../../../Util/Binary/Palettes";
 import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
 import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
-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,
-    };
-};
-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) {
-    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: {},
-        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),
-        },
-    };
-}
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+import { BinaryBuffer } from "../../../Util/Binary/BinaryBuffer";
+import { lightSegments, lightSemgnetGet } from "./Shared";
+import { ProcessedSection, SectorPalette, VoxelStateObjectMap, } from "../Classes/ArchiveClasses";
+import { CreateArchivedSection } from "./CreateArchivedSection";
+import { RemoveDuplicates } from "./RemoveDuplicates";
+import { NumberPalette } from "../../../Util/NumberPalette";
+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(`Column at location ${location} does not exist when trying to arhicve it.`);
-    const sectorPalettes = getColumnPalettes();
+        throw new Error(`Sector at location ${location} does not exist when trying to arhicve it.`);
+    const sectorPalettes = new SectorPalette();
     const processedSections = [];
-    for (const section of sector.sections) {
+    for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
+        const section = sector.sections[sectionIndex];
+        const processedSection = new ProcessedSection(section);
+        {
+            let value = section.buried[0];
+            processedSection.isBuriedAllTheSame = true;
+            for (let i = 0; i < section.buried.length; i++) {
+                if (value != section.buried[i]) {
+                    processedSection.isBuriedAllTheSame = false;
+                    break;
+                }
+            }
+            processedSection.buriedValue = value;
+        }
+        {
+            let value = section.voxelMap[0];
+            processedSection.isVoxelMapAllTheSame = true;
+            for (let i = 0; i < section.voxelMap.length; i++) {
+                if (value != section.voxelMap[i]) {
+                    processedSection.isVoxelMapAllTheSame = false;
+                    break;
+                }
+            }
+            processedSection.voxelMapValue = value;
+        }
+        {
+            let value = section.dirtyMap[0];
+            processedSection.isDirtyMapAllTheSame = true;
+            for (let i = 0; i < section.dirtyMap.length; i++) {
+                if (value != section.dirtyMap[i]) {
+                    processedSection.isDirtyMapAllTheSame = false;
+                    break;
+                }
+            }
+            processedSection.dirtyMapValue = value;
+        }
+        const firstId = section.ids[0];
+        const firstLight = section.light[0];
+        const firstLevel = section.level[0];
+        const firstState = section.state[0];
+        const firstMod = section.mod[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;
-        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 = VoxelPalettesRegister.voxels.getStringId(section.ids[i]);
             const voxelId = !sectorPalettes.ids.isRegistered(stringId)
                 ? sectorPalettes.ids.register(stringId)
                 : sectorPalettes.ids.getNumberId(stringId);
+            processedSection.ids.value = voxelId;
             if (!processedSection.palettes.ids.isRegistered(voxelId))
                 processedSection.palettes.ids.register(voxelId);
-            if (firstId == -1)
-                firstId = voxelId;
             const secondaryId = VoxelTagsRegister.VoxelTags[section.ids[i]]["dve_can_have_secondary"] &&
                 VoxelPalettesRegister.voxels.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];
+                : !sectorPalettes.secondaryValue.isRegistered(section.secondary[i])
+                    ? sectorPalettes.secondaryValue.register(section.secondary[i])
+                    : sectorPalettes.secondaryValue.getId(section.secondary[i]);
+            if (VoxelTagsRegister.VoxelTags[section.ids[i]]["dve_can_have_secondary"]) {
+                if (!processedSection.palettes.secondaryId.isRegistered(voxelSecondary))
+                    processedSection.palettes.secondaryId.register(voxelSecondary);
+            }
+            else {
+                if (!processedSection.palettes.secondaryValue.isRegistered(voxelSecondary))
+                    processedSection.palettes.secondaryValue.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]);
-            if (firstLevel == -1)
-                firstLevel = voxelLevel;
+            let stateMap;
+            if (secondaryId) {
+                if (!sectorPalettes.secondaryStateMap[voxelSecondary]) {
+                    stateMap = new VoxelStateObjectMap();
+                    sectorPalettes.secondaryStateMap[voxelId] = stateMap;
+                }
+                else {
+                    stateMap = sectorPalettes.secondaryStateMap[voxelSecondary];
+                }
+            }
+            else {
+                if (!sectorPalettes.stateMap[voxelId]) {
+                    stateMap = new VoxelStateObjectMap();
+                    sectorPalettes.stateMap[voxelId] = stateMap;
+                }
+                else {
+                    stateMap = sectorPalettes.stateMap[voxelId];
+                }
+            }
             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];
+            if (!stateMap.palette.isRegistered(section.state[i])) {
+                voxelState = stateMap.palette.register(section.state[i]);
             }
             else {
-                voxelState = sectorPalettes.state.getId(section.state[i]);
+                voxelState = stateMap.palette.getId(section.state[i]);
+            }
+            if (!processedSection.palettes.state[voxelId]) {
+                processedSection.palettes.state[voxelId] = new NumberPalette();
+            }
+            if (!processedSection.palettes.state[voxelId].isRegistered(voxelState))
+                processedSection.palettes.state[voxelId].register(voxelState);
+            let modMap;
+            if (secondaryId) {
+                if (!sectorPalettes.secondaryModMap[voxelSecondary]) {
+                    modMap = new VoxelStateObjectMap();
+                    sectorPalettes.secondaryModMap[voxelSecondary] = modMap;
+                }
+                else {
+                    modMap = sectorPalettes.secondaryModMap[voxelSecondary];
+                }
+            }
+            else {
+                if (!sectorPalettes.modMap[voxelId]) {
+                    modMap = new VoxelStateObjectMap();
+                    sectorPalettes.modMap[voxelSecondary] = modMap;
+                }
+                else {
+                    modMap = sectorPalettes.modMap[voxelId];
+                }
             }
-            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];
+            if (!modMap.palette.isRegistered(section.mod[i])) {
+                voxelMod = modMap.palette.register(section.mod[i]);
             }
             else {
-                voxelMod = sectorPalettes.mod.getId(section.mod[i]);
+                voxelMod = modMap.palette.getId(section.mod[i]);
+            }
+            if (!processedSection.palettes.mod[voxelId]) {
+                processedSection.palettes.mod[voxelId] = new NumberPalette();
             }
-            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;
+            if (!processedSection.palettes.mod[voxelId].isRegistered(voxelMod))
+                processedSection.palettes.mod[voxelId].register(voxelMod);
+            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.ids.allTheSame = false;
+            if (section.level[i] != firstLevel)
+                processedSection.level.allTheSame = false;
+            if (section.state[i] != firstState)
+                processedSection.state.allTheSame = false;
+            if (section.mod[i] != firstMod)
+                processedSection.mod.allTheSame = false;
+            if (section.secondary[i] != firstSecondary)
+                processedSection.secondary.allTheSame = false;
+            processedSection.ids.buffer[i] = voxelId;
+            processedSection.level.buffer[i] = voxelLevel;
+            processedSection.state.buffer[i] = voxelState;
+            processedSection.mod.buffer[i] = voxelMod;
+            processedSection.secondary.buffer[i] = voxelSecondary;
         }
-        processedSections.push(processedSection);
+        processedSections[sectionIndex] = processedSection;
+    }
+    let neededPalettes = {
+        level: false,
+        light: {
+            sun: false,
+            red: false,
+            green: false,
+            blue: false,
+        },
+    };
+    for (const state of sectorPalettes.stateMap) {
+        if (!state)
+            continue;
+        if (state.palette.size > sectorPalettes.maxStatePaletteSize)
+            sectorPalettes.maxStatePaletteSize = state.palette.size;
     }
-    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)
+    for (const mod of sectorPalettes.modMap) {
+        if (!mod)
             continue;
-        const length = section.section.ids.length;
+        if (mod.palette.size > sectorPalettes.maxModPaletteSize)
+            sectorPalettes.maxModPaletteSize = mod.palette.size;
+    }
+    for (const archivedSection of processedSections) {
+        for (const stateId in archivedSection.palettes.state) {
+            const state = archivedSection.palettes.state[stateId];
+            if (!state)
+                continue;
+            if (state.size > archivedSection.palettes.maxStatePaletteSize)
+                archivedSection.palettes.maxStatePaletteSize = state.size;
+        }
+        for (const modId in archivedSection.palettes.mod) {
+            const mod = archivedSection.palettes.state[modId];
+            if (!mod)
+                continue;
+            if (mod.size > archivedSection.palettes.maxModPaletteSize)
+                archivedSection.palettes.maxModPaletteSize = mod.size;
+        }
+        //ids
+        archivedSection.ids.isPaletted =
+            sectorPalettes.ids.size <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.ids.size <= BinaryBuffer.ByteArrayMax;
+        archivedSection.ids.remapped =
+            sectorPalettes.ids.size > BinaryBuffer.ByteArrayMax &&
+                archivedSection.palettes.ids.size <= BinaryBuffer.ByteArrayMax &&
+                !archivedSection.ids.allTheSame;
+        //level
+        archivedSection.level.isPaletted =
+            sectorPalettes.level.size <= BinaryBuffer.NibbleArrayMax &&
+                archivedSection.palettes.level.size <= BinaryBuffer.NibbleArrayMax;
+        archivedSection.level.remapped =
+            sectorPalettes.level.size > BinaryBuffer.NibbleArrayMax &&
+                archivedSection.palettes.level.size <= BinaryBuffer.NibbleArrayMax &&
+                !archivedSection.level.allTheSame;
+        if (archivedSection.level.isPaletted && !archivedSection.level.remapped) {
+            neededPalettes.level = true;
+        }
+        //state
+        archivedSection.state.isPaletted =
+            sectorPalettes.maxStatePaletteSize <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.maxStatePaletteSize <= BinaryBuffer.ByteArrayMax;
+        archivedSection.state.remapped =
+            sectorPalettes.maxStatePaletteSize > BinaryBuffer.ByteArrayMax &&
+                archivedSection.palettes.maxStatePaletteSize <=
+                    BinaryBuffer.ByteArrayMax &&
+                !archivedSection.state.allTheSame;
+        //mod
+        archivedSection.mod.isPaletted =
+            sectorPalettes.maxModPaletteSize <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.maxModPaletteSize <= BinaryBuffer.ByteArrayMax;
+        archivedSection.mod.remapped =
+            sectorPalettes.maxModPaletteSize > BinaryBuffer.ByteArrayMax &&
+                archivedSection.palettes.maxModPaletteSize <= BinaryBuffer.ByteArrayMax &&
+                !archivedSection.mod.allTheSame;
+        for (const semgnet of lightSegments) {
+            archivedSection.light[semgnet].isPaletted =
+                sectorPalettes.light[semgnet].size <= BinaryBuffer.HalfNibbleArrayMax ||
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBuffer.HalfNibbleArrayMax;
+            archivedSection.light[semgnet].remapped =
+                sectorPalettes.light[semgnet].size > BinaryBuffer.HalfNibbleArrayMax &&
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBuffer.HalfNibbleArrayMax &&
+                    !archivedSection.light[semgnet].allTheSame;
+            if (archivedSection.light[semgnet].isPaletted &&
+                !archivedSection.light[semgnet].remapped) {
+                neededPalettes.light[semgnet] = true;
+            }
+        }
+        //secondary
+        archivedSection.secondary.isPaletted =
+            (sectorPalettes.secondaryValue.size <= BinaryBuffer.ByteArrayMax &&
+                sectorPalettes.secondaryId.size <= BinaryBuffer.ByteArrayMax) ||
+                (archivedSection.palettes.secondaryValue.size <=
+                    BinaryBuffer.ByteArrayMax &&
+                    archivedSection.palettes.secondaryId.size <= BinaryBuffer.ByteArrayMax);
+        archivedSection.secondary.remapped =
+            Math.max(sectorPalettes.secondaryValue.size, sectorPalettes.secondaryId.size) > BinaryBuffer.ByteArrayMax &&
+                Math.max(archivedSection.palettes.secondaryId.size, archivedSection.palettes.secondaryValue.size) <= BinaryBuffer.ByteArrayMax &&
+                !archivedSection.secondary.allTheSame;
+        if (!archivedSection.ids.remapped &&
+            !archivedSection.light.sun.remapped &&
+            !archivedSection.light.red.remapped &&
+            !archivedSection.light.green.remapped &&
+            !archivedSection.light.blue.remapped &&
+            !archivedSection.secondary.remapped &&
+            !archivedSection.mod.remapped &&
+            !archivedSection.level.remapped)
+            continue;
+        const length = archivedSection.original.ids.length;
         for (let i = 0; i < length; 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] = VoxelTagsRegister.VoxelTags[section.ids[i]]["dve_can_have_secondary"]
-                    ? section.palettes.secondaryId.getId(section.secondary[i])
-                    : section.palettes.secondaryState.getId(section.secondary[i]);
+            let secondary = false;
+            if (VoxelTagsRegister.VoxelTags[archivedSection.original.ids[i]]["dve_can_have_secondary"] &&
+                archivedSection.original.secondary[i] !== 0) {
+                secondary = true;
+            }
+            let stateId = !secondary
+                ? archivedSection.ids.buffer[i]
+                : archivedSection.secondary.buffer[i];
+            if (archivedSection.state.remapped)
+                archivedSection.state.buffer[i] = archivedSection.palettes.state[stateId].getId(sectorPalettes.stateMap[stateId].palette.getId(archivedSection.state.buffer[i]));
+            if (archivedSection.mod.remapped)
+                archivedSection.mod.buffer[i] = archivedSection.palettes.mod[stateId].getId(sectorPalettes.modMap[archivedSection.ids.buffer[i]].palette.getId(stateId));
+            if (archivedSection.ids.remapped)
+                archivedSection.ids.buffer[i] =
+                    archivedSection.palettes.ids.getId(stateId);
+            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.secondary.remapped)
+                archivedSection.secondary.buffer[i] = secondary
+                    ? archivedSection.palettes.secondaryId.getId(archivedSection.secondary.buffer[i])
+                    : archivedSection.palettes.secondaryValue.getId(archivedSection.secondary.buffer[i]);
+        }
+    }
+    const palettes = {
+        id: sectorPalettes.ids._palette,
+        stateMap: [],
+        secondaryStateMap: [],
+        modMap: [],
+        secondaryModMap: [],
+        light: {},
+        secondaryId: sectorPalettes.secondaryId._palette,
+        secondaryValue: new Uint16Array(sectorPalettes.secondaryValue._palette),
+    };
+    const stateMap = palettes.stateMap;
+    for (let i = 0; i < sectorPalettes.stateMap.length; i++) {
+        const states = sectorPalettes.stateMap[i]?.palette;
+        if (!states)
+            continue;
+        const voxelId = sectorPalettes.ids._palette[i];
+        if (!SchemaRegister.hasVoxelSchema(voxelId))
+            continue;
+        const schema = SchemaRegister.getVoxelSchemas(voxelId);
+        const voxelStates = [];
+        stateMap[i] = voxelStates;
+        for (let k = 0; k < states._palette.length; k++) {
+            voxelStates[k] = schema.state.getStateObject(states._palette[k]);
         }
     }
-    const stateMap = {};
-    for (let i = 0; i < sectorPalettes.state._palette.length; i++) {
-        const state = sectorPalettes.state._palette[i];
-        const voxelId = VoxelPalettesRegister.voxels.getStringId(sectorPalettes.stateIdMap[i]);
+    const secondaryStateMap = palettes.secondaryStateMap;
+    for (let i = 0; i < sectorPalettes.secondaryStateMap.length; i++) {
+        const states = sectorPalettes.secondaryStateMap[i]?.palette;
+        if (!states)
+            continue;
+        const voxelId = sectorPalettes.secondaryId._palette[i];
         if (!SchemaRegister.hasVoxelSchema(voxelId))
             continue;
         const schema = SchemaRegister.getVoxelSchemas(voxelId);
-        stateMap[i] = schema.state.getStateObject(state);
+        const voxelStates = [];
+        secondaryStateMap[i] = voxelStates;
+        for (let k = 0; k < states._palette.length; k++) {
+            voxelStates[k] = schema.state.getStateObject(states._palette[k]);
+        }
     }
-    const modMap = {};
-    for (let i = 0; i < sectorPalettes.mod._palette.length; i++) {
-        const mod = sectorPalettes.mod._palette[i];
-        const voxelId = VoxelPalettesRegister.voxels.getStringId(sectorPalettes.modIdMap[i]);
+    const modMap = palettes.modMap;
+    for (let i = 0; i < sectorPalettes.modMap.length; i++) {
+        const mods = sectorPalettes.modMap[i]?.palette;
+        if (!mods)
+            continue;
+        const voxelId = sectorPalettes.ids._palette[i];
         if (!SchemaRegister.hasVoxelSchema(voxelId))
             continue;
         const schema = SchemaRegister.getVoxelSchemas(voxelId);
-        modMap[i] = schema.mod.getStateObject(mod);
+        const voxelMods = [];
+        modMap[i] = voxelMods;
+        for (let k = 0; k < mods._palette.length; k++) {
+            voxelMods[k] = schema.mod.getStateObject(mods._palette[k]);
+        }
+    }
+    const secondaryModMap = palettes.modMap;
+    for (let i = 0; i < sectorPalettes.secondaryModMap.length; i++) {
+        const mods = sectorPalettes.secondaryModMap[i]?.palette;
+        if (!mods)
+            continue;
+        const voxelId = sectorPalettes.secondaryId._palette[i];
+        if (!SchemaRegister.hasVoxelSchema(voxelId))
+            continue;
+        const schema = SchemaRegister.getVoxelSchemas(voxelId);
+        const voxelMods = [];
+        secondaryModMap[i] = voxelMods;
+        for (let k = 0; k < mods._palette.length; k++) {
+            voxelMods[k] = schema.mod.getStateObject(mods._palette[k]);
+        }
     }
     const sections = [];
-    for (const section of processedSections) {
-        sections.push(GetArchivedSection(section, sectorPalettes));
+    for (let sectionIndex = 0; sectionIndex < processedSections.length; sectionIndex++) {
+        sections[sectionIndex] = CreateArchivedSection(processedSections[sectionIndex], 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)
+    if (neededPalettes.level) {
         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 {
+    }
+    for (const segment of lightSegments) {
+        if (neededPalettes.light[segment]) {
+            palettes.light[segment] = new Uint8Array(sectorPalettes.light[segment]._palette);
+        }
+    }
+    const archivedSector = {
         version: "",
-        location: [...archiveData.location],
-        sectorState: {},
+        vloxVersion: EngineSettings.version,
+        dimension: WorldRegister.dimensions.get(archiveData.location[0]).id,
+        location: [
+            archiveData.location[1],
+            archiveData.location[2],
+            archiveData.location[3],
+        ],
+        flags: sector.storeFlags(),
+        timestamps: sector.storeTimestamps(),
         buffers: {},
-        keys: {
-            sectionState: [],
-        },
         palettes,
+        duplicates: {},
         sections,
     };
+    RemoveDuplicates(archivedSector);
+    return archivedSector;
 }