@divinevoxel/vlox 0.0.71 → 0.0.73

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 "../../Data/Cursor/DataCursor.interface";
-export class SectionCursor extends DataCursorInterface {
+export class SectionCursor {
     _section;
     voxel = new WorldVoxelCursor(this);
     _voxelIndex = 0;
@@ -39,18 +38,24 @@ 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];
         this._sectionPosition.z = sectionPos[2];
         return true;
     }
+    getVoxelAtIndex(index) {
+        this._voxelIndex = index;
+        WorldSpaces.voxel.getPositionFromIndex(index, this._voxelPosition);
+        this.voxel.loadIn();
+        return this.voxel;
+    }
     getVoxel(x, y, z) {
         if (!this._section)
             return null;
-        this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);
+        this._voxelIndex = WorldSpaces.voxel.getIndexFromPosition(this._voxelPosition.x, this._voxelPosition.y, this._voxelPosition.z);
         this.voxel.loadIn();
         return this.voxel;
     }

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 "../../Data/Cursor/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;
@@ -15,4 +15,5 @@ export declare class SectorCursor extends DataCursorInterface implements WorldSe
     setSector(dimension: string, 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 "../../Data/Cursor/DataCursor.interface";
-export class SectorCursor extends DataCursorInterface {
+export class SectorCursor {
     _current = null;
     _section;
     voxel = new WorldVoxelCursor(this);
@@ -55,9 +54,12 @@ export class SectorCursor extends DataCursorInterface {
             return null;
         const section = this.getSection(x, y, z);
         this._section = section;
-        this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);
+        this._voxelIndex = WorldSpaces.voxel.getIndexFromPosition(this._voxelPosition.x, this._voxelPosition.y, this._voxelPosition.z);
         this.voxel.loadIn();
         return this.voxel;
     }
+    getVoxelAtIndex(index) {
+        this._voxelIndex = index;
+    }
 }

package/World/Cursor/WorldCursor.d.ts

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

package/World/Cursor/WorldCursor.js

@@ -1,10 +1,9 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
-export class WorldCursor extends DataCursorInterface {
+export class WorldCursor {
     sectorCursors = new Map();
     origin = { x: 0, y: 0, z: 0 };
     dimension = "";
@@ -25,6 +24,8 @@ export class WorldCursor extends DataCursorInterface {
         return WorldSpaces.world.inBounds(x, y, z);
     }
     getSector(x, y, z) {
+        if (!this.inBounds(x, y, z))
+            return null;
         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;
@@ -32,8 +33,10 @@ export class WorldCursor extends DataCursorInterface {
         let cursor = row?.get(cz);
         if (!cursor) {
             cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
-            if (!cursor.setSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z))
+            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);

package/World/Cursor/WorldVoxelCursor.d.ts

@@ -3,17 +3,17 @@ import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 export declare class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor: WorldSectionCursorInterface;
     private _section;
-    get ids(): Uint16Array;
-    get light(): Uint16Array;
-    get level(): Uint8Array;
-    get state(): Uint16Array;
-    get secondary(): Uint16Array;
-    get mod(): Uint16Array;
+    ids: Uint16Array;
+    light: Uint16Array;
+    level: Uint8Array;
+    state: Uint16Array;
+    mod: Uint16Array;
+    secondary: Uint16Array;
     constructor(dataCursor: WorldSectionCursorInterface);
     loadIn(): void;
     /**
      *
      * @param mode 0 for add 1 for remove
      */
-    updateVoxel(mode: 0 | 1): boolean;
+    updateVoxel(mode: 0 | 1 | 2): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -1,27 +1,13 @@
-import { Section } from "../Section/index";
-import { SectionStructProperties } from "../Section/SectionStructProperties";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class WorldVoxelCursor extends VoxelCursorInterface {
     dataCursor;
     _section;
-    get ids() {
-        return this._section.ids;
-    }
-    get light() {
-        return this._section.light;
-    }
-    get level() {
-        return this._section.level;
-    }
-    get state() {
-        return this._section.state;
-    }
-    get secondary() {
-        return this._section.secondary;
-    }
-    get mod() {
-        return this._section.mod;
-    }
+    ids;
+    light;
+    level;
+    state;
+    mod;
+    secondary;
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
@@ -30,6 +16,12 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
         if (!this.dataCursor._section)
             return;
         this._section = this.dataCursor._section;
+        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();
     }
@@ -38,17 +30,22 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
      * @param mode 0 for add 1 for remove
      */
     updateVoxel(mode) {
-        Section.StateStruct.setData(this._section.sectionState);
         const voxelPos = this.dataCursor._voxelPosition;
+        this.dataCursor._section?.sector.setStored(false);
         if (mode == 0) {
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 1);
+            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            this.dataCursor._section?.setHasVoxel(voxelPos.y, true);
             return true;
         }
         if (mode == 1) {
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.dirtyMap, voxelPos.y, 1);
-            Section.StateStruct.setArrayPropertyValue(SectionStructProperties.heightMap, voxelPos.y, 0);
+            this.dataCursor._section?.setBuried(this.dataCursor._voxelIndex, false);
+            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);
+        }
         return false;
     }
 }

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,34 +1,42 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Sector } from "../Sector/Sector.js";
 import { Vec3Array } from "@amodx/math";
