@divinevoxel/vlox 0.0.74 → 0.0.76

package/World/Section/SectionState.d.ts

@@ -1,12 +1,16 @@
 export declare enum SectionStateDefaultFlags {
+    inProgress = 0,
+    logicUpdateInProgress = 1
+}
+export declare enum SectionStateDefaultTicks {
     displayDirty = 0,
     logicDirty = 1,
-    inProgress = 2,
-    logicUpdateInProgress = 3
+    propagationDirty = 2
 }
 export declare class SectionState {
     /**The default bit flags for sections */
     static Flags: typeof SectionStateDefaultFlags;
+    static Ticks: typeof SectionStateDefaultTicks;
     /**A record of bit flags tht are preserved when the section is stored */
     static StoredFlags: Record<string, number>;
 }

package/World/Section/SectionState.js

@@ -1,13 +1,18 @@
 export var SectionStateDefaultFlags;
 (function (SectionStateDefaultFlags) {
-    SectionStateDefaultFlags[SectionStateDefaultFlags["displayDirty"] = 0] = "displayDirty";
-    SectionStateDefaultFlags[SectionStateDefaultFlags["logicDirty"] = 1] = "logicDirty";
-    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 2] = "inProgress";
-    SectionStateDefaultFlags[SectionStateDefaultFlags["logicUpdateInProgress"] = 3] = "logicUpdateInProgress";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 0] = "inProgress";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["logicUpdateInProgress"] = 1] = "logicUpdateInProgress";
 })(SectionStateDefaultFlags || (SectionStateDefaultFlags = {}));
+export var SectionStateDefaultTicks;
+(function (SectionStateDefaultTicks) {
+    SectionStateDefaultTicks[SectionStateDefaultTicks["displayDirty"] = 0] = "displayDirty";
+    SectionStateDefaultTicks[SectionStateDefaultTicks["logicDirty"] = 1] = "logicDirty";
+    SectionStateDefaultTicks[SectionStateDefaultTicks["propagationDirty"] = 2] = "propagationDirty";
+})(SectionStateDefaultTicks || (SectionStateDefaultTicks = {}));
 export class SectionState {
     /**The default bit flags for sections */
     static Flags = SectionStateDefaultFlags;
+    static Ticks = SectionStateDefaultTicks;
     /**A record of bit flags tht are preserved when the section is stored */
     static StoredFlags = {};
 }

package/World/Sector/Sector.d.ts

@@ -1,5 +1,5 @@
 import { Section, SectionData } from "../Section/Section.js";
