@divinevoxel/vlox 0.0.73 → 0.0.75

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: string, 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: string, 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

@@ -2,11 +2,13 @@ import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 export declare class WorldCursor implements DataCursorInterface {
-    sectorCursors: Map<number, Map<number, SectorCursor>>;
+    sectorCursors: Record<number, Record<number, SectorCursor | null>>;
     origin: Vector3Like;
-    dimension: string;
-    setFocalPoint(dimension: string, x: number, y: number, z: number): void;
+    dimension: number;
+    _lastPosition: Vector3Like;
+    setFocalPoint(dimension: number, x: number, y: number, z: number): void;
     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;
 }

package/World/Cursor/WorldCursor.js

@@ -4,21 +4,26 @@ import { WorldSpaces } from "../WorldSpaces";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor {
-    sectorCursors = new Map();
-    origin = { x: 0, y: 0, z: 0 };
-    dimension = "";
+    sectorCursors = {};
+    origin = Vector3Like.Create();
+    dimension = 0;
+    _lastPosition = Vector3Like.Create();
     setFocalPoint(dimension, x, y, z) {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
-        for (const [cx, row] of this.sectorCursors) {
-            for (const [cz, col] of row) {
-                cursorCache.push(col);
+        for (const row in this.sectorCursors) {
+            for (const col in this.sectorCursors[row]) {
+                const cursor = this.sectorCursors[row][col];
+                if (!cursor)
+                    continue;
+                cursorCache.push(cursor);
+                this.sectorCursors[row][col] = null;
             }
         }
-        this.sectorCursors.clear();
         this.dimension = dimension;
         this.origin.x = sectorPos.x / WorldSpaces.sector.bounds.x;
         this.origin.y = sectorPos.y / WorldSpaces.sector.bounds.y;
         this.origin.z = sectorPos.z / WorldSpaces.sector.bounds.z;
+        this.getSector(x, y, z);
     }
     inBounds(x, y, z) {
         return WorldSpaces.world.inBounds(x, y, z);
@@ -29,26 +34,27 @@ export class WorldCursor {
         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;
-        let row = this.sectorCursors.get(cx);
-        let cursor = row?.get(cz);
+        let cursor = this.sectorCursors[cx]?.[cz];
         if (!cursor) {
             cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
-            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
+            if (!cursor.loadSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
                 cursorCache.push(cursor);
                 return null;
             }
-            if (!row) {
-                row = new Map();
-                this.sectorCursors.set(cx, row);
+            if (!this.sectorCursors[cx]) {
+                this.sectorCursors[cx] = {};
             }
-            row.set(cz, cursor);
+            this.sectorCursors[cx][cz] = cursor;
         }
         return cursor;
     }
     getVoxel(x, y, z) {
-        const section = this.getSector(x, y, z);
-        if (!section)
+        const sector = this.getSector(x, y, z);
+        if (!sector)
             return null;
-        return section.getVoxel(x, y, z);
+        return sector.getVoxel(x, y, z);
+    }
+    clone() {
+        return new WorldCursor();
     }
 }

package/World/Cursor/WorldVoxelCursor.d.ts

@@ -1,19 +1,13 @@
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 export declare class WorldVoxelCursor extends VoxelCursorInterface {
-    dataCursor: WorldSectionCursorInterface;
+    protected dataCursor: WorldSectionCursorInterface;
     private _section;
     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 | 2): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -1,12 +1,10 @@
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor;
-    _section;
+    _section = null;
     ids;
     light;
     level;
-    state;
-    mod;
     secondary;
     constructor(dataCursor) {
         super();
@@ -19,33 +17,24 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
         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();
     }
-    /**
-     *
-     * @param mode 0 for add 1 for remove
-     */
     updateVoxel(mode) {
         const voxelPos = this.dataCursor._voxelPosition;
-        this.dataCursor._section?.sector.setStored(false);
+        this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
         if (mode == 0) {
-            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            this.dataCursor._section?.sector.setStored(false);
             this.dataCursor._section?.setHasVoxel(voxelPos.y, true);
             return true;
         }
         if (mode == 1) {
-            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            this.dataCursor._section?.sector.setStored(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/Dimension/Dimension.d.ts

@@ -1,14 +1,17 @@
+import { DimensionSyncData } from "../Types/WorldData.types";
 import { Sector } from "../Sector";
 export interface DimensionData {
     id: string;
+    index: number;
     sectors: Map<string, Sector>;
 }
 export interface Dimension extends DimensionData {
 }
 export declare class Dimension {
-    static CreateNew(id: string): Dimension;
+    static CreateNew(index: number, id?: string): Dimension;
     constructor(data: DimensionData);
     set(sectorId: string, region: Sector): void;
     delete(sectorId: string): void;
     get(sectorId: string): Sector | undefined;
+    getData(): DimensionSyncData;
 }

package/World/Dimension/Dimension.js

@@ -1,7 +1,8 @@
 export class Dimension {
-    static CreateNew(id) {
+    static CreateNew(index, id = "") {
         return new Dimension({
             id,
+            index,
             sectors: new Map(),
         });
     }
@@ -17,4 +18,10 @@ export class Dimension {
     get(sectorId) {
         return this.sectors.get(sectorId);
     }
+    getData() {
+        return {
+            id: this.id,
+            index: this.index,
+        };
+    }
 }

package/World/InitTasks.js

@@ -4,35 +4,59 @@ import { WorldRegister } from "./WorldRegister.js";
 import { WorldSpaces } from "./WorldSpaces.js";
 import { WorldLock } from "./Lock/WorldLock.js";
 import { WorldDataSyncIds } from "./Types/WorldDataSyncIds.js";
+import { EngineSettings } from "../Settings/EngineSettings.js";
+import { SnapShots } from "./SnapShot/SnapShots.js";
 export default function ({ threads, worldStorage, }) {
-    WorldRegister.sectors.setSecotrPool(true);
+    WorldRegister.sectors.setSecotrBufferPool(true);
     const loadInMap = new Map();
-    /*
-  [sectors]
-  */
-    WorldRegister._hooks.sectors.onNew = (location, sector) => {
-        for (const thread of threads) {
-            thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
-        }
-    };
-    WorldRegister._hooks.sectors.onRemove = (location) => {
-        for (const thread of threads) {
-            thread.runTask(WorldDataSyncIds.UnSyncSector, location);
-        }
-    };
-    /*
-  [dimensions]
-  */
-    WorldRegister._hooks.dimension.onNew = (data) => {
-        for (const thread of threads) {
-            thread.runTask(WorldDataSyncIds.SyncDimension, data);
-        }
-    };
+    Threads.registerTask("cache-snap-shot", (data) => {
+        const snapShot = SnapShots._pendingCache.shift();
+        snapShot.restore(data);
+        SnapShots._readyCache.push(snapShot);
+    });
+    //normal array buffers only
+    if (!EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+        Threads.registerTask(WorldDataSyncIds.CheckInSector, async (data) => {
+            const sector = WorldRegister.sectors.get(...data[0]);
+            if (!sector) {
+                console.warn("Tried checking in sector that is not loaded in world", data);
+                return;
+            }
+            sector.setBuffer(data[1]);
+            sector.setCheckedOut(false);
+        });
+    }
+    //shared memeory only
+    if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+        /*
+    [sectors]
+    */
+        WorldRegister._hooks.sectors.onNew = (location, sector) => {
+            for (const thread of threads) {
+                thread.runTask(WorldDataSyncIds.SyncSector, [location, sector.buffer]);
+            }
+        };
+        WorldRegister._hooks.sectors.onRemove = (location) => {
+            for (const thread of threads) {
+                thread.runTask(WorldDataSyncIds.UnSyncSector, location);
+            }
+        };
+        /*
+    [dimensions]
+    */
+        WorldRegister._hooks.dimension.onNew = (data) => {
+            for (const thread of threads) {
+                thread.runTask(WorldDataSyncIds.SyncDimension, data);
+            }
+        };
+    }
     Threads.registerTask("add-sector", async (location) => {
         const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
         if (sector) {
-            for (const thread of threads) {
-                thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
+            if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+                for (const thread of threads) {
+                    thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
+                }
             }
             return;
         }
@@ -65,27 +89,15 @@ export default function ({ threads, worldStorage, }) {
     Threads.registerTask("world-dealloc", async (data) => {
         await WorldLock.removeLock(data);
     });
-    Threads.registerTask("unload-sector", (location) => {
-        if (WorldLock.isLocked(location))
-            return [false];
-        WorldRegister.sectors.remove(location[0], location[1], location[2], location[3]);
-        for (const thread of threads) {
-            thread.runTask(WorldDataSyncIds.UnSyncSector, location);
-        }
-        return [false];
-    });
     Threads.registerTask("load-sector", ([location, sector]) => {
         WorldRegister.sectors.add(location[0], location[1], location[2], location[3], sector);
-        for (const thread of threads) {
-            thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+            for (const thread of threads) {
+                thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
+            }
         }
         return [true];
     });
-    /*   Threads.registerTask<RunBuildQueue>("build-queue", async ([dim, sections]) => {
-      for (const position of sections) {
-        mesher.setLocation([dim, ...position]).buildSection();
-      }
-    }); */
     Threads.registerTask("clear-all", () => {
         WorldRegister.clearAll();
     });

package/World/Lock/Function/LockSectors.d.ts

@@ -0,0 +1,2 @@
+import { BoundsInterface } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+export default function LockSectors(dimension: number, bounds: BoundsInterface): Promise<void>;

package/World/Lock/Function/LockSectors.js

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../WorldSpaces";
+import { WorldRegister } from "../../WorldRegister";
+export default async function LockSectors(dimension, bounds) {
+    const { min, max } = bounds.getMinMax();
+    const { x: sx, y: sy, z: sz, } = WorldSpaces.sector.getPosition(min.x, min.y, min.z, Vector3Like.Create());
+    const { x: ex, y: ey, z: ez, } = WorldSpaces.sector.getPosition(max.x, max.y, max.z, Vector3Like.Create());
+    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const waitingToLockSectors = [];
+    for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
+        for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
+            for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
+                const sector = WorldRegister.sectors.get(dimension, x, y, z);
+                if (!sector)
+                    continue;
+                if (sector.isCheckedOut()) {
+                    waitingToLockSectors.push(sector);
+                    continue;
+                }
+                sector.setLocked(true);
+            }
+        }
+    }
+    await Promise.all(waitingToLockSectors.map((_) => _.waitTillCheckedIn()));
+    for (const sector of waitingToLockSectors) {
+        sector.setLocked(true);
+    }
+}

package/World/Lock/Function/UnLockSectors.d.ts

@@ -0,0 +1,2 @@
+import { BoundsInterface } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+export default function UnLockSectors(dimension: number, bounds: BoundsInterface): Promise<void>;

package/World/Lock/Function/UnLockSectors.js

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../WorldSpaces";
+import { WorldRegister } from "../../WorldRegister";
+export default async function UnLockSectors(dimension, bounds) {
+    const { min, max } = bounds.getMinMax();
+    const { x: sx, y: sy, z: sz, } = WorldSpaces.sector.getPosition(min.x, min.y, min.z, Vector3Like.Create());
+    const { x: ex, y: ey, z: ez, } = WorldSpaces.sector.getPosition(max.x, max.y, max.z, Vector3Like.Create());
+    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const waitingToLockSectors = [];
+    for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
+        for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
+            for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
+                const sector = WorldRegister.sectors.get(dimension, x, y, z);
+                if (!sector)
+                    continue;
+                if (sector.isCheckedOut()) {
+                    waitingToLockSectors.push(sector);
+                    continue;
+                }
+                sector.setLocked(false);
+            }
+        }
+    }
+    await Promise.all(waitingToLockSectors.map((_) => _.waitTillCheckedIn()));
+    for (const sector of waitingToLockSectors) {
+        sector.setLocked(false);
+    }
+}

package/World/Lock/WorldLock.d.ts

@@ -1,5 +1,4 @@
 import type { WorldLockTasks } from "../../Tasks/Tasks.types";
-import type { LocationData } from "../../Math";
 import { WorldStorageInterface } from "../Types/WorldStorage.interface";
 export declare class WorldLock {
     static locks: Map<string, WorldLockTasks>;
@@ -7,5 +6,5 @@ export declare class WorldLock {
     static worldStorage: WorldStorageInterface | null;
     static addLock(taskData: WorldLockTasks): Promise<unknown>;
     static removeLock(data: WorldLockTasks): void;
-    static isLocked([sdim, x, y, z]: LocationData): boolean;
+    static isLocked(sdim: number, x: number, y: number, z: number): boolean;
 }

package/World/Lock/WorldLock.js

@@ -67,7 +67,9 @@ export class WorldLock {
     static removeLock(data) {
         this.locks.delete(data.toString());
     }
-    static isLocked([sdim, x, y, z]) {
+    static isLocked(sdim, x, y, z) {
+        if (!this.locks.size)
+            return false;
         let locked = false;
         for (const [key, [dim, [sx, sy, sz], [ex, ey, ez]]] of this.locks) {
             if (dim != sdim)