@divinevoxel/vlox 0.0.74 → 0.0.75

package/World/Archive/Functions/Sector/RemoveDuplicateSections.js

@@ -0,0 +1,137 @@
+import { BinaryBuffer } from "../../../../Util/BinaryBuffer";
+import { uint16To4CharString } from "../Shared/IntToString";
+import { lightSegments } from "../Shared";
+function compareSection(section1, section2) {
+    if (Object.keys(section1).length != Object.keys(section2).length)
+        return false;
+    if (Object.keys(section1.buffers).length != Object.keys(section2.buffers).length)
+        return false;
+    if (section1.palettes &&
+        section2.palettes &&
+        Object.keys(section1.palettes).length !=
+            Object.keys(section2.palettes).length)
+        return false;
+    if (section1.palettes && !section2.palettes)
+        return false;
+    if (!section1.palettes && section2.palettes)
+        return false;
+    if (section1.palettes) {
+        if (section1.palettes.id && section2.palettes?.id) {
+            if (!BinaryBuffer.Compare(section1.palettes.id, section2.palettes.id))
+                return false;
+        }
+        else if ((!section1.palettes.id && section2.palettes?.id) ||
+            (section1.palettes.id && !section2.palettes?.id))
+            return false;
+        if (section1.palettes.secondary && section2.palettes?.secondary) {
+            if (!BinaryBuffer.Compare(section1.palettes.secondary, section2.palettes.secondary))
+                return false;
+        }
+        else if ((!section1.palettes.secondary && section2.palettes?.secondary) ||
+            (section1.palettes.secondary && !section2.palettes?.secondary))
+            return false;
+        if (section1.palettes.level && section2.palettes?.level) {
+            if (!BinaryBuffer.Compare(section1.palettes.level, section2.palettes.level))
+                return false;
+        }
+        else if ((!section1.palettes.level && section2.palettes?.level) ||
+            (section1.palettes.level && !section2.palettes?.level))
+            return false;
+        if (section1.palettes.light && section2.palettes?.light) {
+            for (const segment of lightSegments) {
+                if (section1.palettes.light?.[segment] &&
+                    section2.palettes.light?.[segment]) {
+                    if (!BinaryBuffer.Compare(section1.palettes.light[segment], section2.palettes.light[segment]))
+                        return false;
+                }
+                else if ((!section1.palettes.light[segment] &&
+                    section2.palettes.light[segment]) ||
+                    (section1.palettes.light[segment] &&
+                        !section2.palettes.light[segment]))
+                    return false;
+            }
+        }
+        else if (!section1.palettes.light && section2.palettes?.light)
+            return false;
+    }
+    if (section1.buffers.id && section2.buffers.id) {
+        if (!BinaryBuffer.Compare(section1.buffers.id, section2.buffers.id))
+            return false;
+    }
+    else if ((!section1.buffers.id && section2.buffers.id) ||
+        (section1.buffers.id && !section2.buffers.id))
+        return false;
+    if (section1.buffers.secondary && section2.buffers.secondary) {
+        if (!BinaryBuffer.Compare(section1.buffers.secondary, section2.buffers.secondary))
+            return false;
+    }
+    else if ((!section1.buffers.secondary && section2.buffers.secondary) ||
+        (section1.buffers.secondary && !section2.buffers.secondary))
+        return false;
+    if (section1.buffers.light && section2.buffers?.light) {
+        for (const segment of lightSegments) {
+            if (section1.buffers.light?.[segment] &&
+                section2.buffers.light?.[segment]) {
+                if (!BinaryBuffer.Compare(section1.buffers.light[segment], section2.buffers.light[segment]))
+                    return false;
+            }
+            else if ((!section1.buffers.light[segment] && section2.buffers.light[segment]) ||
+                (section1.buffers.light[segment] && !section2.buffers.light[segment]))
+                return false;
+        }
+    }
+    else if ((!section1.buffers.light && section2.buffers?.light) ||
+        (section1.buffers.light && !section2.buffers?.light))
+        return false;
+    if (section1.buffers.level && section2.buffers?.level) {
+        if (!BinaryBuffer.Compare(section1.buffers.level, section2.buffers.level))
+            return false;
+    }
+    else if ((!section1.buffers.level && section2.buffers?.level) ||
+        (section1.buffers.level && !section2.buffers?.level))
+        return false;
+    return true;
+}
+export function RemoveDuplicateSections(sector) {
+    const sectionsLength = sector.sections.length;
+    const sections = (sector.sections);
+    const newSections = [];
+    const added = new Set();
+    const duplicates = new Map();
+    for (let i = 0; i < sectionsLength; i++) {
+        const sectionA = sections[i];
+        newSections[i] = sectionA;
+        if (added.has(i))
+            continue;
+        for (let j = 0; j < sectionsLength; j++) {
+            if (i == j)
+                continue;
+            if (added.has(j))
+                continue;
+            const sectionB = sections[j];
+            if (compareSection(sectionA, sectionB)) {
+                let array = duplicates.get(sectionA);
+                if (!array) {
+                    array = [i];
+                    added.add(i);
+                    duplicates.set(sectionA, array);
+                }
+                added.add(j);
+                array.push(j);
+            }
+        }
+    }
+    const duplicateSections = {};
+    let dupIndex = 0;
+    for (const [section, indexes] of duplicates) {
+        const key = uint16To4CharString(dupIndex);
+        duplicateSections[key] = section;
+        for (const index of indexes) {
+            newSections[index] = key;
+        }
+        dupIndex++;
+    }
+    sector.sections = newSections;
+    sector.duplicates ??= {};
+    sector.duplicates.sections = duplicateSections;
+}

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

