@divinevoxel/vlox 0.0.73 → 0.0.75

package/World/Section/Section.d.ts

@@ -1,7 +1,10 @@
 import { Sector } from "../Sector/Sector.js";
-import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "Voxels/index.js";
+import { Vec2Array, Vec3Array } from "@amodx/math";
+import { VoxelDataArrays } from "../../Voxels/index.js";
+import { SectionStateDefaultFlags, SectionStateDefaultTicks } from "./SectionState.js";
 export interface SectionData extends VoxelDataArrays {
+    /**Array of bit ticks for the sector*/
+    tickArray: Uint32Array;
     /**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. */
@@ -14,29 +17,34 @@ export interface SectionData extends VoxelDataArrays {
 export interface Section extends SectionData {
 }
 export declare class Section {
-    sector: Sector;
-    index: number;
     static GetBufferSize(): number;
     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);
+    position: Vec3Array;
+    readonly _Flags: typeof SectionStateDefaultFlags;
+    readonly _Ticks: typeof SectionStateDefaultTicks;
+    index: number;
+    sector: Sector;
+    view: Uint8Array;
+    updatePosition(): void;
+    setBuffer(sector: Sector, buffer: ArrayBufferLike, index: number): void;
+    clear(): void;
     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;
+    isLogicUpdateInProgress(): boolean;
+    setLogicUpdateInProgress(inProgress: boolean): void;
     getBuried(index: number): boolean;
     setBuried(index: number, value: boolean): void;
     setHasVoxel(y: number, hasVoxel: boolean): void;
     getHasVoxel(y: number): boolean;
     setHasVoxelDirty(y: number, dirty: boolean): void;
     getHasVoxelDirty(y: number): boolean;
-    getMinMax(): number[];
+    getTick(tick: number): number;
+    incrementTick(tick: number): void;
+    canRender(): boolean;
+    getMinMax(): Vec2Array;
     storeFlags(): Record<string, boolean>;
     loadFlags(flags: Record<string, boolean>): void;
-    toJSON(): SectionData;
 }

package/World/Section/Section.js

@@ -1,18 +1,19 @@
 import { WorldSpaces } from "../WorldSpaces.js";
 import { Sector } from "../Sector/Sector.js";
-import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
-import { SectionState, SectionStateDefaultFlags } from "./SectionState.js";
-import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
+import { getBitArrayIndex, getBitAtomicArrayIndex, setBitArrayIndex, setBitAtomicArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectionState, SectionStateDefaultFlags, SectionStateDefaultTicks, } from "./SectionState.js";
+import { forceMultipleOf4 } from "../../Util/Binary/BinaryFunctions.js";
+const temp = [0, 0];
 export class Section {
-    sector;
-    index;
     static GetBufferSize() {
         const voxelSize = WorldSpaces.section.volumne;
         const height = WorldSpaces.section.bounds.y;
-        return forceMultipleOf2(
+        return forceMultipleOf4(
         //----- state
-        //2 bytes for flags
-        2 +
+        //4 tick counters
+        4 * 4 +
+            //2 bytes for flags
+            2 +
             //voxelMap
             height / 8 +
             //dirtyMap
@@ -26,94 +27,75 @@ export class Section {
             voxelSize * 2 +
             //level
             voxelSize +
-            //state
-            voxelSize * 2 +
-            //mod
-            voxelSize * 2 +
             //secondary
             voxelSize * 2);
     }
     static GetArrayStartIndex(index) {
         return index * Section.GetBufferSize() + Sector.GetHeaderSize();
     }
-    static CreateNew(index, sectorBuffer) {
+    position = [0, 0, 0];
+    _Flags = SectionStateDefaultFlags;
+    _Ticks = SectionStateDefaultTicks;
+    index;
+    sector;
+    view;
+    updatePosition() {
+        const sector = this.sector;
+        const index = this.index;
+        this.position = WorldSpaces.section.getPositionFromIndexVec3Array(index, this.position);
+        this.position[0] =
+            this.position[0] * WorldSpaces.section.bounds.x + sector.position[0];
+        this.position[1] =
+            this.position[1] * WorldSpaces.section.bounds.y + sector.position[1];
+        this.position[2] =
+            this.position[2] * WorldSpaces.section.bounds.z + sector.position[2];
+    }
+    setBuffer(sector, buffer, index) {
+        this.index = index;
+        this.sector = sector;
+        this.updatePosition();
         const voxelSize = WorldSpaces.section.volumne;
         const height = WorldSpaces.section.bounds.y;
-        let bufferStart = this.GetArrayStartIndex(index);
-        const flagArray = new Uint8Array(sectorBuffer, bufferStart, 2);
+        const startingIndex = Section.GetArrayStartIndex(index);
+        this.view = new Uint8Array(buffer, startingIndex, Section.GetBufferSize());
+        let bufferStart = startingIndex;
+        this.tickArray = new Uint32Array(buffer, bufferStart, 4);
+        bufferStart += 4 * Uint32Array.BYTES_PER_ELEMENT;
+        this.flagArray = new Uint8Array(buffer, bufferStart, 2);
         bufferStart += 2;
-        const voxelMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
+        this.voxelMap = new Uint8Array(buffer, bufferStart, height / 8);
         bufferStart += height / 8;
-        const dirtyMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
+        this.dirtyMap = new Uint8Array(buffer, bufferStart, height / 8);
         bufferStart += height / 8;
-        const buried = new Uint8Array(sectorBuffer, bufferStart, voxelSize / 8);
+        this.buried = new Uint8Array(buffer, bufferStart, voxelSize / 8);
         bufferStart += voxelSize / 8;
-        const ids = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const light = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const state = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const mod = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const secondary = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
+        this.ids = new Uint16Array(buffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * Uint16Array.BYTES_PER_ELEMENT;
+        this.light = new Uint16Array(buffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * Uint16Array.BYTES_PER_ELEMENT;
+        this.secondary = new Uint16Array(buffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * Uint16Array.BYTES_PER_ELEMENT;
+        this.level = new Uint8Array(buffer, bufferStart, voxelSize);
         bufferStart += voxelSize;
-        return {
-            flagArray,
-            voxelMap,
-            dirtyMap,
-            buried,
-            ids,
-            light,
-            level,
-            state,
-            mod,
-            secondary,
-        };
-    }
-    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;
-        this.ids = data.ids;
-        this.level = data.level;
-        this.light = data.light;
-        this.secondary = data.secondary;
-        this.state = data.state;
-        this.mod = data.mod;
+    }
+    clear() {
+        this.flagArray = null;
+        this.voxelMap = null;
+        this.dirtyMap = null;
+        this.buried = null;
+        this.ids = null;
+        this.light = null;
+        this.secondary = null;
+        this.level = null;
     }
     getPosition() {
         return this.position;
     }
     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;
-    }
-    isDirty() {
-        return this.getBitFlag(SectionStateDefaultFlags.isDirty);
-    }
-    setDirty(dirty) {
-        this.setBitFlag(SectionStateDefaultFlags.isDirty, dirty);
-        if (dirty)
-            this.sector.setStored(false);
+        return getBitAtomicArrayIndex(this.flagArray, index) == 1;
     }
     isInProgress() {
         return this.getBitFlag(SectionStateDefaultFlags.inProgress);
@@ -121,6 +103,12 @@ export class Section {
     setInProgress(inProgress) {
         this.setBitFlag(SectionStateDefaultFlags.inProgress, inProgress);
     }
+    isLogicUpdateInProgress() {
+        return this.getBitFlag(SectionStateDefaultFlags.logicUpdateInProgress);
+    }
+    setLogicUpdateInProgress(inProgress) {
+        this.setBitFlag(SectionStateDefaultFlags.logicUpdateInProgress, inProgress);
+    }
     getBuried(index) {
         return getBitArrayIndex(this.buried, index) == 1;
     }
@@ -139,6 +127,16 @@ export class Section {
     getHasVoxelDirty(y) {
         return getBitArrayIndex(this.dirtyMap, y) == 1;
     }
+    getTick(tick) {
+        return this.tickArray[tick];
+    }
+    incrementTick(tick) {
+        this.tickArray[tick]++;
+    }
+    canRender() {
+        const [min, max] = this.getMinMax();
+        return min !== Math.abs(Infinity) && max !== Math.abs(Infinity);
+    }
     getMinMax() {
         let min = Infinity;
         let max = -Infinity;
@@ -151,7 +149,9 @@ export class Section {
                     max = i;
             }
         }
-        return [min, max];
+        temp[0] = min;
+        temp[1] = max;
+        return temp;
     }
     storeFlags() {
         const stored = {};
@@ -170,18 +170,4 @@ export class Section {
             this.setBitFlag(storedIndex, flags[flag]);
         }
     }
-    toJSON() {
-        return {
-            flagArray: this.flagArray,
-            voxelMap: this.voxelMap,
-            dirtyMap: this.dirtyMap,
-            buried: this.buried,
-            ids: this.ids,
-            light: this.light,
-            level: this.level,
-            secondary: this.secondary,
-            state: this.state,
-            mod: this.mod,
-        };
-    }
 }

package/World/Section/SectionState.d.ts

@@ -1,10 +1,16 @@
 export declare enum SectionStateDefaultFlags {
-    isDirty = 0,
-    inProgress = 1
+    inProgress = 0,
+    logicUpdateInProgress = 1
+}
+export declare enum SectionStateDefaultTicks {
+    displayDirty = 0,
+    logicDirty = 1,
+    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,11 +1,18 @@
 export var SectionStateDefaultFlags;
 (function (SectionStateDefaultFlags) {
-    SectionStateDefaultFlags[SectionStateDefaultFlags["isDirty"] = 0] = "isDirty";
-    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 1] = "inProgress";
+    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,27 +12,47 @@ 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;
     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;
+    isDisplayDirty(): boolean;
+    setDisplayDirty(stored: boolean): void;
+    isLogicDirty(): boolean;
+    setLogicDirty(stored: boolean): void;
     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;
+    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,48 +20,99 @@ 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);
+    }
+    setDisplayDirty(stored) {
+        this.setBitFlag(SectorStateDefaultBitFlags.displayDirty, stored);
+    }
+    isLogicDirty() {
+        return this.getBitFlag(SectorStateDefaultBitFlags.logicDirty);
+    }
+    setLogicDirty(stored) {
+        this.setBitFlag(SectorStateDefaultBitFlags.logicDirty, stored);
     }
     setStored(stored) {
-        this.setBitFlag(SectorStateDefaultBitFlags.isStored, stored);
+        this.setBitFlag(SectorStateDefaultBitFlags.stored, stored);
     }
     isStored() {
-        return this.getBitFlag(SectorStateDefaultBitFlags.isStored);
+        return this.getBitFlag(SectorStateDefaultBitFlags.stored);
     }
     setTimeStamp(index, value) {
         this.timeStampArray[index] = value;
@@ -75,13 +128,6 @@ export class Sector {
             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) {
@@ -116,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

@@ -3,8 +3,10 @@ export declare enum SectorStateDefaultBitFlags {
     isWorldDecorDone = 1,
     isWorldPropagationDone = 2,
     isWorldSunDone = 3,
-    isDirty = 4,
-    isStored = 5
+    displayDirty = 4,
+    logicDirty = 5,
+    stored = 6,
+    inProgress = 7
 }
 export declare enum SectorStateDefaultTimeStamps {
     lastSaveTimestamp = 0

package/World/Sector/SectorState.js

@@ -4,8 +4,10 @@ export var SectorStateDefaultBitFlags;
     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["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) {