@divinevoxel/vlox 0.0.72 → 0.0.74

package/World/Archive/InitTasks.js

@@ -11,33 +11,40 @@ function runArchiveSector(location) {
         location: location,
     });
     const transfers = [];
-    if (archived.palettes.light)
-        transfers.push(archived.palettes.light.buffer);
-    if (archived.palettes.state)
-        transfers.push(archived.palettes.state.buffer);
-    if (archived.palettes.secondaryState)
-        transfers.push(archived.palettes.secondaryState.buffer);
+    // if (archived.palettes.light) transfers.push(archived.palettes.light.buffer);
+    // if (archived.palettes.state) transfers.push(archived.palettes.state.buffer);
+    if (archived.palettes.secondaryValue)
+        transfers.push(archived.palettes.secondaryValue.buffer);
     for (const section of archived.sections) {
-        if (typeof section.buffers.id != "number")
+        if (typeof section == "string")
+            continue;
+        if (ArrayBuffer.isView(section.buffers.id?.buffer))
             transfers.push(section.buffers.id.buffer);
-        if (typeof section.buffers.light != "number")
-            transfers.push(section.buffers.light.buffer);
-        if (typeof section.buffers.state != "number")
+        if (ArrayBuffer.isView(section.buffers.state?.buffer))
             transfers.push(section.buffers.state.buffer);
-        if (typeof section.buffers.secondary != "number")
-            transfers.push(section.buffers.secondary.buffer);
-        if (typeof section.buffers.mod != "number")
+        if (ArrayBuffer.isView(section.buffers.mod?.buffer))
             transfers.push(section.buffers.mod.buffer);
+        if (ArrayBuffer.isView(section.buffers.state?.buffer))
+            transfers.push(section.buffers.state.buffer);
+        if (ArrayBuffer.isView(section.buffers.light?.sun?.buffer))
+            transfers.push((section.buffers.light?.sun).buffer);
+        if (ArrayBuffer.isView(section.buffers.light?.red?.buffer))
+            transfers.push((section.buffers.light?.red).buffer);
+        if (ArrayBuffer.isView(section.buffers.light?.green?.buffer))
+            transfers.push((section.buffers.light?.green).buffer);
+        if (ArrayBuffer.isView(section.buffers.light?.blue?.buffer))
+            transfers.push((section.buffers.light?.blue).buffer);
+        if (ArrayBuffer.isView(section.buffers.secondary?.buffer))
+            transfers.push(section.buffers.secondary.buffer);
+        if (!section.palettes)
+            continue;
         if (section.palettes.id)
             transfers.push(section.palettes.id.buffer);
-        if (section.palettes.light)
-            transfers.push(section.palettes.light.buffer);
-        if (section.palettes.state)
-            transfers.push(section.palettes.state.buffer);
-        if (section.palettes.mod)
-            transfers.push(section.palettes.mod.buffer);
-        if (section.palettes.secondaryState)
-            transfers.push(section.palettes.secondaryState.buffer);
+        //   if (section.palettes.light) transfers.push(section.palettes.light.buffer);
+        //  if (section.palettes.state) transfers.push(section.palettes.state.buffer);
+        //  if (section.palettes.mod) transfers.push(section.palettes.mod.buffer);
+        if (section.palettes.secondaryValue)
+            transfers.push(section.palettes.secondaryValue.buffer);
         if (section.palettes.secondaryId)
             transfers.push(section.palettes.secondaryId.buffer);
     }
