@divinevoxel/vlox 0.0.4 → 0.0.6

package/World/Archive/InitTasks.js

@@ -0,0 +1,70 @@
+import { Threads } from "@amodx/threads";
+import ArchiveSector from "./Functions/ArchiveSector";
+import { WorldRegister } from "../WorldRegister";
+import ImportSector from "./Functions/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)
+        throw new Error(`Sector at location ${location.toString()} does not exist`);
+    const archived = ArchiveSector({
+        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.secondaryState)
+        transfers.push(archived.palettes.secondaryState.buffer);
+    for (const section of archived.sections) {
+        if (typeof section.buffers.id != "number")
+            transfers.push(section.buffers.id.buffer);
+        if (typeof section.buffers.light != "number")
+            transfers.push(section.buffers.light.buffer);
+        if (typeof section.buffers.state != "number")
+            transfers.push(section.buffers.state.buffer);
+        if (typeof section.buffers.secondary != "number")
+            transfers.push(section.buffers.secondary.buffer);
+        if (typeof section.buffers.mod != "number")
+            transfers.push(section.buffers.mod.buffer);
+        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.secondaryState)
+            transfers.push(section.palettes.secondaryState.buffer);
+        if (section.palettes.secondaryId)
+            transfers.push(section.palettes.secondaryId.buffer);
+    }
+    return [archived, transfers];
+}
+export default function InitTasks(props) {
+    Threads.registerTask("archive-sector", async (location) => {
+        return runArchiveSector(location);
+    });
+    Threads.registerTask("archive-sector-binary", async (location) => {
+        const [archived] = runArchiveSector(location);
+        const compressed = await compressBinaryObject(archived);
+        return [compressed, [compressed]];
+    });
+    Threads.registerTask("import-sector", async (archived) => {
+        const importedSector = ImportSector(archived, {});
+        await props.worldThread.runTaskAsync("load-sector", [
+            archived.location,
+            importedSector,
+        ]);
+    });
+    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,
+        ]);
+    });
+}

package/World/Cursor/SectionCursor.d.ts

@@ -0,0 +1,16 @@
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+import type { Section } from "../Section/index";
+export declare class SectionCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+    _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;
+    getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
+}

package/World/Cursor/SectionCursor.js

@@ -0,0 +1,57 @@
+import { WorldRegister } from "../WorldRegister";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { WorldSpaces } from "../WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+export class SectionCursor extends DataCursorInterface {
+    _section;
+    voxel = new WorldVoxelCursor(this);
+    _voxelIndex = 0;
+    _voxelPosition = Vector3Like.Create();
+    _sectionPosition = Vector3Like.Create();
+    inBounds(x, y, z) {
+        const maxX = this._sectionPosition.x + WorldSpaces.section.bounds.x;
+        const maxY = this._sectionPosition.y + WorldSpaces.section.bounds.y;
+        const maxZ = this._sectionPosition.z + WorldSpaces.section.bounds.z;
+        if (x < this._sectionPosition.x)
+            return false;
+        if (y < this._sectionPosition.y)
+            return false;
+        if (z < this._sectionPosition.z)
+            return false;
+        if (x > maxX)
+            return false;
+        if (y > maxY)
+            return false;
+        if (z > maxZ)
+            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);
+        if (!sector)
+            return false;
+        this._section = sector.getSection(y || 0);
+        const sectionPos = this._section.getPosition();
+        this._sectionPosition.x = sectionPos[0];
+        this._sectionPosition.y = sectionPos[1];
+        this._sectionPosition.z = sectionPos[2];
+        return true;
+    }
+    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.voxel.loadIn();
+        return this.voxel;
+    }
+}

package/{Data/Cursor/World/ColumnCursor.d.ts → World/Cursor/SectorCursor.d.ts}

@@ -1,16 +1,17 @@
-import { Chunk, Column } from "../../World/Classes";
+import type { Section } from "../Section/index";
+import type { Sector } from "../Sector/index";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
-export declare class ColumnCursor extends DataCursorInterface implements WorldSectionCursorInterface {
-    _current: Column | null;
-    _chunk: Chunk | null;
+export declare class SectorCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+    _current: Sector | null;
+    _section: Section | null;
     private voxel;
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
-    _columnPosition: Vector3Like;
+    _sectorPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
-    setColumn(dimension: string, x: number, y: number, z: number): boolean;
+    setSector(dimension: string, x: number, y: number, z: number): boolean;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
 }

