@divinevoxel/vlox 0.0.71 → 0.0.73

package/World/Archive/Functions/ArchiveSector.js

@@ -1,54 +1,65 @@
 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";
+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 {
-        section,
+        original: section,
         palettes: getSectionPalettes(),
+        isBuriedAllTheSame: false,
+        buriedValue: 0,
+        isVoxelMapAllTheSame: false,
+        voxelMapValue: 0,
+        isDirtyMapAllTheSame: false,
+        dirtyMapValue: 0,
         // ids
-        ids: new Uint16Array(section.ids.length),
-        idsAllTheSame: true,
-        remappedIds: false,
+        ids: getProcessedData(new Uint16Array(section.ids.length)),
         // light
-        light: new Uint16Array(section.light.length),
-        lightAllTheSame: true,
-        isLightPaletted: false,
-        remappedLight: false,
+        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: new Uint8Array(section.level.length),
-        levelAllTheSame: true,
-        isLevelPaletted: false,
-        remappedLevel: false,
+        level: getProcessedData(new Uint8Array(section.level.length)),
         // state
-        state: new Uint16Array(section.state.length),
-        stateAllTheSame: true,
-        isStatePaletted: false,
-        remappedState: false,
+        state: getProcessedData(new Uint16Array(section.level.length)),
         // mod
-        mod: new Uint16Array(section.mod.length),
-        modAllTheSame: true,
-        isModPaletted: false,
-        remappedMod: false,
+        mod: getProcessedData(new Uint16Array(section.mod.length)),
         // secondary
-        secondary: new Uint16Array(section.secondary.length),
-        isSecondaryPaletted: false,
-        secondaryAllTheSame: true,
-        remappedSecondary: false,
+        secondary: getProcessedData(new Uint16Array(section.mod.length)),
     };
 };
-let sectorStructInstance;
-let sectionStructInstance;
+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: new NumberPalette(),
+        light: getLightPalette(),
         state: new NumberPalette(),
         mod: new NumberPalette(),
         secondaryId: new NumberPalette(),
