@divinevoxel/vlox 0.0.73 → 0.0.74

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

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

package/World/Archive/Functions/CreateArchivedSection.js

@@ -0,0 +1,207 @@
+import { BinaryBuffer, BinaryBufferTypes, } from "../../../Util/Binary/BinaryBuffer";
+import { getLightBuffer, lightSegments } from "./Shared";
+export function CreateArchivedSection(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) {
+        for (const i in archiveSection.palettes.state) {
+            palettes.state ??= [];
+            palettes.state[i] = Uint16Array.from(archiveSection.palettes.state[i]._palette);
+        }
+        for (const i in archiveSection.palettes.secondaryState) {
+            palettes.secondaryState ??= [];
+            palettes.secondaryState[i] = Uint16Array.from(archiveSection.palettes.secondaryState[i]._palette);
+        }
+    }
+    if (archiveSection.mod.remapped) {
+        for (const i in archiveSection.palettes.mod) {
+            palettes.mod ??= [];
+            palettes.mod[i] = Uint16Array.from(archiveSection.palettes.mod[i]._palette);
+        }
+        for (const i in archiveSection.palettes.secondaryMod) {
+            palettes.secondaryMod ??= [];
+            palettes.secondaryMod[i] = Uint16Array.from(archiveSection.palettes.secondaryMod[i]._palette);
+        }
+    }
+    if (archiveSection.secondary.remapped) {
+        palettes.secondaryId = Uint16Array.from(archiveSection.palettes.secondaryId._palette);
+        palettes.secondaryValue = Uint16Array.from(archiveSection.palettes.secondaryValue._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, BinaryBufferTypes.ShortArray, type).buffer,
+            type,
+        });
+    }
+    else {
+        buffers.id = BinaryBuffer.Create({
+            buffer: archiveSection.ids.buffer.buffer,
+            type: BinaryBufferTypes.ShortArray,
+        });
+    }
+    //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, BinaryBufferTypes.ByteArray, type).buffer,
+            type,
+        });
+    }
+    else {
+        buffers.level = BinaryBuffer.Create({
+            buffer: archiveSection.original.level.slice().buffer,
+            type: BinaryBufferTypes.ByteArray,
+        });
+    }
+    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, BinaryBufferTypes.ByteArray, type).buffer,
+                type,
+            });
+        }
+        else {
+            buffers.light ??= {};
+            buffers.light[semgnet] = BinaryBuffer.Create({
+                buffer: getLightBuffer(semgnet, archiveSection.original.light).buffer,
+                type: BinaryBufferTypes.NibbleArray,
+            });
+        }
+    }
+    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.maxStatePaletteSize
+            : sectorPalettes.maxStatePaletteSize);
+        buffers.state = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.state.buffer, BinaryBufferTypes.ShortArray, type).buffer,
+            type,
+        });
+    }
+    else {
+        buffers.state = BinaryBuffer.Create({
+            buffer: archiveSection.state.buffer.buffer,
+            type: BinaryBufferTypes.ShortArray,
+        });
+    }
+    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.maxModPaletteSize
+            : sectorPalettes.maxModPaletteSize);
+        buffers.mod = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.mod.buffer, BinaryBufferTypes.ShortArray, type).buffer,
+            type,
+        });
+    }
+    else {
+        buffers.mod = BinaryBuffer.Create({
+            buffer: archiveSection.mod.buffer.buffer,
+            type: BinaryBufferTypes.ShortArray,
+        });
+    }
+    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.secondaryValue.size, archiveSection.palettes.secondaryId.size)
+            : Math.max(sectorPalettes.secondaryValue.size, sectorPalettes.secondaryId.size));
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(archiveSection.secondary.buffer, BinaryBufferTypes.ShortArray, type).buffer,
+            type,
+        });
+    }
+    else {
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: archiveSection.secondary.buffer.buffer,
+            type: BinaryBufferTypes.ShortArray,
+        });
+    }
+    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,
+    };
+}

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

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

package/World/Archive/Functions/ImportSector.js

@@ -1,245 +1,17 @@
 import { Sector } from "../../index";