package/World/Cursor/SectorCursor.js

@@ -0,0 +1,57 @@
+import { WorldRegister } from "../WorldRegister";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { WorldSpaces } from "../WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+export class SectorCursor extends DataCursorInterface {
+    _current = null;
+    _section;
+    voxel = new WorldVoxelCursor(this);
+    _voxelIndex = 0;
+    _voxelPosition = Vector3Like.Create();
+    _sectorPosition = Vector3Like.Create();
+    inBounds(x, y, z) {
+        const maxX = this._sectorPosition.x + WorldSpaces.sector.bounds.x;
+        const maxY = this._sectorPosition.y + WorldSpaces.sector.bounds.y;
+        const maxZ = this._sectorPosition.z + WorldSpaces.sector.bounds.z;
+        if (x < this._sectorPosition.x)
+            return false;
+        if (y < this._sectorPosition.y)
+            return false;
+        if (z < this._sectorPosition.z)
+            return false;
+        if (x > maxX)
+            return false;
+        if (y > maxY)
+            return false;
+        if (z > maxZ)
+            return false;
+        return true;
+    }
+    setSector(dimension, x, y, z) {
+        const sector = WorldRegister.sectors.get(dimension, x, y, z);
+        if (!sector)
+            return false;
+        this._current = sector;
+        this._sectorPosition.x = sector.position[0];
+        this._sectorPosition.y = sector.position[1];
+        this._sectorPosition.z = sector.position[2];
+        return true;
+    }
+    getVoxel(x, y, z) {
+        if (!this._current)
+            return null;
+        const section = this._current.sections[WorldSpaces.section.getIndex(x, y, z)];
+        if (!section) {
+            if (!section)
+                throw new Error(`Could not load section at ${x}-${y}-${z} | ${WorldSpaces.section.getIndex(x, y, z)}`);
+            this._section = null;
+            return null;
+        }
+        this._section = section;
+        this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
+        WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);
+        this.voxel.loadIn();
+        return this.voxel;
+    }
+}

package/{Data/Cursor/World → World/Cursor}/WorldCursor.d.ts

@@ -1,12 +1,12 @@
 import { Vector3Like } from "@amodx/math";
-import { ColumnCursor } from "./ColumnCursor";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { SectorCursor } from "./SectorCursor";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 export declare class WorldCursor extends DataCursorInterface {
-    columnCursors: Map<number, Map<number, ColumnCursor>>;
+    sectorCursors: Map<number, Map<number, SectorCursor>>;
     origin: Vector3Like;
     dimension: string;
     setFocalPoint(dimension: string, x: number, y: number, z: number): void;
     inBounds(x: number, y: number, z: number): boolean;
-    getColumn(x: number, y: number, z: number): ColumnCursor | null;
+    getSector(x: number, y: number, z: number): SectorCursor | null;
     getVoxel(x: number, y: number, z: number): import("./WorldVoxelCursor").WorldVoxelCursor | null;
 }

package/World/Cursor/WorldCursor.js

@@ -0,0 +1,51 @@
+import { Vector3Like } from "@amodx/math";
+import { SectorCursor } from "./SectorCursor";
+import { WorldSpaces } from "../WorldSpaces";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+let cursorCache = [];
+const tempPosition = Vector3Like.Create();
+export class WorldCursor extends DataCursorInterface {
+    sectorCursors = new Map();
+    origin = { x: 0, y: 0, z: 0 };
+    dimension = "";
+    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);
+            }
+        }
+        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;
+    }
+    inBounds(x, y, z) {
+        return WorldSpaces.world.inBounds(x, y, z);
+    }
+    getSector(x, y, z) {
+        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);
+        if (!cursor) {
+            cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
+            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z))
+                return null;
+            if (!row) {
+                row = new Map();
+                this.sectorCursors.set(cx, row);
+            }
+            row.set(cz, cursor);
+        }
+        return cursor;
+    }
+    getVoxel(x, y, z) {
+        const section = this.getSector(x, y, z);
+        if (!section)
+            return null;
+        return section.getVoxel(x, y, z);
+    }
+}

package/{Data/Cursor/World → World/Cursor}/WorldSectionCursor.interface.d.ts

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
-import { Chunk } from "../../World/Classes";
+import type { Section } from "../Section/index";
 export interface WorldSectionCursorInterface {
-    _chunk: Chunk | null;
+    _section: Section | null;
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
 }

package/{Data/Cursor/World → World/Cursor}/WorldVoxelCursor.d.ts

