@divinevoxel/vlox 0.0.73 → 0.0.74

package/World/Archive/Functions/ArchiveSector.js

@@ -1,337 +1,25 @@
-import { StringPalette } from "../../../Util/StringPalette";
-import { NumberPalette } from "../../../Util/NumberPalette";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
 import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
 import { EngineSettings } from "../../../Settings/EngineSettings";
-import { setNibbleArrayIndex } from "../../../Util/Binary/BinaryArrays";
 import { BinaryBuffer } from "../../../Util/Binary/BinaryBuffer";
-import { compareSection, lightSegments, lightSemgnetGet, uint16To4CharString, } from "./Shared";
-function getProcessedData(buffer) {
-    return {
-        buffer,
-        allTheSame: true,
-        isPaletted: false,
-        remapped: false,
-        value: 0,
-    };
-}
-const getProcessedSection = (section) => {
-    return {
-        original: section,
-        palettes: getSectionPalettes(),
-        isBuriedAllTheSame: false,
-        buriedValue: 0,
-        isVoxelMapAllTheSame: false,
-        voxelMapValue: 0,
-        isDirtyMapAllTheSame: false,
-        dirtyMapValue: 0,
-        // ids
-        ids: getProcessedData(new Uint16Array(section.ids.length)),
-        // light
-        light: {
-            sun: getProcessedData(new Uint8Array(section.light.length)),
-            red: getProcessedData(new Uint8Array(section.light.length)),
-            green: getProcessedData(new Uint8Array(section.light.length)),
-            blue: getProcessedData(new Uint8Array(section.light.length)),
-        },
-        // level
-        level: getProcessedData(new Uint8Array(section.level.length)),
-        // state
-        state: getProcessedData(new Uint16Array(section.level.length)),
-        // mod
-        mod: getProcessedData(new Uint16Array(section.mod.length)),
-        // secondary
-        secondary: getProcessedData(new Uint16Array(section.mod.length)),
-    };
-};
-function getLightPalette() {
-    return {
-        sun: new NumberPalette(),
-        red: new NumberPalette(),
-        green: new NumberPalette(),
-        blue: new NumberPalette(),
-    };
-}
-function getSectionPalettes() {
-    return {
-        ids: new NumberPalette(),
-        level: new NumberPalette(),
-        light: getLightPalette(),
-        state: new NumberPalette(),
-        mod: new NumberPalette(),
-        secondaryId: new NumberPalette(),
-        secondaryState: new NumberPalette(),
-    };
-}
-function getColumnPalettes() {
-    return {
-        ids: new StringPalette(),
-        level: new NumberPalette(),
-        light: getLightPalette(),
-        stateIdMap: [],
-        state: new NumberPalette(),
-        modIdMap: [],
-        mod: new NumberPalette(),
-        secondaryId: new StringPalette(),
-        secondaryState: new NumberPalette(),
-    };
-}
-function getLightBuffer(light, buffer) {
-    const array = new Uint8Array(buffer.length / 2);
-    for (let i = 0; i < buffer.length; i++) {
-        let l = 0;
-        if (light == "sun")
-            l = lightData.getS(buffer[i]);
-        if (light == "red")
-            l = lightData.getR(buffer[i]);
-        if (light == "green")
-            l = lightData.getG(buffer[i]);
-        if (light == "blue")
-            l = lightData.getB(buffer[i]);
-        setNibbleArrayIndex(array, i, l);
-    }
-    return array;
-}
-function GetArchivedSection(archiveSection, sectorPalettes) {
-    const palettes = {};
-    if (archiveSection.ids.remapped)
-        palettes.id = Uint16Array.from(archiveSection.palettes.ids._palette);
-    if (archiveSection.level.remapped)
-        palettes.level = Uint8Array.from(archiveSection.palettes.level._palette);
-    if (archiveSection.light.sun.remapped) {
-        palettes.light ??= {};
-        palettes.light.sun = Uint8Array.from(archiveSection.palettes.light.sun._palette);
-    }
-    if (archiveSection.light.red.remapped) {
-        palettes.light ??= {};
-        palettes.light.red = Uint8Array.from(archiveSection.palettes.light.red._palette);
-    }
-    if (archiveSection.light.green.remapped) {
-        palettes.light ??= {};
-        palettes.light.green = Uint8Array.from(archiveSection.palettes.light.green._palette);
-    }
-    if (archiveSection.light.blue.remapped) {
-        palettes.light ??= {};
-        palettes.light.blue = Uint8Array.from(archiveSection.palettes.light.blue._palette);
-    }
-    if (archiveSection.state.remapped)
-        palettes.state = Uint16Array.from(archiveSection.palettes.state._palette);
-    if (archiveSection.mod.remapped)
-        palettes.mod = Uint16Array.from(archiveSection.palettes.mod._palette);
-    if (archiveSection.secondary.remapped) {
-        palettes.secondaryId = Uint16Array.from(archiveSection.palettes.secondaryId._palette);
-        palettes.secondaryState = Uint16Array.from(archiveSection.palettes.secondaryState._palette);
-    }
-    const buffers = {};
-    //id
-    if (archiveSection.ids.allTheSame) {
-        if (archiveSection.ids.buffer[0] !== 0) {
-            buffers.id = archiveSection.ids.buffer[0];
-        }
-    }
-    else if (archiveSection.ids.isPaletted) {
-        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.ids.remapped
-            ? archiveSection.palettes.ids.size
-            : sectorPalettes.ids.size);
-        buffers.id = BinaryBuffer.Create({
-            buffer: BinaryBuffer.Convert(archiveSection.ids.buffer, "16-bit", type),
-            type,
-        });
-    }
-    else {
-        buffers.id = BinaryBuffer.Create({
-            buffer: archiveSection.ids.buffer,
-        });
-    }
-    //level
-    if (archiveSection.level.allTheSame) {
-        if (archiveSection.level.buffer[0] !== 0) {
-            buffers.level = archiveSection.level.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, "8-bit", type),
-            type,
-        });
-    }
-    else {
-        buffers.level = BinaryBuffer.Create({
-            buffer: archiveSection.original.level.slice(),
-        });
-    }
-    for (const semgnet of lightSegments) {
-        if (archiveSection.light[semgnet].allTheSame) {
-            if (archiveSection.light[semgnet].value !== 0) {
-                buffers.light ??= {};
-                buffers.light[semgnet] = archiveSection.light[semgnet].value;
-            }
-        }
-        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, "8-bit", type),
-                type,
-            });
-        }
-        else {
-            buffers.light ??= {};
-            buffers.light[semgnet] = BinaryBuffer.Create({
-                buffer: getLightBuffer(semgnet, archiveSection.original.light),
-                type: "4-bit",
-            });
-        }
-    }
-    if (archiveSection.state.allTheSame) {
-        if (archiveSection.state.buffer[0] !== 0) {
-            buffers.state = archiveSection.state.buffer[0];
-        }
-    }
-    else if (archiveSection.state.isPaletted) {
-        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.state.remapped
-            ? archiveSection.palettes.state.size
-            : sectorPalettes.state.size);
-        buffers.state = BinaryBuffer.Create({
-            buffer: BinaryBuffer.Convert(archiveSection.state.buffer, "16-bit", type),
-            type,
-        });
-    }
-    else {
-        buffers.state = BinaryBuffer.Create({
-            buffer: archiveSection.state.buffer,
-        });
-    }
-    if (archiveSection.mod.allTheSame) {
-        if (archiveSection.mod.buffer[0] !== 0) {
-            buffers.mod = archiveSection.mod.buffer[0];
-        }
-    }
-    else if (archiveSection.mod.isPaletted) {
-        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.mod.remapped
-            ? archiveSection.palettes.mod.size
-            : sectorPalettes.mod.size);
-        buffers.mod = BinaryBuffer.Create({
-            buffer: BinaryBuffer.Convert(archiveSection.mod.buffer, "16-bit", type),
-            type,
-        });
-    }
-    else {
-        buffers.mod = BinaryBuffer.Create({
-            buffer: archiveSection.mod.buffer,
-        });
-    }
-    if (archiveSection.secondary.allTheSame) {
-        if (archiveSection.secondary.buffer[0] !== 0) {
-            buffers.secondary = archiveSection.secondary.buffer[0];
-        }
-    }
-    else if (archiveSection.secondary.isPaletted) {
-        const type = BinaryBuffer.DetermineSubByteArray(archiveSection.secondary.remapped
-            ? Math.max(archiveSection.palettes.secondaryState.size, archiveSection.palettes.secondaryId.size)
-            : Math.max(sectorPalettes.secondaryState.size, sectorPalettes.secondaryId.size));
-        buffers.secondary = BinaryBuffer.Create({
-            buffer: BinaryBuffer.Convert(archiveSection.secondary.buffer, "16-bit", type),
-            type,
-        });
-    }
-    else {
-        buffers.secondary = BinaryBuffer.Create({
-            buffer: archiveSection.secondary.buffer,
-        });
-    }
-    if (archiveSection.isBuriedAllTheSame) {
-        if (archiveSection.buriedValue !== 0) {
-            buffers.buried = archiveSection.buriedValue;
-        }
-    }
-    else {
-        buffers.buried = archiveSection.original.buried.slice();
-    }
-    if (archiveSection.isVoxelMapAllTheSame) {
-        if (archiveSection.voxelMapValue !== 0) {
-            buffers.voxelMap = archiveSection.voxelMapValue;
-        }
-    }
-    else {
-        buffers.voxelMap = archiveSection.original.voxelMap.slice();
-    }
-    if (archiveSection.isDirtyMapAllTheSame) {
-        if (archiveSection.dirtyMapValue !== 0) {
-            buffers.dirtyMap = archiveSection.dirtyMapValue;
-        }
-    }
-    else {
-        buffers.dirtyMap = archiveSection.original.dirtyMap.slice();
-    }
-    const flags = archiveSection.original.storeFlags();
-    return {
-        ...(Object.keys(flags).length ? { flags } : {}),
-        ...(Object.keys(palettes).length ? { palettes } : {}),
-        buffers,
-    };
-}
-function RemoveDuplicates(data) {
-    const duplicateSectionMap = new Map();
-    let duplicateSections = [];
-    for (let i = 0; i < data.sections.length; i++) {
-        for (let j = 0; j < data.sections.length; j++) {
-            const section1 = data.sections[i];
-            const section2 = data.sections[j];
-            if (i == j)
-                continue;
-            if (typeof section1 == "string" || typeof section2 == "string")
-                continue;
-            let index = -1;
-            if (compareSection(section1, section2)) {
-                if (duplicateSectionMap.has(section2)) {
-                    index = duplicateSectionMap.get(section2)[1];
-                }
-                else {
-                    let found = false;
-                    for (let k = 0; k < duplicateSections.length; k++) {
-                        if (compareSection(section1, duplicateSections[k])) {
-                            index = k;
-                            found = true;
-                        }
-                    }
-                    if (!found) {
-                        duplicateSections.push(section1);
-                        index = duplicateSections.length - 1;
-                    }
-                }
-                duplicateSectionMap.set(section1, [i, index]);
-            }
-        }
-    }
-    const sections = {};
-    for (const [object, [sectionIndex, index]] of duplicateSectionMap) {
-        const id = uint16To4CharString(index);
-        if (!sections[id])
-            sections[id] = object;
-        data.sections[sectionIndex] = id;
-    }
-    data.duplicates = {
-        sections,
-    };
-}
+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) {
-        const processedSection = getProcessedSection(section);
+    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;
@@ -392,46 +80,84 @@ export default function ArchiveSector(archiveData) {
                 ? !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]);
