@divinevoxel/vlox 0.0.74 → 0.0.76

package/World/Cursor/WorldCursor.js

@@ -37,21 +37,24 @@ export class WorldCursor {
         let cursor = this.sectorCursors[cx]?.[cz];
         if (!cursor) {
             cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
-            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
+            if (!cursor.loadSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
                 cursorCache.push(cursor);
                 return null;
             }
             if (!this.sectorCursors[cx]) {
-                this.sectorCursors[cx] ??= {};
+                this.sectorCursors[cx] = {};
             }
             this.sectorCursors[cx][cz] = cursor;
         }
         return cursor;
     }
     getVoxel(x, y, z) {
-        const section = this.getSector(x, y, z);
-        if (!section)
+        const sector = this.getSector(x, y, z);
+        if (!sector)
             return null;
-        return section.getVoxel(x, y, z);
+        return sector.getVoxel(x, y, z);
+    }
+    clone() {
+        return new WorldCursor();
     }
 }

package/World/Cursor/WorldVoxelCursor.d.ts

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

package/World/Cursor/WorldVoxelCursor.js

@@ -2,12 +2,10 @@ import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface"
 export class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor;
     _section = null;
-    ids = new Uint16Array(1);
-    light = new Uint16Array(1);
-    level = new Uint8Array(1);
-    state = new Uint16Array(1);
-    mod = new Uint16Array(1);
-    secondary = new Uint16Array(1);
+    ids;
+    light;
+    level;
+    secondary;
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
@@ -19,42 +17,24 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
         this.ids = this._section.ids;
         this.light = this._section.light;
         this.level = this._section.level;
-        this.state = this._section.state;
-        this.mod = this._section.mod;
         this.secondary = this._section.secondary;
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
     updateVoxel(mode) {
         const voxelPos = this.dataCursor._voxelPosition;
-        this.dataCursor._section?.sector.setStored(false);
         this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
         if (mode == 0) {
-            if (this.doesVoxelAffectLogic()) {
-                this.dataCursor._section?.setLogicDirty(true);
-                this.dataCursor._section?.setLogicSliceDirty(voxelPos.y, true);
-                this.dataCursor._section?.setVoxelLogicDirty(this.dataCursor._voxelIndex, true);
-            }
+            this.dataCursor._section?.sector.setStored(false);
             this.dataCursor._section?.setHasVoxel(voxelPos.y, true);
             return true;
         }
         if (mode == 1) {
-            if (this.doesVoxelAffectLogic()) {
-                this.dataCursor._section?.setLogicDirty(true);
-                this.dataCursor._section?.setLogicSliceDirty(voxelPos.y, true);
-                this.dataCursor._section?.setVoxelLogicDirty(this.dataCursor._voxelIndex, true);
-            }
+            this.dataCursor._section?.sector.setStored(false);
             this.dataCursor._section?.setHasVoxelDirty(voxelPos.y, true);
             this.dataCursor._section?.setHasVoxel(voxelPos.y, false);
             return true;
         }
-        if (mode == 2) {
-            if (this.doesVoxelAffectLogic()) {
-                this.dataCursor._section?.setLogicDirty(true);
-                this.dataCursor._section?.setLogicSliceDirty(voxelPos.y, true);
-                this.dataCursor._section?.setVoxelLogicDirty(this.dataCursor._voxelIndex, true);
-            }
-        }
         return false;
     }
 }

package/World/InitTasks.js

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

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

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

package/World/Lock/Function/LockSectors.js

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

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

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

package/World/Lock/Function/UnLockSectors.js

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

package/World/Lock/WorldLock.d.ts

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

package/World/Lock/WorldLock.js

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

package/World/Section/Section.d.ts

@@ -1,42 +1,36 @@
 import { Sector } from "../Sector/Sector.js";
 import { Vec2Array, Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "Voxels/index.js";
+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. */
     voxelMap: Uint8Array;
     /**Y slice of the section to tell if the slice is dirty and voxelMap needs to be re-checked. */
     dirtyMap: Uint8Array;
-    /**Y slice of the section to tell if the slice is needs it voxel logic checked.*/
-    logicDirtyMap: Uint8Array;
     /**A bit array used to cache if a voxel is exposed or not. */
     buried: Uint8Array;
-    /**A bit array used to cache if a voxel needs its logic evaled or not*/
-    logicDirty: Uint8Array;
 }
 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;