@@ -1,10 +1,11 @@
-import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 export declare class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor: WorldSectionCursorInterface;
-    private _chunk;
+    private _section;
     get ids(): Uint16Array;
     get light(): Uint16Array;
+    get level(): Uint8Array;
     get state(): Uint16Array;
     get secondary(): Uint16Array;
     get mod(): Uint16Array;

package/World/Cursor/WorldVoxelCursor.js

@@ -0,0 +1,58 @@
+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;
+    }
+    constructor(dataCursor) {
+        super();
+        this.dataCursor = dataCursor;
+    }
+    loadIn() {
+        if (!this.dataCursor._section)
+            return;
+        this._section = this.dataCursor._section;
+        this._index = this.dataCursor._voxelIndex;
+        this.process();
+    }
+    /**
+     *
+     * @param mode 0 for add 1 for remove
+     * @param x
+     * @param y
+     * @param z
+     * @returns
+     */
+    updateHeightMap(mode) {
+        Section.StateStruct.setData(this._section.sectionState);
+        const voxelPos = this.dataCursor._voxelPosition;
+        if (mode == 0) {
+            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 1);
+            return true;
+        }
+        if (mode == 1) {
+            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.dirtyMap, voxelPos.y, 1);
+            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 0);
+            return true;
+        }
+        return false;
+    }
+}

package/{Data/World/Classes → World/Dimension}/Dimension.d.ts

@@ -1,14 +1,14 @@
-import { Region } from "./Region";
+import { Sector } from "../Sector";
 export interface DimensionData {
     id: string;
-    regions: Map<string, Region>;
+    sectors: Map<string, Sector>;
 }
 export interface Dimension extends DimensionData {
 }
 export declare class Dimension {
     static CreateNew(id: string): Dimension;
     constructor(data: DimensionData);
-    set(regionId: string, region: Region): void;
-    delete(regionId: string): void;
-    get(regionId: string): Region | undefined;
+    set(sectorId: string, region: Sector): void;
+    delete(sectorId: string): void;
+    get(sectorId: string): Sector | undefined;
 }

package/World/Dimension/Dimension.js

@@ -0,0 +1,20 @@
+export class Dimension {
+    static CreateNew(id) {
+        return new Dimension({
+            id,
+            sectors: new Map(),
+        });
+    }
+    constructor(data) {
+        return Object.assign(this, data);
+    }
+    set(sectorId, region) {
+        this.sectors.set(sectorId, region);
+    }
+    delete(sectorId) {
+        this.sectors.delete(sectorId);
+    }
+    get(sectorId) {
+        return this.sectors.get(sectorId);
+    }
+}

package/World/InitTasks.d.ts

@@ -0,0 +1,6 @@
+import { Thread } from "@amodx/threads/";
+import { WorldStorageInterface } from "./Storage/WorldStorage.interface.js";
+export default function ({ threads, worldStorage, }: {
+    threads: Thread[];
+    worldStorage?: WorldStorageInterface;
+}): void;

package/World/InitTasks.js

@@ -0,0 +1,92 @@
+import { Threads } from "@amodx/threads/";
+//data
+import { WorldRegister } from "./WorldRegister.js";
+import { WorldSpaces } from "./WorldSpaces.js";
+import { WorldLock } from "./Lock/WorldLock.js";
+import { WorldDataSyncIds } from "./Types/WorldDataSyncIds.js";
+export default function ({ threads, worldStorage, }) {
+    WorldRegister.sectors.setSecotrPool(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("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]);
+            }
+            return;
+        }
+        if (!sector && !worldStorage) {
+            WorldRegister.sectors.new(location[0], location[1], location[2], location[3]);
+        }
+        if (worldStorage) {
+            const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
+            const sectorLocation = [
+                location[0],
+                sectorPos.x,
+                sectorPos.y,
+                sectorPos.z,
+            ];
+            const sectorId = sectorLocation.toString();
+            if (loadInMap.has(sectorId))
+                return;
+            loadInMap.set(sectorId, true);
+            const success = await worldStorage.loadSector(sectorLocation);
+            loadInMap.delete(sectorId);
+            if (!success) {
+                WorldRegister.sectors.new(sectorLocation[0], sectorLocation[1], sectorLocation[2], sectorLocation[3]);
+            }
+            return;
+        }
+    });
+    Threads.registerTask("world-alloc", async (data) => {
+        await WorldLock.addLock(data);
+    });
+    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]);
+        }
+        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/WorldLock.d.ts

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