-export interface VoxelDataArrays {
-    /**The runtime numeric voxel ids */
-    ids: Uint16Array;
-    /**The light data for voxels stored as 4 nibbles. 0 -> sun light 1 -> red light 2 -> green light 3 -> blue light */
-    light: Uint16Array;
-    /**The levels of the voxel. Used mainly for waterflow now. */
-    level: Uint8Array;
-    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
-    state: Uint16Array;
-    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
-    mod: Uint16Array;
-    /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
-     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
-     */
-    secondary: Uint16Array;
+import { VoxelDataArrays } from "Voxels/index.js";
+export interface SectionData extends VoxelDataArrays {
+    /**Array of bit flags for the sector*/
+    flagArray: Uint8Array;
+    /**Y slice of the section to tell if there is voxels or not. Used for height maps. */
+    voxelMap: Uint8Array;
+    /**Y slice of the section to tell if the slice is dirty and voxelMap needs to be re-checked. */
+    dirtyMap: Uint8Array;
+    /**A bit array used to cache if a voxel is exposed or not. */
+    buried: Uint8Array;
 }
-export interface Section 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): VoxelDataArrays;
-    static toObject(sector: Sector, index: number, data: VoxelDataArrays): Section;
-    static StateStruct: RemoteBinaryStruct;
-    sectionState: DataView;
-    constructor(sector: Sector, index: number, data: VoxelDataArrays);
+    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>;
-    serialize(): VoxelDataArrays;
+    setBitFlag(index: number, value: boolean): void;
+    getBitFlag(index: number): boolean;
+    isDirty(): boolean;
+    setDirty(dirty: boolean): void;
+    isInProgress(): boolean;
+    setInProgress(inProgress: boolean): void;
+    getBuried(index: number): boolean;
+    setBuried(index: number, value: boolean): void;
+    setHasVoxel(y: number, hasVoxel: boolean): void;
+    getHasVoxel(y: number): boolean;
+    setHasVoxelDirty(y: number, dirty: boolean): void;
+    getHasVoxelDirty(y: number): boolean;
+    getMinMax(): number[];
+    storeFlags(): Record<string, boolean>;
+    loadFlags(flags: Record<string, boolean>): void;
+    toJSON(): SectionData;
 }

package/World/Section/Section.js

@@ -1,16 +1,25 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { WorldSpaces } from "../WorldSpaces.js";
 import { Sector } from "../Sector/Sector.js";