@@ -0,0 +1,2 @@
+import { BaseArchivedDataBase } from "../../Types/Archive.types";
+export declare function getBaseData(dimension: string): BaseArchivedDataBase;

package/World/Archive/Functions/Shared/BaseData.js

@@ -0,0 +1,14 @@
+import { WorldSpaces } from "../../../WorldSpaces";
+import { EngineSettings } from "../../../../Settings/EngineSettings";
+import { VoxelArchivePalette } from "../../../../Voxels/Archive/VoxelPaletteArechive";
+export function getBaseData(dimension) {
+    return {
+        dimension,
+        formatVersion: "",
+        engineVersion: EngineSettings.version,
+        dataKey: {
+            voxelPalette: VoxelArchivePalette.GetVoxelPaletteDataKey(),
+            ...WorldSpaces.getDataKey(),
+        },
+    };
+}

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

@@ -0,0 +1 @@
+export declare function uint16To4CharString(value: number): string;

package/World/Archive/Functions/Shared/IntToString.js

@@ -0,0 +1,13 @@
+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;
+}

package/World/Archive/Functions/{Shared.d.ts → Shared/LightSegments.d.ts}

@@ -1,6 +1,5 @@
-import { ArchivedLightSegments } from "../Archive.types";
+import { ArchivedLightSegments } from "../../Types/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 → Shared/LightSegments.js}

