@divinevoxel/vlox 0.0.73 → 0.0.74

package/World/Archive/InitTasks.js

@@ -12,10 +12,9 @@ function runArchiveSector(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.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 == "string")
             continue;
@@ -42,12 +41,10 @@ function runArchiveSector(location) {
         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.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);
     }

package/World/Cursor/SectionCursor.d.ts

@@ -11,7 +11,7 @@ export declare class SectionCursor implements DataCursorInterface, WorldSectionC
     _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/SectorCursor.d.ts

@@ -12,7 +12,7 @@ export declare class SectorCursor implements DataCursorInterface, WorldSectionCu
     _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/WorldCursor.d.ts

@@ -2,10 +2,11 @@ import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 export declare class WorldCursor implements DataCursorInterface {
-    sectorCursors: Map<number, Map<number, SectorCursor>>;
+    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

@@ -4,21 +4,26 @@ import { WorldSpaces } from "../WorldSpaces";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor {
-    sectorCursors = new Map();
-    origin = { x: 0, y: 0, z: 0 };
-    dimension = "";
+    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);
@@ -29,19 +34,17 @@ export class WorldCursor {
         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,26 +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/Section/Section.d.ts

@@ -1,5 +1,5 @@
 import { Sector } from "../Sector/Sector.js";
-import { Vec3Array } from "@amodx/math";
+import { Vec2Array, Vec3Array } from "@amodx/math";
 import { VoxelDataArrays } from "Voxels/index.js";
 export interface SectionData extends VoxelDataArrays {
     /**Array of bit flags for the sector*/
@@ -8,8 +8,12 @@ export interface SectionData extends VoxelDataArrays {
     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 {
 }
@@ -25,17 +29,26 @@ export declare class Section {
     getPosition(): Readonly<Vec3Array>;
     setBitFlag(index: number, value: boolean): void;
     getBitFlag(index: number): boolean;
-    isDirty(): boolean;
-    setDirty(dirty: boolean): void;
+    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

@@ -3,6 +3,7 @@ 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";
+const temp = [0, 0];
 export class Section {
     sector;
     index;
@@ -17,8 +18,12 @@ export class Section {
             height / 8 +
             //dirtyMap
             height / 8 +
+            //logicDirtyMap
+            height / 8 +
             //bureid
             voxelSize / 8 +
+            //logic dirty
+            voxelSize / 8 +
             //---- voxel data arrays
             //ids
             voxelSize * 2 +
@@ -46,8 +51,12 @@ export class Section {
         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);
@@ -64,6 +73,8 @@ export class Section {
             flagArray,
             voxelMap,
             dirtyMap,
+            logicDirtyMap,
+            logicDirty,
             buried,
             ids,
             light,
@@ -90,6 +101,8 @@ export class Section {
         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;
@@ -107,13 +120,36 @@ export class Section {
     getBitFlag(index) {
         return getBitArrayIndex(this.flagArray, index) == 1;
     }
-    isDirty() {
-        return this.getBitFlag(SectionStateDefaultFlags.isDirty);
+    isDisplayDirty() {
+        return this.getBitFlag(SectionStateDefaultFlags.displayDirty);
     }
-    setDirty(dirty) {
-        this.setBitFlag(SectionStateDefaultFlags.isDirty, dirty);
-        if (dirty)
+    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);
@@ -121,6 +157,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;
     }
@@ -151,7 +193,25 @@ 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 = {};
@@ -173,6 +233,8 @@ export class Section {
     toJSON() {
         return {
             flagArray: this.flagArray,
+            logicDirtyMap: this.logicDirtyMap,
+            logicDirty: this.logicDirty,
             voxelMap: this.voxelMap,
             dirtyMap: this.dirtyMap,
             buried: this.buried,

package/World/Section/SectionState.d.ts

@@ -1,6 +1,8 @@
 export declare enum SectionStateDefaultFlags {
-    isDirty = 0,
-    inProgress = 1
+    displayDirty = 0,
+    logicDirty = 1,
+    inProgress = 2,
+    logicUpdateInProgress = 3
 }
 export declare class SectionState {
     /**The default bit flags for sections */

package/World/Section/SectionState.js

@@ -1,7 +1,9 @@
 export var SectionStateDefaultFlags;
 (function (SectionStateDefaultFlags) {
-    SectionStateDefaultFlags[SectionStateDefaultFlags["isDirty"] = 0] = "isDirty";
-    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 1] = "inProgress";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["displayDirty"] = 0] = "displayDirty";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["logicDirty"] = 1] = "logicDirty";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["inProgress"] = 2] = "inProgress";
+    SectionStateDefaultFlags[SectionStateDefaultFlags["logicUpdateInProgress"] = 3] = "logicUpdateInProgress";
 })(SectionStateDefaultFlags || (SectionStateDefaultFlags = {}));
 export class SectionState {
     /**The default bit flags for sections */

package/World/Sector/Sector.d.ts

@@ -24,12 +24,18 @@ export declare class Sector {
     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;
+    getLogicDirtySections(): Generator<Section>;
+    anySectionDisplayDirty(): boolean;
+    anySectionLogicDirty(): boolean;
     storeFlags(): Record<string, boolean>;
     loadFlags(flags: Record<string, boolean>): void;
     storeTimestamps(): Record<string, number>;

package/World/Sector/Sector.js

@@ -55,11 +55,23 @@ export class Sector {
     getBitFlag(index) {
         return getBitArrayIndex(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,11 +87,32 @@ export class Sector {
             yield section;
         }
     }
-    anySectionDirty() {
+    *getLogicDirtySections() {
+        for (const section of this.sections) {
+            const [min, max] = section.getLogicMinMax();
+            if (min == Infinity || max == -Infinity)
+                continue;
+            yield section;
+        }
+    }
+    anySectionDisplayDirty() {
+        if (!this.isDisplayDirty())
+            return false;
+        for (let i = 0; i < this.sections.length; i++) {
+            if (this.sections[i].isDisplayDirty() && !this.sections[i].isInProgress())
+                return true;
+        }
+        this.setDisplayDirty(false);
+        return false;
+    }
+    anySectionLogicDirty() {
+        if (!this.isLogicDirty())
+            return false;
         for (let i = 0; i < this.sections.length; i++) {
-            if (this.sections[i].isDirty() && !this.sections[i].isInProgress())
+            if (this.sections[i].isLogicDirty() && !this.sections[i].isLogicUpdateInProgress())
                 return true;
         }
+        this.setLogicDirty(false);
         return false;
     }
     storeFlags() {

package/World/Sector/SectorState.d.ts

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

package/World/Sector/SectorState.js

@@ -4,8 +4,9 @@ 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 = {}));
 export var SectorStateDefaultTimeStamps;
 (function (SectorStateDefaultTimeStamps) {

package/World/Types/WorldData.types.d.ts

@@ -1,11 +1,6 @@
-export type DimensionOptions = {
-    liquidFlowSpeed: number;
-    magmaFlowSpeed: number;
-    sunLight: boolean;
-};
-export type DimensionData = {
+export type DimensionSyncData = {
     id: string;
-    options: DimensionOptions;
+    index: number;
 };
 export type RichDataSchema = Record<string, Record<string, any>>;
 export type RichSector = {

package/World/WorldRegister.d.ts

@@ -1,10 +1,10 @@
 import { Dimension } from "./Dimension/Dimension";
 import { Sector, SectorData } from "./Sector/Sector.js";
 import type { LocationData } from "../Math/index.js";
-import { DimensionData } from "./Types/WorldData.types.js";
+import { DimensionSyncData } from "./Types/WorldData.types.js";
 declare class WorldDataHooks {
     static dimension: {
-        onNew: (dimension: DimensionData) => void;
+        onNew: (dimension: DimensionSyncData) => void;
         onRemove: (location: LocationData) => void;
     };
     static sectors: {
@@ -13,22 +13,22 @@ declare class WorldDataHooks {
     };
 }
 declare class WorldRegisterDimensions {
-    static add(id: string): Dimension;
-    static get(id: string): Dimension | undefined;
+    static add(index: number, id?: string): Dimension;
+    static get(index: number): Dimension | undefined;
 }
 declare class WorldRegisterSectors {
     static setSecotrPool(enabled: boolean): void;
-    static add(dimensionId: string, x: number, y: number, z: number, sector: SectorData): Sector;
+    static add(dimensionId: number, x: number, y: number, z: number, sector: SectorData): Sector;
     static addAt(location: LocationData, sector: SectorData): Sector;
-    static new(dimensionId: string, x: number, y: number, z: number): boolean;
+    static new(dimensionId: number, x: number, y: number, z: number): boolean;
     static newAt(location: LocationData): boolean;
-    static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
+    static get(dimensionId: number, x: number, y: number, z: number): false | Sector;
     static getAt(location: LocationData): false | Sector;
-    static remove(dimensionId: string, x: number, y: number, z: number): boolean;
+    static remove(dimensionId: number, x: number, y: number, z: number): boolean;
     static removeAt(location: LocationData): boolean;
 }
 export declare class WorldRegister {
-    static _dimensions: Map<string, Dimension>;
+    static _dimensions: Map<number, Dimension>;
     static _hooks: typeof WorldDataHooks;
     static dimensions: typeof WorldRegisterDimensions;
     static sectors: typeof WorldRegisterSectors;

package/World/WorldRegister.js

@@ -13,13 +13,14 @@ class WorldDataHooks {
     };
 }
 class WorldRegisterDimensions {
-    static add(id) {
-        const dimesnion = Dimension.CreateNew(id);
-        WorldRegister._dimensions.set(id, dimesnion);
+    static add(index, id = "") {
+        const dimesnion = Dimension.CreateNew(index, id);
+        WorldRegister._dimensions.set(index, dimesnion);
+        WorldDataHooks.dimension.onNew(dimesnion.getData());
         return dimesnion;
     }
-    static get(id) {
-        return WorldRegister._dimensions.get(id);
+    static get(index) {
+        return WorldRegister._dimensions.get(index);
     }
 }
 const tempPosition = Vector3Like.Create();
@@ -97,7 +98,9 @@ class WorldRegisterSectors {
     }
 }
 export class WorldRegister {
-    static _dimensions = new Map();
+    static _dimensions = new Map([
+        [0, new Dimension(Dimension.CreateNew(0, "main"))],
+    ]);
     static _hooks = WorldDataHooks;
     static dimensions = WorldRegisterDimensions;
     static sectors = WorldRegisterSectors;