-import { NumberPalette } from "../../../Util/NumberPalette";
-import { StringPalette } from "../../../Util/StringPalette";
-import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
-import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
-import { BinaryBuffer } from "../../../Util/Binary/BinaryBuffer";
-import { lightSegments, lightSemgnetSet } from "./Shared";
-const getImportedSectorData = (sector) => {
-    return {
-        sector,
-        idPalette: new StringPalette(sector.palettes.id),
-        secondaryId: new StringPalette(sector.palettes.secondaryId),
-        levelPalette: sector.palettes.level
-            ? new NumberPalette(sector.palettes.level)
-            : undefined,
-        lightPalette: {
-            sun: sector.palettes.light.sun
-                ? new NumberPalette(sector.palettes.light.sun)
-                : null,
-            red: sector.palettes.light.red
-                ? new NumberPalette(sector.palettes.light.red)
-                : null,
-            green: sector.palettes.light.green
-                ? new NumberPalette(sector.palettes.light.green)
-                : null,
-            blue: sector.palettes.light.blue
-                ? new NumberPalette(sector.palettes.light.blue)
-                : null,
-        },
-        statePalette: new NumberPalette(sector.palettes.state),
-        modPalette: new NumberPalette(sector.palettes.mod),
-        secondaryState: new NumberPalette(sector.palettes.secondaryState),
-    };
-};
-const getImportedSectionData = (section) => {
-    return {
-        section,
-        buffers: {
-            ids: !section.buffers.id
-                ? new BinaryBuffer({ buffer: 0 })
-                : typeof section.buffers.id == "number"
-                    ? new BinaryBuffer({ buffer: section.buffers.id })
-                    : new BinaryBuffer(section.buffers.id),
-            level: !section.buffers.level
-                ? new BinaryBuffer({ buffer: 0 })
-                : typeof section.buffers.level == "number"
-                    ? new BinaryBuffer({ buffer: section.buffers.level })
-                    : new BinaryBuffer(section.buffers.level),
-            light: {
-                sun: !section.buffers.light?.sun
-                    ? new BinaryBuffer({ buffer: 0 })
-                    : typeof section.buffers.light.sun == "number"
-                        ? new BinaryBuffer({ buffer: section.buffers.light.sun })
-                        : new BinaryBuffer(section.buffers.light.sun),
-                red: !section.buffers.light?.red
-                    ? new BinaryBuffer({ buffer: 0 })
-                    : typeof section.buffers.light.red == "number"
-                        ? new BinaryBuffer({ buffer: section.buffers.light.red })
-                        : new BinaryBuffer(section.buffers.light.red),
-                green: !section.buffers.light?.green
-                    ? new BinaryBuffer({ buffer: 0 })
-                    : typeof section.buffers.light.green == "number"
-                        ? new BinaryBuffer({ buffer: section.buffers.light.green })
-                        : new BinaryBuffer(section.buffers.light.green),
-                blue: !section.buffers.light?.blue
-                    ? new BinaryBuffer({ buffer: 0 })
-                    : typeof section.buffers.light.blue == "number"
-                        ? new BinaryBuffer({ buffer: section.buffers.light.blue })
-                        : new BinaryBuffer(section.buffers.light.blue),
-            },
-            state: !section.buffers.state
-                ? new BinaryBuffer({ buffer: 0 })
-                : typeof section.buffers.state == "number"
-                    ? new BinaryBuffer({ buffer: section.buffers.state })
-                    : new BinaryBuffer(section.buffers.state),
-            mod: !section.buffers.mod
-                ? new BinaryBuffer({ buffer: 0 })
-                : typeof section.buffers.mod == "number"
-                    ? new BinaryBuffer({ buffer: section.buffers.mod })
-                    : new BinaryBuffer(section.buffers.mod),
-            secondary: !section.buffers.secondary
-                ? new BinaryBuffer({ buffer: 0 })
-                : typeof section.buffers.secondary == "number"
-                    ? new BinaryBuffer({ buffer: section.buffers.secondary })
-                    : new BinaryBuffer(section.buffers.secondary),
-        },
-        idPalette: section.palettes?.id
-            ? new NumberPalette(section.palettes?.id)
-            : undefined,
-        lightPalette: {
-            sun: section.palettes?.light?.sun
-                ? new NumberPalette(section.palettes?.light?.sun)
-                : null,
-            red: section.palettes?.light?.red
-                ? new NumberPalette(section.palettes?.light?.red)
-                : null,
-            green: section.palettes?.light?.green
-                ? new NumberPalette(section.palettes?.light?.green)
-                : null,
-            blue: section.palettes?.light?.blue
-                ? new NumberPalette(section.palettes?.light?.blue)
-                : null,
-        },
-        levelPalette: section.palettes?.level
-            ? new NumberPalette(section.palettes?.level)
-            : undefined,
-        statePalette: section.palettes?.state
-            ? new NumberPalette(section.palettes?.state)
-            : undefined,
-        modPalette: section.palettes?.mod
-            ? new NumberPalette(section.palettes?.mod)
-            : undefined,
-        secondaryState: section.palettes?.secondaryState
-            ? new NumberPalette(section.palettes?.secondaryState)
-            : undefined,
-        secondaryId: section.palettes?.secondaryId
-            ? new NumberPalette(section.palettes?.secondaryId)
-            : undefined,
-    };
-};
-const getId = (value, importedSector, importedSection) => {
-    if (importedSection.buffers.ids.type == "value") {
-        return VoxelPalettesRegister.voxels.getNumberId(importedSector.idPalette.getStringId(value));
-    }
-    if (importedSection.idPalette) {
-        return VoxelPalettesRegister.voxels.getNumberId(importedSector.idPalette.getStringId(importedSection.idPalette.getValue(value)));
-    }
-    return VoxelPalettesRegister.voxels.getNumberId(importedSector.idPalette.getStringId(value));
-};
-const getLight = (index, importedSector, importedSection) => {
-    let finalLight = 0;
-    for (let l = 0; l < lightSegments.length; l++) {
-        const segment = lightSegments[l];
-        let value = 0;
-        if (importedSection.buffers.light[segment].type == "value") {
-            value = importedSection.buffers.light[segment].getValue(index);
-        }
-        else {
-            if (importedSection.buffers.light[segment].type == "4-bit") {
-                value = importedSection.buffers.light[segment].getValue(index);
-            }
-            else {
-                if (importedSection.lightPalette[segment]) {
-                    value = importedSection.lightPalette[segment].getValue(importedSection.buffers.light[segment].getValue(index));
-                }
-                else if (importedSector.lightPalette[segment]) {
-                    value = importedSector.lightPalette[segment].getValue(importedSection.buffers.light[segment].getValue(index));
-                }
-            }
-        }
-        finalLight = lightSemgnetSet[segment](value, finalLight);
-    }
-    return finalLight;
-};
-const getLevel = (value, importedSector, importedSection) => {
-    if (importedSection.levelPalette) {
-        return importedSection.levelPalette.getValue(value);
-    }
-    if (importedSector.levelPalette) {
-        return importedSector.levelPalette.getValue(value);
-    }
-    return value;
-};
-const getState = (voxelId, value, processedState, importedSector, importedSection) => {
-    const voxelStringId = VoxelPalettesRegister.voxels.getStringId(voxelId);
-    if (!SchemaRegister.hasVoxelSchema(voxelStringId))
-        return value;
-    let stateId = -1;
-    if (importedSection.section.buffers.state instanceof Uint16Array ||
-        typeof importedSection.section.buffers.state == "number") {
-        stateId = value;
-    }
-    if (importedSection.statePalette) {
-        stateId = importedSection.statePalette.getValue(value);
-    }
-    else if (importedSector.statePalette) {
-        stateId = value;
-    }
-    if (processedState[stateId] !== undefined)
-        return processedState[stateId];
-    value = SchemaRegister.getVoxelSchemas(voxelStringId).state.fromStateObject(importedSector.sector.palettes.stateMap[stateId]);
-    processedState[stateId] = value;
-    return value;
-};
-const getMod = (voxelId, value, processedMod, importedSector, importedSection) => {
-    const voxelStringId = VoxelPalettesRegister.voxels.getStringId(voxelId);
-    if (!SchemaRegister.hasVoxelSchema(voxelStringId))
-        return value;
-    let modId = -1;
-    if (importedSection.section.buffers.state instanceof Uint16Array ||
-        typeof importedSection.section.buffers.state == "number") {
-        modId = value;
-    }
-    if (importedSection.modPalette) {
-        modId = importedSection.modPalette.getValue(value);
-    }
-    else if (importedSector.modPalette) {
-        modId = value;
-    }
-    if (processedMod[modId] !== undefined)
-        return processedMod[modId];
-    value = SchemaRegister.getVoxelSchemas(voxelStringId).mod.fromStateObject(importedSector.sector.palettes.modMap[modId]);
-    processedMod[modId] = value;
-    return value;
-};
-const getSecondary = (voxelId, value, importedSector, importedSection) => {
-    if (VoxelTagsRegister.VoxelTags[voxelId]["dve_can_have_secondary"]) {
-        if (importedSection.secondaryId) {
-            return VoxelPalettesRegister.voxels.getNumberId(importedSector.secondaryId.getStringId(importedSection.secondaryId.getValue(value)));
-        }
-        return VoxelPalettesRegister.voxels.getNumberId(importedSector.sector.palettes.secondaryId[value]);
-    }
-    if (typeof importedSection.section.buffers.secondary == "number") {
-        return value;
-    }
-    if (importedSection.secondaryState && importedSector.secondaryState) {
-        return importedSector.secondaryState.getValue(importedSection.secondaryState.getValue(value));
-    }
-    if (importedSector.secondaryState) {
-        return importedSector.secondaryState.getId(value);
-    }
-    return value;
-};
+import { ImportedSector } from "../Classes/ImportedSector";
 export default function ImportSector(archivedSector, archiveData) {
     const sector = new Sector(Sector.CreateNew(), [
+        archivedSector.location[0],
         archivedSector.location[1],
         archivedSector.location[2],
-        archivedSector.location[3],
     ]);
     sector.loadFlags(archivedSector.flags);
     sector.loadTimestamps(archivedSector.timestamps);
-    const importedSector = getImportedSectorData(archivedSector);
-    const processedState = {};
-    const processedMod = {};
-    for (let sectionIndex = 0; sectionIndex < archivedSector.sections.length; sectionIndex++) {
-        const archivedSectionValue = archivedSector.sections[sectionIndex];
-        const archivedSection = typeof archivedSectionValue == "string"
-            ? archivedSector.duplicates?.sections?.[archivedSectionValue]
-            : archivedSectionValue;
-        const importedSection = getImportedSectionData(archivedSection);
-        const section = sector.sections[sectionIndex];
+    const importedSector = new ImportedSector(archivedSector);
+    for (const importedSection of importedSector.sections) {
+        const archivedSection = importedSection.section;
+        const section = sector.sections[importedSection.sectionIndex];
         archivedSection.flags && section.loadFlags(archivedSection.flags);
         if (!ArrayBuffer.isView(archivedSection.buffers.buried)) {
             for (let i = 0; i < section.buried.length; i++) {
@@ -272,17 +44,14 @@ export default function ImportSector(archivedSector, archiveData) {
             }
         }
         for (let i = 0; i < section.ids.length; i++) {
-            section.ids[i] = getId(importedSection.buffers.ids.getValue(i), importedSector, importedSection);
-            section.level[i] = getLevel(importedSection.buffers.level.getValue(i), importedSector, importedSection);
-            section.light[i] = getLight(i, importedSector, importedSection);
-            section.secondary[i] = getSecondary(section.ids[i], importedSection.buffers.secondary.getValue(i), importedSector, importedSection);
-            let secondary = VoxelTagsRegister.VoxelTags[section.ids[i]]["dve_can_have_secondary"] &&
-                section.secondary[i] > 0;
-            section.state[i] = getState(secondary ? section.secondary[i] : section.ids[i], importedSection.buffers.state.getValue(i), processedState, importedSector, importedSection);
-            section.mod[i] = getMod(secondary ? section.secondary[i] : section.ids[i], importedSection.buffers.mod.getValue(i), processedMod, importedSector, importedSection);
+            section.ids[i] = importedSection.getId(i);
+            section.level[i] = importedSection.getLevel(i);
+            section.light[i] = importedSection.getLight(i);
+            section.secondary[i] = importedSection.getSecondary(i);
+            section.state[i] = importedSection.getState(i);
+            section.mod[i] = importedSection.getMod(i);
         }
-        sector.sections[sectionIndex] = section;
     }
-    sector.setBitFlag(Sector.FlagIds.isStored, true);
+    sector.setBitFlag(Sector.FlagIds.stored, true);
     return sector;
 }

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

@@ -0,0 +1,3 @@
+import { ArchivedSectionData, ArchivedSectorData } from "../Archive.types";
+export declare function compareSection(section1: ArchivedSectionData, section2: ArchivedSectionData): boolean;
+export declare function RemoveDuplicates(data: ArchivedSectorData): void;

package/World/Archive/Functions/RemoveDuplicates.js

@@ -0,0 +1,92 @@
+import { uint16To4CharString } from "./Shared";
+function traverseSection(source, target) {
+    if (typeof source == "object" && typeof target == "object") {
+        if (Object.keys(source).length != Object.keys(target).length)
+            return false;
+    }
+    for (const key in source) {
+        if (!(key in target))
+            return false;
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (!ArrayBuffer.isView(sourceValue) &&
+            typeof sourceValue === "object" &&
+            sourceValue !== null &&
+            !ArrayBuffer.isView(targetValue) &&
+            typeof targetValue == "object" &&
+            targetValue !== null) {
+            if (!traverseSection(sourceValue, targetValue))
+                return false;
+            continue;
+        }
+        if (typeof sourceValue === "number" ||
+            typeof sourceValue === "string" ||
+            typeof targetValue === "number" ||
+            typeof targetValue === "string") {
+            if (sourceValue !== targetValue)
+                return false;
+            continue;
+        }
+        if (sourceValue instanceof Uint8Array ||
+            sourceValue instanceof Uint16Array) {
+            if (!(targetValue instanceof sourceValue.constructor))
+                return false;
+            if (sourceValue.length !== targetValue.length)
+                return false;
+            let target = targetValue;
+            for (let i = 0; i < target.length; i++) {
+                if (sourceValue[i] != target[i])
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+export function compareSection(section1, section2) {
+    return traverseSection(section1, section2);
+}
+export function RemoveDuplicates(data) {
+    const duplicateSectionMap = new Map();
+    let duplicateSections = [];
+    for (let i = 0; i < data.sections.length; i++) {
+        for (let j = i + 1; j < data.sections.length; j++) {
+            const section1 = data.sections[i];
+            const section2 = data.sections[j];
+            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 (let i = 0; i < data.sections.length; i++) {
+        const section = data.sections[i];
+        if (duplicateSectionMap.has(section)) {
+            const [, dupIndex] = duplicateSectionMap.get(section);
+            const id = uint16To4CharString(dupIndex);
+            data.sections[i] = id;
+            sections[id] = section;
+        }
+    }
+    data.duplicates = {
+        sections,
+    };
+}

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

@@ -1,6 +1,6 @@
-import { ArchivedLightSegments, ArchivedSectionData } from "../Archive.types";
+import { ArchivedLightSegments } from "../Archive.types";
 export declare const lightSegments: ArchivedLightSegments[];
 export declare const lightSemgnetGet: Record<ArchivedLightSegments, (value: number) => number>;
 export declare const lightSemgnetSet: Record<ArchivedLightSegments, (value: number, source: number) => number>;
 export declare function uint16To4CharString(value: number): string;
-export declare function compareSection(section1: ArchivedSectionData, section2: ArchivedSectionData): boolean;
+export declare function getLightBuffer(light: ArchivedLightSegments, buffer: Uint16Array): Uint8Array;

package/World/Archive/Functions/Shared.js

@@ -1,3 +1,4 @@
+import { setNibbleArrayIndex } from "../../../Util/Binary/BinaryArrays";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
 const lightData = new VoxelLightData();
 export const lightSegments = [
@@ -31,45 +32,19 @@ export function uint16To4CharString(value) {
     const result = chars.join("").replace(/^0+(?!$)/, "");
     return result;
 }
-function traverseSection(source, target) {
-    for (const key in source) {
-        if (!(key in target))
-            return false;
-        const sourceValue = source[key];
-        const targetValue = target[key];
-        if (!ArrayBuffer.isView(sourceValue) &&
-            typeof sourceValue === "object" &&
-            sourceValue !== null &&
-            !ArrayBuffer.isView(targetValue) &&
-            typeof targetValue == "object" &&
-            targetValue !== null) {
-            if (!traverseSection(sourceValue, targetValue))
-                return false;
-            continue;
-        }
-        if (typeof sourceValue === "number" ||
-            typeof sourceValue === "string" ||
-            typeof targetValue === "number" ||
-            typeof targetValue === "string") {
-            if (sourceValue !== targetValue)
-                return false;
-            continue;
-        }
-        if (sourceValue instanceof Uint8Array ||
-            sourceValue instanceof Uint16Array) {
-            if (!(targetValue instanceof sourceValue.constructor))
-                return false;
-            if (sourceValue.length !== targetValue.length)
-                return false;
-            let target = targetValue;
-            for (let i = 0; i < target.length; i++) {
-                if (sourceValue[i] != target[i])
-                    return false;
-            }
-        }
+export 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 true;
-}
-export function compareSection(section1, section2) {
-    return traverseSection(section1, section2);
+    return array;
 }