package/{Contexts/World → World}/Lock/WorldLock.js

@@ -1,34 +1,29 @@
-import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
-import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
-export const WorldLock = {
-    locks: new Map(),
-    dataLoader: {},
-    init(dataLoaderTool) {
-        this.dataLoader = dataLoaderTool;
-    },
-    _loadMap: new Map(),
-    addLock(taskData) {
+import { WorldRegister } from "../../World/WorldRegister.js";
+import { WorldSpaces } from "../../World/WorldSpaces.js";
+export class WorldLock {
+    static locks = new Map();
+    static _loadMap = new Map();
+    static worldStorage = null;
+    static addLock(taskData) {
         return new Promise(async (resolve) => {
             this.locks.set(taskData.toString(), taskData);
             const [dim, [ssx, ssy, ssz], [esx, esy, esz]] = taskData;
-            const { x: sx, y: sy, z: sz, } = WorldSpaces.column.getPositionXYZ(ssx, ssy, ssz);
-            const { x: ex, y: ey, z: ez, } = WorldSpaces.column.getPositionXYZ(esx, esy, esz);
+            const { x: sx, y: sy, z: sz, } = WorldSpaces.sector.getPosition(ssx, ssy, ssz);
+            const { x: ex, y: ey, z: ez, } = WorldSpaces.sector.getPosition(esx, esy, esz);
             const run = async () => {
                 let allFound = true;
-                for (let y = sy; y < ey + WorldSpaces.column._bounds.y; y += WorldSpaces.column._bounds.y) {
-                    for (let x = sx; x <= ex; x += WorldSpaces.column._bounds.x) {
-                        for (let z = sz; z <= ez; z += WorldSpaces.column._bounds.z) {
-                            const columnPos = WorldSpaces.column.getPositionXYZ(x, y, z);
+                for (let y = sy; y < ey + WorldSpaces.sector.bounds.y; y += WorldSpaces.sector.bounds.y) {
+                    for (let x = sx; x <= ex; x += WorldSpaces.sector.bounds.x) {
+                        for (let z = sz; z <= ez; z += WorldSpaces.sector.bounds.z) {
+                            const sectorPos = WorldSpaces.sector.getPosition(x, y, z);
                             const location = [
                                 taskData[0],
-                                columnPos.x,
-                                columnPos.y,
-                                columnPos.z,
+                                sectorPos.x,
+                                sectorPos.y,
+                                sectorPos.z,
                             ];
                             location[0] = dim;
-                            WorldRegister.instance.setDimension(location[0]);
-                            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                            if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3]))
                                 continue;
                             allFound = false;
                             const key = location.toString();
@@ -36,19 +31,19 @@ export const WorldLock = {
                                 continue;
                             this._loadMap.set(key, true);
                             let success = false;
-                            if (!this.dataLoader.isEnabled()) {
-                                if (WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+                            if (!this.worldStorage) {
+                                if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3])) {
                                     success = true;
                                 }
                             }
                             else {
-                                success = await this.dataLoader.loadIfExists(location);
+                                success = await this.worldStorage.loadSector(location);
                             }
                             this._loadMap.delete(key);
-                            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                            if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3]))
                                 return;
                             if (!success) {
-                                WorldRegister.instance.column.fill(location[1], location[2], location[3]);
+                                WorldRegister.sectors.new(location[0], location[1], location[2], location[3]);
                             }
                         }
                     }
@@ -58,20 +53,21 @@ export const WorldLock = {
             const didRun = await run();
             if (didRun)
                 return resolve(true);
-            const inte = new SafeInterval().setInterval(100).setOnRun(async () => {
+            const readyCheck = async () => {
                 const didRun = await run();
                 if (didRun) {
-                    inte.stop();
                     resolve(true);
+                    return;
                 }
-            });
-            inte.start();
+                setTimeout(readyCheck, 10);
+            };
+            readyCheck();
         });
-    },
-    removeLock(data) {
+    }
+    static removeLock(data) {
         this.locks.delete(data.toString());
-    },
-    isLocked([sdim, x, y, z]) {
+    }
+    static isLocked([sdim, x, y, z]) {
         let locked = false;
         for (const [key, [dim, [sx, sy, sz], [ex, ey, ez]]] of this.locks) {
             if (dim != sdim)
@@ -82,5 +78,5 @@ export const WorldLock = {
             break;
         }
         return locked;
-    },
-};
+    }
+}