@divinevoxel/vlox 0.0.7 → 0.0.72

package/World/Archive/Functions/ArchiveArea.js

@@ -1,5 +1,4 @@
 import { BinaryObject } from "@amodx/binary";
-import { Sector } from "../../../World/index";
 const charset = "0123456789ABCDEF";
 function uint16To4CharString(value) {
     if (value < 0 || value > 0xffff) {
@@ -13,7 +12,6 @@ function uint16To4CharString(value) {
     const result = chars.join("").replace(/^0+(?!$)/, "");
     return result;
 }
-let sectorStructInstance;
 const processPalettes = (archiveData) => {
     const allRegistered = new Set();
     for (const sector of archiveData.sectors) {
@@ -107,7 +105,7 @@ const buildSectorState = (archiveData) => {
     const maped = new Map();
     const binaryObjects = new Map();
     let count = 0;
-    const sectorStateKeys = sectorStructInstance.getKeys();
+    const sectorStateKeys = [];
     const created = new Map();
     const processSectorState = (sector, sectorStateMap) => {
         if (typeof sector.sectorState == "string")
@@ -246,9 +244,7 @@ function SectorToArchivedAreaSector(sector) {
     };
 }
 export default function CreateArchiveArea(archiveData) {
-    if (!sectorStructInstance)
-        sectorStructInstance = Sector.StateStruct.instantiate();
-    const sectorStateKeys = sectorStructInstance.getKeys();
+    const sectorStateKeys = [];
     const sectors = [];
     for (const sector of archiveData.sectors) {
         sectors.push(SectorToArchivedAreaSector(sector));

package/World/Archive/Functions/ArchiveSector.js

@@ -1,12 +1,10 @@
 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 { convertToPaletteBuffer } from "../../../Util/Binary/Palettes";
 import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
 const getProcessedSection = (section) => {
     return {
         section,
@@ -42,8 +40,6 @@ const getProcessedSection = (section) => {
         remappedSecondary: false,
     };
 };
-let sectorStructInstance;
-let sectionStructInstance;
 function getSectionPalettes() {
     return {
         ids: new NumberPalette(),
@@ -69,7 +65,6 @@ function getColumnPalettes() {
     };
 }
 function GetArchivedSection(archiveSection, sectorPalettes) {
-    sectionStructInstance.setData(archiveSection.section.sectionState);
     const palettes = {};
     if (archiveSection.remappedIds)
         palettes.id = Uint16Array.from(archiveSection.palettes.ids._palette);
@@ -86,7 +81,7 @@ function GetArchivedSection(archiveSection, sectorPalettes) {
         palettes.secondaryState = Uint16Array.from(archiveSection.palettes.secondaryState._palette);
     }
     return {
-        state: Object.values(sectionStructInstance.serialize()),
+        state: {},
         palettes,
         buffers: {
             id: archiveSection.idsAllTheSame
@@ -136,13 +131,7 @@ 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;
@@ -154,8 +143,7 @@ export default function ArchiveSector(archiveData) {
         let firstSecondary = -1;
         const processedSection = getProcessedSection(section);
         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);
@@ -163,8 +151,8 @@ export default function ArchiveSector(archiveData) {
                 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)
@@ -283,7 +271,6 @@ export default function ArchiveSector(archiveData) {
             continue;
         const length = section.section.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)
@@ -295,16 +282,15 @@ export default function ArchiveSector(archiveData) {
             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]);
+                section.secondary[i] = VoxelTagsRegister.VoxelTags[section.ids[i]]["dve_can_have_secondary"]
+                    ? section.palettes.secondaryId.getId(section.secondary[i])
+                    : section.palettes.secondaryState.getId(section.secondary[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 +299,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);
@@ -343,10 +329,10 @@ export default function ArchiveSector(archiveData) {
     return {
         version: "",
         location: [...archiveData.location],
-        sectorState,
+        sectorState: {},
         buffers: {},
         keys: {
-            sectionState: [...sectionStructInstance.getKeys()],
+            sectionState: [],
         },
         palettes,
         sections,

package/World/Archive/Functions/ImportSector.js

@@ -1,13 +1,10 @@
-import { VoxelPalette } from "../../../Voxels/Palettes/VoxelPalette";
-import { Section, Sector } from "../../index";
-import { VoxelStruct } from "../../../Voxels/Structs/VoxelStruct";
-import { VoxelStructIds } from "../../../Voxels/Types/Voxel.types";
+import { Sector } from "../../index";
 import { NumberPalette } from "../../../Util/NumberPalette";
 import { StringPalette } from "../../../Util/StringPalette";
-import { getPaletteArray } from "../../../Data/Functions/Palettes";
+import { getPaletteArray } from "../../../Util/Binary/Palettes";
 import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-let sectorStructInstance;
-let sectionStructInstance;
+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)) &&
@@ -33,7 +30,8 @@ const updateSectionBuffers = (sector, section) => {
         section.palettes.secondaryState.length <= 15) ||
         (sector.palettes.secondaryState &&
             sector.palettes.secondaryState.length <= 15)) &&
-        ((section.palettes.secondaryId && section.palettes.secondaryId.length <= 15) ||
+        ((section.palettes.secondaryId &&
+            section.palettes.secondaryId.length <= 15) ||
             (sector.palettes.secondaryId &&
                 sector.palettes.secondaryId.length <= 15)) &&
         ArrayBuffer.isView(section.buffers.secondary)) {
@@ -88,12 +86,12 @@ const getId = (value, importedColumn, importedSection) => {
     if (importedSection.section.buffers.state instanceof Uint16Array)
         return value;
     if (typeof importedSection.section.buffers.id == "number") {
-        return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.id[importedSection.section.buffers.id]);
+        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.id[importedSection.section.buffers.id]);
     }
     if (importedSection.idPalette) {
-        return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(importedSection.idPalette.getValue(value)));
+        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.idPalette.getStringId(importedSection.idPalette.getValue(value)));
     }
-    return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(value));
+    return VoxelPalettesRegister.voxels.getNumberId(importedColumn.idPalette.getStringId(value));
 };
 const getLight = (value, importedColumn, importedSection) => {
     if (importedSection.section.buffers.light instanceof Uint16Array)
@@ -110,7 +108,7 @@ const getLight = (value, importedColumn, importedSection) => {
     return value;
 };
 const getState = (voxelId, value, processedState, importedColumn, importedSection) => {
-    const voxelStringId = VoxelPalette.ids.getStringId(voxelId);
+    const voxelStringId = VoxelPalettesRegister.voxels.getStringId(voxelId);
     if (!SchemaRegister.hasVoxelSchema(voxelStringId))
         return value;
     let stateId = -1;
@@ -131,7 +129,7 @@ const getState = (voxelId, value, processedState, importedColumn, importedSectio
     return value;
 };
 const getMod = (voxelId, value, processedMod, importedColumn, importedSection) => {
-    const voxelStringId = VoxelPalette.ids.getStringId(voxelId);
+    const voxelStringId = VoxelPalettesRegister.voxels.getStringId(voxelId);
     if (!SchemaRegister.hasVoxelSchema(voxelStringId))
         return value;
     let modId = -1;
@@ -152,15 +150,14 @@ const getMod = (voxelId, value, processedMod, importedColumn, importedSection) =
     return value;
 };
 const getSecondary = (voxelId, value, importedColumn, importedSection) => {
-    VoxelStruct.setVoxel(voxelId);
-    if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
+    if (VoxelTagsRegister.VoxelTags[voxelId]["dve_can_have_secondary"]) {
         if (typeof importedSection.section.buffers.secondary == "number") {
-            return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.secondaryId[importedSection.section.buffers.secondary]);
+            return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.secondaryId[importedSection.section.buffers.secondary]);
         }
         if (importedSection.secondaryId) {
-            return VoxelPalette.ids.getNumberId(importedColumn.secondaryId.getStringId(importedSection.secondaryId.getValue(value)));
+            return VoxelPalettesRegister.voxels.getNumberId(importedColumn.secondaryId.getStringId(importedSection.secondaryId.getValue(value)));
         }
-        return VoxelPalette.ids.getNumberId(importedColumn.sector.palettes.secondaryId[value]);
+        return VoxelPalettesRegister.voxels.getNumberId(importedColumn.sector.palettes.secondaryId[value]);
     }
     if (typeof importedSection.section.buffers.secondary == "number") {
         return value;
@@ -174,17 +171,12 @@ const getSecondary = (voxelId, value, importedColumn, importedSection) => {
     return value;
 };
 export default function ImportSector(sector, archiveData) {
-    if (!sectorStructInstance)
-        sectorStructInstance = Sector.StateStruct.instantiate();
-    if (!sectionStructInstance)
-        sectionStructInstance = Section.StateStruct.instantiate();
     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.setData(newSector.sectorState);
-        sectorStructInstance.deserialize(sector.sectorState);
+        //sectorStructInstance.deserialize(sector.sectorState);
     }
     else {
         archiveData.loadColumnState(sector.sectorState, newSector);
@@ -201,13 +193,16 @@ export default function ImportSector(sector, archiveData) {
             sectionState[sector.keys.sectionState[i]] = section.state[i];
         }
         updateSectionBuffers(sector, section);
-        if (!archiveData.loadSectionState) {
-            sectionStructInstance.setData(newSection.sectionState);
-            sectionStructInstance.deserialize(sectionState);
-        }
-        else {
-            archiveData.loadSectionState(sector.keys.sectionState, section.state, newSection);
-        }
+        /* 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
@@ -218,9 +213,7 @@ export default function ImportSector(sector, archiveData) {
             newSection.secondary[i] = getSecondary(newSection.ids[i], typeof section.buffers.secondary == "number"
                 ? section.buffers.secondary
                 : section.buffers.secondary[i], importedSector, importedSection);
-            VoxelStruct.setVoxel(newSection.ids[i]);
-            let secondary = VoxelStruct.instance[VoxelStructIds.canHaveSecondary] &&
-                newSection.secondary[i] > 0;
+            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);

package/World/Cursor/SectionCursor.d.ts

@@ -1,6 +1,6 @@
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 import type { Section } from "../Section/index";
 export declare class SectionCursor extends DataCursorInterface implements WorldSectionCursorInterface {
@@ -12,5 +12,6 @@ export declare class SectionCursor extends DataCursorInterface implements WorldS
     inBounds(x: number, y: number, z: number): boolean;
     setSection(section: Section): boolean;
     setSection(dimension: string, x: number, y: number, z: number): boolean;
+    getVoxelAtIndex(index: number): WorldVoxelCursor;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
 }

package/World/Cursor/SectionCursor.js

@@ -2,7 +2,7 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 export class SectionCursor extends DataCursorInterface {
     _section;
     voxel = new WorldVoxelCursor(this);
@@ -46,11 +46,17 @@ export class SectionCursor extends DataCursorInterface {
         this._sectionPosition.z = sectionPos[2];
         return true;
     }
+    getVoxelAtIndex(index) {
+        this._voxelIndex = index;
+        WorldSpaces.voxel.getPositionFromIndex(index, this._voxelPosition);
+        this.voxel.loadIn();
+        return this.voxel;
+    }
     getVoxel(x, y, z) {
         if (!this._section)
             return null;
-        this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);
+        this._voxelIndex = WorldSpaces.voxel.getIndexFromPosition(this._voxelPosition.x, this._voxelPosition.y, this._voxelPosition.z);
         this.voxel.loadIn();
         return this.voxel;
     }

package/World/Cursor/SectorCursor.d.ts

@@ -2,7 +2,7 @@ import type { Section } from "../Section/index";
 import type { Sector } from "../Sector/index";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 export declare class SectorCursor extends DataCursorInterface implements WorldSectionCursorInterface {
     _current: Sector | null;
@@ -15,4 +15,5 @@ export declare class SectorCursor extends DataCursorInterface implements WorldSe
     setSector(dimension: string, x: number, y: number, z: number): boolean;
     getSection(x: number, y: number, z: number): Section | null;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
+    getVoxelAtIndex(index: number): void;
 }

package/World/Cursor/SectorCursor.js

@@ -2,7 +2,7 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 export class SectorCursor extends DataCursorInterface {
     _current = null;
     _section;
@@ -55,9 +55,12 @@ export class SectorCursor extends DataCursorInterface {
             return null;
         const section = this.getSection(x, y, z);
         this._section = section;
-        this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);
+        this._voxelIndex = WorldSpaces.voxel.getIndexFromPosition(this._voxelPosition.x, this._voxelPosition.y, this._voxelPosition.z);
         this.voxel.loadIn();
         return this.voxel;
     }
+    getVoxelAtIndex(index) {
+        this._voxelIndex = index;
+    }
 }

package/World/Cursor/WorldCursor.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 export declare class WorldCursor extends DataCursorInterface {
     sectorCursors: Map<number, Map<number, SectorCursor>>;
     origin: Vector3Like;

package/World/Cursor/WorldCursor.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor extends DataCursorInterface {
@@ -25,6 +25,8 @@ export class WorldCursor extends DataCursorInterface {
         return WorldSpaces.world.inBounds(x, y, z);
     }
     getSector(x, y, z) {
+        if (!this.inBounds(x, y, z))
+            return null;
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         const cx = sectorPos.x / WorldSpaces.sector.bounds.x - this.origin.x;
         const cz = sectorPos.z / WorldSpaces.sector.bounds.z - this.origin.z;
@@ -32,8 +34,10 @@ export class WorldCursor extends DataCursorInterface {
         let cursor = row?.get(cz);
         if (!cursor) {
             cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
-            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z))
+            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
+                cursorCache.push(cursor);
                 return null;
+            }
             if (!row) {
                 row = new Map();
                 this.sectorCursors.set(cx, row);

package/World/Cursor/WorldVoxelCursor.d.ts

@@ -3,17 +3,17 @@ import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 export declare class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor: WorldSectionCursorInterface;
     private _section;
-    get ids(): Uint16Array;
-    get light(): Uint16Array;
-    get level(): Uint8Array;
-    get state(): Uint16Array;
-    get secondary(): Uint16Array;
-    get mod(): Uint16Array;
+    ids: Uint16Array;
+    light: Uint16Array;
+    level: Uint8Array;
+    state: Uint16Array;
+    mod: Uint16Array;
+    secondary: Uint16Array;
     constructor(dataCursor: WorldSectionCursorInterface);
     loadIn(): void;
     /**
      *
      * @param mode 0 for add 1 for remove
      */
-    updateVoxel(mode: 0 | 1): boolean;
+    updateVoxel(mode: 0 | 1 | 2): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -1,27 +1,13 @@
-import { Section } from "../Section/index";
-import { SectionStructProperties } from "../Section/SectionStructProperties";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor;
     _section;
-    get ids() {
-        return this._section.ids;
-    }
-    get light() {
-        return this._section.light;
-    }
-    get level() {
-        return this._section.level;
-    }
-    get state() {
-        return this._section.state;
-    }
-    get secondary() {
-        return this._section.secondary;
-    }
-    get mod() {
-        return this._section.mod;
-    }
+    ids;
+    light;
+    level;
+    state;
+    mod;
+    secondary;
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
@@ -30,6 +16,12 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
         if (!this.dataCursor._section)
             return;
         this._section = this.dataCursor._section;
+        this.ids = this._section.ids;
+        this.light = this._section.light;
+        this.level = this._section.level;
+        this.state = this._section.state;
+        this.mod = this._section.mod;
+        this.secondary = this._section.secondary;
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
@@ -38,17 +30,21 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
      * @param mode 0 for add 1 for remove
      */
     updateVoxel(mode) {
-        Section.StateStruct.setData(this._section.sectionState);
         const voxelPos = this.dataCursor._voxelPosition;
         if (mode == 0) {
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 1);
+            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            this.dataCursor._section?.setHasVoxel(voxelPos.y, true);
             return true;
         }
         if (mode == 1) {
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.dirtyMap, voxelPos.y, 1);
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 0);
+            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            this.dataCursor._section?.setHasVoxelDirty(voxelPos.y, true);
+            this.dataCursor._section?.setHasVoxel(voxelPos.y, false);
             return true;
         }
+        if (mode == 2) {
+            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+        }
         return false;
     }
 }

package/World/Section/Section.d.ts

@@ -1,4 +1,3 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Sector } from "../Sector/Sector.js";
 import { Vec3Array } from "@amodx/math";
 export interface VoxelDataArrays {
@@ -17,18 +16,31 @@ export interface VoxelDataArrays {
      */
     secondary: Uint16Array;
 }
-export interface Section extends VoxelDataArrays {
+export interface SectionData extends VoxelDataArrays {
+    /**Y slice of the section to tell if there is voxels or not. Used for height maps. */
+    voxelMap: Uint8Array;
+    /**Y slice of the section to tell if the slice is dirty and voxelMap needs to be re-checked. */
+    dirtyMap: Uint8Array;
+    /**A bit array used to cache if a voxel is exposed or not. */
+    buried: Uint8Array;
+}
+export interface Section extends SectionData {
 }
 export declare class Section {
     sector: Sector;
     index: number;
     static GetBufferSize(): number;
     static GetArrayStartIndex(index: number): number;
-    static CreateNew(index: number, sectorBuffer: ArrayBufferLike): VoxelDataArrays;
-    static toObject(sector: Sector, index: number, data: VoxelDataArrays): Section;
-    static StateStruct: RemoteBinaryStruct;
-    sectionState: DataView;
-    constructor(sector: Sector, index: number, data: VoxelDataArrays);
+    static CreateNew(index: number, sectorBuffer: ArrayBufferLike): SectionData;
+    static toObject(sector: Sector, index: number, data: SectionData): Section;
+    constructor(sector: Sector, index: number, data: SectionData);
     getPosition(): Readonly<Vec3Array>;
-    serialize(): VoxelDataArrays;
+    getBuried(index: number): boolean;
+    setBuried(index: number, value: boolean): void;
+    setHasVoxel(y: number, hasVoxel: boolean): void;
+    getHasVoxel(y: number): boolean;
+    setHasVoxelDirty(y: number, dirty: boolean): void;
+    getHasVoxelDirty(y: number): boolean;
+    getMinMax(): number[];
+    toJSON(): SectionData;
 }