@divinevoxel/vlox 0.0.72 → 0.0.74

package/World/Section/SectionState.d.ts

@@ -0,0 +1,12 @@
+export declare enum SectionStateDefaultFlags {
+    displayDirty = 0,
+    logicDirty = 1,
+    inProgress = 2,
+    logicUpdateInProgress = 3
+}
+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,13 @@
+export var SectionStateDefaultFlags;
+(function (SectionStateDefaultFlags) {
+    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 */
+    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,8 +1,7 @@
 import { Section, SectionData } from "../Section/Section.js";
 import { Vec3Array } from "@amodx/math";
-import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
+import { SectorStateDefaultBitFlags } from "./SectorState.js";
 export interface SectorData {
-    position: Vec3Array;
     buffer: ArrayBufferLike;
     /**Array of timestamps for the sector */
     timeStampArray: Uint32Array;
@@ -13,18 +12,33 @@ export interface SectorData {
 export interface Sector extends SectorData {
 }
 export declare class Sector {
-    static FlagIds: typeof SectorStateFlags;
-    static TimeStampIds: typeof SectorTimestampFlags;
+    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;
-    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;
+    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>;
+    getLogicDirtySections(): Generator<Section>;
+    anySectionDisplayDirty(): boolean;
+    anySectionLogicDirty(): boolean;
+    storeFlags(): Record<string, boolean>;
+    loadFlags(flags: Record<string, boolean>): void;
+    storeTimestamps(): Record<string, number>;
+    loadTimestamps(stored: Record<string, number>): void;
     toJSON(): SectorData;
 }

package/World/Sector/Sector.js

@@ -1,13 +1,12 @@
 import { Section } from "../Section/Section.js";
 import { WorldSpaces } from "../WorldSpaces";
-import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BitArray.js";
-import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
-function forceMultipleOf2(n) {
-    return n % 2 === 0 ? n : n + 1;
-}
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays.js";
+import { SectorState, SectorStateDefaultBitFlags } from "./SectorState.js";
+import { forceMultipleOf2 } from "../../Util/Binary/BinaryFunctions.js";
 export class Sector {
-    static FlagIds = SectorStateFlags;
-    static TimeStampIds = SectorTimestampFlags;
+    position;
+    static FlagIds = SectorState.Flags;
+    static TimeStampIds = SectorState.TimeStamps;
     static GetHeaderSize() {
         return forceMultipleOf2(
         //12 bytes fot flags
@@ -22,14 +21,13 @@ export class Sector {
     static CreateNew() {
         const buffer = new SharedArrayBuffer(this.GetBufferSize());
         const flagArray = new Uint8Array(buffer, 0, 12);
-        const timeStampArray = new Uint32Array(buffer, 12, 12 * 4);
+        const timeStampArray = new Uint32Array(buffer, 12, 12);
         const sections = [];
-        const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
+        const totalSections = WorldSpaces.sector.sectionVolumne;
         for (let i = 0; i < totalSections; i++) {
             sections[i] = Section.CreateNew(i, buffer);
         }
         return {
-            position: [0, 0, 0],
             buffer,
             flagArray,
             timeStampArray,
@@ -38,8 +36,8 @@ export class Sector {
     }
     sections = [];
     bufferView;
-    constructor(data) {
-        this.position = data.position;
+    constructor(data, position) {
+        this.position = position;
         this.flagArray = data.flagArray;
         this.timeStampArray = data.timeStampArray;
         this.buffer = data.buffer;
@@ -48,10 +46,8 @@ export class Sector {
             this.sections[i] = new Section(this, i, data.sections[i]);
         }
     }
-    getSection(y) {
-        const ry = y - this.position[1];
-        const index = ry / WorldSpaces.section.bounds.y;
-        return this.sections[index];
+    getSection(x, y, z) {
+        return this.sections[WorldSpaces.section.getIndex(x, y, z)];
     }
     setBitFlag(index, value) {
         setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
@@ -59,19 +55,106 @@ 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.stored, stored);
+    }
+    isStored() {
+        return this.getBitFlag(SectorStateDefaultBitFlags.stored);
+    }
     setTimeStamp(index, value) {
         this.timeStampArray[index] = value;
     }
     getTimeStamp(index) {
         return this.timeStampArray[index];
     }
+    *getRenerableSections() {
+        for (const section of this.sections) {
+            const [min, max] = section.getMinMax();
+            if (min == Infinity || max == -Infinity)
+                continue;
+            yield section;
+        }
+    }
+    *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].isLogicDirty() && !this.sections[i].isLogicUpdateInProgress())
+                return true;
+        }
+        this.setLogicDirty(false);
+        return false;
+    }
+    storeFlags() {
+        const stored = {};
+        for (const key in SectorState.StoredFlags) {
+            stored[key] = this.getBitFlag(SectorState.StoredFlags[key]);
+        }
+        return stored;
+    }
+    loadFlags(flags) {
+        for (const flag in flags) {
+            const storedIndex = SectorState.StoredFlags[flag];
+            if (storedIndex === undefined) {
+                console.warn(`${flag} does not exist on stored flags for sector`);
+                continue;
+            }
+            this.setBitFlag(storedIndex, flags[flag]);
+        }
+    }
+    storeTimestamps() {
+        const stored = {};
+        for (const key in SectorState.StoredTimeStamps) {
+            stored[key] = this.getTimeStamp(SectorState.StoredTimeStamps[key]);
+        }
+        return stored;
+    }
+    loadTimestamps(stored) {
+        for (const timeStamp in stored) {
+            const storedIndex = SectorState.StoredTimeStamps[timeStamp];
+            if (storedIndex === undefined) {
+                console.warn(`${timeStamp} does not exist on stored timestamps for sector`);
+                continue;
+            }
+            this.setTimeStamp(storedIndex, stored[timeStamp]);
+        }
+    }
     toJSON() {
         const sections = [];
         for (const section of this.sections) {
             sections.push(section.toJSON());
         }
         return {
-            position: this.position,
             buffer: this.buffer,
             flagArray: this.flagArray,
             timeStampArray: this.timeStampArray,

package/World/Sector/SectorHeightMap.js

@@ -31,11 +31,11 @@ export class SectorHeightMap {
             const section = sector.sections[i];
             if (!section)
                 continue;
-            const sectionPOS = y + i * WorldSpaces.section.bounds.y;
+            const sectionPOS = section.getPosition();
             let [sectionMin, sectionMax] = section.getMinMax();
             if (Math.abs(sectionMax) == Infinity)
                 continue;
-            sectionMax = sectionPOS + sectionMax;
+            sectionMax = sectionPOS[1] + sectionMax;
             if (maxHeight < sectionMax) {
                 maxHeight = sectionMax;
             }

package/World/Sector/SectorState.d.ts

@@ -1,13 +1,22 @@
-export declare enum SectorStateFlags {
+export declare enum SectorStateDefaultBitFlags {
     isWorldGenDone = 0,
     isWorldDecorDone = 1,
     isWorldPropagationDone = 2,
     isWorldSunDone = 3,
-    isDirty = 4,
-    isStored = 5,
-    persistent = 6
+    displayDirty = 4,
+    logicDirty = 5,
+    stored = 6
 }
-export declare enum SectorTimestampFlags {
-    lastSaveTimestamp = 0,
-    lastAnalyzerUpdateTimestamp = 1
+export declare enum SectorStateDefaultTimeStamps {
+    lastSaveTimestamp = 0
+}
+export declare class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags: typeof SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags: Record<string, number>;
+    /**The default  timestamps for secotrs */
+    static TimeStamps: typeof SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps: Record<string, number>;
 }

package/World/Sector/SectorState.js

@@ -1,15 +1,29 @@
-export var SectorStateFlags;
-(function (SectorStateFlags) {
-    SectorStateFlags[SectorStateFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
-    SectorStateFlags[SectorStateFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
-    SectorStateFlags[SectorStateFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
-    SectorStateFlags[SectorStateFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
-    SectorStateFlags[SectorStateFlags["isDirty"] = 4] = "isDirty";
-    SectorStateFlags[SectorStateFlags["isStored"] = 5] = "isStored";
-    SectorStateFlags[SectorStateFlags["persistent"] = 6] = "persistent";
-})(SectorStateFlags || (SectorStateFlags = {}));
-export var SectorTimestampFlags;
-(function (SectorTimestampFlags) {
-    SectorTimestampFlags[SectorTimestampFlags["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
-    SectorTimestampFlags[SectorTimestampFlags["lastAnalyzerUpdateTimestamp"] = 1] = "lastAnalyzerUpdateTimestamp";
-})(SectorTimestampFlags || (SectorTimestampFlags = {}));
+export var SectorStateDefaultBitFlags;
+(function (SectorStateDefaultBitFlags) {
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["displayDirty"] = 4] = "displayDirty";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["logicDirty"] = 5] = "logicDirty";
+    SectorStateDefaultBitFlags[SectorStateDefaultBitFlags["stored"] = 6] = "stored";
+})(SectorStateDefaultBitFlags || (SectorStateDefaultBitFlags = {}));
+export var SectorStateDefaultTimeStamps;
+(function (SectorStateDefaultTimeStamps) {
+    SectorStateDefaultTimeStamps[SectorStateDefaultTimeStamps["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
+})(SectorStateDefaultTimeStamps || (SectorStateDefaultTimeStamps = {}));
+export class SectorState {
+    /**The default bit flags for secotrs */
+    static Flags = SectorStateDefaultBitFlags;
+    /**An array of bit flags tht are preserved when the sector is stored */
+    static StoredFlags = {
+        dve_is_world_gen_done: SectorStateDefaultBitFlags.isWorldGenDone,
+        dve_is_world_decoration_done: SectorStateDefaultBitFlags.isWorldDecorDone,
+        dve_is_world_progation_done: SectorStateDefaultBitFlags.isWorldPropagationDone,
+        dve_is_world_sun_done: SectorStateDefaultBitFlags.isWorldSunDone,
+    };
+    /**The default  timestamps for secotrs */
+    static TimeStamps = SectorStateDefaultTimeStamps;
+    /**An array of bit timestamps tht are preserved when the sector is stored */
+    static StoredTimeStamps = {};
+}

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/Types/WorldStorage.interface.js

@@ -0,0 +1 @@
+export {};

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,18 +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 new(dimensionId: string, x: number, y: number, z: number): boolean;
-    static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
-    static remove(dimensionId: string, x: number, y: number, z: number): boolean;
+    static add(dimensionId: number, x: number, y: number, z: number, sector: SectorData): Sector;
+    static addAt(location: LocationData, sector: SectorData): Sector;
+    static new(dimensionId: number, x: number, y: number, z: number): boolean;
+    static newAt(location: LocationData): boolean;
+    static get(dimensionId: number, x: number, y: number, z: number): false | Sector;
+    static getAt(location: LocationData): false | Sector;
+    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();
@@ -35,6 +36,7 @@ class SectorPool {
     }
     static returnSector(secotr) {
         secotr.bufferView.fill(0);
+        this._secotrs.push(secotr.toJSON());
     }
 }
 class WorldRegisterSectors {
@@ -46,21 +48,26 @@ class WorldRegisterSectors {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        WorldSpaces.sector.getPositionVec3Array(x, y, z, sector.position);
-        const newSector = new Sector(sector);
+        const newSector = new Sector(sector, WorldSpaces.sector.getPositionVec3Array(x, y, z));
         dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
+    static addAt(location, sector) {
+        return this.add(...location, sector);
+    }
     static new(dimensionId, x, y, z) {
         if (this.get(dimensionId, x, y, z))
             return false;
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const sector = this.add(dimensionId, x, y, z, Sector.CreateNew());
+        const sector = this.add(dimensionId, x, y, z, SectorPool.getSector());
         WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
+    static newAt(location) {
+        return this.new(...location);
+    }
     static get(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -68,6 +75,9 @@ class WorldRegisterSectors {
         const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
         return sector || false;
     }
+    static getAt(location) {
+        return this.get(...location);
+    }
     static remove(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
@@ -83,9 +93,14 @@ class WorldRegisterSectors {
         dimension.sectors.delete(sectorKey);
         return true;
     }
+    static removeAt(location) {
+        return this.remove(...location);
+    }
 }
 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;

package/World/WorldSpaces.d.ts

@@ -23,6 +23,8 @@ declare class SectorSpace {
     static power2Axes: Vector3Like;
     static bounds: Vector3Like;
     static volumne: number;
+    static sectionBounds: Vector3Like;
+    static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
 }
@@ -33,6 +35,8 @@ declare class SectionSpace {
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
     static getIndex(x: number, y: number, z: number): number;
+    static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionFromIndexVec3Array(index: number, refPosition?: Vec3Array): Vec3Array;
 }
 declare class VoxelSpace {
     static bounds: Vector3Like;

package/World/WorldSpaces.js

@@ -1,7 +1,7 @@
 //types
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { Vector3Like } from "@amodx/math";
-import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, } from "../Math/Indexing.js";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, GetYXZOrderArrayPositionVec3Array, } from "../Math/Indexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
 class WorldBounds {
@@ -57,6 +57,8 @@ class SectorSpace {
     static power2Axes = Vector3Like.Create();
     static bounds = Vector3Like.Create();
     static volumne = 0;
+    static sectionBounds = Vector3Like.Create();
+    static sectionVolumne = 0;
     static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
         CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
@@ -81,7 +83,13 @@ class SectionSpace {
     static getIndex(x, y, z) {
         SectionSpace.getPosition(x, y, z, tempPosition);
         SectorSpace.getPosition(x, y, z, tempPosition2);
-        return (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y;
+        return GetYXZOrderArrayIndex((tempPosition.x - tempPosition2.x) / SectionSpace.bounds.x, (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y, (tempPosition.z - tempPosition2.z) / SectionSpace.bounds.z, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z);
+    }
+    static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
+        return GetYXZOrderArrayPositionVec3(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
+    }
+    static getPositionFromIndexVec3Array(index, refPosition = [0, 0, 0]) {
+        return GetYXZOrderArrayPositionVec3Array(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
     }
 }
 class VoxelSpace {
@@ -132,22 +140,27 @@ export class WorldSpaces {
 EngineSettings.addEventListener("synced", (event) => {
     const { settings } = event.detail.settings;
     WorldBounds.setWorldBounds(settings.world.min.x, settings.world.min.y, settings.world.min.z, settings.world.max.x, settings.world.max.y, settings.world.max.z);
-    SectorSpace.power2Axes.x = settings.sectors.power2Size.x;
-    SectorSpace.power2Axes.y = settings.sectors.power2Size.y;
-    SectorSpace.power2Axes.z = settings.sectors.power2Size.z;
+    SectorSpace.power2Axes.x = settings.world.sectorPower2Size.x;
+    SectorSpace.power2Axes.y = settings.world.sectorPower2Size.y;
+    SectorSpace.power2Axes.z = settings.world.sectorPower2Size.z;
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
-    SectionSpace.power2Axes.x = settings.sections.power2Size.x;
-    SectionSpace.power2Axes.y = settings.sections.power2Size.y;
-    SectionSpace.power2Axes.z = settings.sections.power2Size.z;
+    SectorSpace.volumne =
+        SectorSpace.bounds.x * SectorSpace.bounds.y * SectorSpace.bounds.z;
+    SectionSpace.power2Axes.x = settings.world.sectionPower2Size.x;
+    SectionSpace.power2Axes.y = settings.world.sectionPower2Size.y;
+    SectionSpace.power2Axes.z = settings.world.sectionPower2Size.z;
     SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
     SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;
     SectionSpace.volumne =
         SectionSpace.bounds.x * SectionSpace.bounds.y * SectionSpace.bounds.z;
-    SectorSpace.volumne =
-        (SectorSpace.bounds.x / SectionSpace.bounds.x) *
-            (SectorSpace.bounds.y / SectionSpace.bounds.y) *
-            (SectorSpace.bounds.z / SectionSpace.bounds.z);
+    SectorSpace.sectionBounds.x = SectorSpace.bounds.x / SectionSpace.bounds.x;
+    SectorSpace.sectionBounds.y = SectorSpace.bounds.y / SectionSpace.bounds.y;
+    SectorSpace.sectionBounds.z = SectorSpace.bounds.z / SectionSpace.bounds.z;
+    SectorSpace.sectionVolumne =
+        SectorSpace.sectionBounds.x *
+            SectorSpace.sectionBounds.y *
+            SectorSpace.sectionBounds.z;
 });

package/{Tasks/IWG → WorldSimulation}/Internal/Classes/DimensionSegment.d.ts

@@ -20,7 +20,7 @@ declare class SectorQueue {
     addSector(sector: Sector): void;
 }
 export declare class DimensionSegment {
-    id: string;
+    id: number;
     tasks: Map<string, TaskSegment>;
     queue: number[];
     vistedMap: SectorVisistedMap;
@@ -28,7 +28,7 @@ export declare class DimensionSegment {
     inProgress: SectorVisistedMap;
     unRenderQueue: SectorQueue;
     unLoadQueue: SectorQueue;
-    constructor(id: string);
+    constructor(id: number);
     addTask(id: string): void;
     getTask(id: string): TaskSegment;
     clearAllTasks(): void;

package/{Tasks/IWG → WorldSimulation}/Internal/Classes/Generator.d.ts

@@ -1,7 +1,10 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
+import { TaskTool } from "../../../Tools/Tasks/TasksTool";
+import { BuildQueue } from "./Queues/BuildQueue";
+import { LogicQueue } from "./Queues/LogiccQueue";
 export interface GeneratorData {
-    dimension: string;
+    dimension: number;
     building?: boolean;
     culling?: boolean;
     position: Vector3Like;
@@ -10,8 +13,9 @@ export interface GeneratorData {
     maxRadius: number;
 }
 export declare class Generator {
+    taskTool: TaskTool;
     position: Vector3Like;
-    _dimension: string;
+    _dimension: number;
     _building: boolean;
     _positonChanged: boolean;
     _waitingForCull: boolean;
@@ -22,6 +26,9 @@ export declare class Generator {
     _genCircle: Circle;
     _renderCircle: Circle;
     _maxCircle: Circle;
-    constructor(data: GeneratorData);
+    buildQueue: BuildQueue;
+    logicQueue: LogicQueue;
+    constructor(taskTool: TaskTool, data: GeneratorData);
     update(): void;
+    tick(): void;
 }