+                : !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.secondaryState.isRegistered(voxelSecondary))
-                    processedSection.palettes.secondaryState.register(voxelSecondary);
+                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]);
+            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 = 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 {
-                voxelState = sectorPalettes.state.getId(section.state[i]);
+                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);
             let voxelMod = -1;
-            if (!sectorPalettes.mod.isRegistered(section.mod[i])) {
-                voxelMod = sectorPalettes.mod.register(section.mod[i]);
-                sectorPalettes.modIdMap[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 (!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]);
@@ -461,7 +187,7 @@ export default function ArchiveSector(archiveData) {
             processedSection.mod.buffer[i] = voxelMod;
             processedSection.secondary.buffer[i] = voxelSecondary;
         }
-        processedSections.push(processedSection);
+        processedSections[sectionIndex] = processedSection;
     }
     let neededPalettes = {
         level: false,
@@ -472,53 +198,78 @@ export default function ArchiveSector(archiveData) {
             blue: false,
         },
     };
+    for (const state of sectorPalettes.stateMap) {
+        if (!state)
+            continue;
+        if (state.palette.size > sectorPalettes.maxStatePaletteSize)
+            sectorPalettes.maxStatePaletteSize = state.palette.size;
+    }
+    for (const mod of sectorPalettes.modMap) {
+        if (!mod)
+            continue;
+        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.BytePaletteMax ||
-                archivedSection.palettes.ids.size <= BinaryBuffer.BytePaletteMax;
+            sectorPalettes.ids.size <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.ids.size <= BinaryBuffer.ByteArrayMax;
         archivedSection.ids.remapped =
-            sectorPalettes.ids.size > BinaryBuffer.BytePaletteMax &&
-                archivedSection.palettes.ids.size <= BinaryBuffer.BytePaletteMax &&
+            sectorPalettes.ids.size > BinaryBuffer.ByteArrayMax &&
+                archivedSection.palettes.ids.size <= BinaryBuffer.ByteArrayMax &&
                 !archivedSection.ids.allTheSame;
         //level
         archivedSection.level.isPaletted =
-            sectorPalettes.level.size <= BinaryBuffer.NibblePaletteMax &&
-                archivedSection.palettes.level.size <= BinaryBuffer.NibblePaletteMax;
+            sectorPalettes.level.size <= BinaryBuffer.NibbleArrayMax &&
+                archivedSection.palettes.level.size <= BinaryBuffer.NibbleArrayMax;
         archivedSection.level.remapped =
-            sectorPalettes.level.size > BinaryBuffer.NibblePaletteMax &&
-                archivedSection.palettes.level.size <= BinaryBuffer.NibblePaletteMax &&
+            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.state.size <= BinaryBuffer.BytePaletteMax ||
-                archivedSection.palettes.state.size <= BinaryBuffer.BytePaletteMax;
+            sectorPalettes.maxStatePaletteSize <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.maxStatePaletteSize <= BinaryBuffer.ByteArrayMax;
         archivedSection.state.remapped =
-            sectorPalettes.state.size > BinaryBuffer.BytePaletteMax &&
-                archivedSection.palettes.state.size <= BinaryBuffer.BytePaletteMax &&
+            sectorPalettes.maxStatePaletteSize > BinaryBuffer.ByteArrayMax &&
+                archivedSection.palettes.maxStatePaletteSize <=
+                    BinaryBuffer.ByteArrayMax &&
                 !archivedSection.state.allTheSame;
         //mod
         archivedSection.mod.isPaletted =
-            sectorPalettes.mod.size <= BinaryBuffer.BytePaletteMax ||
-                archivedSection.palettes.mod.size <= BinaryBuffer.BytePaletteMax;
+            sectorPalettes.maxModPaletteSize <= BinaryBuffer.ByteArrayMax ||
+                archivedSection.palettes.maxModPaletteSize <= BinaryBuffer.ByteArrayMax;
         archivedSection.mod.remapped =
-            sectorPalettes.mod.size > BinaryBuffer.BytePaletteMax &&
-                archivedSection.palettes.mod.size <= BinaryBuffer.BytePaletteMax &&
+            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.HalfNibblePaletteMax ||
+                sectorPalettes.light[semgnet].size <= BinaryBuffer.HalfNibbleArrayMax ||
                     archivedSection.palettes.light[semgnet].size <=
-                        BinaryBuffer.HalfNibblePaletteMax;
+                        BinaryBuffer.HalfNibbleArrayMax;
             archivedSection.light[semgnet].remapped =
-                sectorPalettes.light[semgnet].size >
-                    BinaryBuffer.HalfNibblePaletteMax &&
+                sectorPalettes.light[semgnet].size > BinaryBuffer.HalfNibbleArrayMax &&
                     archivedSection.palettes.light[semgnet].size <=
-                        BinaryBuffer.HalfNibblePaletteMax &&
+                        BinaryBuffer.HalfNibbleArrayMax &&
                     !archivedSection.light[semgnet].allTheSame;
             if (archivedSection.light[semgnet].isPaletted &&
                 !archivedSection.light[semgnet].remapped) {
@@ -527,15 +278,14 @@ export default function ArchiveSector(archiveData) {
         }
         //secondary
         archivedSection.secondary.isPaletted =
-            (sectorPalettes.secondaryState.size <= BinaryBuffer.BytePaletteMax &&
-                sectorPalettes.secondaryId.size <= BinaryBuffer.BytePaletteMax) ||
-                (archivedSection.palettes.secondaryState.size <=
-                    BinaryBuffer.BytePaletteMax &&
-                    archivedSection.palettes.secondaryId.size <=
-                        BinaryBuffer.BytePaletteMax);
+            (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.secondaryState.size, sectorPalettes.secondaryId.size) > BinaryBuffer.BytePaletteMax &&
-                Math.max(archivedSection.palettes.secondaryId.size, archivedSection.palettes.secondaryState.size) <= BinaryBuffer.BytePaletteMax &&
+            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 &&
@@ -548,8 +298,21 @@ export default function ArchiveSector(archiveData) {
             continue;
         const length = archivedSection.original.ids.length;
         for (let i = 0; i < length; 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(archivedSection.ids.buffer[i]);
+                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) {
@@ -559,48 +322,86 @@ export default function ArchiveSector(archiveData) {
             }
             if (archivedSection.level.remapped)
                 archivedSection.level.buffer[i] = archivedSection.palettes.level.getId(archivedSection.original.level[i]);
-            if (archivedSection.state.remapped)
-                archivedSection.state.buffer[i] = archivedSection.palettes.state.getId(sectorPalettes.state.getId(archivedSection.state.buffer[i]));
-            if (archivedSection.mod.remapped)
-                archivedSection.mod.buffer[i] = archivedSection.palettes.mod.getId(sectorPalettes.mod.getId(archivedSection.mod.buffer[i]));
             if (archivedSection.secondary.remapped)
-                archivedSection.secondary.buffer[i] = VoxelTagsRegister.VoxelTags[archivedSection.original.ids[i]]["dve_can_have_secondary"]
+                archivedSection.secondary.buffer[i] = secondary
                     ? archivedSection.palettes.secondaryId.getId(archivedSection.secondary.buffer[i])
-                    : archivedSection.palettes.secondaryState.getId(archivedSection.secondary.buffer[i]);
+                    : archivedSection.palettes.secondaryValue.getId(archivedSection.secondary.buffer[i]);
         }
     }
-    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 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);
-        stateMap[i] = schema.state.getStateObject(state);
+        const voxelStates = [];
+        stateMap[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 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);
-        modMap[i] = schema.mod.getStateObject(mod);
+        const voxelStates = [];
+        secondaryStateMap[i] = voxelStates;
+        for (let k = 0; k < states._palette.length; k++) {
+            voxelStates[k] = schema.state.getStateObject(states._palette[k]);
+        }
+    }
+    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);
+        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),
-        light: {},
-        secondaryId: sectorPalettes.secondaryId._palette,
-        secondaryState: new Uint16Array(sectorPalettes.secondaryState._palette),
-    };
     if (neededPalettes.level) {
         palettes.level = new Uint8Array(sectorPalettes.level._palette);
     }
@@ -612,7 +413,12 @@ export default function ArchiveSector(archiveData) {
     const archivedSector = {
         version: "",
         vloxVersion: EngineSettings.version,
-        location: [...archiveData.location],
+        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: {},