@@ -59,7 +70,7 @@ function getColumnPalettes() {
     return {
         ids: new StringPalette(),
         level: new NumberPalette(),
-        light: new NumberPalette(),
+        light: getLightPalette(),
         stateIdMap: [],
         state: new NumberPalette(),
         modIdMap: [],
@@ -68,103 +79,315 @@ function getColumnPalettes() {
         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) {
-    sectionStructInstance.setData(archiveSection.section.sectionState);
     const palettes = {};
-    if (archiveSection.remappedIds)
+    if (archiveSection.ids.remapped)
         palettes.id = Uint16Array.from(archiveSection.palettes.ids._palette);
-    if (archiveSection.remappedLevel)
+    if (archiveSection.level.remapped)
         palettes.level = Uint8Array.from(archiveSection.palettes.level._palette);
-    if (archiveSection.remappedLight)
-        palettes.light = Uint16Array.from(archiveSection.palettes.light._palette);
-    if (archiveSection.remappedState)
+    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.remappedMod)
+    if (archiveSection.mod.remapped)
         palettes.mod = Uint16Array.from(archiveSection.palettes.mod._palette);
-    if (archiveSection.remappedSecondary) {
+    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 {
-        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),
-        },
+        ...(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,
     };
 }
+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.`);
-    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);
+        {
+            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;
         for (let i = 0; i < length; i++) {
-            const stringId = VoxelPalette.ids.getStringId(section.ids[i]);
-            VoxelStruct.setStringVoxel(stringId);
+            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 = VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1 &&
-                VoxelPalette.ids.getStringId(section.secondary[i]);
+            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)
@@ -172,20 +395,19 @@ export default function ArchiveSector(archiveData) {
                 : !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) &&
+            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 (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]);
@@ -198,12 +420,10 @@ export default function ArchiveSector(archiveData) {
             }
             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
+                sectorPalettes.modIdMap[voxelMod] = secondaryId
                     ? section.secondary[i]
                     : section.ids[i];
             }
@@ -212,99 +432,147 @@ export default function ArchiveSector(archiveData) {
             }
             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;
+            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);
     }
-    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)
+    let neededPalettes = {
+        level: false,
+        light: {
+            sun: false,
+            red: false,
+            green: false,
+            blue: false,
+        },
+    };
+    for (const archivedSection of processedSections) {
+        //ids
+        archivedSection.ids.isPaletted =
+            sectorPalettes.ids.size <= BinaryBuffer.BytePaletteMax ||
+                archivedSection.palettes.ids.size <= BinaryBuffer.BytePaletteMax;
+        archivedSection.ids.remapped =
+            sectorPalettes.ids.size > BinaryBuffer.BytePaletteMax &&
+                archivedSection.palettes.ids.size <= BinaryBuffer.BytePaletteMax &&
+                !archivedSection.ids.allTheSame;
+        //level
+        archivedSection.level.isPaletted =
+            sectorPalettes.level.size <= BinaryBuffer.NibblePaletteMax &&
+                archivedSection.palettes.level.size <= BinaryBuffer.NibblePaletteMax;
+        archivedSection.level.remapped =
+            sectorPalettes.level.size > BinaryBuffer.NibblePaletteMax &&
+                archivedSection.palettes.level.size <= BinaryBuffer.NibblePaletteMax &&
+                !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;
+        archivedSection.state.remapped =
+            sectorPalettes.state.size > BinaryBuffer.BytePaletteMax &&
+                archivedSection.palettes.state.size <= BinaryBuffer.BytePaletteMax &&
+                !archivedSection.state.allTheSame;
+        //mod
+        archivedSection.mod.isPaletted =
+            sectorPalettes.mod.size <= BinaryBuffer.BytePaletteMax ||
+                archivedSection.palettes.mod.size <= BinaryBuffer.BytePaletteMax;
+        archivedSection.mod.remapped =
+            sectorPalettes.mod.size > BinaryBuffer.BytePaletteMax &&
+                archivedSection.palettes.mod.size <= BinaryBuffer.BytePaletteMax &&
+                !archivedSection.mod.allTheSame;
+        for (const semgnet of lightSegments) {
+            archivedSection.light[semgnet].isPaletted =
+                sectorPalettes.light[semgnet].size <=
+                    BinaryBuffer.HalfNibblePaletteMax ||
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBuffer.HalfNibblePaletteMax;
+            archivedSection.light[semgnet].remapped =
+                sectorPalettes.light[semgnet].size >
+                    BinaryBuffer.HalfNibblePaletteMax &&
+                    archivedSection.palettes.light[semgnet].size <=
+                        BinaryBuffer.HalfNibblePaletteMax &&
+                    !archivedSection.light[semgnet].allTheSame;
+            if (archivedSection.light[semgnet].isPaletted &&
+                !archivedSection.light[semgnet].remapped) {
+                neededPalettes.light[semgnet] = true;
+            }
+        }
+        //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);
+        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 &&
+                !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 = section.section.ids.length;
+        const length = archivedSection.original.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]);
+            if (archivedSection.ids.remapped)
+                archivedSection.ids.buffer[i] = archivedSection.palettes.ids.getId(archivedSection.ids.buffer[i]);
+            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.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.palettes.secondaryId.getId(archivedSection.secondary.buffer[i])
+                    : archivedSection.palettes.secondaryState.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 = VoxelPalette.ids.getStringId(sectorPalettes.stateIdMap[i]);
+        const voxelId = VoxelPalettesRegister.voxels.getStringId(sectorPalettes.stateIdMap[i]);
         if (!SchemaRegister.hasVoxelSchema(voxelId))
             continue;
         const schema = SchemaRegister.getVoxelSchemas(voxelId);
@@ -313,7 +581,7 @@ export default function ArchiveSector(archiveData) {
     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]);
+        const voxelId = VoxelPalettesRegister.voxels.getStringId(sectorPalettes.modIdMap[i]);
         if (!SchemaRegister.hasVoxelSchema(voxelId))
             continue;
         const schema = SchemaRegister.getVoxelSchemas(voxelId);
@@ -329,26 +597,29 @@ export default function ArchiveSector(archiveData) {
         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 (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: "",
+        vloxVersion: EngineSettings.version,
         location: [...archiveData.location],
-        sectorState,
+        flags: sector.storeFlags(),
+        timestamps: sector.storeTimestamps(),
         buffers: {},
-        keys: {
-            sectionState: [...sectionStructInstance.getKeys()],
-        },
         palettes,
+        duplicates: {},
         sections,
     };
+    RemoveDuplicates(archivedSector);
+    return archivedSector;
 }