@divinevoxel/vlox 0.0.72 → 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 { VoxelDataArrays, 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: VoxelDataArrays) => void;
 };
-export default function ImportSector(sector: ArchivedSectorData, archiveData: RunData): SectorData;
+export default function ImportSector(archivedSector: ArchivedSectorData, archiveData: RunData): SectorData;
 export {};

package/World/Archive/Functions/ImportSector.js

@@ -1,227 +1,57 @@
 import { Sector } from "../../index";
-import { NumberPalette } from "../../../Util/NumberPalette";
-import { StringPalette } from "../../../Util/StringPalette";
-import { getPaletteArray } from "../../../Util/Binary/Palettes";
-import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
-import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
-const updateSectionBuffers = (sector, section) => {
-    if ((sector.palettes.id.length <= 15 ||
-        (section.palettes.id && section.palettes.id.length <= 15)) &&
-        ArrayBuffer.isView(section.buffers.id)) {
-        section.buffers.id = getPaletteArray(Math.min(section.palettes.id?.length || Infinity, sector.palettes.id?.length || 0), section.buffers.id);
-    }
-    if (((section.palettes.light && section.palettes.light.length <= 15) ||
-        (sector.palettes.light && sector.palettes.light.length <= 15)) &&
-        ArrayBuffer.isView(section.buffers.light)) {
-        section.buffers.light = getPaletteArray(Math.min(section.palettes.light?.length || Infinity, sector.palettes.light?.length || 0), section.buffers.light);
-    }
-    if (((section.palettes.state && section.palettes.state.length <= 15) ||
-        (sector.palettes.state && sector.palettes.state.length <= 15)) &&
-        ArrayBuffer.isView(section.buffers.state)) {
-        section.buffers.state = getPaletteArray(Math.min(section.palettes.state?.length || Infinity, sector.palettes.state?.length || 0), section.buffers.state);
-    }
-    if (((section.palettes.mod && section.palettes.mod.length <= 15) ||
-        (sector.palettes.mod && sector.palettes.mod.length <= 15)) &&
-        ArrayBuffer.isView(section.buffers.mod)) {
-        section.buffers.mod = getPaletteArray(Math.min(section.palettes.mod?.length || Infinity, sector.palettes.mod?.length || 0), section.buffers.mod);
-    }
-    if (((section.palettes.secondaryState &&
-        section.palettes.secondaryState.length <= 15) ||
-        (sector.palettes.secondaryState &&
-            sector.palettes.secondaryState.length <= 15)) &&
-        ((section.palettes.secondaryId &&
-            section.palettes.secondaryId.length <= 15) ||
-            (sector.palettes.secondaryId &&
-                sector.palettes.secondaryId.length <= 15)) &&
-        ArrayBuffer.isView(section.buffers.secondary)) {
-        section.buffers.secondary = getPaletteArray(Math.max(Math.min(section.palettes.secondaryId?.length || Infinity, sector.palettes.secondaryId?.length || 0), Math.min(section.palettes.secondaryState?.length || Infinity, sector.palettes.secondaryState?.length || 0)), section.buffers.secondary);
-    }
-};
-const getImportedColumnData = (sector) => {
-    return {
-        sector,
-        idPalette: new StringPalette(sector.palettes.id),
-        secondaryId: sector.palettes.secondaryId
-            ? new StringPalette(sector.palettes.secondaryId)
-            : undefined,
-        lightPalette: sector.palettes.light
-            ? new NumberPalette(sector.palettes.light)
-            : undefined,
-        statePalette: sector.palettes.state
-            ? new NumberPalette(sector.palettes.state)
-            : undefined,
-        modPalette: sector.palettes.mod
-            ? new NumberPalette(sector.palettes.mod)
-            : undefined,
-        secondaryState: sector.palettes.secondaryState
-            ? new NumberPalette(sector.palettes.secondaryState)
-            : undefined,
-    };
-};
-const getImportedSectionData = (section) => {
-    return {
-        section,
-        idPalette: section.palettes.id
-            ? new NumberPalette(section.palettes.id)
-            : undefined,
-        lightPalette: section.palettes.light
-            ? new NumberPalette(section.palettes.light)
-            : undefined,
-        statePalette: section.palettes.state
-            ? new NumberPalette(section.palettes.state)
-            : undefined,
-        modPalette: section.palettes.mod
-            ? new NumberPalette(section.palettes.mod)
-            : undefined,
-        secondaryState: section.palettes.secondaryState
-            ? new NumberPalette(section.palettes.secondaryState)
-            : undefined,
-        secondaryId: section.palettes.secondaryId
-            ? new NumberPalette(section.palettes.secondaryId)
-            : undefined,
-    };
-};
-const getId = (value, importedColumn, importedSection) => {
-    if (importedSection.section.buffers.state instanceof Uint16Array)
-        return value;
-    if (typeof importedSection.section.buffers.id == "number") {
-        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.id[importedSection.section.buffers.id]);
-    }
-    if (importedSection.idPalette) {
-        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.idPalette.getStringId(importedSection.idPalette.getValue(value)));
-    }
-    return VoxelPalettesRegister.voxels.getNumberId(importedColumn.idPalette.getStringId(value));
-};
-const getLight = (value, importedColumn, importedSection) => {
-    if (importedSection.section.buffers.light instanceof Uint16Array)
-        return value;
-    if (typeof importedSection.section.buffers.light == "number") {
-        return value;
-    }
-    if (importedSection.lightPalette) {
-        return importedSection.lightPalette.getValue(value);
-    }
-    if (importedColumn.lightPalette) {
-        return importedColumn.lightPalette.getValue(value);
-    }
-    return value;
-};
-const getState = (voxelId, value, processedState, importedColumn, importedSection) => {
-    const voxelStringId = 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 (importedColumn.statePalette) {
-        stateId = value;
-    }
-    if (processedState[stateId] !== undefined)
-        return processedState[stateId];
-    value = SchemaRegister.getVoxelSchemas(voxelStringId).state.fromStateObject(importedColumn.sector.palettes.stateMap[stateId]);
-    processedState[stateId] = value;
-    return value;
-};
-const getMod = (voxelId, value, processedMod, importedColumn, importedSection) => {
-    const voxelStringId = 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 (importedColumn.modPalette) {
-        modId = value;
-    }
-    if (processedMod[modId] !== undefined)
-        return processedMod[modId];
-    value = SchemaRegister.getVoxelSchemas(voxelStringId).mod.fromStateObject(importedColumn.sector.palettes.modMap[modId]);
-    processedMod[modId] = value;
-    return value;
-};
-const getSecondary = (voxelId, value, importedColumn, importedSection) => {
-    if (VoxelTagsRegister.VoxelTags[voxelId]["dve_can_have_secondary"]) {
-        if (typeof importedSection.section.buffers.secondary == "number") {
-            return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.secondaryId[importedSection.section.buffers.secondary]);
+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],
+    ]);
+    sector.loadFlags(archivedSector.flags);
+    sector.loadTimestamps(archivedSector.timestamps);
+    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++) {
+                section.buried[i] = archivedSection.buffers.buried || 0;
+            }
         }
