@divinevoxel/vlox 0.0.74 → 0.0.75

package/World/WorldRegister.d.ts

@@ -2,6 +2,7 @@ import { Dimension } from "./Dimension/Dimension";
 import { Sector, SectorData } from "./Sector/Sector.js";
 import type { LocationData } from "../Math/index.js";
 import { DimensionSyncData } from "./Types/WorldData.types.js";
+import { Section } from "./Section/Section.js";
 declare class WorldDataHooks {
     static dimension: {
         onNew: (dimension: DimensionSyncData) => void;
@@ -13,21 +14,32 @@ declare class WorldDataHooks {
     };
 }
 declare class WorldRegisterDimensions {
+    static _dimensionMap: Map<string, number>;
     static add(index: number, id?: string): Dimension;
     static get(index: number): Dimension | undefined;
 }
+declare class WorldRegisterPools {
+    static _sectorBuffers: ArrayBufferLike[];
+    static _sectors: Sector[];
+    static _sections: Section[];
+    static _sectorBufferEnabled: boolean;
+    static getSector(): ArrayBufferLike;
+    static returnSector(sector: Sector): void;
+}
 declare class WorldRegisterSectors {
-    static setSecotrPool(enabled: boolean): void;
-    static add(dimensionId: number, x: number, y: number, z: number, sector: SectorData): Sector;
-    static addAt(location: LocationData, sector: SectorData): Sector;
+    static setSecotrBufferPool(enabled: boolean): void;
+    static add(dimensionId: number, x: number, y: number, z: number, sector: ArrayBufferLike): Sector;
+    static addAt(location: LocationData, sector: ArrayBufferLike): 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;
+    static get(dimensionId: number, x: number, y: number, z: number): null | Sector;
+    static getAt(location: LocationData): Sector | null;
+    static remove(dimensionId: number, x: number, y: number, z: number): ArrayBuffer | null;
+    static removeAt(location: LocationData): ArrayBuffer | null;
 }
 export declare class WorldRegister {
+    static proxy: boolean;
+    static _pools: typeof WorldRegisterPools;
     static _dimensions: Map<number, Dimension>;
     static _hooks: typeof WorldDataHooks;
     static dimensions: typeof WorldRegisterDimensions;

package/World/WorldRegister.js

@@ -2,6 +2,7 @@ import { WorldSpaces } from "./WorldSpaces.js";
 import { Dimension } from "./Dimension/Dimension";
 import { Sector } from "./Sector/Sector.js";
 import { Vector3Like } from "@amodx/math";
+import { EngineSettings } from "../Settings/EngineSettings.js";
 class WorldDataHooks {
     static dimension = {
         onNew: (dimension) => { },
@@ -13,6 +14,7 @@ class WorldDataHooks {
     };
 }
 class WorldRegisterDimensions {
+    static _dimensionMap = new Map([["main", 0]]);
     static add(index, id = "") {
         const dimesnion = Dimension.CreateNew(index, id);
         WorldRegister._dimensions.set(index, dimesnion);
@@ -24,31 +26,47 @@ class WorldRegisterDimensions {
     }
 }
 const tempPosition = Vector3Like.Create();
-class SectorPool {
-    static _secotrs = [];
-    static _enabled = false;
+class WorldRegisterPools {
+    static _sectorBuffers = [];
+    static _sectors = [];
+    static _sections = [];
+    static _sectorBufferEnabled = false;
     static getSector() {
-        if (!this._enabled)
-            return Sector.CreateNew();
-        if (this._secotrs.length)
-            return this._secotrs.shift();
-        return Sector.CreateNew();
+        if (!this._sectorBufferEnabled)
+            return Sector.CreateNewBuffer();
+        if (this._sectorBuffers.length)
+            return this._sectorBuffers.shift();
+        return Sector.CreateNewBuffer();
     }
-    static returnSector(secotr) {
-        secotr.bufferView.fill(0);
-        this._secotrs.push(secotr.toJSON());
+    static returnSector(sector) {
+        if (this._sectorBufferEnabled) {
+            sector.bufferView.fill(0);
+            this._sectorBuffers.push(sector.buffer);
+        }
+        this._sectors.push(sector);
+        sector.clear();
+        for (let i = 0; i < sector.sections.length; i++) {
+            sector.sections[i].clear();
+            this._sections.push(sector.sections[i]);
+        }
+        sector.setReleased(true);
     }
 }
 class WorldRegisterSectors {
-    static setSecotrPool(enabled) {
-        SectorPool._enabled = enabled;
-        SectorPool._secotrs.length = 0;
+    static setSecotrBufferPool(enabled) {
+        WorldRegisterPools._sectorBufferEnabled = enabled;
+        WorldRegisterPools._sectorBuffers.length = 0;
     }
     static add(dimensionId, x, y, z, sector) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const newSector = new Sector(sector, WorldSpaces.sector.getPositionVec3Array(x, y, z));
+        const newSector = WorldRegisterPools._sectors.length
+            ? WorldRegisterPools._sectors.shift()
+            : new Sector();
+        newSector.setReleased(false);
+        WorldSpaces.sector.getPositionVec3Array(x, y, z, newSector.position);
+        newSector.setBuffer(sector);
         dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
@@ -61,7 +79,7 @@ class WorldRegisterSectors {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const sector = this.add(dimensionId, x, y, z, SectorPool.getSector());
+        const sector = this.add(dimensionId, x, y, z, WorldRegisterPools.getSector());
         WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
@@ -71,9 +89,9 @@ class WorldRegisterSectors {
     static get(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
-            return false;
+            return null;
         const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
-        return sector || false;
+        return sector || null;
     }
     static getAt(location) {
         return this.get(...location);
@@ -81,23 +99,29 @@ class WorldRegisterSectors {
     static remove(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
-            return false;
+            return null;
         const position = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         const sectorKey = WorldSpaces.hash.hashVec3(position);
         const sector = dimension.sectors.get(sectorKey);
         if (!sector)
-            return false;
-        if (SectorPool._enabled)
-            SectorPool.returnSector(sector);
+            return null;
         WorldDataHooks.sectors.onRemove([dimensionId, position.x, position.y, position.z], sector);
+        if (!EngineSettings.settings.memoryAndCPU.useSharedMemory &&
+            WorldRegister.proxy == true) {
+            dimension.sectors.delete(sectorKey);
+            return sector.buffer;
+        }
+        WorldRegisterPools.returnSector(sector);
         dimension.sectors.delete(sectorKey);
-        return true;
+        return null;
     }
     static removeAt(location) {
         return this.remove(...location);
     }
 }
 export class WorldRegister {
+    static proxy = false;
+    static _pools = WorldRegisterPools;
     static _dimensions = new Map([
         [0, new Dimension(Dimension.CreateNew(0, "main"))],
     ]);

package/World/WorldSpaces.d.ts

@@ -1,4 +1,20 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
+import { IndexOrderingTypes } from "../Math/Indexing.js";
+export type WorldSpaceDataKey = {
+    sector: {
+        size: Vector3Like;
+        sectionArrayOrder: IndexOrderingTypes;
+    };
+    section: {
+        size: Vector3Like;
+        arrayOrders: {
+            id: IndexOrderingTypes;
+            light: IndexOrderingTypes;
+            level: IndexOrderingTypes;
+            secondary: IndexOrderingTypes;
+        };
+    };
+};
 declare class WorldBounds {
     static bounds: {
         MinZ: number;
@@ -26,6 +42,7 @@ declare class SectorSpace {
     static sectionBounds: Vector3Like;
     static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
 }
 declare class SectionSpace {
@@ -33,6 +50,7 @@ declare class SectionSpace {
     static bounds: Vector3Like;
     static volumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static transformPosition(position: 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;
@@ -42,6 +60,7 @@ declare class VoxelSpace {
     static bounds: Vector3Like;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
     static getIndex(x: number, y: number, z: number): number;
     static getIndexFromPosition(x: number, y: number, z: number): number;
@@ -57,5 +76,6 @@ export declare class WorldSpaces {
     static sector: typeof SectorSpace;
     static section: typeof SectionSpace;
     static voxel: typeof VoxelSpace;
+    static getDataKey(): WorldSpaceDataKey;
 }
 export {};

package/World/WorldSpaces.js

@@ -63,6 +63,10 @@ class SectorSpace {
         CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
     }
+    static transformPosition(position) {
+        CubeHashVec3(position.x, position.y, position.z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, position);
+        return position;
+    }
     static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
         CubeHashVec3Array(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
@@ -76,6 +80,10 @@ class SectionSpace {
         CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
         return refPosition;
     }
+    static transformPosition(position) {
+        CubeHashVec3(position.x, position.y, position.z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, position);
+        return position;
+    }
     static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
         CubeHashVec3Array(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
         return refPosition;
@@ -108,6 +116,14 @@ class VoxelSpace {
         refPosition[2] = z - refPosition[2];
         return refPosition;
     }
+    static transformPosition(position) {
+        const { x, y, z } = position;
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, position);
+        position.x = x - position.x;
+        position.y = y - position.y;
+        position.z = z - position.z;
+        return position;
+    }
     static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
         return GetYXZOrderArrayPositionVec3(index, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
     }
@@ -136,6 +152,23 @@ export class WorldSpaces {
     static sector = SectorSpace;
     static section = SectionSpace;
     static voxel = VoxelSpace;
+    static getDataKey() {
+        return {
+            sector: {
+                size: { ...WorldSpaces.sector.bounds },
+                sectionArrayOrder: "YXZ",
+            },
+            section: {
+                size: { ...WorldSpaces.section.bounds },
+                arrayOrders: {
+                    id: "YXZ",
+                    level: "YXZ",
+                    light: "YXZ",
+                    secondary: "YXZ",
+                },
+            },
+        };
+    }
 }
 EngineSettings.addEventListener("synced", (event) => {
     const { settings } = event.detail.settings;

package/WorldSimulation/Dimensions/DimensionSegment.d.ts

@@ -0,0 +1,38 @@
+import { Vector3Like } from "@amodx/math";
+import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { TaskSegment } from "../Tasks/TaskSegment";
+import { Generator } from "./Generator";
+import { SimulationSector } from "./SimulationSector";
+import { DimensionSimulation } from "./DimensionSimulation";
+import { SimulationBrush } from "../Tools/SimulationBrush";
+declare class ActiveSectors {
+    dimension: DimensionSegment;
+    _sectors: SimulationSector[];
+    _map: Map<string, SimulationSector>;
+    constructor(dimension: DimensionSegment);
+    add(x: number, y: number, z: number): false | undefined;
+    get(x: number, y: number, z: number): SimulationSector | null | undefined;
+    remove(x: number, y: number, z: number): false | undefined;
+}
+export declare class DimensionSegment {
+    id: number;
+    taskTool: TaskTool;
+    private tick;
+    tasks: Map<string, TaskSegment>;
+    activeSectors: ActiveSectors;
+    generators: Generator[];
+    simulation: DimensionSimulation;
+    _updatePosition: Vector3Like;
+    constructor(id: number, taskTool: TaskTool);
+    getBrush(): SimulationBrush;
+    incrementTick(): void;
+    getTick(): number;
+    addGenerator(generator: Generator): void;
+    removeGenerator(generator: Generator): void;
+    getUpdatePosition(): Vector3Like;
+    addTask(id: string, generationTask: boolean): void;
+    getTask(id: string): TaskSegment;
+    clearAllTasks(): void;
+    logTasks(): string;
+}
+export {};

package/WorldSimulation/Dimensions/DimensionSegment.js

@@ -0,0 +1,120 @@
+import { Vector3Like } from "@amodx/math";
+import { TaskSegment } from "../Tasks/TaskSegment";
+import { SimulationSector } from "./SimulationSector";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { DimensionSimulation } from "./DimensionSimulation";
+import { SimulationBrush } from "../Tools/SimulationBrush";
+const tempPosition = Vector3Like.Create();
+class ActiveSectors {
+    dimension;
+    _sectors = [];
+    _map = new Map();
+    constructor(dimension) {
+        this.dimension = dimension;
+    }
+    add(x, y, z) {
+        WorldSpaces.sector.getPosition(x, y, z, tempPosition);
+        const key = WorldSpaces.hash.hashVec3(tempPosition);
+        if (this._map.has(key))
+            return false;
+        const newSector = new SimulationSector(this.dimension);
+        newSector.position[0] = tempPosition.x;
+        newSector.position[1] = tempPosition.y;
+        newSector.position[2] = tempPosition.z;
+        this._sectors.push(newSector);
+        this._map.set(key, newSector);
+    }
+    get(x, y, z) {
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
+        if (!this._map.has(key))
+            return null;
+        return this._map.get(key);
+    }
+    remove(x, y, z) {
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
+        if (!this._map.has(key))
+            return false;
+        for (let i = 0; i < this._sectors.length; i++) {
+            if (this._sectors[i])
+                this._sectors.splice(i, 1);
+        }
+    }
+}
+export class DimensionSegment {
+    id;
+    taskTool;
+    tick = 0;
+    tasks = new Map();
+    activeSectors = new ActiveSectors(this);
+    generators = [];
+    simulation = new DimensionSimulation(this);
+    _updatePosition = Vector3Like.Create();
+    constructor(id, taskTool) {
+        this.id = id;
+        this.taskTool = taskTool;
+    }
+    getBrush() {
+        return new SimulationBrush(this);
+    }
+    incrementTick() {
+        this.tick++;
+    }
+    getTick() {
+        return this.tick;
+    }
+    addGenerator(generator) {
+        this.generators.push(generator);
+    }
+    removeGenerator(generator) {
+        for (let i = 0; i < this.generators.length; i++) {
+            if (this.generators[i] == generator)
+                this.generators.splice(i, 1);
+        }
+    }
+    getUpdatePosition() {
+        const numGenerators = this.generators.length;
+        if (numGenerators === 0) {
+            this._updatePosition.x = 0;
+            this._updatePosition.y = 0;
+            this._updatePosition.z = 0;
+            return this._updatePosition;
+        }
+        if (numGenerators === 1) {
+            this._updatePosition.x = this.generators[0].position.x;
+            this._updatePosition.y = this.generators[0].position.y;
+            this._updatePosition.z = this.generators[0].position.z;
+            return this._updatePosition;
+        }
+        let sumX = 0, sumY = 0, sumZ = 0;
+        for (let i = 0; i < numGenerators; i++) {
+            sumX += this.generators[i].position.x;
+            sumY += this.generators[i].position.y;
+            sumZ += this.generators[i].position.z;
+        }
+        this._updatePosition.x = sumX / numGenerators;
+        this._updatePosition.y = sumY / numGenerators;
+        this._updatePosition.z = sumZ / numGenerators;
+        return this._updatePosition;
+    }
+    addTask(id, generationTask) {
+        this.tasks.set(id, new TaskSegment(this, generationTask));
+    }
+    getTask(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            throw new Error(`Task with id [${id}] not registered in dimension segment ${this.id}`);
+        return task;
+    }
+    clearAllTasks() {
+        for (const [key, task] of this.tasks) {
+            task.clear();
+        }
+    }
+    logTasks() {
+        const tasks = [];
+        for (const [key, task] of this.tasks) {
+            tasks.push(`${key} | ${task.waitingFor}`);
+        }
+        return tasks.join("\n");
+    }
+}

package/WorldSimulation/Dimensions/DimensionSimulation.d.ts

@@ -0,0 +1,26 @@
+import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { DimensionSegment } from "./DimensionSegment";
+import { Vector3Like } from "@amodx/math";
+import { PriorityQueue } from "../../Util/PriorityQueue";
+import { VoxelUpdate } from "../Voxels/Behaviors";
+declare class UpdatedBounds {
+    displayMin: Vector3Like;
+    displayMax: Vector3Like;
+    dimension: number;
+    start(dimension?: number): void;
+    updateDisplay(x: number, y: number, z: number): void;
+    markDisplayDirty(): false | undefined;
+}
+export declare class DimensionSimulation {
+    dimension: DimensionSegment;
+    private cursor;
+    nDataCursor: WorldCursor;
+    sDataCursor: WorldCursor;
+    bounds: UpdatedBounds;
+    updateQueue: PriorityQueue<VoxelUpdate>;
+    constructor(dimension: DimensionSegment);
+    setOrigin(x: number, y: number, z: number): void;
+    getVoxelForUpdate(x: number, y: number, z: number): import("../../World/Cursor/WorldVoxelCursor").WorldVoxelCursor;
+    scheduleUpdate(type: string, x: number, y: number, z: number, delay: number, data?: null): void;
+}
+export {};

package/WorldSimulation/Dimensions/DimensionSimulation.js

@@ -0,0 +1,95 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldRegister } from "../../World/WorldRegister";
+import { Vector3Like } from "@amodx/math";
+import { VoxelTickUpdate } from "../Voxels/Ticks/VoxelTickUpdate";
+import { PriorityQueue } from "../../Util/PriorityQueue";
+const NegativeInfinityVec3 = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
+const tempPosition = Vector3Like.Create();
+class UpdatedBounds {
+    displayMin = Vector3Like.Clone(InfinityVec3);
+    displayMax = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = 0;
+    start(dimension) {
+        this.dimension = dimension || 0;
+        Vector3Like.Copy(this.displayMin, InfinityVec3);
+        Vector3Like.Copy(this.displayMax, NegativeInfinityVec3);
+    }
+    updateDisplay(x, y, z) {
+        if (x < this.displayMin.x)
+            this.displayMin.x = x;
+        if (y < this.displayMin.y)
+            this.displayMin.y = y;
+        if (z < this.displayMin.z)
+            this.displayMin.z = z;
+        if (x > this.displayMax.x)
+            this.displayMax.x = x;
+        if (y > this.displayMax.y)
+            this.displayMax.y = y;
+        if (z > this.displayMax.z)
+            this.displayMax.z = z;
+    }
+    markDisplayDirty() {
+        if (this.displayMax.x == -Infinity ||
+            this.displayMax.y == -Infinity ||
+            this.displayMax.z == -Infinity)
+            return false;
+        if (this.displayMin.x == Infinity ||
+            this.displayMin.y == Infinity ||
+            this.displayMin.z == Infinity)
+            return false;
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x - 1, this.displayMin.y - 1, this.displayMin.z - 1, tempPosition);
+        const minX = minSectionPos.x;
+        const minY = minSectionPos.y;
+        const minZ = minSectionPos.z;
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x + 1, this.displayMax.y + 1, this.displayMax.z + 1, tempPosition);
+        const maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
+                for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(this.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(x, y, z);
+                    if (!section.canRender())
+                        continue;
+                    section.incrementTick(section._Ticks.displayDirty);
+                }
+            }
+        }
+    }
+}
+export class DimensionSimulation {
+    dimension;
+    cursor = new WorldCursor();
+    nDataCursor = new WorldCursor();
+    sDataCursor = new WorldCursor();
+    bounds = new UpdatedBounds();
+    updateQueue = new PriorityQueue();
+    constructor(dimension) {
+        this.dimension = dimension;
+    }
+    setOrigin(x, y, z) {
+        this.cursor.setFocalPoint(this.dimension.id, x, y, z);
+        this.nDataCursor.setFocalPoint(this.dimension.id, x, y, z);
+        this.sDataCursor.setFocalPoint(this.dimension.id, x, y, z);
+    }
+    getVoxelForUpdate(x, y, z) {
+        const voxel = this.cursor.getVoxel(x, y, z);
+        if (!voxel)
+            throw new Error(`Tried to run tick update on voxel that does not exist at [${x} ${y} ${z}]`);
+        return voxel;
+    }
+    scheduleUpdate(type, x, y, z, delay, data = null) {
+        const active = this.dimension.activeSectors.get(x, y, z);
+        if (!active)
+            throw new Error(`Tried to schedule a voxel update on a non loaded active sector`);
+        const update = new VoxelTickUpdate(type, x, y, z, data);
+        active.tickQueue.addTick(update, delay);
+    }
+}

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

@@ -1,8 +1,5 @@
 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: number;
     building?: boolean;
@@ -10,25 +7,24 @@ export interface GeneratorData {
     position: Vector3Like;
     renderRadius: number;
     generationRadius: number;
+    tickRadius: number;
     maxRadius: number;
 }
 export declare class Generator {
-    taskTool: TaskTool;
     position: Vector3Like;
     _dimension: number;
     _building: boolean;
-    _positonChanged: boolean;
+    _isNew: boolean;
+    _dirty: boolean;
     _waitingForCull: boolean;
     _cullTime: number;
     _culling: boolean;
     _cachedPosition: Vector3Like;
     _sectorPosition: Vector3Like;
     _genCircle: Circle;
+    _tickCircle: Circle;
     _renderCircle: Circle;
     _maxCircle: Circle;
-    buildQueue: BuildQueue;
-    logicQueue: LogicQueue;
-    constructor(taskTool: TaskTool, data: GeneratorData);
+    constructor(data: GeneratorData);
     update(): void;
-    tick(): void;
 }

package/WorldSimulation/{Internal/Classes → Dimensions}/Generator.js

@@ -1,26 +1,22 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
-import { WorldSpaces } from "../../../World/WorldSpaces";
-import { BuildQueue } from "./Queues/BuildQueue";
-import { LogicQueue } from "./Queues/LogiccQueue";
+import { WorldSpaces } from "../../World/WorldSpaces";
 export class Generator {
-    taskTool;
     position;
     _dimension = 0;
     _building = true;
-    _positonChanged = false;
+    _isNew = true;
+    _dirty = true;
     _waitingForCull = false;
     _cullTime = 0;
     _culling = true;
     _cachedPosition = Vector3Like.Create();
     _sectorPosition = Vector3Like.Create();
     _genCircle = new Circle({ x: 0, y: 0 }, 0);
+    _tickCircle = new Circle({ x: 0, y: 0 }, 0);
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
-    buildQueue;
-    logicQueue;
-    constructor(taskTool, data) {
-        this.taskTool = taskTool;
+    constructor(data) {
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -28,30 +24,23 @@ export class Generator {
         this._culling = typeof data.culling !== "undefined" ? data.culling : true;
         this._renderCircle.radius = data.renderRadius;
         this._genCircle.radius = data.generationRadius;
+        this._tickCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
-        this.buildQueue = new BuildQueue(taskTool);
-        this.logicQueue = new LogicQueue(taskTool);
     }
     update() {
-        this._positonChanged = false;
+        this._dirty = false;
         WorldSpaces.section.getPosition(this.position.x, 0, this.position.z, this._sectorPosition);
         if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
-            this._positonChanged = true;
+            this._dirty = true;
             Vector3Like.Copy(this._cachedPosition, this._sectorPosition);
         }
         this._renderCircle.center.x = this._sectorPosition.x;
         this._renderCircle.center.y = this._sectorPosition.z;
         this._genCircle.center.x = this._sectorPosition.x;
         this._genCircle.center.y = this._sectorPosition.z;
+        this._tickCircle.center.x = this._sectorPosition.x;
+        this._tickCircle.center.y = this._sectorPosition.z;
         this._maxCircle.center.x = this._sectorPosition.x;
         this._maxCircle.center.y = this._sectorPosition.z;
     }
-    tick() {
-        if (this._building) {
-            this.buildQueue.sort(this.position.x, this.position.y, this.position.z);
-            this.buildQueue.run(125);
-        }
-        this.logicQueue.sort(this.position.x, this.position.y, this.position.z);
-        this.logicQueue.run();
-    }
 }