@divinevoxel/vlox 0.0.72 → 0.0.73

package/World/Cursor/WorldCursor.d.ts

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

package/World/Cursor/WorldCursor.js

@@ -1,10 +1,9 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
-export class WorldCursor extends DataCursorInterface {
+export class WorldCursor {
     sectorCursors = new Map();
     origin = { x: 0, y: 0, z: 0 };
     dimension = "";

package/World/Cursor/WorldVoxelCursor.js

@@ -31,6 +31,7 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
      */
     updateVoxel(mode) {
         const voxelPos = this.dataCursor._voxelPosition;
+        this.dataCursor._section?.sector.setStored(false);
         if (mode == 0) {
             this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
             this.dataCursor._section?.setHasVoxel(voxelPos.y, true);

package/World/InitTasks.d.ts

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

package/World/Lock/WorldLock.d.ts

@@ -1,6 +1,6 @@
 import type { WorldLockTasks } from "../../Tasks/Tasks.types";
 import type { LocationData } from "../../Math";
-import { WorldStorageInterface } from "../../World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "../Types/WorldStorage.interface";
 export declare class WorldLock {
     static locks: Map<string, WorldLockTasks>;
     static _loadMap: Map<string, boolean>;

package/World/Section/Section.d.ts

@@ -1,22 +1,9 @@
 import { Sector } from "../Sector/Sector.js";
 import { Vec3Array } from "@amodx/math";
-export interface VoxelDataArrays {
-    /**The runtime numeric voxel ids */
-    ids: Uint16Array;
-    /**The light data for voxels stored as 4 nibbles. 0 -> sun light 1 -> red light 2 -> green light 3 -> blue light */
-    light: Uint16Array;
-    /**The levels of the voxel. Used mainly for waterflow now. */
-    level: Uint8Array;
-    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
-    state: Uint16Array;
-    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
-    mod: Uint16Array;
-    /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
-     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
-     */
-    secondary: Uint16Array;
-}
+import { VoxelDataArrays } from "Voxels/index.js";
 export interface SectionData extends VoxelDataArrays {
+    /**Array of bit flags for the sector*/
+    flagArray: Uint8Array;
     /**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. */
@@ -33,8 +20,15 @@ export declare class Section {
     static GetArrayStartIndex(index: number): number;
     static CreateNew(index: number, sectorBuffer: ArrayBufferLike): SectionData;
     static toObject(sector: Sector, index: number, data: SectionData): Section;
+    readonly position: Vec3Array;
     constructor(sector: Sector, index: number, data: SectionData);
     getPosition(): Readonly<Vec3Array>;
+    setBitFlag(index: number, value: boolean): void;
+    getBitFlag(index: number): boolean;
+    isDirty(): boolean;
+    setDirty(dirty: boolean): void;
+    isInProgress(): boolean;
+    setInProgress(inProgress: boolean): void;
     getBuried(index: number): boolean;
     setBuried(index: number, value: boolean): void;
     setHasVoxel(y: number, hasVoxel: boolean): void;
@@ -42,5 +36,7 @@ export declare class Section {
     setHasVoxelDirty(y: number, dirty: boolean): void;
     getHasVoxelDirty(y: number): boolean;
     getMinMax(): number[];
+    storeFlags(): Record<string, boolean>;
+    loadFlags(flags: Record<string, boolean>): void;
     toJSON(): SectionData;
 }

package/World/Section/Section.js

@@ -1,10 +1,8 @@
 import { WorldSpaces } from "../WorldSpaces.js";
 import { Sector } from "../Sector/Sector.js";
-import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BitArray.js";
-function forceMultipleOf2(n) {
-    return n % 2 === 0 ? n : n + 1;
-}
-const position = [0, 0, 0];
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectionState, SectionStateDefaultFlags } from "./SectionState.js";
+import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
 export class Section {
     sector;
     index;
@@ -12,18 +10,16 @@ export class Section {
         const voxelSize = WorldSpaces.section.volumne;
         const height = WorldSpaces.section.bounds.y;
         return forceMultipleOf2(
-        //-----
-        //voxelMap
-        height / 8 +
+        //----- state
+        //2 bytes for flags
+        2 +
+            //voxelMap
+            height / 8 +
             //dirtyMap
             height / 8 +
-            //-----
-            //cache
+            //bureid
             voxelSize / 8 +
-            //exposed
-            voxelSize * 2 +
-            //-----
-            //voxel data
+            //---- voxel data arrays
             //ids
             voxelSize * 2 +
             //light
@@ -42,8 +38,10 @@ export class Section {
     }
     static CreateNew(index, sectorBuffer) {
         const voxelSize = WorldSpaces.section.volumne;
-        let bufferStart = this.GetArrayStartIndex(index);
         const height = WorldSpaces.section.bounds.y;
+        let bufferStart = this.GetArrayStartIndex(index);
+        const flagArray = new Uint8Array(sectorBuffer, bufferStart, 2);
+        bufferStart += 2;
         const voxelMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
         bufferStart += height / 8;
         const dirtyMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
@@ -63,6 +61,7 @@ export class Section {
         const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize;
         return {
+            flagArray,
             voxelMap,
             dirtyMap,
             buried,
@@ -77,9 +76,18 @@ export class Section {
     static toObject(sector, index, data) {
         return new Section(sector, index, data);
     }
+    position;
     constructor(sector, index, data) {
         this.sector = sector;
         this.index = index;
+        this.position = WorldSpaces.section.getPositionFromIndexVec3Array(this.index);
+        this.position[0] =
+            this.position[0] * WorldSpaces.section.bounds.x + this.sector.position[0];
+        this.position[1] =
+            this.position[1] * WorldSpaces.section.bounds.y + this.sector.position[1];
+        this.position[2] =
+            this.position[2] * WorldSpaces.section.bounds.z + this.sector.position[2];
+        this.flagArray = data.flagArray;
         this.voxelMap = data.voxelMap;
         this.dirtyMap = data.dirtyMap;
         this.buried = data.buried;
@@ -91,11 +99,27 @@ export class Section {
         this.mod = data.mod;
     }
     getPosition() {
-        position[0] = this.sector.position[0];
-        position[1] =
-            this.sector.position[1] + this.index * WorldSpaces.section.bounds.y;
-        position[2] = this.sector.position[2];
-        return position;
+        return this.position;
+    }
+    setBitFlag(index, value) {
+        setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
+    }
+    getBitFlag(index) {
+        return getBitArrayIndex(this.flagArray, index) == 1;
+    }
+    isDirty() {
+        return this.getBitFlag(SectionStateDefaultFlags.isDirty);
+    }
+    setDirty(dirty) {
+        this.setBitFlag(SectionStateDefaultFlags.isDirty, dirty);
+        if (dirty)
+            this.sector.setStored(false);
+    }
+    isInProgress() {
+        return this.getBitFlag(SectionStateDefaultFlags.inProgress);
+    }
+    setInProgress(inProgress) {
+        this.setBitFlag(SectionStateDefaultFlags.inProgress, inProgress);
     }
     getBuried(index) {
         return getBitArrayIndex(this.buried, index) == 1;
@@ -129,8 +153,26 @@ export class Section {
         }
         return [min, max];
     }
+    storeFlags() {
+        const stored = {};
+        for (const key in SectionState.StoredFlags) {
+            stored[key] = this.getBitFlag(SectionState.StoredFlags[key]);
+        }
+        return stored;
+    }
+    loadFlags(flags) {
+        for (const flag in flags) {
+            const storedIndex = SectionState.StoredFlags[flag];
+            if (storedIndex === undefined) {
+                console.warn(`${flag} does not exist on stored flags for section`);
+                continue;
+            }
+            this.setBitFlag(storedIndex, flags[flag]);
+        }
+    }
     toJSON() {
         return {
+            flagArray: this.flagArray,
             voxelMap: this.voxelMap,
             dirtyMap: this.dirtyMap,
             buried: this.buried,

package/World/Section/SectionState.d.ts

@@ -0,0 +1,10 @@
+export declare enum SectionStateDefaultFlags {
+    isDirty = 0,
+    inProgress = 1
+}
+export declare class SectionState {
+    /**The default bit flags for sections */
+    static Flags: typeof SectionStateDefaultFlags;
+    /**A record of bit flags tht are preserved when the section is stored */
+    static StoredFlags: Record<string, number>;
+}

package/World/Section/SectionState.js

@@ -0,0 +1,11 @@
+export var SectionStateDefaultFlags;
+(function (SectionStateDefaultFlags) {
+    SectionStateDefaultFlags[SectionStateDefaultFlags["isDirty"] = 0] = "isDirty";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 1] = "inProgress";
+})(SectionStateDefaultFlags || (SectionStateDefaultFlags = {}));
+export class SectionState {
+    /**The default bit flags for sections */
+    static Flags = SectionStateDefaultFlags;
+    /**A record of bit flags tht are preserved when the section is stored */
+    static StoredFlags = {};
+}

package/World/Sector/Sector.d.ts

@@ -1,8 +1,7 @@
 import { Section, SectionData } from "../Section/Section.js";
 import { Vec3Array } from "@amodx/math";
-import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
+import { SectorStateDefaultBitFlags } from "./SectorState.js";
 export interface SectorData {
-    position: Vec3Array;
     buffer: ArrayBufferLike;
     /**Array of timestamps for the sector */
     timeStampArray: Uint32Array;
@@ -13,18 +12,27 @@ export interface SectorData {
 export interface Sector extends SectorData {
 }
 export declare class Sector {
-    static FlagIds: typeof SectorStateFlags;
-    static TimeStampIds: typeof SectorTimestampFlags;
+    position: Vec3Array;
+    static FlagIds: typeof SectorStateDefaultBitFlags;
+    static TimeStampIds: typeof import("./SectorState.js").SectorStateDefaultTimeStamps;
     static GetHeaderSize(): number;
     static GetBufferSize(): number;
     static CreateNew(): SectorData;
     sections: Section[];
     bufferView: Uint8Array;
-    constructor(data: SectorData);
-    getSection(y: number): Section;
+    constructor(data: SectorData, position: Vec3Array);
+    getSection(x: number, y: number, z: number): Section;
     setBitFlag(index: number, value: boolean): void;
     getBitFlag(index: number): boolean;
+    setStored(stored: boolean): void;
+    isStored(): boolean;
     setTimeStamp(index: number, value: number): void;
     getTimeStamp(index: number): number;
+    getRenerableSections(): Generator<Section>;
+    anySectionDirty(): boolean;
+    storeFlags(): Record<string, boolean>;
+    loadFlags(flags: Record<string, boolean>): void;
+    storeTimestamps(): Record<string, number>;
+    loadTimestamps(stored: Record<string, number>): void;
     toJSON(): SectorData;
 }

package/World/Sector/Sector.js

@@ -1,13 +1,12 @@
 import { Section } from "../Section/Section.js";
 import { WorldSpaces } from "../WorldSpaces";
-import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BitArray.js";
-import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
-function forceMultipleOf2(n) {
-    return n % 2 === 0 ? n : n + 1;
-}
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectorState, SectorStateDefaultBitFlags } from "./SectorState.js";
+import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
 export class Sector {
-    static FlagIds = SectorStateFlags;
-    static TimeStampIds = SectorTimestampFlags;
+    position;
+    static FlagIds = SectorState.Flags;
+    static TimeStampIds = SectorState.TimeStamps;
     static GetHeaderSize() {
         return forceMultipleOf2(
         //12 bytes fot flags
@@ -22,14 +21,13 @@ export class Sector {
     static CreateNew() {
         const buffer = new SharedArrayBuffer(this.GetBufferSize());
         const flagArray = new Uint8Array(buffer, 0, 12);
-        const timeStampArray = new Uint32Array(buffer, 12, 12 * 4);
+        const timeStampArray = new Uint32Array(buffer, 12, 12);
         const sections = [];
-        const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
+        const totalSections = WorldSpaces.sector.sectionVolumne;
         for (let i = 0; i < totalSections; i++) {
             sections[i] = Section.CreateNew(i, buffer);
         }
         return {
-            position: [0, 0, 0],
             buffer,
             flagArray,
             timeStampArray,
@@ -38,8 +36,8 @@ export class Sector {
     }
     sections = [];
     bufferView;
-    constructor(data) {
-        this.position = data.position;
+    constructor(data, position) {
+        this.position = position;
         this.flagArray = data.flagArray;
         this.timeStampArray = data.timeStampArray;
         this.buffer = data.buffer;
@@ -48,10 +46,8 @@ export class Sector {
             this.sections[i] = new Section(this, i, data.sections[i]);
         }
     }
-    getSection(y) {
-        const ry = y - this.position[1];
-        const index = ry / WorldSpaces.section.bounds.y;
-        return this.sections[index];
+    getSection(x, y, z) {
+        return this.sections[WorldSpaces.section.getIndex(x, y, z)];
     }
     setBitFlag(index, value) {
         setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
@@ -59,19 +55,73 @@ export class Sector {
     getBitFlag(index) {
         return getBitArrayIndex(this.flagArray, index) == 1;
     }
+    setStored(stored) {
+        this.setBitFlag(SectorStateDefaultBitFlags.isStored, stored);
+    }
+    isStored() {
+        return this.getBitFlag(SectorStateDefaultBitFlags.isStored);
+    }
     setTimeStamp(index, value) {
         this.timeStampArray[index] = value;
     }
     getTimeStamp(index) {
         return this.timeStampArray[index];
     }
+    *getRenerableSections() {
+        for (const section of this.sections) {
+            const [min, max] = section.getMinMax();
+            if (min == Infinity || max == -Infinity)
+                continue;
+            yield section;
+        }
+    }
+    anySectionDirty() {
+        for (let i = 0; i < this.sections.length; i++) {
+            if (this.sections[i].isDirty() && !this.sections[i].isInProgress())
+                return true;
+        }
+        return false;
+    }
+    storeFlags() {
+        const stored = {};
+        for (const key in SectorState.StoredFlags) {
+            stored[key] = this.getBitFlag(SectorState.StoredFlags[key]);
+        }
+        return stored;
+    }
+    loadFlags(flags) {
+        for (const flag in flags) {
+            const storedIndex = SectorState.StoredFlags[flag];
+            if (storedIndex === undefined) {
+                console.warn(`${flag} does not exist on stored flags for sector`);
+                continue;
+            }
+            this.setBitFlag(storedIndex, flags[flag]);
+        }
+    }
+    storeTimestamps() {
+        const stored = {};
+        for (const key in SectorState.StoredTimeStamps) {
+            stored[key] = this.getTimeStamp(SectorState.StoredTimeStamps[key]);
+        }
+        return stored;
+    }
+    loadTimestamps(stored) {
+        for (const timeStamp in stored) {
+            const storedIndex = SectorState.StoredTimeStamps[timeStamp];
+            if (storedIndex === undefined) {
+                console.warn(`${timeStamp} does not exist on stored timestamps for sector`);
+                continue;
+            }
+            this.setTimeStamp(storedIndex, stored[timeStamp]);
+        }
+    }
     toJSON() {
         const sections = [];
         for (const section of this.sections) {
             sections.push(section.toJSON());
         }
         return {
-            position: this.position,
             buffer: this.buffer,
             flagArray: this.flagArray,
             timeStampArray: this.timeStampArray,

package/World/Sector/SectorHeightMap.js

@@ -31,11 +31,11 @@ export class SectorHeightMap {
             const section = sector.sections[i];
             if (!section)
                 continue;
-            const sectionPOS = y + i * WorldSpaces.section.bounds.y;
+            const sectionPOS = section.getPosition();
             let [sectionMin, sectionMax] = section.getMinMax();
             if (Math.abs(sectionMax) == Infinity)
                 continue;
-            sectionMax = sectionPOS + sectionMax;
+            sectionMax = sectionPOS[1] + sectionMax;
             if (maxHeight < sectionMax) {
                 maxHeight = sectionMax;
             }

package/World/Sector/SectorState.d.ts

@@ -1,13 +1,21 @@
-export declare enum SectorStateFlags {
+export declare enum SectorStateDefaultBitFlags {
     isWorldGenDone = 0,
     isWorldDecorDone = 1,
     isWorldPropagationDone = 2,
     isWorldSunDone = 3,
     isDirty = 4,
-    isStored = 5,
-    persistent = 6
+    isStored = 5
 }
-export declare enum SectorTimestampFlags {
-    lastSaveTimestamp = 0,
-    lastAnalyzerUpdateTimestamp = 1
+export declare enum SectorStateDefaultTimeStamps {
+    lastSaveTimestamp = 0
+}
+export declare class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags: typeof SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags: Record<string, number>;
+    /**The default  timestamps for secotrs */
+    static TimeStamps: typeof SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps: Record<string, number>;
 }

package/World/Sector/SectorState.js

@@ -1,15 +1,28 @@
-export var SectorStateFlags;
-(function (SectorStateFlags) {
-    SectorStateFlags[SectorStateFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
-    SectorStateFlags[SectorStateFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
-    SectorStateFlags[SectorStateFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
-    SectorStateFlags[SectorStateFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
-    SectorStateFlags[SectorStateFlags["isDirty"] = 4] = "isDirty";
-    SectorStateFlags[SectorStateFlags["isStored"] = 5] = "isStored";
-    SectorStateFlags[SectorStateFlags["persistent"] = 6] = "persistent";
-})(SectorStateFlags || (SectorStateFlags = {}));
-export var SectorTimestampFlags;
-(function (SectorTimestampFlags) {
-    SectorTimestampFlags[SectorTimestampFlags["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
-    SectorTimestampFlags[SectorTimestampFlags["lastAnalyzerUpdateTimestamp"] = 1] = "lastAnalyzerUpdateTimestamp";
-})(SectorTimestampFlags || (SectorTimestampFlags = {}));
+export var SectorStateDefaultBitFlags;
+(function (SectorStateDefaultBitFlags) {
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isDirty"] = 4] = "isDirty";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isStored"] = 5] = "isStored";
+})(SectorStateDefaultBitFlags || (SectorStateDefaultBitFlags = {}));
+export var SectorStateDefaultTimeStamps;
+(function (SectorStateDefaultTimeStamps) {
+    SectorStateDefaultTimeStamps[SectorStateDefaultTimeStamps["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
+})(SectorStateDefaultTimeStamps || (SectorStateDefaultTimeStamps = {}));
+export class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags = SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags = {
+        dve_is_world_gen_done: SectorStateDefaultBitFlags.isWorldGenDone,
+        dve_is_world_decoration_done: SectorStateDefaultBitFlags.isWorldDecorDone,
+        dve_is_world_progation_done: SectorStateDefaultBitFlags.isWorldPropagationDone,
+        dve_is_world_sun_done: SectorStateDefaultBitFlags.isWorldSunDone,
+    };
+    /**The default  timestamps for secotrs */
+    static TimeStamps = SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps = {};
+}

package/World/Types/WorldStorage.interface.js

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

package/World/WorldRegister.d.ts

@@ -19,9 +19,13 @@ declare class WorldRegisterDimensions {
 declare class WorldRegisterSectors {
     static setSecotrPool(enabled: boolean): void;
     static add(dimensionId: string, x: number, y: number, z: number, sector: SectorData): Sector;
+    static addAt(location: LocationData, sector: SectorData): Sector;
     static new(dimensionId: string, x: number, y: number, z: number): boolean;
+    static newAt(location: LocationData): boolean;
     static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
+    static getAt(location: LocationData): false | Sector;
     static remove(dimensionId: string, x: number, y: number, z: number): boolean;
+    static removeAt(location: LocationData): boolean;
 }
 export declare class WorldRegister {
     static _dimensions: Map<string, Dimension>;

package/World/WorldRegister.js

@@ -35,6 +35,7 @@ class SectorPool {
     }
     static returnSector(secotr) {
         secotr.bufferView.fill(0);
+        this._secotrs.push(secotr.toJSON());
     }
 }
 class WorldRegisterSectors {
@@ -46,21 +47,26 @@ class WorldRegisterSectors {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        WorldSpaces.sector.getPositionVec3Array(x, y, z, sector.position);
-        const newSector = new Sector(sector);
+        const newSector = new Sector(sector, WorldSpaces.sector.getPositionVec3Array(x, y, z));
         dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
+    static addAt(location, sector) {
+        return this.add(...location, sector);
+    }
     static new(dimensionId, x, y, z) {
         if (this.get(dimensionId, x, y, z))
             return false;
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const sector = this.add(dimensionId, x, y, z, Sector.CreateNew());
+        const sector = this.add(dimensionId, x, y, z, SectorPool.getSector());
         WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
+    static newAt(location) {
+        return this.new(...location);
+    }
     static get(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -68,6 +74,9 @@ class WorldRegisterSectors {
         const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
         return sector || false;
     }
+    static getAt(location) {
+        return this.get(...location);
+    }
     static remove(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -83,6 +92,9 @@ class WorldRegisterSectors {
         dimension.sectors.delete(sectorKey);
         return true;
     }
+    static removeAt(location) {
+        return this.remove(...location);
+    }
 }
 export class WorldRegister {
     static _dimensions = new Map();

package/World/WorldSpaces.d.ts

@@ -23,6 +23,8 @@ declare class SectorSpace {
     static power2Axes: Vector3Like;
     static bounds: Vector3Like;
     static volumne: number;
+    static sectionBounds: Vector3Like;
+    static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
 }
@@ -33,6 +35,8 @@ declare class SectionSpace {
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
     static getIndex(x: number, y: number, z: number): number;
+    static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionFromIndexVec3Array(index: number, refPosition?: Vec3Array): Vec3Array;
 }
 declare class VoxelSpace {
     static bounds: Vector3Like;