-        if (importedSection.secondaryId) {
-            return VoxelPalettesRegister.voxels.getNumberId(importedColumn.secondaryId.getStringId(importedSection.secondaryId.getValue(value)));
+        else {
+            for (let i = 0; i < section.buried.length; i++) {
+                section.buried[i] = archivedSection.buffers.buried[i];
+            }
         }
-        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.secondaryId[value]);
-    }
-    if (typeof importedSection.section.buffers.secondary == "number") {
-        return value;
-    }
-    if (importedSection.secondaryState && importedColumn.secondaryState) {
-        return importedColumn.secondaryState.getValue(importedSection.secondaryState.getValue(value));
-    }
-    if (importedColumn.secondaryState) {
-        return importedColumn.secondaryState.getId(value);
-    }
-    return value;
-};
-export default function ImportSector(sector, archiveData) {
-    const newSector = new Sector(Sector.CreateNew());
-    newSector.position[0] = sector.location[1];
-    newSector.position[1] = sector.location[2];
-    newSector.position[2] = sector.location[3];
-    if (!archiveData.loadColumnState) {
-        //sectorStructInstance.deserialize(sector.sectorState);
-    }
-    else {
-        archiveData.loadColumnState(sector.sectorState, newSector);
-    }
-    const importedSector = getImportedColumnData(sector);
-    const processedState = {};
-    const processedMod = {};
-    for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
-        const section = sector.sections[sectionIndex];
-        const importedSection = getImportedSectionData(section);
-        const newSection = newSector.sections[sectionIndex];
-        const sectionState = {};
-        for (let i = 0; i < sector.keys.sectionState.length; i++) {
-            sectionState[sector.keys.sectionState[i]] = section.state[i];
+        if (!ArrayBuffer.isView(archivedSection.buffers.voxelMap)) {
+            for (let i = 0; i < section.voxelMap.length; i++) {
+                section.voxelMap[i] = archivedSection.buffers.voxelMap || 0;
+            }
+        }
+        else {
+            for (let i = 0; i < section.voxelMap.length; i++) {
+                section.voxelMap[i] = archivedSection.buffers.voxelMap[i];
+            }
+        }
+        if (!ArrayBuffer.isView(archivedSection.buffers.dirtyMap)) {
+            for (let i = 0; i < section.dirtyMap.length; i++) {
+                section.dirtyMap[i] = archivedSection.buffers.dirtyMap || 0;
+            }
+        }
+        else {
+            for (let i = 0; i < section.dirtyMap.length; i++) {
+                section.dirtyMap[i] = archivedSection.buffers.dirtyMap[i];
+            }
         }
-        updateSectionBuffers(sector, section);
-        /* if (!archiveData.loadSectionState) {
-          sectionStructInstance.setData(newSection.sectionState);
-          sectionStructInstance.deserialize(sectionState);
-        } else {
-          archiveData.loadSectionState(
-            sector.keys.sectionState,
-            section.state,
-            newSection
-          );
-        } */
-        for (let i = 0; i < newSection.ids.length; i++) {
-            newSection.ids[i] = getId(typeof section.buffers.id == "number"
-                ? section.buffers.id
-                : section.buffers.id[i], importedSector, importedSection);
-            newSection.light[i] = getLight(typeof section.buffers.light == "number"
-                ? section.buffers.light
-                : section.buffers.light[i], importedSector, importedSection);
-            newSection.secondary[i] = getSecondary(newSection.ids[i], typeof section.buffers.secondary == "number"
-                ? section.buffers.secondary
-                : section.buffers.secondary[i], importedSector, importedSection);
-            let secondary = VoxelTagsRegister.VoxelTags[newSection.ids[i]]["dve_can_have_secondary"] && newSection.secondary[i] > 0;
-            newSection.state[i] = getState(secondary ? newSection.secondary[i] : newSection.ids[i], typeof section.buffers.state == "number"
-                ? section.buffers.state
-                : section.buffers.state[i], processedState, importedSector, importedSection);
-            newSection.mod[i] = getMod(secondary ? newSection.secondary[i] : newSection.ids[i], typeof section.buffers.mod == "number"
-                ? section.buffers.mod
-                : section.buffers.mod[i], processedMod, importedSector, importedSection);
+        for (let i = 0; i < section.ids.length; i++) {
+            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);
         }
-        newSector.sections[sectionIndex] = newSection;
     }
-    return newSector;
+    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

@@ -0,0 +1,6 @@
+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 getLightBuffer(light: ArchivedLightSegments, buffer: Uint16Array): Uint8Array;

package/World/Archive/Functions/Shared.js

@@ -0,0 +1,50 @@
+import { setNibbleArrayIndex } from "../../../Util/Binary/BinaryArrays";
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
+const lightData = new VoxelLightData();
+export const lightSegments = [
+    "sun",
+    "red",
+    "green",
+    "blue",
+];
+export const lightSemgnetGet = {
+    sun: (value) => lightData.getS(value),
+    red: (value) => lightData.getR(value),
+    green: (value) => lightData.getG(value),
+    blue: (value) => lightData.getB(value),
+};
+export const lightSemgnetSet = {
+    sun: (value, source) => lightData.setS(value, source),
+    red: (value, source) => lightData.setR(value, source),
+    green: (value, source) => lightData.setG(value, source),
+    blue: (value, source) => lightData.setB(value, source),
+};
+const charset = "0123456789ABCDEF";
+export function uint16To4CharString(value) {
+    if (value < 0 || value > 0xffff) {
+        throw new RangeError("Value must be a 16-bit unsigned integer.");
+    }
+    const chars = [];
+    for (let i = 0; i < 4; i++) {
+        const charCode = (value >> (i * 4)) & 0x0f;
+        chars.unshift(charset[charCode]);
+    }
+    const result = chars.join("").replace(/^0+(?!$)/, "");
+    return result;
+}
+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 array;
+}