@@ -1,5 +1,5 @@
-import { setNibbleArrayIndex } from "../../../Util/Binary/BinaryArrays";
-import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
+import { setNibbleArrayIndex } from "../../../../Util/Binary/BinaryArrays";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 const lightData = new VoxelLightData();
 export const lightSegments = [
     "sun",
@@ -19,19 +19,6 @@ export const lightSemgnetSet = {
     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++) {

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

@@ -0,0 +1,3 @@
+export * from "./BaseData";
+export * from "./IntToString";
+export * from "./LightSegments";

package/World/Archive/Functions/Shared/index.js

@@ -0,0 +1,3 @@
+export * from "./BaseData";
+export * from "./IntToString";
+export * from "./LightSegments";

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

@@ -1,3 +1,3 @@
-export * from "./ArchiveArea";
-export * from "./ArchiveSector";
-export * from "./ImportSector";
+export * from "./Area/ArchiveArea";
+export * from "./Sector/ArchiveSector";
+export * from "./Sector/ImportSector";

package/World/Archive/Functions/index.js

@@ -1,3 +1,3 @@
-export * from "./ArchiveArea";
-export * from "./ArchiveSector";
-export * from "./ImportSector";
+export * from "./Area/ArchiveArea";
+export * from "./Sector/ArchiveSector";
+export * from "./Sector/ImportSector";

package/World/Archive/InitTasks.js

@@ -1,31 +1,23 @@
 import { Threads } from "@amodx/threads";
-import ArchiveSector from "./Functions/ArchiveSector";
+import ArchiveSector from "./Functions/Sector/ArchiveSector";
 import { WorldRegister } from "../WorldRegister";
-import ImportSector from "./Functions/ImportSector";
+import ImportSector from "./Functions/Sector/ImportSector";
 import { compressBinaryObject, expandBinaryObject, } from "../../Util/BinaryObject";
 function runArchiveSector(location) {
-    const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
-    if (!sector)
+    const sector = WorldRegister.sectors.get(...location);
+    if (!sector) {
+        console.warn([...location], WorldRegister._dimensions.get(0).sectors, sector);
         throw new Error(`Sector at location ${location.toString()} does not exist`);
+    }
     const archived = ArchiveSector({
-        location: location,
+        location,
     });
     const transfers = [];
-    // if (archived.palettes.light) transfers.push(archived.palettes.light.buffer);
-    // if (archived.palettes.state) transfers.push(archived.palettes.state.buffer);
-    if (archived.palettes.secondaryValue)
-        transfers.push(archived.palettes.secondaryValue.buffer);
     for (const section of archived.sections) {
         if (typeof section == "string")
             continue;
         if (ArrayBuffer.isView(section.buffers.id?.buffer))
             transfers.push(section.buffers.id.buffer);
-        if (ArrayBuffer.isView(section.buffers.state?.buffer))
-            transfers.push(section.buffers.state.buffer);
-        if (ArrayBuffer.isView(section.buffers.mod?.buffer))
-            transfers.push(section.buffers.mod.buffer);
-        if (ArrayBuffer.isView(section.buffers.state?.buffer))
-            transfers.push(section.buffers.state.buffer);
         if (ArrayBuffer.isView(section.buffers.light?.sun?.buffer))
             transfers.push((section.buffers.light?.sun).buffer);
         if (ArrayBuffer.isView(section.buffers.light?.red?.buffer))
@@ -40,13 +32,6 @@ function runArchiveSector(location) {
             continue;
         if (section.palettes.id)
             transfers.push(section.palettes.id.buffer);
-        //   if (section.palettes.light) transfers.push(section.palettes.light.buffer);
-        //  if (section.palettes.state) transfers.push(section.palettes.state.buffer);
-        //  if (section.palettes.mod) transfers.push(section.palettes.mod.buffer);
-        if (section.palettes.secondaryValue)
-            transfers.push(section.palettes.secondaryValue.buffer);
-        if (section.palettes.secondaryId)
-            transfers.push(section.palettes.secondaryId.buffer);
     }
     return [archived, transfers];
 }
@@ -68,17 +53,23 @@ export default function InitTasks(props) {
     });
     Threads.registerTask("import-sector", async (archived) => {
         const importedSector = ImportSector(archived, {});
-        await props.worldThread.runTaskAsync("load-sector", [
-            archived.location,
-            importedSector,
-        ]);
+        props.worldThread.runTask("load-sector", [
+            [
+                WorldRegister.dimensions._dimensionMap.get(archived.dimension) || 0,
+                archived.position.x,
+                archived.position.y,
+                archived.position.z,
+            ],
+            importedSector.buffer,
+        ], importedSector.buffer instanceof ArrayBuffer
+            ? [importedSector.buffer]
+            : []);
     });
     Threads.registerTask("import-sector-binary", async ([location, archived]) => {
         const archivedSector = await expandBinaryObject(archived, true);
         const importedSector = ImportSector(archivedSector, {});
-        await props.worldThread.runTaskAsync("load-sector", [
-            location,
-            importedSector,
-        ]);
+        props.worldThread.runTask("load-sector", [location, importedSector.buffer], importedSector.buffer instanceof ArrayBuffer
+            ? [importedSector.buffer]
+            : []);
     });
 }

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

@@ -0,0 +1,45 @@
+import { Vector3Like } from "@amodx/math";
+import { ArchivedVoxelPaletteDataKey } from "Voxels/Archive/VoxelArchive.types";
+import { WorldSpaceDataKey } from "World/WorldSpaces";
+export type ArchivedLightSegments = "sun" | "red" | "green" | "blue";
+export interface ArchivedDataKey extends WorldSpaceDataKey {
+    voxelPalette: ArchivedVoxelPaletteDataKey;
+}
+export interface BaseArchivedDataBase {
+    dimension: string;
+    /** A user provided version of the data. */
+    formatVersion: string;
+    /** The version of vlox the data was stored in. */
+    engineVersion: string;
+    dataKey: ArchivedDataKey;
+}
+export interface BaseArchivedSectorData {
+    /** The location of the sector in the world. */
+    position: Vector3Like;
+    /** Record of the sector's bit flags.  */
+    flags: Record<string, boolean>;
+    /** Record of the sector's timestamps. */
+    timestamps: Record<string, number>;
+}
+export interface BaseArchivedSectionData {
+    /** Record of the section's bit flags.  */
+    flags?: Record<string, boolean>;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface BaseArchivedSectionPaletteData<BufferType> {
+    id?: BufferType;
+    light?: Partial<Record<ArchivedLightSegments, BufferType>>;
+    level?: BufferType;
+    secondary?: BufferType;
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface BaseArchivedSectionBuffers<BufferType> {
+    id?: BufferType;
+    light?: Partial<Record<ArchivedLightSegments, BufferType>>;
+    level?: BufferType;
+    secondary?: BufferType;
+}

package/World/Archive/Types/Archive.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+import { VoxelBinaryStateSchemaNode } from "../../../Voxels/State/State.types";
+import { BinaryBufferData } from "../../../Util/BinaryBuffer/BinaryBuffer.types";
+import { ArchivedLightSegments, BaseArchivedDataBase, BaseArchivedSectorData } from "./Archive.types";
+import { ArchivedSectionData, ArchivedSectorDuplicteData } from "./ArchivedSector.types";
+export interface ArchiveAreaPalettesData {
+    voxelStateSchemas: Record<string, VoxelBinaryStateSchemaNode[]>;
+    voxelSchemas: Record<string, {
+        stateSchemaId?: string;
+        modSchema?: VoxelBinaryStateSchemaNode[];
+    } | null>;
+}
+/**
+ * Interface for an archived area.
+ */
+export interface ArchivedAreaData extends BaseArchivedDataBase {
+    palettes: ArchiveAreaPalettesData;
+    /** Array of archived sector data within the area. */
+    sectors: ArchivedAreaSectorData[];
+}
+/**
+ * Interface representing the palette data for a sector.
+ */
+export interface ArchivedAreaSectorPaletteData {
+    id: string[];
+    voxelPalette: BinaryBufferData;
+    level?: BinaryBufferData;
+    light?: Partial<Record<ArchivedLightSegments, BinaryBufferData>>;
+}
+/**
+ * Interface representing the archived data for a sector within an area.
+ */
+export interface ArchivedAreaSectorData extends BaseArchivedSectorData {
+    /** The palette data used within the sector. */
+    palettes: ArchivedAreaSectorPaletteData;
+    /** Array of archived section data or references to section data. */
+    sections: (ArchivedSectionData | string)[];
+    duplicates: ArchivedSectorDuplicteData;
+}

package/World/Archive/Types/ArchiveArea.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,52 @@
+import { JSONBinaryBufferData } from "../../../Util/BinaryBuffer/BinaryBuffer.types";
+import { ArchivedLightSegments, BaseArchivedDataBase, BaseArchivedSectionBuffers, BaseArchivedSectionData, BaseArchivedSectionPaletteData, BaseArchivedSectorData } from "./Archive.types";
+import { ArchiveAreaPalettesData } from "./ArchiveArea.types";
+export interface ArchivedSectorDuplicteJSONData {
+    sections?: Record<string, ArchivedSectionJSONData>;
+}
+/**
+ * Interface for an archived section.
+ */
+export interface ArchivedSectionJSONData extends BaseArchivedSectionData {
+    /** Palette data used within the section. */
+    palettes?: ArchivedSectionPaletteJSONData;
+    /** Buffer data for the section, holding voxel type identifiers, light data, state, and secondary state. */
+    buffers: ArchivedSectionBuffersJSONData;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface ArchivedSectionPaletteJSONData extends BaseArchivedSectionPaletteData<JSONBinaryBufferData> {
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface ArchivedSectionBuffersJSONData extends BaseArchivedSectionBuffers<JSONBinaryBufferData> {
+}
+/**
+ * Interface for an archived area.
+ */
+export interface ArchivedAreaJSONData extends BaseArchivedDataBase {
+    palettes: ArchiveAreaPalettesData;
+    /** Array of archived sector data within the area. */
+    sectors: ArchivedAreaSectorJSONData[];
+}
+/**
+ * Interface representing the palette data for a sector.
+ */
+export interface ArchivedAreaSectorPaletteJSONData {
+    id: string[];
+    voxelPalette: JSONBinaryBufferData;
+    level?: JSONBinaryBufferData;
+    light?: Partial<Record<ArchivedLightSegments, JSONBinaryBufferData>>;
+}
+/**
+ * Interface representing the archived data for a sector within an area.
+ */
+export interface ArchivedAreaSectorJSONData extends BaseArchivedSectorData {
+    /** The palette data used within the sector. */
+    palettes: ArchivedAreaSectorPaletteJSONData;
+    /** Array of archived section data or references to section data. */
+    sections: (ArchivedSectionJSONData | string)[];
+    duplicates: ArchivedSectorDuplicteJSONData;
+}

package/World/Archive/Types/ArchiveJSON.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,43 @@
+import { BinaryBufferData } from "../../../Util/BinaryBuffer/BinaryBuffer.types";
+import { VoxelArchivePaletteData } from "../../../Voxels/Archive/VoxelArchive.types";
+import { ArchivedLightSegments, BaseArchivedDataBase, BaseArchivedSectionBuffers, BaseArchivedSectionData, BaseArchivedSectionPaletteData, BaseArchivedSectorData } from "./Archive.types";
+/**
+ * Interface for an archived sector.
+ */
+export interface ArchivedSectorData extends BaseArchivedDataBase, BaseArchivedSectorData {
+    /** The palette data used within the sector. */
+    palettes: ArchivedSectorPaletteData;
+    /**Contains duplicate data like duplicate sections. */
+    duplicates: ArchivedSectorDuplicteData;
+    /** Array of archived section data within the sector. */
+    sections: (ArchivedSectionData | string)[];
+}
+export interface ArchivedSectorDuplicteData {
+    sections?: Record<string, ArchivedSectionData>;
+}
+/**
+ * Interface for the palettes of an archived sector.
+ */
+export interface ArchivedSectorPaletteData extends VoxelArchivePaletteData {
+    level?: BinaryBufferData;
+    light?: Partial<Record<ArchivedLightSegments, BinaryBufferData>>;
+}
+/**
+ * Interface for an archived section.
+ */
+export interface ArchivedSectionData extends BaseArchivedSectionData {
+    /** Palette data used within the section. */
+    palettes?: ArchivedSectionPaletteData;
+    /** Buffer data for the section, holding voxel type identifiers, light data, state, and secondary state. */
+    buffers: ArchivedSectionBuffers;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface ArchivedSectionPaletteData extends BaseArchivedSectionPaletteData<BinaryBufferData> {
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface ArchivedSectionBuffers extends BaseArchivedSectionBuffers<BinaryBufferData> {
+}

package/World/Archive/Types/ArchivedSector.types.js

@@ -0,0 +1 @@
+export {};

package/World/Archive/Types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Archive.types";
+export * from "./ArchiveArea.types";
+export * from "./ArchivedSector.types";
+export * from "./ArchiveJSON.types";

package/World/Archive/Types/index.js

@@ -0,0 +1,4 @@
+export * from "./Archive.types";
+export * from "./ArchiveArea.types";
+export * from "./ArchivedSector.types";
+export * from "./ArchiveJSON.types";

package/World/Archive/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./Functions/index";
-export * from "./Archive.types";
+export * from "./Types/Archive.types";

package/World/Archive/index.js

@@ -1,2 +1,2 @@
 export * from "./Functions/index";
-export * from "./Archive.types";
+export * from "./Types/Archive.types";

package/World/Cursor/SectionCursor.d.ts

@@ -3,15 +3,16 @@ import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 import type { Section } from "../Section/index";
-export declare class SectionCursor implements DataCursorInterface, WorldSectionCursorInterface {
+export declare class SectionCursor implements WorldSectionCursorInterface, DataCursorInterface {
     _section: Section | null;
     private voxel;
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
     _sectionPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
-    setSection(section: Section): boolean;
-    setSection(dimension: number, x: number, y: number, z: number): boolean;
+    setSection(section: Section): void;
+    loadSection(dimension: number, x: number, y: number, z: number): boolean;
     getVoxelAtIndex(index: number): WorldVoxelCursor;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
+    clone(): SectionCursor;
 }

package/World/Cursor/SectionCursor.js

@@ -26,19 +26,18 @@ export class SectionCursor {
             return false;
         return true;
     }
-    setSection(sectionOrDimension, x, y, z) {
-        if (typeof sectionOrDimension == "object") {
-            this._section = sectionOrDimension;
-            const sectionPos = this._section.getPosition();
-            this._sectionPosition.x = sectionPos[0];
-            this._sectionPosition.y = sectionPos[1];
-            this._sectionPosition.z = sectionPos[2];
-            return;
-        }
-        const sector = WorldRegister.sectors.get(sectionOrDimension, x || 0, y || 0, z || 0);
+    setSection(section) {
+        this._section = section;
+        const sectionPos = this._section.getPosition();
+        this._sectionPosition.x = sectionPos[0];
+        this._sectionPosition.y = sectionPos[1];
+        this._sectionPosition.z = sectionPos[2];
+    }
+    loadSection(dimension, x, y, z) {
+        const sector = WorldRegister.sectors.get(dimension, x, y, z);
         if (!sector)
             return false;
-        this._section = sector.getSection(x || 0, y || 0, z || 0);
+        this._section = sector.getSection(x, y, z);
         const sectionPos = this._section.getPosition();
         this._sectionPosition.x = sectionPos[0];
         this._sectionPosition.y = sectionPos[1];
@@ -59,4 +58,7 @@ export class SectionCursor {
         this.voxel.loadIn();
         return this.voxel;
     }
+    clone() {
+        return new SectionCursor();
+    }
 }

package/World/Cursor/SectorCursor.d.ts

@@ -1,5 +1,5 @@
 import type { Section } from "../Section/index";
-import type { Sector } from "../Sector/index";
+import { Sector } from "../Sector/index";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
@@ -12,8 +12,10 @@ export declare class SectorCursor implements DataCursorInterface, WorldSectionCu
     _voxelPosition: Vector3Like;
     _sectorPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
-    setSector(dimension: number, x: number, y: number, z: number): boolean;
+    setSector(sector: Sector): boolean;
+    loadSector(dimension: number, 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;
+    clone(): SectorCursor;
 }

package/World/Cursor/SectorCursor.js

@@ -27,7 +27,14 @@ export class SectorCursor {
             return false;
         return true;
     }
-    setSector(dimension, x, y, z) {
+    setSector(sector) {
+        this._current = sector;
+        this._sectorPosition.x = sector.position[0];
+        this._sectorPosition.y = sector.position[1];
+        this._sectorPosition.z = sector.position[2];
+        return true;
+    }
+    loadSector(dimension, x, y, z) {
         const sector = WorldRegister.sectors.get(dimension, x, y, z);
         if (!sector)
             return false;
@@ -62,4 +69,7 @@ export class SectorCursor {
     getVoxelAtIndex(index) {
         this._voxelIndex = index;
     }
+    clone() {
+        return new SectorCursor();
+    }
 }

package/World/Cursor/WorldCursor.d.ts

@@ -10,4 +10,5 @@ export declare class WorldCursor implements DataCursorInterface {
     inBounds(x: number, y: number, z: number): boolean;
     getSector(x: number, y: number, z: number): SectorCursor | null;
     getVoxel(x: number, y: number, z: number): import("./WorldVoxelCursor").WorldVoxelCursor | null;
+    clone(): WorldCursor;
 }