-import { Vec3Array } from "@amodx/math";
+import { Vec2Array, Vec3Array } from "@amodx/math";
 import { SectorStateDefaultBitFlags } from "./SectorState.js";
 export interface SectorData {
     buffer: ArrayBufferLike;
@@ -12,15 +12,32 @@ export interface SectorData {
 export interface Sector extends SectorData {
 }
 export declare class Sector {
-    position: Vec3Array;
     static FlagIds: typeof SectorStateDefaultBitFlags;
     static TimeStampIds: typeof import("./SectorState.js").SectorStateDefaultTimeStamps;
     static GetHeaderSize(): number;
     static GetBufferSize(): number;
-    static CreateNew(): SectorData;
+    static CreateNewBuffer(): ArrayBuffer | SharedArrayBuffer;
     sections: Section[];
     bufferView: Uint8Array;
-    constructor(data: SectorData, position: Vec3Array);
+    position: Vec3Array;
+    private _released;
+    setReleased(released: boolean): void;
+    isReleased(): boolean;
+    private _checkedOut;
+    /**Set if the sector is checked out into another thread.  */
+    setCheckedOut(checkedOut: boolean): void;
+    /**Will return true if the sector is checked out into another thread. */
+    isCheckedOut(): boolean;
+    /**Returns a promise that will resolve when the sector is no longer checked out. */
+    waitTillCheckedIn(): true | Promise<boolean>;
+    private _locked;
+    /**Set if the secotr is locked and can't be checked out.*/
+    setLocked(locked: boolean): void;
+    /**Will return true if the sector is locked out and can't be checked out. */
+    isLocked(): boolean;
+    setBuffer(buffer: ArrayBufferLike): void;
+    clear(): void;
+    updateSectionDirectly(index: number, view: Uint8Array): void;
     getSection(x: number, y: number, z: number): Section;
     setBitFlag(index: number, value: boolean): void;
     getBitFlag(index: number): boolean;
@@ -33,12 +50,9 @@ export declare class Sector {
     setTimeStamp(index: number, value: number): void;
     getTimeStamp(index: number): number;
     getRenerableSections(): Generator<Section>;
-    getLogicDirtySections(): Generator<Section>;
-    anySectionDisplayDirty(): boolean;
-    anySectionLogicDirty(): boolean;
     storeFlags(): Record<string, boolean>;
     loadFlags(flags: Record<string, boolean>): void;
     storeTimestamps(): Record<string, number>;
     loadTimestamps(stored: Record<string, number>): void;
-    toJSON(): SectorData;
+    getMinMax(): Vec2Array;
 }

package/World/Sector/Sector.js

@@ -1,14 +1,16 @@
 import { Section } from "../Section/Section.js";
 import { WorldSpaces } from "../WorldSpaces";
-import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { getBitAtomicArrayIndex, setBitAtomicArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
 import { SectorState, SectorStateDefaultBitFlags } from "./SectorState.js";
-import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
+import { forceMultipleOf4 } from "../../Util/Binary/BinaryFunctions.js";
+import { WorldRegister } from "../WorldRegister.js";
+import { EngineSettings } from "../../Settings/EngineSettings.js";
+const temp = [0, 0];
 export class Sector {
-    position;
     static FlagIds = SectorState.Flags;
     static TimeStampIds = SectorState.TimeStamps;
     static GetHeaderSize() {
-        return forceMultipleOf2(
+        return forceMultipleOf4(
         //12 bytes fot flags
         12 +
             //12 * 4 bytes for time stamps
@@ -18,42 +20,81 @@ export class Sector {
         const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
         return this.GetHeaderSize() + Section.GetBufferSize() * totalSections;
     }
-    static CreateNew() {
-        const buffer = new SharedArrayBuffer(this.GetBufferSize());
-        const flagArray = new Uint8Array(buffer, 0, 12);
-        const timeStampArray = new Uint32Array(buffer, 12, 12);
-        const sections = [];
-        const totalSections = WorldSpaces.sector.sectionVolumne;
-        for (let i = 0; i < totalSections; i++) {
-            sections[i] = Section.CreateNew(i, buffer);
-        }
-        return {
-            buffer,
-            flagArray,
-            timeStampArray,
-            sections,
-        };
+    static CreateNewBuffer() {
+        return EngineSettings.settings.memoryAndCPU.useSharedMemory
+            ? new SharedArrayBuffer(this.GetBufferSize())
+            : new ArrayBuffer(this.GetBufferSize());
     }
     sections = [];
     bufferView;
-    constructor(data, position) {
-        this.position = position;
-        this.flagArray = data.flagArray;
-        this.timeStampArray = data.timeStampArray;
-        this.buffer = data.buffer;
-        this.bufferView = new Uint8Array(data.buffer);
-        for (let i = 0; i < data.sections.length; i++) {
-            this.sections[i] = new Section(this, i, data.sections[i]);
+    position = [0, 0, 0];
+    _released = false;
+    setReleased(released) {
+        this._released = released;
+    }
+    isReleased() {
+        return this._released;
+    }
+    _checkedOut = false;
+    /**Set if the sector is checked out into another thread.  */
+    setCheckedOut(checkedOut) {
+        this._checkedOut = checkedOut;
+    }
+    /**Will return true if the sector is checked out into another thread. */
+    isCheckedOut() {
+        return this._checkedOut || this.buffer.byteLength == 0;
+    }
+    /**Returns a promise that will resolve when the sector is no longer checked out. */
+    waitTillCheckedIn() {
+        if (!this._checkedOut)
+            return true;
+        return new Promise((resolve) => {
+            const inte = () => {
+                if (!this._checkedOut)
+                    return resolve(true);
+                setTimeout(inte, 10);
+            };
+            inte();
+        });
+    }
+    _locked = false;
+    /**Set if the secotr is locked and can't be checked out.*/
+    setLocked(locked) {
+        this._locked = locked;
+    }
+    /**Will return true if the sector is locked out and can't be checked out. */
+    isLocked() {
+        return this._locked;
+    }
+    setBuffer(buffer) {
+        this.buffer = buffer;
+        this.flagArray = new Uint8Array(buffer, 0, 12);
+        this.timeStampArray = new Uint32Array(buffer, 12, 12);
+        this.bufferView = new Uint8Array(buffer);
+        const totalSections = WorldSpaces.sector.sectionVolumne;
+        for (let i = 0; i < totalSections; i++) {
+            this.sections[i] = WorldRegister._pools._sections.length
+                ? WorldRegister._pools._sections.shift()
+                : new Section();
+            this.sections[i].setBuffer(this, buffer, i);
         }
     }
+    clear() {
+        this.flagArray = null;
+        this.timeStampArray = null;
+        this.bufferView = null;
+    }
+    updateSectionDirectly(index, view) {
+        this.sections[index].view.set(view);
+    }
     getSection(x, y, z) {
         return this.sections[WorldSpaces.section.getIndex(x, y, z)];
     }
     setBitFlag(index, value) {
-        setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
+        setBitAtomicArrayIndex(this.flagArray, index, value ? 1 : 0);
     }
     getBitFlag(index) {
-        return getBitArrayIndex(this.flagArray, index) == 1;
+        return getBitAtomicArrayIndex(this.flagArray, index) == 1;
     }
     isDisplayDirty() {
         return this.getBitFlag(SectorStateDefaultBitFlags.displayDirty);
@@ -87,34 +128,6 @@ export class Sector {
             yield section;
         }
     }
-    *getLogicDirtySections() {
-        for (const section of this.sections) {
-            const [min, max] = section.getLogicMinMax();
-            if (min == Infinity || max == -Infinity)
-                continue;
-            yield section;
-        }
-    }
-    anySectionDisplayDirty() {
-        if (!this.isDisplayDirty())
-            return false;
-        for (let i = 0; i < this.sections.length; i++) {
-            if (this.sections[i].isDisplayDirty() && !this.sections[i].isInProgress())
-                return true;
-        }
-        this.setDisplayDirty(false);
-        return false;
-    }
-    anySectionLogicDirty() {
-        if (!this.isLogicDirty())
-            return false;
-        for (let i = 0; i < this.sections.length; i++) {
-            if (this.sections[i].isLogicDirty() && !this.sections[i].isLogicUpdateInProgress())
-                return true;
-        }
-        this.setLogicDirty(false);
-        return false;
-    }
     storeFlags() {
         const stored = {};
         for (const key in SectorState.StoredFlags) {
@@ -149,16 +162,22 @@ export class Sector {
             this.setTimeStamp(storedIndex, stored[timeStamp]);
         }
     }
-    toJSON() {
-        const sections = [];
-        for (const section of this.sections) {
-            sections.push(section.toJSON());
+    getMinMax() {
+        temp[0] = Infinity;
+        temp[1] = -Infinity;
+        const [x, y, z] = this.position;
+        for (let i = 0; i < this.sections.length; i++) {
+            const [min, max] = this.sections[i].getMinMax();
+            if (Math.abs(min) == Infinity || Math.abs(max) == Infinity) {
+                continue;
+            }
+            if (min + y < temp[0]) {
+                temp[0] = min + y;
+            }
+            if (max + y > temp[1]) {
+                temp[1] = max + y;
+            }
         }
-        return {
-            buffer: this.buffer,
-            flagArray: this.flagArray,
-            timeStampArray: this.timeStampArray,
-            sections,
-        };
+        return temp;
     }
 }

package/World/Sector/SectorHeightMap.d.ts

@@ -1,5 +1,5 @@
 import { LocationData } from "../../Math";
 export declare class SectorHeightMap {
     static getRelative(location: LocationData): number;
-    static getAbsolute(location: LocationData): number;
+    static getAbsolute(dimension: number, x: number, sy: number, z: number): number;
 }

package/World/Sector/SectorHeightMap.js

@@ -1,4 +1,4 @@
-import { $2dMooreNeighborhood } from "../../Math/CardinalNeighbors";
+import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
@@ -8,24 +8,24 @@ export class SectorHeightMap {
         const sectionDepth = WorldSpaces.section.bounds.z;
         let maxHeight = -Infinity;
         const [dimension, x, y, z] = location;
-        for (const check of $2dMooreNeighborhood) {
+        for (const check of MooreNeighborhood2D) {
             location[1] = check[0] * sectionWidth + x;
             location[3] = check[1] * sectionDepth + z;
-            const height = this.getAbsolute(location);
+            const height = this.getAbsolute(...location);
             if (height > maxHeight) {
                 maxHeight = height;
             }
         }
         return maxHeight;
     }
-    static getAbsolute(location) {
-        const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+    static getAbsolute(dimension, x, sy, z) {
+        const sector = WorldRegister.sectors.get(dimension, x, sy, z);
         if (!sector)
             return WorldSpaces.world.bounds.MinY;
         if (sector.sections.length == 0)
             return WorldSpaces.world.bounds.MinY;
         let maxHeight = WorldSpaces.world.bounds.MinY;
-        const positon = [location[1], location[2], location[3]];
+        const positon = [x, sy, z];
         let y = positon[1];
         for (let i = 0; i < sector.sections.length; i++) {
             const section = sector.sections[i];

package/World/Sector/SectorState.d.ts

@@ -5,7 +5,8 @@ export declare enum SectorStateDefaultBitFlags {
     isWorldSunDone = 3,
     displayDirty = 4,
     logicDirty = 5,
-    stored = 6
+    stored = 6,
+    inProgress = 7
 }
 export declare enum SectorStateDefaultTimeStamps {
     lastSaveTimestamp = 0

package/World/Sector/SectorState.js

@@ -7,6 +7,7 @@ export var SectorStateDefaultBitFlags;
     SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["displayDirty"] = 4] = "displayDirty";
     SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["logicDirty"] = 5] = "logicDirty";
     SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["stored"] = 6] = "stored";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["inProgress"] = 7] = "inProgress";
 })(SectorStateDefaultBitFlags || (SectorStateDefaultBitFlags = {}));
 export var SectorStateDefaultTimeStamps;
 (function (SectorStateDefaultTimeStamps) {

package/World/SnapShot/SectionSnapShot.d.ts

@@ -0,0 +1,19 @@
+import { Flat3DIndex } from "@amodx/math";
+import { LocationData } from "../../Math";
+export interface SectionSnapShotTransferData {
+    location: LocationData;
+    sections: Uint8Array[];
+}
+export declare class SectionSnapShot {
+    sections: Uint8Array[];
+    location: LocationData;
+    index: Flat3DIndex;
+    private _buffers;
+    constructor();
+    setLocation([dimension, x, y, z]: LocationData): void;
+    storeSnapShot(): void;
+    private _isTransfered;
+    isTransfered(): boolean;
+    transfer(): [SectionSnapShotTransferData, ArrayBuffer[]];
+    restore(data: SectionSnapShotTransferData): void;
+}

package/World/SnapShot/SectionSnapShot.js

@@ -0,0 +1,72 @@
+import { Flat3DIndex } from "@amodx/math";
+import { WorldSpaces } from "../WorldSpaces";
+import { Section } from "../Section/Section";
+import { WorldRegister } from "../WorldRegister";
+export class SectionSnapShot {
+    sections = [];
+    location = [0, 0, 0, 0];
+    index = Flat3DIndex.GetXYZOrder();
+    _buffers = [];
+    constructor() {
+        this.index.setBounds(3, 3, 3);
+        let totalSections = this.index.size;
+        while (totalSections--) {
+            const buffer = new ArrayBuffer(Section.GetBufferSize());
+            this.sections.push(new Uint8Array(buffer));
+            this._buffers.push(buffer);
+        }
+    }
+    setLocation([dimension, x, y, z]) {
+        this.location[0] = dimension;
+        this.location[1] = x;
+        this.location[2] = y;
+        this.location[3] = z;
+    }
+    storeSnapShot() {
+        const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.section.bounds;
+        const [dim, ox, oy, oz] = this.location;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const wx = ox + (x - 1) * sizeX;
+                    const wy = oy + (y - 1) * sizeY;
+                    const wz = oz + (z - 1) * sizeZ;
+                    const snapShotSection = this.sections[this.index.getIndexXYZ(x, y, z)];
+                    if (!WorldSpaces.world.inBounds(wx, wy, wz)) {
+                        snapShotSection.fill(0);
+                        continue;
+                    }
+                    const sector = WorldRegister.sectors.get(dim, wx, wy, wz);
+                    if (!sector) {
+                        snapShotSection.fill(0);
+                        continue;
+                    }
+                    snapShotSection.set(sector.getSection(wx, wy, wz).view);
+                }
+            }
+        }
+    }
+    _isTransfered = false;
+    isTransfered() {
+        return this._isTransfered;
+    }
+    transfer() {
+        this._isTransfered = true;
+        return [
+            {
+                location: [...this.location],
+                sections: [...this.sections],
+            },
+            this._buffers,
+        ];
+    }
+    restore(data) {
+        this.sections = data.sections;
+        this.location = data.location;
+        this._buffers = [];
+        this._isTransfered = false;
+        for (let i = 0; i < this.sections.length; i++) {
+            this._buffers.push(this.sections[i].buffer);
+        }
+    }
+}

package/World/SnapShot/SectionSnapShotCursor.d.ts

@@ -0,0 +1,23 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { SectionSnapShot } from "./SectionSnapShot";
+import { Sector } from "../Sector";
+import { SectorCursor } from "../Cursor/SectorCursor";
+import { SectionCursor } from "../Cursor/SectionCursor";
+export declare class SectionSnapshotCursor implements DataCursorInterface {
+    origin: Vector3Like;
+    sectorOrigin: Vector3Like;
+    dimension: number;
+    sectors: Sector[];
+    cursors: SectorCursor[];
+    index: Flat3DIndex;
+    constructor();
+    private _snapShot;
+    private _centeralCursor;
+    getCenteralCursor(): SectionCursor | null;
+    setSectionSnapShot(snapShot: SectionSnapShot): void;
+    protected getSectorIndex(x: number, y: number, z: number): number;
+    inBounds(x: number, y: number, z: number): boolean;
+    getVoxel(x: number, y: number, z: number): import("../Cursor/WorldVoxelCursor").WorldVoxelCursor | null;
+    clone(): SectionSnapshotCursor;
+}

package/World/SnapShot/SectionSnapShotCursor.js

@@ -0,0 +1,107 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../WorldSpaces";
+import { Sector } from "../Sector";
+import { SectorCursor } from "../Cursor/SectorCursor";
+import { SectionCursor } from "../Cursor/SectionCursor";
+const tempPosition = Vector3Like.Create();
+export class SectionSnapshotCursor {
+    origin = Vector3Like.Create();
+    sectorOrigin = Vector3Like.Create();
+    dimension = 0;
+    sectors = [];
+    cursors = [];
+    index = Flat3DIndex.GetXYZOrder();
+    constructor() {
+        this.index.setBounds(3, 3, 3);
+        const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.sector.bounds;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    if (!WorldSpaces.world.inBounds((x - 1) * sizeX, (y - 1) * sizeY, (z - 1) * sizeZ))
+                        continue;
+                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    const sector = new Sector();
+                    sector.setBuffer(Sector.CreateNewBuffer());
+                    const cursor = new SectorCursor();
+                    cursor.setSector(sector);
+                    this.sectors[sectorIndex] = sector;
+                    this.cursors[sectorIndex] = cursor;
+                }
+            }
+        }
+    }
+    _snapShot;
+    _centeralCursor = new SectionCursor();
+    getCenteralCursor() {
+        const [dim, x, y, z] = this._snapShot.location;
+        const sector = this.sectors[this.getSectorIndex(x, y, z)];
+        if (!sector)
+            return null;
+        const section = sector.getSection(x, y, z);
+        if (!section)
+            return null;
+        this._centeralCursor.setSection(section);
+        return this._centeralCursor;
+    }
+    setSectionSnapShot(snapShot) {
+        this._snapShot = snapShot;
+        const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+        this.origin.x = snapShot.location[1];
+        this.origin.y = snapShot.location[2];
+        this.origin.z = snapShot.location[3];
+        this.sectorOrigin.x = this.origin.x;
+        this.sectorOrigin.y = this.origin.y;
+        this.sectorOrigin.z = this.origin.z;
+        WorldSpaces.sector.transformPosition(this.sectorOrigin);
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    const sector = this.sectors[sectorIndex];
+                    if (!sector)
+                        continue;
+                    const secotrPosition = WorldSpaces.sector.getPosition(this.sectorOrigin.x + (x - 1) * sectorSizeX, this.sectorOrigin.y + (y - 1) * sectorSizeY, this.sectorOrigin.z + (z - 1) * sectorSizeZ, tempPosition);
+                    sector.position[0] = secotrPosition.x;
+                    sector.position[1] = secotrPosition.y;
+                    sector.position[2] = secotrPosition.z;
+                    this.cursors[sectorIndex].setSector(sector);
+                }
+            }
+        }
+        const { x: sectionSizeX, y: sectionSizeY, z: sectionSizeZ, } = WorldSpaces.section.bounds;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const sectionX = this.origin.x + (x - 1) * sectionSizeX;
+                    const sectionY = this.origin.y + (y - 1) * sectionSizeY;
+                    const sectionZ = this.origin.z + (z - 1) * sectionSizeZ;
+                    if (!WorldSpaces.world.inBounds(sectionX, sectionY, sectionZ))
+                        continue;
+                    const sectorIndex = this.getSectorIndex(sectionX, sectionY, sectionZ);
+                    const sector = this.sectors[sectorIndex];
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(sectionX, sectionY, sectionZ);
+                    section.updatePosition();
+                    section.view.set(snapShot.sections[snapShot.index.getIndexXYZ(x, y, z)]);
+                }
+            }
+        }
+    }
+    getSectorIndex(x, y, z) {
+        const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
+        return this.index.getIndexXYZ((sectorPos.x - this.sectorOrigin.x) / WorldSpaces.sector.bounds.x + 1, (sectorPos.y - this.sectorOrigin.y) / WorldSpaces.sector.bounds.y + 1, (sectorPos.z - this.sectorOrigin.z) / WorldSpaces.sector.bounds.z + 1);
+    }
+    inBounds(x, y, z) {
+        return WorldSpaces.world.inBounds(x, y, z);
+    }
+    getVoxel(x, y, z) {
+        const sector = this.cursors[this.getSectorIndex(x, y, z)];
+        if (!sector)
+            return null;
+        return sector.getVoxel(x, y, z);
+    }
+    clone() {
+        return new SectionSnapshotCursor();
+    }
+}

package/World/SnapShot/SnapShots.d.ts

@@ -0,0 +1,11 @@
+import { LocationData } from "../../Math";
+import { SectionSnapShot } from "./SectionSnapShot";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare class SnapShots {
+    static _readyCache: SectionSnapShot[];
+    static _pendingCache: SectionSnapShot[];
+    private static bounds;
+    static getSnapShotBounds(x: number, y: number, z: number): Readonly<BoundingBox>;
+    static createSnapShot(location: LocationData): SectionSnapShot;
+    static transferSnapShot(snapShot: SectionSnapShot): void;
+}

package/World/SnapShot/SnapShots.js

@@ -0,0 +1,24 @@
+import { SectionSnapShot } from "./SectionSnapShot";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { WorldSpaces } from "../WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+export class SnapShots {
+    static _readyCache = [];
+    static _pendingCache = [];
+    static bounds = new BoundingBox();
+    static getSnapShotBounds(x, y, z) {
+        this.bounds.setMinMax(WorldSpaces.section.transformPosition(Vector3Like.Subtract({ x, y, z }, WorldSpaces.section.bounds)), WorldSpaces.section.transformPosition(Vector3Like.Add({ x, y, z }, WorldSpaces.section.bounds)));
+        return this.bounds;
+    }
+    static createSnapShot(location) {
+        let snapShot = this._readyCache.length
+            ? this._readyCache.shift()
+            : new SectionSnapShot();
+        snapShot.setLocation(location);
+        snapShot.storeSnapShot();
+        return snapShot;
+    }
+    static transferSnapShot(snapShot) {
+        this._pendingCache.push(snapShot);
+    }
+}

package/World/Types/WorldDataSyncIds.d.ts

@@ -1,6 +1,8 @@
 export declare enum WorldDataSyncIds {
     SyncSector = "sync-sector",
     UnSyncSector = "unsync-sector",
+    CheckInSector = "check-in-sector",
+    CheckOutSector = "check-out-sector",
     SyncDimension = "sync-dimension",
     UnSyncDimension = "unsync-dimension"
 }

package/World/Types/WorldDataSyncIds.js

@@ -2,6 +2,8 @@ export var WorldDataSyncIds;
 (function (WorldDataSyncIds) {
     WorldDataSyncIds["SyncSector"] = "sync-sector";
     WorldDataSyncIds["UnSyncSector"] = "unsync-sector";
+    WorldDataSyncIds["CheckInSector"] = "check-in-sector";
+    WorldDataSyncIds["CheckOutSector"] = "check-out-sector";
     WorldDataSyncIds["SyncDimension"] = "sync-dimension";
     WorldDataSyncIds["UnSyncDimension"] = "unsync-dimension";
 })(WorldDataSyncIds || (WorldDataSyncIds = {}));