@divinevoxel/vlox 0.0.72 → 0.0.74

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

@@ -1,9 +1,12 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { BuildQueue } from "./Queues/BuildQueue";
+import { LogicQueue } from "./Queues/LogiccQueue";
 export class Generator {
+    taskTool;
     position;
-    _dimension = "main";
+    _dimension = 0;
     _building = true;
     _positonChanged = false;
     _waitingForCull = false;
@@ -14,7 +17,10 @@ export class Generator {
     _genCircle = new Circle({ x: 0, y: 0 }, 0);
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
-    constructor(data) {
+    buildQueue;
+    logicQueue;
+    constructor(taskTool, data) {
+        this.taskTool = taskTool;
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -23,6 +29,8 @@ export class Generator {
         this._renderCircle.radius = data.renderRadius;
         this._genCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
+        this.buildQueue = new BuildQueue(taskTool);
+        this.logicQueue = new LogicQueue(taskTool);
     }
     update() {
         this._positonChanged = false;
@@ -38,4 +46,12 @@ export class Generator {
         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();
+    }
 }

package/WorldSimulation/Internal/Classes/Queues/BuildQueue.d.ts

@@ -0,0 +1,5 @@
+import { LocationData } from "Math";
+import { TickQueue } from "../TickQueue";
+export declare class BuildQueue extends TickQueue {
+    runTask(section: LocationData): void;
+}

package/WorldSimulation/Internal/Classes/Queues/BuildQueue.js

@@ -0,0 +1,6 @@
+import { TickQueue } from "../TickQueue";
+export class BuildQueue extends TickQueue {
+    runTask(section) {
+        this.tasks.build.section.run(section);
+    }
+}

package/WorldSimulation/Internal/Classes/Queues/LogiccQueue.d.ts

@@ -0,0 +1,5 @@
+import { LocationData } from "Math";
+import { TickQueue } from "../TickQueue";
+export declare class LogicQueue extends TickQueue {
+    runTask(section: LocationData): void;
+}

package/WorldSimulation/Internal/Classes/Queues/LogiccQueue.js

@@ -0,0 +1,6 @@
+import { TickQueue } from "../TickQueue";
+export class LogicQueue extends TickQueue {
+    runTask(section) {
+        this.tasks.voxel.logic.run(section);
+    }
+}

package/{Tasks/IWG → WorldSimulation}/Internal/Classes/SectorVisistedMap.js

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { WorldSpaces } from "../../../World/WorldSpaces";
 const tempPosition = Vector3Like.Create();
 export class SectorVisistedMap {
     _map = new Set();

package/WorldSimulation/Internal/Classes/TickQueue.d.ts

@@ -0,0 +1,12 @@
+import { LocationData } from "../../../Math";
+import { TaskTool } from "../../../Tools/Tasks/TasksTool";
+export declare abstract class TickQueue {
+    tasks: TaskTool;
+    hash: Set<unknown>;
+    sections: LocationData[];
+    constructor(tasks: TaskTool);
+    add(dimension: number, x: number, y: number, z: number): false | undefined;
+    sort(x: number, y: number, z: number): LocationData[];
+    abstract runTask(section: LocationData): void;
+    run(limit?: number): void;
+}

package/WorldSimulation/Internal/Classes/TickQueue.js

@@ -0,0 +1,58 @@
+import { WorldSpaces } from "../../../World/WorldSpaces";
+const pool = [];
+export class TickQueue {
+    tasks;
+    hash = new Set();
+    sections = [];
+    constructor(tasks) {
+        this.tasks = tasks;
+    }
+    add(dimension, x, y, z) {
+        const key = WorldSpaces.hash.hashXYZ(x, y, z);
+        if (this.hash.has(key))
+            return false;
+        this.hash.add(key);
+        const location = pool.length ? pool.shift() : [0, 0, 0, 0];
+        location[0] = dimension;
+        location[1] = x;
+        location[2] = y;
+        location[3] = z;
+        this.sections.push(location);
+    }
+    sort(x, y, z) {
+        const sections = this.sections;
+        const sx = x, sy = y, sz = z;
+        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
+        while (i > 1) {
+            for (j = 1; j < i; j++) {
+                (ax = sections[j - 1][1]),
+                    (ay = sections[j - 1][2]),
+                    (az = sections[j - 1][3]);
+                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
+                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
+                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
+                if (distA > distB) {
+                    temp = sections[j - 1];
+                    sections[j - 1] = sections[j];
+                    sections[j] = temp;
+                }
+            }
+            i--;
+        }
+        return sections;
+    }
+    run(limit = 25) {
+        let count = 0;
+        while (this.sections.length) {
+            const vec = this.sections.shift();
+            const [, x, y, z] = vec;
+            this.runTask(vec);
+            this.tasks.build.section.run(vec);
+            this.hash.delete(WorldSpaces.hash.hashXYZ(x, y, z));
+            count++;
+            pool.push(vec);
+            if (count > limit)
+                break;
+        }
+    }
+}

package/WorldSimulation/Internal/Classes/WorldSimulationTaskBase.d.ts

@@ -0,0 +1,15 @@
+import { LocationData } from "../../../Math/index.js";
+import { DimensionSegment } from "./DimensionSegment.js";
+export type WorldSimulationTaskBase = {
+    id: string;
+    propagationBlocking?: boolean;
+    run(location: LocationData, onDone: () => void, dimension: DimensionSegment): void;
+};
+export declare class IWGTaskBase {
+    data: WorldSimulationTaskBase;
+    constructor(data: WorldSimulationTaskBase);
+    add(dimensionId: number, x: number, y: number, z: number): void;
+    remove(dimensionId: number, x: number, y: number, z: number): void;
+    cancelAll(dimensionId?: number | null): void;
+    runTask(max?: number): void;
+}

package/{Tasks/IWG/Internal/Classes/IWGTaskBase.js → WorldSimulation/Internal/Classes/WorldSimulationTaskBase.js}

@@ -1,11 +1,11 @@
-import { IWGDimensions } from "../../Internal/IWGDimensions.js";
+import { WorldSimulationDimensions } from "../WorldSimulationDimensions.js";
 export class IWGTaskBase {
     data;
     constructor(data) {
         this.data = data;
     }
     add(dimensionId, x, y, z) {
-        const dimension = IWGDimensions.getDimension(dimensionId);
+        const dimension = WorldSimulationDimensions.getDimension(dimensionId);
         const task = dimension.getTask(this.data.id);
         if (task.vistedMap.has(x, y, z))
             return;
@@ -15,7 +15,7 @@ export class IWGTaskBase {
         task.vistedMap.add(x, y, z);
     }
     remove(dimensionId, x, y, z) {
-        const dimension = IWGDimensions.getDimension(dimensionId);
+        const dimension = WorldSimulationDimensions.getDimension(dimensionId);
         const task = dimension.getTask(this.data.id);
         task.vistedMap.remove(x, y, z);
         if (this.data.propagationBlocking) {
@@ -24,18 +24,18 @@ export class IWGTaskBase {
     }
     cancelAll(dimensionId = null) {
         if (dimensionId) {
-            const dimension = IWGDimensions.getDimension(dimensionId);
+            const dimension = WorldSimulationDimensions.getDimension(dimensionId);
             const task = dimension.getTask(this.data.id);
             task.clear();
         }
         else {
-            for (const [key, dimension] of IWGDimensions._dimensions) {
+            for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
                 dimension.clearAllTasks();
             }
         }
     }
     runTask(max = 1000) {
-        for (const [key, dimension] of IWGDimensions._dimensions) {
+        for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
             const task = dimension.getTask(this.data.id);
             if (task.waitingFor < 0)
                 task.waitingFor = 0;
@@ -47,12 +47,12 @@ export class IWGTaskBase {
                 const z = task.queue.shift();
                 task.waitingFor++;
                 if (this.data.propagationBlocking) {
-                    dimension.inProgress.add(x, 0, z);
+                    dimension.inProgress.add(x, y, z);
                 }
                 this.data.run([dimension.id, x, y, z], () => {
                     task.vistedMap.remove(x, y, z);
                     if (this.data.propagationBlocking) {
-                        dimension.inProgress.remove(x, 0, z);
+                        dimension.inProgress.remove(x, y, z);
                     }
                     task.waitingFor--;
                 }, dimension);

package/{Tasks/IWG → WorldSimulation}/Internal/Functions/cullSectors.js

@@ -1,13 +1,13 @@
 import { Circle, Square } from "@amodx/math";
-import { IWGDimensions } from "../IWGDimensions";
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { IWGTools } from "../IWGTools";
-import { WorldLock } from "../../../../World/Lock/WorldLock";
+import { WorldSimulationDimensions } from "../WorldSimulationDimensions";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldSimulationTools } from "../WorldSimulationTools";
+import { WorldLock } from "../../../World/Lock/WorldLock";
 const sectorSquare = new Square();
 export function cullSectors(generatos, cullGenerators) {
     const time = performance.now();
-    for (const [, dimension] of IWGDimensions._dimensions) {
+    for (const [, dimension] of WorldSimulationDimensions._dimensions) {
         for (let i = dimension.unRenderQueue.nodes.length - 1; i > -1; i--) {
             const node = dimension.unRenderQueue.nodes[i];
             const [cx, cy, cz] = node.position;
@@ -31,7 +31,7 @@ export function cullSectors(generatos, cullGenerators) {
             if (delta > 5_000) {
                 dimension.rendered.remove(cx, cy, cz);
                 dimension.inProgress.add(cx, cy, cz);
-                IWGTools.parent
+                WorldSimulationTools.parent
                     .runTaskAsync("remove-sector", [dimension.id, cx, cy, cz])
                     .then(() => {
                     dimension.inProgress.remove(cx, cy, cz);
@@ -61,9 +61,9 @@ export function cullSectors(generatos, cullGenerators) {
             const delta = time - node.time;
             if (delta > 5_000) {
                 dimension.unLoadQueue.removeIndex(i);
-                if (IWGTools.worldStorage) {
+                if (WorldSimulationTools.worldStorage) {
                     dimension.inProgress.add(cx, cy, cz);
-                    IWGTools.worldStorage
+                    WorldSimulationTools.worldStorage
                         .unloadSector([dimension.id, cx, cy, cz])
                         .finally(() => {
                         dimension.inProgress.remove(cx, cy, cz);

package/{Tasks/IWG → WorldSimulation}/Internal/Functions/getSectorState.d.ts

@@ -1,4 +1,4 @@
 import { SectorState } from "../Classes/SectorState";
-import { Sector } from "../../../../World/index";
+import { Sector } from "../../../World/index";
 import { DimensionSegment } from "../Classes/DimensionSegment";
 export declare function getSectorState(sector: Sector, state: SectorState, segment: DimensionSegment): SectorState;

package/{Tasks/IWG → WorldSimulation}/Internal/Functions/getSectorState.js

@@ -1,7 +1,7 @@
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { $2dMooreNeighborhood } from "../../../../Math/CardinalNeighbors";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { Sector } from "../../../../World/index";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { $2dMooreNeighborhood } from "../../../Math/CardinalNeighbors";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { Sector } from "../../../World/index";
 import { Vector3Like } from "@amodx/math";
 const tempPosition = Vector3Like.Create();
 export function getSectorState(sector, state, segment) {

package/WorldSimulation/Internal/Functions/runTickUpdate.d.ts

@@ -0,0 +1,2 @@
+import { Generator } from "../Classes/Generator";
+export declare function runTickUpdate(generators: Generator[]): void;

package/{Tasks/IWG/Internal/Functions/runBuildUpdate.js → WorldSimulation/Internal/Functions/runTickUpdate.js}

@@ -1,17 +1,39 @@
 import { Circle, Square } from "@amodx/math";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { WorldSpaces } from "../../../World/WorldSpaces";
 import { SectorState } from "../Classes/SectorState";
-import { WorldRegister } from "../../../../World/WorldRegister";
+import { WorldRegister } from "../../../World/WorldRegister";
 import { getSectorState } from "./getSectorState";
-import { IWGTasks } from "../IWGTasks";
-import { IWGDimensions } from "../IWGDimensions";
+import { WorldSimulationDimensions } from "../WorldSimulationDimensions";
 const stateCursor = new SectorState();
 const sectorSquare = new Square();
-export function runBuildUpdate(generators) {
+function buildCheck(dimenion, sector, generator, x, y, z) {
+    let rendered = true;
+    if (!dimenion.rendered.has(x, y, z)) {
+        rendered = false;
+        dimenion.rendered.add(x, y, z);
+    }
+    for (const section of sector.getRenerableSections()) {
+        if (rendered && (section.isInProgress() || !section.isDisplayDirty()))
+            continue;
+        section.setInProgress(true);
+        generator.buildQueue.add(dimenion.id, ...section.position);
+    }
+}
+function logicCheck(dimenion, sector, generator, x, y, z) {
+    if (!sector.isLogicDirty())
+        return false;
+    for (const section of sector.getLogicDirtySections()) {
+        if (section.isLogicUpdateInProgress() || !section.isLogicDirty())
+            continue;
+        section.setLogicUpdateInProgress(true);
+        generator.logicQueue.add(dimenion.id, ...section.position);
+    }
+}
+export function runTickUpdate(generators) {
     for (const generator of generators) {
         if (!generator._building)
             continue;
-        const segment = IWGDimensions._dimensions.get(generator._dimension);
+        const segment = WorldSimulationDimensions._dimensions.get(generator._dimension);
         if (!segment)
             throw new Error(`No segment for dimensions ${generator._dimension} found.`);
         const queue = segment.queue;
@@ -39,13 +61,20 @@ export function runBuildUpdate(generators) {
             if (state.nWorldGenAllDone &&
                 state.nSunAllDone &&
                 state.nPropagtionAllDone) {
-                if (segment.rendered.has(cx, cy, cz))
+                if (!segment.rendered.has(cx, cy, cz)) {
+                    buildCheck(segment, sector, generator, cx, cy, cz);
                     continue;
-                IWGTasks.buildTasks.add(generator._dimension, cx, cy, cz);
+                }
+                if (sector.anySectionLogicDirty()) {
+                    logicCheck(segment, sector, generator, cx, cy, cz);
+                }
+                if (sector.anySectionDisplayDirty()) {
+                    buildCheck(segment, sector, generator, cx, cy, cz);
+                }
             }
         }
     }
-    for (const [, dimension] of IWGDimensions._dimensions) {
+    for (const [, dimension] of WorldSimulationDimensions._dimensions) {
         dimension.vistedMap.clear();
     }
 }

package/{Tasks/IWG → WorldSimulation}/Internal/Functions/runWorldUpdate.js

@@ -1,17 +1,17 @@
 import { Circle, Square } from "@amodx/math";
 import { getSectorState } from "./getSectorState";
 import { SectorState } from "../Classes/SectorState";
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { Sector } from "../../../../World";
-import { WorldLock } from "../../../../World/Lock/WorldLock";
-import { IWGTasks } from "../IWGTasks";
-import { IWGDimensions } from "../IWGDimensions";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { Sector } from "../../../World";
+import { WorldLock } from "../../../World/Lock/WorldLock";
+import { WorldSimulationTasks } from "../WorldSimulationTasks";
+import { WorldSimulationDimensions } from "../WorldSimulationDimensions";
+import { WorldSpaces } from "../../../World/WorldSpaces";
 const stateCursor = new SectorState();
 const sectorSquare = new Square();
 export function runWorldUpdate(generators) {
     for (const generator of generators) {
-        const segment = IWGDimensions._dimensions.get(generator._dimension);
+        const segment = WorldSimulationDimensions._dimensions.get(generator._dimension);
         if (!segment)
             throw new Error(`No segment for dimensions ${generator._dimension} found.`);
         const queue = segment.queue;
@@ -36,34 +36,34 @@ export function runWorldUpdate(generators) {
                 continue;
             const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
             if (!sector) {
-                IWGTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
+                WorldSimulationTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             const state = getSectorState(sector, stateCursor, segment);
             sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
             if (state.allLoaded &&
                 !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
-                IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
+                WorldSimulationTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nWorldGenAllDone &&
                 !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
-                IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
+                WorldSimulationTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nDecorAllDone &&
                 !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
-                IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
+                WorldSimulationTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nPropagtionAllDone &&
                 !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
-                IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
+                WorldSimulationTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
         }
     }
-    for (const [key, dimension] of IWGDimensions._dimensions) {
+    for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
         dimension.vistedMap.clear();
     }
 }

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

@@ -1,7 +1,7 @@
 import { DimensionSegment } from "./Classes/DimensionSegment";
-import { IWGTaskBase, IWGTasksData } from "./Classes/IWGTaskBase";
+import { IWGTaskBase, WorldSimulationTaskBase } from "./Classes/WorldSimulationTaskBase";
 export declare class TaskRegister {
     static readonly tasks: IWGTaskBase[];
-    static addTasks(data: IWGTasksData): IWGTaskBase;
+    static addTasks(data: WorldSimulationTaskBase): IWGTaskBase;
     static addToDimension(dimension: DimensionSegment): void;
 }

package/{Tasks/IWG → WorldSimulation}/Internal/TaskRegister.js

@@ -1,4 +1,4 @@
-import { IWGTaskBase } from "./Classes/IWGTaskBase";
+import { IWGTaskBase } from "./Classes/WorldSimulationTaskBase";
 export class TaskRegister {
     static tasks = [];
     static addTasks(data) {

package/WorldSimulation/Internal/WorldSimulationDimensions.d.ts

@@ -0,0 +1,6 @@
+import { DimensionSegment } from "./Classes/DimensionSegment";
+export declare class WorldSimulationDimensions {
+    static readonly _dimensions: Map<number, DimensionSegment>;
+    static addDimension(dimensionId: number): void;
+    static getDimension(dimensionId: number): DimensionSegment;
+}

package/{Tasks/IWG/Internal/IWGDimensions.js → WorldSimulation/Internal/WorldSimulationDimensions.js}

@@ -1,6 +1,6 @@
 import { DimensionSegment } from "./Classes/DimensionSegment";
 import { TaskRegister } from "./TaskRegister";
-export class IWGDimensions {
+export class WorldSimulationDimensions {
     static _dimensions = new Map();
     static addDimension(dimensionId) {
         const segment = new DimensionSegment(dimensionId);

package/WorldSimulation/Internal/WorldSimulationTasks.d.ts

@@ -0,0 +1,30 @@
+export declare class WorldSimulationTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static readonly worldLoadTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# Generate Sectors
+     * ---
+     */
+    static readonly worldGenTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# Decorate Sectors
+     * ---
+     */
+    static readonly worldDecorateTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# World Sun
+     * ---
+     */
+    static readonly worldSunTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# World Propagation
+     * ---
+     */
+    static readonly worldPropagationTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# Save Sector
+     * ---
+     */
+    static readonly saveTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+    /**# Save & Unload Sector
+     * ---
+     */
+    static readonly saveAndUnloadTasks: import("./Classes/WorldSimulationTaskBase").IWGTaskBase;
+}

package/{Tasks/IWG/Internal/IWGTasks.js → WorldSimulation/Internal/WorldSimulationTasks.js}

@@ -1,8 +1,8 @@
-import { WorldRegister } from "../../../World/WorldRegister";
-import { Sector } from "../../../World/index";
-import { IWGTools } from "./IWGTools";
+import { WorldRegister } from "../../World/WorldRegister";
+import { Sector } from "../../World/index";
+import { WorldSimulationTools } from "./WorldSimulationTools";
 import { TaskRegister } from "./TaskRegister";
-export class IWGTasks {
+export class WorldSimulationTasks {
     /**# Load Sectors
      * ---
      */
@@ -14,11 +14,11 @@ export class IWGTasks {
             const sector = WorldRegister.sectors.get(location[0], x, y, z);
             if (sector)
                 return onDone();
-            if (!IWGTools.worldStorage) {
+            if (!WorldSimulationTools.worldStorage) {
                 WorldRegister.sectors.new(location[0], x, y, z);
                 return onDone();
             }
-            const loaded = await IWGTools.worldStorage.loadSector([
+            const loaded = await WorldSimulationTools.worldStorage.loadSector([
                 dimension,
                 x,
                 y,
@@ -42,7 +42,7 @@ export class IWGTasks {
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
             if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
                 return onDone();
-            IWGTools.taskTool.generate.run([location, []], null, () => {
+            WorldSimulationTools.taskTool.generate.run([location, []], null, () => {
                 sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
                 onDone();
             });
@@ -60,7 +60,7 @@ export class IWGTasks {
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
             if (sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
                 return onDone();
-            IWGTools.taskTool.decorate.run([location, []], null, () => {
+            WorldSimulationTools.taskTool.decorate.run([location, []], null, () => {
                 sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
                 onDone();
             });
@@ -78,7 +78,7 @@ export class IWGTasks {
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
             if (sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
                 return onDone();
-            IWGTools.taskTool.worldSun.run(location, null, () => {
+            WorldSimulationTools.taskTool.worldSun.run(location, null, () => {
                 sector.setBitFlag(Sector.FlagIds.isWorldSunDone, true);
                 onDone();
             });
@@ -96,7 +96,7 @@ export class IWGTasks {
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
             if (sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
                 return onDone();
-            IWGTools.taskTool.propagation.run(location, null, () => {
+            WorldSimulationTools.taskTool.propagation.run(location, null, () => {
                 sector.setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
                 onDone();
             });
@@ -108,9 +108,9 @@ export class IWGTasks {
     static saveTasks = TaskRegister.addTasks({
         id: "save",
         async run(location, onDone) {
-            if (!IWGTools.worldStorage)
+            if (!WorldSimulationTools.worldStorage)
                 return onDone();
-            await IWGTools.worldStorage.saveSector(location);
+            await WorldSimulationTools.worldStorage.saveSector(location);
             onDone();
         },
     });
@@ -120,20 +120,10 @@ export class IWGTasks {
     static saveAndUnloadTasks = TaskRegister.addTasks({
         id: "save_and_unload",
         async run(location, onDone) {
-            if (!IWGTools.worldStorage)
+            if (!WorldSimulationTools.worldStorage)
                 return onDone();
-            await IWGTools.worldStorage.unloadSector(location);
+            await WorldSimulationTools.worldStorage.unloadSector(location);
             onDone();
         },
     });
-    /**# Build Task
-     * ---
-     */
-    static buildTasks = TaskRegister.addTasks({
-        id: "build_tasks",
-        async run(location, onDone, dimenion) {
-            dimenion.rendered.add(location[1], location[2], location[3]);
-            IWGTools.taskTool.build.sector.run(location, null, onDone);
-        },
-    });
 }

package/WorldSimulation/Internal/WorldSimulationTools.d.ts

@@ -0,0 +1,8 @@
+import { Thread } from "@amodx/threads";
+import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { WorldStorageInterface } from "../../World/Types/WorldStorage.interface";
+export declare class WorldSimulationTools {
+    static taskTool: TaskTool;
+    static worldStorage: WorldStorageInterface | null;
+    static parent: Thread;
+}

package/{Tasks/IWG/Internal/IWGTools.js → WorldSimulation/Internal/WorldSimulationTools.js}

@@ -1,4 +1,4 @@
-export class IWGTools {
+export class WorldSimulationTools {
     static taskTool;
     static worldStorage = null;
     static parent;

package/{Tasks/IWG → WorldSimulation}/Procedures/InitalLoad.d.ts

@@ -4,7 +4,7 @@ import { GeneratorData } from "../Internal/Classes/Generator";
  * Load the world without building.
  */
 export declare function InitalLoad(props: {
-    dimension?: string;
+    dimension?: number;
     logTasks?: true;
     genData: Partial<GeneratorData>;
 }): Promise<unknown>;