-    isDisplayDirty(): boolean;
-    setDisplayDirty(dirty: boolean): void;
-    isLogicDirty(): boolean;
-    setLogicDirty(dirty: boolean): void;
-    isLogicSliceDirty(y: number): boolean;
-    setLogicSliceDirty(y: number, dirty: boolean): void;
-    getVoxelLogicDirty(index: number): boolean;
-    setVoxelLogicDirty(index: number, value: boolean): void;
     isInProgress(): boolean;
     setInProgress(inProgress: boolean): void;
     isLogicUpdateInProgress(): boolean;
@@ -47,9 +41,10 @@ export declare class Section {
     getHasVoxel(y: number): boolean;
     setHasVoxelDirty(y: number, dirty: boolean): void;
     getHasVoxelDirty(y: number): boolean;
+    getTick(tick: number): number;
+    incrementTick(tick: number): void;
+    canRender(): boolean;
     getMinMax(): Vec2Array;
-    getLogicMinMax(): Vec2Array;
     storeFlags(): Record<string, boolean>;
     loadFlags(flags: Record<string, boolean>): void;
-    toJSON(): SectionData;
 }

package/World/Section/Section.js

@@ -1,29 +1,25 @@
 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
             height / 8 +
-            //logicDirtyMap
-            height / 8 +
             //bureid
             voxelSize / 8 +
-            //logic dirty
-            voxelSize / 8 +
             //---- voxel data arrays
             //ids
             voxelSize * 2 +
@@ -31,125 +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);
-        bufferStart += height / 8;
-        const dirtyMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
+        this.voxelMap = new Uint8Array(buffer, bufferStart, height / 8);
         bufferStart += height / 8;
-        const logicDirtyMap = 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);
-        bufferStart += voxelSize / 8;
-        const logicDirty = 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,
-            logicDirtyMap,
-            logicDirty,
-            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.logicDirty = data.logicDirty;
-        this.logicDirtyMap = data.logicDirtyMap;
-        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;
-    }
-    isDisplayDirty() {
-        return this.getBitFlag(SectionStateDefaultFlags.displayDirty);
-    }
-    setDisplayDirty(dirty) {
-        this.setBitFlag(SectionStateDefaultFlags.displayDirty, dirty);
-        if (dirty) {
-            this.sector.setStored(false);
-            this.sector.setDisplayDirty(true);
-        }
-    }
-    isLogicDirty() {
-        return this.getBitFlag(SectionStateDefaultFlags.logicDirty);
-    }
-    setLogicDirty(dirty) {
-        this.setBitFlag(SectionStateDefaultFlags.logicDirty, dirty);
-        if (dirty) {
-            this.sector.setLogicDirty(true);
-        }
-    }
-    isLogicSliceDirty(y) {
-        return getBitArrayIndex(this.logicDirtyMap, y) == 1;
-    }
-    setLogicSliceDirty(y, dirty) {
-        setBitArrayIndex(this.logicDirtyMap, y, dirty ? 1 : 0);
-    }
-    getVoxelLogicDirty(index) {
-        return getBitArrayIndex(this.logicDirty, index) == 1;
-    }
-    setVoxelLogicDirty(index, value) {
-        return setBitArrayIndex(this.logicDirty, index, value ? 1 : 0);
+        return getBitAtomicArrayIndex(this.flagArray, index) == 1;
     }
     isInProgress() {
         return this.getBitFlag(SectionStateDefaultFlags.inProgress);
@@ -181,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;
@@ -197,22 +153,6 @@ export class Section {
         temp[1] = max;
         return temp;
     }
-    getLogicMinMax() {
-        let min = Infinity;
-        let max = -Infinity;
-        let i = WorldSpaces.section.bounds.y;
-        while (i--) {
-            if (this.isLogicSliceDirty(i)) {
-                if (i < min)
-                    min = i;
-                if (i > max)
-                    max = i;
-            }
-        }
-        temp[0] = min;
-        temp[1] = max;
-        return temp;
-    }
     storeFlags() {
         const stored = {};
         for (const key in SectionState.StoredFlags) {
@@ -230,20 +170,4 @@ export class Section {
             this.setBitFlag(storedIndex, flags[flag]);
         }
     }
-    toJSON() {
-        return {
-            flagArray: this.flagArray,
-            logicDirtyMap: this.logicDirtyMap,
-            logicDirty: this.logicDirty,
-            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,
-        };
-    }
 }