@divinevoxel/vlox 0.0.72 → 0.0.74

package/World/Archive/Archive.types.d.ts

@@ -1,44 +1,58 @@
 import { Vec3Array } from "@amodx/math";
-import { LocationData } from "../../Math";
+import { BinaryBufferData } from "../../Util/Binary/BinaryBuffer";
+export type ArchivedLightSegments = "sun" | "red" | "green" | "blue";
 /**
  * Interface for an archived sector.
  */
 export interface ArchivedSectorData {
-    /** The version of vlox the data was stored in. */
+    /** A user provided version of the data. */
     version: string;
+    /** The version of vlox the data was stored in. */
+    vloxVersion: string;
+    dimension: string;
     /** The location of the sector in the world. */
-    location: LocationData;
-    /** Record of the sector's state, storing dynamic or user-defined data. */
-    sectorState: Record<string, any>;
+    location: Vec3Array;
+    /** Record of the sector's bit flags.  */
+    flags: Record<string, boolean>;
+    /** Record of the sector's timestamps. */
+    timestamps: Record<string, number>;
     /** The palette data used within the sector. */
     palettes: ArchivedSectorPaletteData;
     /** Placeholder for future buffer data. */
     buffers: ArchivedSectorBuffersData;
-    /** Keys associated with section states and other objects. */
-    keys: ArchivedSectorKeysData;
+    /**Contains duplicate data like duplicate sections. */
+    duplicates: ArchivedSectorDuplicteData;
     /** Array of archived section data within the sector. */
-    sections: ArchivedSectionData[];
+    sections: (ArchivedSectionData | string)[];
+}
+export interface ArchivedSectorDuplicteData {
+    sections?: Record<string, ArchivedSectionData>;
 }
 /**
  * Interface for the palettes of an archived sector.
  */
 export interface ArchivedSectorPaletteData {
     id: string[];
-    secondaryId?: string[];
+    secondaryId: string[];
+    /**A map of sector voxel ids to a palette of store state objects.
+     *1. First depth -> voxels
+     *2. Second depth -> voxel states
+     *3. Third depth -> state object
+     */
+    stateMap: any[][][];
+    /**Same as state map but for secondary voxels */
+    secondaryStateMap: any[][][];
+    /**A map of sector voxel ids to a palette of store mod state objects.
+     *1. First depth -> voxels
+     *2. Second depth -> voxel mode states
+     *3. Third depth -> mode state object
+     */
+    modMap: any[][][];
+    /**Same as mod map but for secondary voxels */
+    secondaryModMap: any[][][];
     level?: Uint8Array;
-    stateMap: Record<number, any[]>;
-    modMap: Record<number, any[]>;
-    state: Uint16Array;
-    mod: Uint16Array;
-    light?: Uint16Array;
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface for the keys of an archived sector.
- */
-export interface ArchivedSectorKeysData {
-    /** Array of strings that are the keys for the section state struct.  */
-    sectionState: string[];
+    light: Partial<Record<ArchivedLightSegments, Uint8Array>>;
+    secondaryValue?: Uint16Array;
 }
 /**
  * Placeholder interface for future buffer data in a sector.
@@ -49,10 +63,10 @@ export interface ArchivedSectorBuffersData {
  * Interface for an archived section.
  */
 export interface ArchivedSectionData {
-    /** Array representing the section's state, holding dynamic or user-defined data. */
-    state: any[];
+    /** Record of the sections's bit flags.  */
+    flags?: Record<string, boolean>;
     /** Palette data used within the section. */
-    palettes: ArchivedSectionPaletteData;
+    palettes?: ArchivedSectionPaletteData;
     /** Buffer data for the section, holding voxel type identifiers, light data, state, and secondary state. */
     buffers: ArchivedSectionBuffers;
 }
@@ -61,23 +75,32 @@ export interface ArchivedSectionData {
  */
 export interface ArchivedSectionPaletteData {
     id?: Uint16Array;
-    light?: Uint16Array;
+    light?: Partial<Record<ArchivedLightSegments, Uint8Array>>;
     level?: Uint8Array;
     secondaryId?: Uint16Array;
-    state?: Uint16Array;
-    mod?: Uint16Array;
-    secondaryState?: Uint16Array;
+    /** Palette of sector voxel ids to a palette of state ids for the voxel*/
+    state?: Record<number, Uint16Array>;
+    /** Palette of sector secondary voxel ids to a palette of state ids for the voxel*/
+    secondaryState?: Record<number, Uint16Array>;
+    /** Palette of sector voxel ids to a palette of mod ids for the voxel*/
+    mod?: Record<number, Uint16Array>;
+    /** Palette of sector secondary voxel ids to a palette of mod ids for the voxel*/
+    secondaryMod?: Record<number, Uint16Array>;
+    secondaryValue?: Uint16Array;
 }
 /**
  * Interface representing the buffer data for a section.
  */
 export interface ArchivedSectionBuffers {
-    id: Uint16Array | Uint8Array | number;
-    light: Uint16Array | Uint8Array | number;
-    level: Uint8Array | number;
-    state: Uint16Array | Uint8Array | number;
-    mod: Uint16Array | Uint8Array | number;
-    secondary: Uint16Array | Uint8Array | number;
+    buried?: Uint8Array | number;
+    voxelMap?: Uint8Array | number;
+    dirtyMap?: Uint8Array | number;
+    id?: BinaryBufferData | number;
+    light?: Partial<Record<ArchivedLightSegments, BinaryBufferData | number>>;
+    level?: BinaryBufferData | number;
+    state?: BinaryBufferData | number;
+    mod?: BinaryBufferData | number;
+    secondary?: BinaryBufferData | number;
 }
 /**
  * Interface for an archived area.
@@ -113,7 +136,7 @@ export interface ArchivedAreaMapData {
     /** Record mapping string IDs to arrays of secondary voxel identifiers. */
     secondaryIdPalette: Record<string, string[]>;
     /** Record mapping string IDs to Uint16Arrays of secondary voxel states. */
-    secondaryStatePalette: Record<string, Uint16Array>;
+    secondaryValuePalette: Record<string, Uint16Array>;
     /** Record mapping section identifiers to `ArchivedSectionData`. */
     section: Record<string, ArchivedSectionData>;
     /** Record mapping sector state identifiers to arrays of state data. */
@@ -133,14 +156,14 @@ export interface ArchivedAreaKeysData {
  */
 export interface ArchivedAreaSectorPaletteData {
     id: string[];
-    light?: Uint16Array;
-    level?: Uint8Array;
-    state?: Uint16Array;
-    mod?: Uint16Array;
+    light: Uint16Array;
+    level: Uint8Array;
+    state: Uint16Array;
+    mod: Uint16Array;
     stateMap: Record<number, any[]>;
     modMap: Record<number, any[]>;
-    secondaryId?: string[];
-    secondaryState?: Uint16Array;
+    secondaryId: string[];
+    secondaryValueState: Uint16Array;
 }
 /**
  * Interface representing the archived data for a sector within an area.

package/World/Archive/Classes/ArchiveClasses.d.ts

@@ -0,0 +1,66 @@
+import { StringPalette } from "../../../Util/StringPalette";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { Section } from "../../../World/Section";
+import { ArchivedLightSegments } from "../Archive.types";
+declare class ProcessedData<Buffer = any> {
+    buffer: Buffer;
+    constructor(buffer: Buffer);
+    allTheSame: boolean;
+    isPaletted: boolean;
+    remapped: boolean;
+    value: number;
+}
+declare class SectionPalette {
+    ids: NumberPalette;
+    level: NumberPalette;
+    light: LightPalette;
+    maxStatePaletteSize: number;
+    state: Record<number, NumberPalette>;
+    secondaryState: Record<number, NumberPalette>;
+    maxModPaletteSize: number;
+    mod: Record<number, NumberPalette>;
+    secondaryMod: Record<number, NumberPalette>;
+    secondaryId: NumberPalette;
+    secondaryValue: NumberPalette;
+}
+export declare class ProcessedSection {
+    original: Section;
+    palettes: SectionPalette;
+    isBuriedAllTheSame: boolean;
+    buriedValue: number;
+    isVoxelMapAllTheSame: boolean;
+    voxelMapValue: number;
+    isDirtyMapAllTheSame: boolean;
+    dirtyMapValue: number;
+    ids: ProcessedData<Uint16Array>;
+    light: Record<ArchivedLightSegments, ProcessedData<Uint8Array>>;
+    level: ProcessedData<Uint8Array>;
+    state: ProcessedData<Uint16Array>;
+    mod: ProcessedData<Uint16Array>;
+    secondary: ProcessedData<Uint16Array>;
+    constructor(original: Section);
+}
+declare class LightPalette {
+    sun: NumberPalette;
+    red: NumberPalette;
+    green: NumberPalette;
+    blue: NumberPalette;
+}
+export declare class VoxelStateObjectMap {
+    palette: NumberPalette;
+    states: any[];
+}
+export declare class SectorPalette {
+    ids: StringPalette;
+    level: NumberPalette;
+    light: LightPalette;
+    stateMap: VoxelStateObjectMap[];
+    secondaryStateMap: VoxelStateObjectMap[];
+    maxStatePaletteSize: number;
+    modMap: VoxelStateObjectMap[];
+    secondaryModMap: VoxelStateObjectMap[];
+    maxModPaletteSize: number;
+    secondaryId: StringPalette;
+    secondaryValue: NumberPalette;
+}
+export {};

package/World/Archive/Classes/ArchiveClasses.js

@@ -0,0 +1,78 @@
+import { StringPalette } from "../../../Util/StringPalette";
+import { NumberPalette } from "../../../Util/NumberPalette";
+class ProcessedData {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    allTheSame = true;
+    isPaletted = false;
+    remapped = false;
+    value = 0;
+}
+class SectionPalette {
+    ids = new NumberPalette();
+    level = new NumberPalette();
+    light = new LightPalette();
+    maxStatePaletteSize = 0;
+    state = {};
+    secondaryState = {};
+    maxModPaletteSize = 0;
+    mod = {};
+    secondaryMod = {};
+    secondaryId = new NumberPalette();
+    secondaryValue = new NumberPalette();
+}
+export class ProcessedSection {
+    original;
+    palettes = new SectionPalette();
+    isBuriedAllTheSame = false;
+    buriedValue = 0;
+    isVoxelMapAllTheSame = false;
+    voxelMapValue = 0;
+    isDirtyMapAllTheSame = false;
+    dirtyMapValue = 0;
+    ids;
+    light;
+    level;
+    state;
+    mod;
+    secondary;
+    constructor(original) {
+        this.original = original;
+        this.ids = new ProcessedData(new Uint16Array(original.ids.length));
+        this.level = new ProcessedData(new Uint8Array(original.level.length));
+        this.light = {
+            sun: new ProcessedData(new Uint8Array(original.light.length)),
+            red: new ProcessedData(new Uint8Array(original.light.length)),
+            green: new ProcessedData(new Uint8Array(original.light.length)),
+            blue: new ProcessedData(new Uint8Array(original.light.length)),
+        };
+        this.state = new ProcessedData(new Uint16Array(original.state.length));
+        this.mod = new ProcessedData(new Uint16Array(original.mod.length));
+        this.secondary = new ProcessedData(new Uint16Array(original.mod.length));
+    }
+}
+class LightPalette {
+    sun = new NumberPalette();
+    red = new NumberPalette();
+    green = new NumberPalette();
+    blue = new NumberPalette();
+}
+export class VoxelStateObjectMap {
+    palette = new NumberPalette();
+    states = [];
+}
+export class SectorPalette {
+    ids = new StringPalette();
+    level = new NumberPalette();
+    light = new LightPalette();
+    stateMap = [];
+    secondaryStateMap = [];
+    maxStatePaletteSize = 0;
+    modMap = [];
+    secondaryModMap = [];
+    maxModPaletteSize = 0;
+    secondaryId = new StringPalette();
+    secondaryValue = new NumberPalette();
+}

package/World/Archive/Classes/ImportedSection.d.ts

@@ -0,0 +1,40 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { ArchivedLightSegments, ArchivedSectionData } from "../Archive.types";
+import { BinaryBuffer } from "../../../Util/Binary/BinaryBuffer";
+import { ImportedSector } from "./ImportedSector";
+declare class ImportedSectionBuffers {
+    ids: BinaryBuffer;
+    level: BinaryBuffer;
+    light: Record<ArchivedLightSegments, BinaryBuffer>;
+    state: BinaryBuffer;
+    mod: BinaryBuffer;
+    secondary: BinaryBuffer;
+    constructor(section: ArchivedSectionData);
+}
+declare class ImportedSectionPalettes {
+    id?: NumberPalette;
+    level?: NumberPalette;
+    light: Record<ArchivedLightSegments, NumberPalette | null>;
+    state?: NumberPalette[];
+    secondaryState?: NumberPalette[];
+    mod?: NumberPalette[];
+    secondaryMod?: NumberPalette[];
+    secondaryId?: NumberPalette;
+    secondaryValue?: NumberPalette;
+    constructor(section: ArchivedSectionData);
+}
+export declare class ImportedSection {
+    sectionIndex: number;
+    sector: ImportedSector;
+    section: ArchivedSectionData;
+    buffers: ImportedSectionBuffers;
+    palettes: ImportedSectionPalettes;
+    constructor(sectionIndex: number, sector: ImportedSector, section: ArchivedSectionData);
+    getId(index: number): number;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+    getState(index: number): number;
+    getMod(index: number): number;
+}
+export {};

package/World/Archive/Classes/ImportedSection.js

@@ -0,0 +1,307 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { BinaryBuffer, BinaryBufferTypes, } from "../../../Util/Binary/BinaryBuffer";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { lightSegments, lightSemgnetSet } from "../Functions/Shared";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+class ImportedSectionBuffers {
+    ids;
+    level;
+    light;
+    state;
+    mod;
+    secondary;
+    constructor(section) {
+        this.ids = !section.buffers.id
+            ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+            : typeof section.buffers.id == "number"
+                ? new BinaryBuffer({
+                    buffer: section.buffers.id,
+                    type: BinaryBufferTypes.Value,
+                })
+                : new BinaryBuffer(section.buffers.id);
+        this.level = !section.buffers.level
+            ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+            : typeof section.buffers.level == "number"
+                ? new BinaryBuffer({
+                    buffer: section.buffers.level,
+                    type: BinaryBufferTypes.Value,
+                })
+                : new BinaryBuffer(section.buffers.level);
+        this.light = {
+            sun: !section.buffers.light?.sun
+                ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+                : typeof section.buffers.light.sun == "number"
+                    ? new BinaryBuffer({
+                        buffer: section.buffers.light.sun,
+                        type: BinaryBufferTypes.Value,
+                    })
+                    : new BinaryBuffer(section.buffers.light.sun),
+            red: !section.buffers.light?.red
+                ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+                : typeof section.buffers.light.red == "number"
+                    ? new BinaryBuffer({
+                        buffer: section.buffers.light.red,
+                        type: BinaryBufferTypes.Value,
+                    })
+                    : new BinaryBuffer(section.buffers.light.red),
+            green: !section.buffers.light?.green
+                ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+                : typeof section.buffers.light.green == "number"
+                    ? new BinaryBuffer({
+                        buffer: section.buffers.light.green,
+                        type: BinaryBufferTypes.Value,
+                    })
+                    : new BinaryBuffer(section.buffers.light.green),
+            blue: !section.buffers.light?.blue
+                ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+                : typeof section.buffers.light.blue == "number"
+                    ? new BinaryBuffer({
+                        buffer: section.buffers.light.blue,
+                        type: BinaryBufferTypes.Value,
+                    })
+                    : new BinaryBuffer(section.buffers.light.blue),
+        };
+        this.state = !section.buffers.state
+            ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+            : typeof section.buffers.state == "number"
+                ? new BinaryBuffer({
+                    buffer: section.buffers.state,
+                    type: BinaryBufferTypes.Value,
+                })
+                : new BinaryBuffer(section.buffers.state);
+        this.mod = !section.buffers.mod
+            ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+            : typeof section.buffers.mod == "number"
+                ? new BinaryBuffer({
+                    buffer: section.buffers.mod,
+                    type: BinaryBufferTypes.Value,
+                })
+                : new BinaryBuffer(section.buffers.mod);
+        this.secondary = !section.buffers.secondary
+            ? new BinaryBuffer({ buffer: 0, type: BinaryBufferTypes.Value })
+            : typeof section.buffers.secondary == "number"
+                ? new BinaryBuffer({
+                    buffer: section.buffers.secondary,
+                    type: BinaryBufferTypes.Value,
+                })
+                : new BinaryBuffer(section.buffers.secondary);
+    }
+}
+class ImportedSectionPalettes {
+    id;
+    level;
+    light;
+    state;
+    secondaryState;
+    mod;
+    secondaryMod;
+    secondaryId;
+    secondaryValue;
+    constructor(section) {
+        this.id = section.palettes?.id
+            ? new NumberPalette(section.palettes?.id)
+            : undefined;
+        this.light = {
+            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,
+        };
+        this.level = section.palettes?.level
+            ? new NumberPalette(section.palettes?.level)
+            : undefined;
+        if (section.palettes?.state) {
+            for (const stateKey in section.palettes.state) {
+                this.state ??= [];
+                this.state[stateKey] = new NumberPalette(section.palettes.state[stateKey]);
+            }
+        }
+        if (section.palettes?.mod) {
+            for (const modKey in section.palettes.mod) {
+                this.mod ??= [];
+                this.mod[modKey] = new NumberPalette(section.palettes.mod[modKey]);
+            }
+        }
+        this.secondaryValue = section.palettes?.secondaryValue
+            ? new NumberPalette(section.palettes?.secondaryValue)
+            : undefined;
+        this.secondaryId = section.palettes?.secondaryId
+            ? new NumberPalette(section.palettes?.secondaryId)
+            : undefined;
+    }
+}
+export class ImportedSection {
+    sectionIndex;
+    sector;
+    section;
+    buffers;
+    palettes;
+    constructor(sectionIndex, sector, section) {
+        this.sectionIndex = sectionIndex;
+        this.sector = sector;
+        this.section = section;
+        this.buffers = new ImportedSectionBuffers(section);
+        this.palettes = new ImportedSectionPalettes(section);
+    }
+    getId(index) {
+        const value = this.buffers.ids.getValue(index);
+        if (this.buffers.ids.type == BinaryBufferTypes.Value) {
+            return VoxelPalettesRegister.voxels.getNumberId(this.sector.palettes.id.getStringId(value));
+        }
+        if (this.palettes.id) {
+            return VoxelPalettesRegister.voxels.getNumberId(this.sector.palettes.id.getStringId(this.palettes.id.getValue(value)));
+        }
+        return VoxelPalettesRegister.voxels.getNumberId(this.sector.palettes.id.getStringId(value));
+    }
+    getLight(index) {
+        let finalLight = 0;
+        for (let l = 0; l < lightSegments.length; l++) {
+            const segment = lightSegments[l];
+            let value = 0;
+            if (this.buffers.light[segment].type == BinaryBufferTypes.Value) {
+                value = this.buffers.light[segment].getValue(index);
+            }
+            else {
+                if (this.buffers.light[segment].type == BinaryBufferTypes.NibbleArray) {
+                    value = this.buffers.light[segment].getValue(index);
+                }
+                else {
+                    if (this.palettes.light[segment]) {
+                        value = this.palettes.light[segment].getValue(this.buffers.light[segment].getValue(index));
+                    }
+                    else if (this.sector.palettes.light[segment]) {
+                        value = this.sector.palettes.light[segment].getValue(this.buffers.light[segment].getValue(index));
+                    }
+                }
+            }
+            finalLight = lightSemgnetSet[segment](value, finalLight);
+        }
+        return finalLight;
+    }
+    getLevel(index) {
+        const value = this.buffers.level.getValue(index);
+        if (this.palettes.level) {
+            return this.palettes.level.getValue(value);
+        }
+        if (this.sector.palettes.level) {
+            return this.sector.palettes.level.getValue(value);
+        }
+        return value;
+    }
+    getSecondary(index) {
+        const voxelId = this.getId(index);
+        const value = this.buffers.secondary.getValue(index);
+        if (VoxelTagsRegister.VoxelTags[voxelId]["dve_can_have_secondary"]) {
+            if (this.palettes.secondaryId) {
+                return VoxelPalettesRegister.voxels.getNumberId(this.sector.palettes.secondaryId.getStringId(this.palettes.secondaryId.getValue(value)));
+            }
+            return VoxelPalettesRegister.voxels.getNumberId(this.sector.sector.palettes.secondaryId[value]);
+        }
+        if (typeof this.section.buffers.secondary == "number") {
+            return value;
+        }
+        if (this.palettes.secondaryValue && this.sector.palettes.secondaryValue) {
+            return this.sector.palettes.secondaryValue.getValue(this.palettes.secondaryValue.getValue(value));
+        }
+        if (this.sector.palettes.secondaryValue) {
+            return this.sector.palettes.secondaryValue.getId(value);
+        }
+        return value;
+    }
+    getState(index) {
+        const stateIndex = this.buffers.state.getValue(index);
+        let returnValue = stateIndex;
+        let voxelId = VoxelPalettesRegister.voxels.getStringId(this.getId(index));
+        const secondary = VoxelTagsRegister.VoxelTags[this.getId(index)]["dve_can_have_secondary"] && this.getSecondary(index) > 0;
+        if (secondary) {
+            voxelId = VoxelPalettesRegister.voxels.getStringId(this.getSecondary(index));
+            let voxelIndex = this.sector.palettes.secondaryId.getNumberId(voxelId);
+            const statePalette = this.sector.palettes.secondaryState[voxelIndex];
+            if (!statePalette)
+                return 0;
+            if (this.buffers.state.type == BinaryBufferTypes.Value) {
+                returnValue = statePalette[stateIndex];
+            }
+            else {
+                if (this.section.palettes?.secondaryState) {
+                    returnValue =
+                        statePalette[this.section.palettes?.secondaryState[voxelIndex][stateIndex]];
+                }
+                else {
+                    returnValue = statePalette[stateIndex];
+                }
+            }
+        }
+        else {
+            let voxelIndex = this.sector.palettes.id.getNumberId(voxelId);
+            const statePalette = this.sector.palettes.state[voxelIndex];
+            if (!statePalette)
+                return 0;
+            if (this.buffers.state.type == BinaryBufferTypes.Value) {
+                returnValue = statePalette[stateIndex];
+            }
+            else {
+                if (this.section.palettes?.state) {
+                    returnValue =
+                        statePalette[this.section.palettes?.state[voxelIndex][stateIndex]];
+                }
+                else {
+                    returnValue = statePalette[stateIndex];
+                }
+            }
+        }
+        return returnValue;
+    }
+    getMod(index) {
+        const modIndex = this.buffers.mod.getValue(index);
+        let returnValue = modIndex;
+        let voxelId = VoxelPalettesRegister.voxels.getStringId(this.getId(index));
+        const secondary = VoxelTagsRegister.VoxelTags[this.getId(index)]["dve_can_have_secondary"] && this.getSecondary(index) > 0;
+        if (secondary) {
+            voxelId = VoxelPalettesRegister.voxels.getStringId(this.getSecondary(index));
+            let voxelIndex = this.sector.palettes.secondaryId.getNumberId(voxelId);
+            const modPalette = this.sector.palettes.secondaryMod[voxelIndex];
+            if (!modPalette)
+                return 0;
+            if (this.buffers.mod.type == BinaryBufferTypes.Value) {
+                returnValue = modPalette[modIndex];
+            }
+            else {
+                if (this.section.palettes?.secondaryMod) {
+                    returnValue =
+                        modPalette[this.section.palettes?.secondaryMod[voxelIndex][modIndex]];
+                }
+                else {
+                    returnValue = modPalette[modIndex];
+                }
+            }
+        }
+        else {
+            let voxelIndex = this.sector.palettes.id.getNumberId(voxelId);
+            const modPalette = this.sector.palettes.mod[voxelIndex];
+            if (!modPalette)
+                return 0;
+            if (this.buffers.mod.type == BinaryBufferTypes.Value) {
+                returnValue = modPalette[modIndex];
+            }
+            else {
+                if (this.section.palettes?.mod) {
+                    returnValue =
+                        modPalette[this.section.palettes?.mod[voxelIndex][modIndex]];
+                }
+                else {
+                    returnValue = modPalette[modIndex];
+                }
+            }
+        }
+        return returnValue;
+    }
+}

package/World/Archive/Classes/ImportedSector.d.ts

@@ -0,0 +1,23 @@
+import { StringPalette } from "../../../Util/StringPalette";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { ArchivedLightSegments, ArchivedSectorData } from "../Archive.types";
+import { ImportedSection } from "./ImportedSection";
+declare class ImportedSectorPalettes {
+    id: StringPalette;
+    secondaryId: StringPalette;
+    secondaryValue: NumberPalette;
+    level?: NumberPalette;
+    light: Record<ArchivedLightSegments, NumberPalette | null>;
+    state: number[][];
+    secondaryState: number[][];
+    mod: number[][];
+    secondaryMod: number[][];
+    constructor(sector: ArchivedSectorData);
+}
+export declare class ImportedSector {
+    sector: ArchivedSectorData;
+    sections: ImportedSection[];
+    palettes: ImportedSectorPalettes;
+    constructor(sector: ArchivedSectorData);
+}
+export {};