-function forceMultipleOf2(n) {
-    return n % 2 === 0 ? n : n + 1;
-}
-const position = [0, 0, 0];
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectionState, SectionStateDefaultFlags } from "./SectionState.js";
+import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
 export class Section {
     sector;
     index;
     static GetBufferSize() {
         const voxelSize = WorldSpaces.section.volumne;
-        return forceMultipleOf2(forceMultipleOf2(Section.StateStruct.structSize) +
+        const height = WorldSpaces.section.bounds.y;
+        return forceMultipleOf2(
+        //----- state
+        //2 bytes for flags
+        2 +
+            //voxelMap
+            height / 8 +
+            //dirtyMap
+            height / 8 +
+            //bureid
+            voxelSize / 8 +
+            //---- voxel data arrays
             //ids
             voxelSize * 2 +
             //light
@@ -25,13 +34,20 @@ export class Section {
             voxelSize * 2);
     }
     static GetArrayStartIndex(index) {
-        return (index * Section.GetBufferSize() +
-            Sector.GetHeaderSize() +
-            forceMultipleOf2(Section.StateStruct.structSize));
+        return index * Section.GetBufferSize() + Sector.GetHeaderSize();
     }
     static CreateNew(index, sectorBuffer) {
         const voxelSize = WorldSpaces.section.volumne;
+        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 buried = 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);
@@ -45,6 +61,10 @@ export class Section {
         const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize;
         return {
+            flagArray,
+            voxelMap,
+            dirtyMap,
+            buried,
             ids,
             light,
             level,
@@ -56,12 +76,21 @@ export class Section {
     static toObject(sector, index, data) {
         return new Section(sector, index, data);
     }
-    static StateStruct = new RemoteBinaryStruct("section-tags");
-    sectionState;
+    position;
     constructor(sector, index, data) {
         this.sector = sector;
         this.index = index;
-        this.sectionState = new DataView(sector.buffer, index * Section.GetBufferSize() + Sector.GetHeaderSize(), Section.StateStruct.structSize);
+        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;
@@ -70,14 +99,83 @@ export class Section {
         this.mod = data.mod;
     }
     getPosition() {
-        position[0] = this.sector.position[0];
-        position[1] =
-            this.sector.position[1] + this.index * WorldSpaces.section.bounds.y;
-        position[2] = this.sector.position[2];
-        return position;
+        return this.position;
+    }
+    setBitFlag(index, value) {
+        setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
+    }
+    getBitFlag(index) {
+        return getBitArrayIndex(this.flagArray, index) == 1;
+    }
+    isDirty() {
+        return this.getBitFlag(SectionStateDefaultFlags.isDirty);
+    }
+    setDirty(dirty) {
+        this.setBitFlag(SectionStateDefaultFlags.isDirty, dirty);
+        if (dirty)
+            this.sector.setStored(false);
+    }
+    isInProgress() {
+        return this.getBitFlag(SectionStateDefaultFlags.inProgress);
+    }
+    setInProgress(inProgress) {
+        this.setBitFlag(SectionStateDefaultFlags.inProgress, inProgress);
+    }
+    getBuried(index) {
+        return getBitArrayIndex(this.buried, index) == 1;
+    }
+    setBuried(index, value) {
+        return setBitArrayIndex(this.buried, index, value ? 1 : 0);
+    }
+    setHasVoxel(y, hasVoxel) {
+        return setBitArrayIndex(this.voxelMap, y, hasVoxel ? 1 : 0);
+    }
+    getHasVoxel(y) {
+        return getBitArrayIndex(this.voxelMap, y) == 1;
+    }
+    setHasVoxelDirty(y, dirty) {
+        return setBitArrayIndex(this.dirtyMap, y, dirty ? 1 : 0);
+    }
+    getHasVoxelDirty(y) {
+        return getBitArrayIndex(this.dirtyMap, y) == 1;
+    }
+    getMinMax() {
+        let min = Infinity;
+        let max = -Infinity;
+        let i = WorldSpaces.section.bounds.y;
+        while (i--) {
+            if (this.getHasVoxel(i) || this.getHasVoxelDirty(i)) {
+                if (i < min)
+                    min = i;
+                if (i > max)
+                    max = i;
+            }
+        }
+        return [min, max];
+    }
+    storeFlags() {
+        const stored = {};
+        for (const key in SectionState.StoredFlags) {
+            stored[key] = this.getBitFlag(SectionState.StoredFlags[key]);
+        }
+        return stored;
+    }
+    loadFlags(flags) {
+        for (const flag in flags) {
+            const storedIndex = SectionState.StoredFlags[flag];
+            if (storedIndex === undefined) {
+                console.warn(`${flag} does not exist on stored flags for section`);
+                continue;
+            }
+            this.setBitFlag(storedIndex, flags[flag]);
+        }
     }
-    serialize() {
+    toJSON() {
         return {
+            flagArray: this.flagArray,
+            voxelMap: this.voxelMap,
+            dirtyMap: this.dirtyMap,
+            buried: this.buried,
             ids: this.ids,
             light: this.light,
             level: this.level,

package/World/Section/SectionState.d.ts

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

package/World/Section/SectionState.js

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

package/World/Sector/Sector.d.ts

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