@@ -49,8 +56,15 @@ export default function InitTasks(props) {
     });
     Threads.registerTask("archive-sector-binary", async (location) => {
         const [archived] = runArchiveSector(location);
-        const compressed = await compressBinaryObject(archived);
-        return [compressed, [compressed]];
+        try {
+            const compressed = await compressBinaryObject(archived);
+            return [compressed, [compressed]];
+        }
+        catch (error) {
+            console.log(archived);
+            console.error(error);
+        }
+        return [null, []];
     });
     Threads.registerTask("import-sector", async (archived) => {
         const importedSector = ImportSector(archived, {});

package/World/Cursor/SectionCursor.d.ts

@@ -1,9 +1,9 @@
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 import type { Section } from "../Section/index";
-export declare class SectionCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+export declare class SectionCursor implements DataCursorInterface, WorldSectionCursorInterface {
     _section: Section | null;
     private voxel;
     _voxelIndex: number;
@@ -11,7 +11,7 @@ export declare class SectionCursor extends DataCursorInterface implements WorldS
     _sectionPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
     setSection(section: Section): boolean;
-    setSection(dimension: string, x: number, y: number, z: number): boolean;
+    setSection(dimension: number, x: number, y: number, z: number): boolean;
     getVoxelAtIndex(index: number): WorldVoxelCursor;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
 }

package/World/Cursor/SectionCursor.js

@@ -2,8 +2,7 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
-export class SectionCursor extends DataCursorInterface {
+export class SectionCursor {
     _section;
     voxel = new WorldVoxelCursor(this);
     _voxelIndex = 0;
@@ -39,7 +38,7 @@ export class SectionCursor extends DataCursorInterface {
         const sector = WorldRegister.sectors.get(sectionOrDimension, x || 0, y || 0, z || 0);
         if (!sector)
             return false;
-        this._section = sector.getSection(y || 0);
+        this._section = sector.getSection(x || 0, y || 0, z || 0);
         const sectionPos = this._section.getPosition();
         this._sectionPosition.x = sectionPos[0];
         this._sectionPosition.y = sectionPos[1];

package/World/Cursor/SectorCursor.d.ts

@@ -2,9 +2,9 @@ import type { Section } from "../Section/index";
 import type { Sector } from "../Sector/index";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
-export declare class SectorCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+export declare class SectorCursor implements DataCursorInterface, WorldSectionCursorInterface {
     _current: Sector | null;
     _section: Section | null;
     private voxel;
@@ -12,7 +12,7 @@ export declare class SectorCursor extends DataCursorInterface implements WorldSe
     _voxelPosition: Vector3Like;
     _sectorPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
-    setSector(dimension: string, x: number, y: number, z: number): boolean;
+    setSector(dimension: number, x: number, y: number, z: number): boolean;
     getSection(x: number, y: number, z: number): Section | null;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
     getVoxelAtIndex(index: number): void;

package/World/Cursor/SectorCursor.js

@@ -2,8 +2,7 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
-export class SectorCursor extends DataCursorInterface {
+export class SectorCursor {
     _current = null;
     _section;
     voxel = new WorldVoxelCursor(this);

package/World/Cursor/WorldCursor.d.ts

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

package/World/Cursor/WorldCursor.js

@@ -1,25 +1,29 @@
 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 {
-    sectorCursors = new Map();
-    origin = { x: 0, y: 0, z: 0 };
-    dimension = "";
+export class WorldCursor {
+    sectorCursors = {};
+    origin = Vector3Like.Create();
+    dimension = 0;
+    _lastPosition = Vector3Like.Create();
     setFocalPoint(dimension, x, y, z) {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
-        for (const [cx, row] of this.sectorCursors) {
-            for (const [cz, col] of row) {
-                cursorCache.push(col);
+        for (const row in this.sectorCursors) {
+            for (const col in this.sectorCursors[row]) {
+                const cursor = this.sectorCursors[row][col];
+                if (!cursor)
+                    continue;
+                cursorCache.push(cursor);
+                this.sectorCursors[row][col] = null;
             }
         }
-        this.sectorCursors.clear();
         this.dimension = dimension;
         this.origin.x = sectorPos.x / WorldSpaces.sector.bounds.x;
         this.origin.y = sectorPos.y / WorldSpaces.sector.bounds.y;
         this.origin.z = sectorPos.z / WorldSpaces.sector.bounds.z;
+        this.getSector(x, y, z);
     }
     inBounds(x, y, z) {
         return WorldSpaces.world.inBounds(x, y, z);
@@ -30,19 +34,17 @@ export class WorldCursor extends DataCursorInterface {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         const cx = sectorPos.x / WorldSpaces.sector.bounds.x - this.origin.x;
         const cz = sectorPos.z / WorldSpaces.sector.bounds.z - this.origin.z;
-        let row = this.sectorCursors.get(cx);
-        let cursor = row?.get(cz);
+        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)) {
                 cursorCache.push(cursor);
                 return null;
             }
-            if (!row) {
-                row = new Map();
-                this.sectorCursors.set(cx, row);
+            if (!this.sectorCursors[cx]) {
+                this.sectorCursors[cx] ??= {};
             }
-            row.set(cz, cursor);
+            this.sectorCursors[cx][cz] = cursor;
         }
         return cursor;
     }

package/World/Cursor/WorldVoxelCursor.d.ts

@@ -11,9 +11,5 @@ export declare class WorldVoxelCursor extends VoxelCursorInterface {
     secondary: Uint16Array;
     constructor(dataCursor: WorldSectionCursorInterface);
     loadIn(): void;
-    /**
-     *
-     * @param mode 0 for add 1 for remove
-     */
     updateVoxel(mode: 0 | 1 | 2): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -1,13 +1,13 @@
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor;
-    _section;
-    ids;
-    light;
-    level;
-    state;
-    mod;
-    secondary;
+    _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);
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
@@ -25,25 +25,35 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
-    /**
-     *
-     * @param mode 0 for add 1 for remove
-     */
     updateVoxel(mode) {
         const voxelPos = this.dataCursor._voxelPosition;
+        this.dataCursor._section?.sector.setStored(false);
+        this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
         if (mode == 0) {
-            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            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?.setHasVoxel(voxelPos.y, true);
             return true;
         }
         if (mode == 1) {
-            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            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?.setHasVoxelDirty(voxelPos.y, true);
             this.dataCursor._section?.setHasVoxel(voxelPos.y, false);
             return true;
         }
         if (mode == 2) {
-            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            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/Dimension/Dimension.d.ts

@@ -1,14 +1,17 @@
+import { DimensionSyncData } from "../Types/WorldData.types";
 import { Sector } from "../Sector";
 export interface DimensionData {
     id: string;
+    index: number;
     sectors: Map<string, Sector>;
 }
 export interface Dimension extends DimensionData {
 }
 export declare class Dimension {
-    static CreateNew(id: string): Dimension;
+    static CreateNew(index: number, id?: string): Dimension;
     constructor(data: DimensionData);
     set(sectorId: string, region: Sector): void;
     delete(sectorId: string): void;
     get(sectorId: string): Sector | undefined;
+    getData(): DimensionSyncData;
 }

package/World/Dimension/Dimension.js

@@ -1,7 +1,8 @@
 export class Dimension {
-    static CreateNew(id) {
+    static CreateNew(index, id = "") {
         return new Dimension({
             id,
+            index,
             sectors: new Map(),
         });
     }
@@ -17,4 +18,10 @@ export class Dimension {
     get(sectorId) {
         return this.sectors.get(sectorId);
     }
+    getData() {
+        return {
+            id: this.id,
+            index: this.index,
+        };
+    }
 }

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,28 +1,19 @@
 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 { Vec2Array, Vec3Array } from "@amodx/math";
+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. */
     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 {
 }
@@ -33,14 +24,32 @@ 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;
+    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;
+    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[];
+    getMinMax(): Vec2Array;
+    getLogicMinMax(): Vec2Array;
+    storeFlags(): Record<string, boolean>;
+    loadFlags(flags: Record<string, boolean>): void;
     toJSON(): SectionData;
 }

package/World/Section/Section.js

@@ -1,10 +1,9 @@
 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";
+const temp = [0, 0];
 export class Section {
     sector;
     index;
@@ -12,18 +11,20 @@ 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
+            //logicDirtyMap
+            height / 8 +
+            //bureid
             voxelSize / 8 +
-            //exposed
-            voxelSize * 2 +
-            //-----
-            //voxel data
+            //logic dirty
+            voxelSize / 8 +
+            //---- voxel data arrays
             //ids
             voxelSize * 2 +
             //light
@@ -42,14 +43,20 @@ 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);
         bufferStart += height / 8;
+        const logicDirtyMap = new Uint8Array(sectorBuffer, 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);
+        bufferStart += voxelSize / 8;
         const ids = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
         const light = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
@@ -63,8 +70,11 @@ export class Section {
         const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize;
         return {
+            flagArray,
             voxelMap,
             dirtyMap,
+            logicDirtyMap,
+            logicDirty,
             buried,
             ids,
             light,
@@ -77,11 +87,22 @@ 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.logicDirty = data.logicDirty;
+        this.logicDirtyMap = data.logicDirtyMap;
         this.buried = data.buried;
         this.ids = data.ids;
         this.level = data.level;
@@ -91,11 +112,56 @@ 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;
+    }
+    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);
+    }
+    isInProgress() {
+        return this.getBitFlag(SectionStateDefaultFlags.inProgress);
+    }
+    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;
@@ -127,10 +193,48 @@ export class Section {
                     max = i;
             }
         }
-        return [min, max];
+        temp[0] = min;
+        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) {
+            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,
+            logicDirtyMap: this.logicDirtyMap,
+            logicDirty: this.logicDirty,
             voxelMap: this.voxelMap,
             dirtyMap: this.dirtyMap,
             buried: this.buried,