@divinevoxel/vlox 0.0.73 → 0.0.75

package/WorldSimulation/Dimensions/SimulationSector.js

@@ -0,0 +1,214 @@
+import { Vector3Like } from "@amodx/math";
+import { SectorState } from "./SectorState";
+import { Sector } from "../../World/Sector";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSimulationTasks } from "../Internal/WorldSimulationTasks";
+import { TickQueue } from "../Tick/TickQueue";
+import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
+import { WorldDataSyncIds } from "../../World/Types/WorldDataSyncIds";
+import { EngineSettings } from "../../Settings/EngineSettings";
+const tempPosition = Vector3Like.Create();
+export class SimulationSector {
+    dimension;
+    position = [0, 0, 0];
+    renderering = false;
+    generating = false;
+    ticking = false;
+    state = new SectorState(this);
+    sector = null;
+    _rendered = false;
+    _genAllDone = false;
+    /**An array of the last tick each section was built at */
+    _displayTicks = new Uint32Array(WorldSpaces.sector.sectionVolumne);
+    tickQueue;
+    neighbors = [];
+    fullNeighbors = false;
+    maxNeighbors = MooreNeighborhood2D.length - 1;
+    constructor(dimension) {
+        this.dimension = dimension;
+        this.tickQueue = new TickQueue(dimension);
+    }
+    updateNeighbors() {
+        this.neighbors.length = 0;
+        const [cx, cy, cz] = this.position;
+        this.fullNeighbors = true;
+        for (let i = 0; i < MooreNeighborhood2D.length; i++) {
+            const [nx, nz] = MooreNeighborhood2D[i];
+            if (nx === 0 && nz === 0)
+                continue;
+            const sectorPOS = WorldSpaces.sector.getPosition(cx + nx * WorldSpaces.sector.bounds.x, cy, cz + nz * WorldSpaces.sector.bounds.z, tempPosition);
+            const sector = this.dimension.activeSectors.get(sectorPOS.x, cy, sectorPOS.z);
+            if (!sector) {
+                this.fullNeighbors = false;
+                continue;
+            }
+            this.neighbors.push(sector);
+        }
+    }
+    canCheckOut() {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return true;
+        if (!this.fullNeighbors)
+            return false;
+        if (!this.sector || this.sector.isCheckedOut() || this.sector.isLocked())
+            return false;
+        for (const simSector of this.neighbors) {
+            if (!simSector.sector)
+                return false;
+            if (simSector.sector.isCheckedOut() || simSector.sector.isLocked())
+                return false;
+        }
+        return true;
+    }
+    checkOut(thread) {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return;
+        if (!this.sector)
+            return;
+        for (const simSector of this.neighbors) {
+            const sector = simSector?.sector;
+            sector.setCheckedOut(true);
+            thread.runTask(WorldDataSyncIds.CheckInSector, [[this.dimension.id, ...simSector.position], sector.buffer], [sector.buffer]);
+        }
+        this.sector.setCheckedOut(true);
+        thread.runTask(WorldDataSyncIds.CheckInSector, [[this.dimension.id, ...this.position], this.sector.buffer], [this.sector.buffer]);
+    }
+    checkIn(thread) {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return;
+        if (!this.sector)
+            return;
+        for (const simSector of this.neighbors) {
+            thread.runTask(WorldDataSyncIds.CheckOutSector, [
+                this.dimension.id,
+                ...simSector.position,
+            ]);
+        }
+        thread.runTask(WorldDataSyncIds.CheckOutSector, [
+            this.dimension.id,
+            ...this.position,
+        ]);
+    }
+    tickUpdate() {
+        if (!this.fullNeighbors)
+            return false;
+        if (this.sector?.isCheckedOut()) {
+            return false;
+        }
+        if ((!this.renderering && !this.ticking) || !this.sector)
+            return false;
+        if (!this._genAllDone)
+            return false;
+        let renderedSection = false;
+        const sector = this.sector;
+        if (this.renderering) {
+            for (const section of sector.sections) {
+                if (!this._rendered ||
+                    this._displayTicks[section.index] !==
+                        section.getTick(section._Ticks.displayDirty)) {
+                    this._displayTicks[section.index] = section.getTick(section._Ticks.displayDirty);
+                    WorldSimulationTasks.buildTasks.add(this.dimension.id, ...section.position);
+                    renderedSection = true;
+                }
+            }
+            this._rendered = true;
+        }
+        /*   if (this.ticking) {
+          this.dimension.simulation.setOrigin(...this.position);
+          this.dimension.simulation.bounds.start();
+          this.tickQueue.run();
+    
+          const [min, max] = sector.getMinMax();
+          if (min == Math.abs(Infinity) || max == Math.abs(Infinity)) return true;
+    
+          const height = max - min + 1;
+          let attempts = 100;
+          let ticks = 20;
+          while (attempts) {
+            const randomX =
+              Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
+              this.sector.position[0];
+            const randomY =
+              Math.floor(height * Math.random()) + min + this.sector.position[1];
+            const randomZ =
+              Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
+              this.sector.position[2];
+            const voxel = this.dimension.simulation.nDataCursor.getVoxel(
+              randomX,
+              randomY,
+              randomZ
+            );
+            if (!voxel || voxel.isAir()) {
+              attempts--;
+              continue;
+            }
+    
+            const behavior = VoxelBehaviorsRegister.get(
+              voxel.tags["dve_simulation_behavior"]
+            );
+            behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
+    
+            ticks--;
+    
+            if (!ticks) break;
+          }
+    
+          this.dimension.simulation.bounds.markDisplayDirty();
+        } */
+        return true;
+    }
+    generateUpdate() {
+        if (!this.fullNeighbors)
+            return false;
+        if (this.sector?.isCheckedOut())
+            return;
+        if (this._genAllDone)
+            return true;
+        if (!this.generating)
+            return false;
+        if (!this.sector) {
+            const sector = WorldRegister.sectors.get(this.dimension.id, ...this.position);
+            if (!sector) {
+                WorldSimulationTasks.worldLoadTasks.add(this.dimension.id, ...this.position);
+                return;
+            }
+            this.sector = sector;
+        }
+        const sector = this.sector;
+        const state = this.state.update();
+        /*     if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+          console.log(
+            "world gen set true",
+            state.nWorldGenAllDone,
+            state.allLoaded
+          );
+        } */
+        if (state.allLoaded && !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+            // console.log("add to world gen", ...this.position);
+            WorldSimulationTasks.worldGenTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nWorldGenAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
+            //  console.log("add to world decor");
+            WorldSimulationTasks.worldDecorateTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nDecorAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
+            WorldSimulationTasks.worldPropagationTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nPropagtionAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+            WorldSimulationTasks.worldSunTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nSunAllDone && sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+            this._genAllDone = true;
+            return true;
+        }
+        return true;
+    }
+}

package/WorldSimulation/Internal/WorldSimulationDimensions.d.ts

@@ -0,0 +1,6 @@
+import { DimensionSegment } from "../Dimensions/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,9 +1,10 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
-import { TaskRegister } from "./TaskRegister";
-export class IWGDimensions {
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+import { TaskRegister } from "../Tasks/TaskRegister";
+import { WorldSimulationTools } from "./WorldSimulationTools";
+export class WorldSimulationDimensions {
     static _dimensions = new Map();
     static addDimension(dimensionId) {
-        const segment = new DimensionSegment(dimensionId);
+        const segment = new DimensionSegment(dimensionId, WorldSimulationTools.taskTool);
         TaskRegister.addToDimension(segment);
         this._dimensions.set(dimensionId, segment);
     }

package/WorldSimulation/Internal/WorldSimulationTasks.d.ts

@@ -0,0 +1,35 @@
+export declare class WorldSimulationTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static readonly worldLoadTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# Generate Sectors
+     * ---
+     */
+    static readonly worldGenTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# Decorate Sectors
+     * ---
+     */
+    static readonly worldDecorateTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# World Propagation
+     * ---
+     */
+    static readonly worldPropagationTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# World Sun
+     * ---
+     */
+    static readonly worldSunTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# Save Sector
+     * ---
+     */
+    static readonly saveTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# Save & Unload Sector
+     * ---
+     */
+    static readonly unloadTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    /**# Build Task
+     * ---
+     */
+    static readonly buildTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+    static readonly unbuildTasks: import("../Tasks/SimulationTaskBase").SimulationTaskBase;
+}

package/WorldSimulation/Internal/WorldSimulationTasks.js

@@ -0,0 +1,200 @@
+import { WorldRegister } from "../../World/WorldRegister";
+import { Sector } from "../../World/index";
+import { WorldSimulationTools } from "./WorldSimulationTools";
+import { TaskRegister } from "../Tasks/TaskRegister";
+import { Threads } from "@amodx/threads";
+import { setLocationData } from "../../Util/LocationData";
+import { EngineSettings } from "../../Settings/EngineSettings";
+import { SnapShots } from "../../World/SnapShot/SnapShots";
+import LockSectors from "../../World/Lock/Function/LockSectors";
+import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
+export class WorldSimulationTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static worldLoadTasks = TaskRegister.addTasks({
+        id: "load",
+        generationTask: true,
+        checkInRequired: false,
+        async run(dimesnion, location, taskId, task) {
+            const [dimension, x, y, z] = location;
+            const sector = WorldRegister.sectors.get(location[0], x, y, z);
+            if (sector)
+                return task.completeTask(taskId);
+            if (!WorldSimulationTools.worldStorage) {
+                WorldRegister.sectors.new(location[0], x, y, z);
+                return task.completeTask(taskId);
+            }
+            const loaded = await WorldSimulationTools.worldStorage.loadSector([
+                dimension,
+                x,
+                y,
+                z,
+            ]);
+            if (!loaded) {
+                WorldRegister.sectors.new(location[0], x, y, z);
+            }
+            task.completeTask(taskId);
+        },
+    });
+    /**# Generate Sectors
+     * ---
+     */
+    static worldGenTasks = TaskRegister.addTasks({
+        id: "generate",
+        generationTask: true,
+        checkInRequired: true,
+        log: true,
+        checkDone(location) {
+            const sector = WorldRegister.sectors.get(...location);
+            if (!sector || sector.isCheckedOut())
+                return false;
+            const worldGenDone = sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
+            return worldGenDone;
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.generate.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
+        },
+    });
+    /**# Decorate Sectors
+     * ---
+     */
+    static worldDecorateTasks = TaskRegister.addTasks({
+        id: "decorate",
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
+            const sector = WorldRegister.sectors.get(...location);
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldDecorDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.decorate.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
+        },
+    });
+    /**# World Propagation
+     * ---
+     */
+    static worldPropagationTasks = TaskRegister.addTasks({
+        id: "world_propagation",
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
+            const sector = WorldRegister.sectors.get(...location);
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.propagation.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
+        },
+    });
+    /**# World Sun
+     * ---
+     */
+    static worldSunTasks = TaskRegister.addTasks({
+        id: "wolrd_sun",
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
+            const sector = WorldRegister.sectors.get(...location);
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldSunDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.worldSun.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
+        },
+    });
+    /**# Save Sector
+     * ---
+     */
+    static saveTasks = TaskRegister.addTasks({
+        id: "save",
+        checkInRequired: false,
+        async run(dimension, location, taskId, task) {
+            if (!WorldSimulationTools.worldStorage)
+                return task.completeTask(taskId);
+            await WorldSimulationTools.worldStorage.saveSector(location);
+            task.completeTask(taskId);
+        },
+    });
+    /**# Save & Unload Sector
+     * ---
+     */
+    static unloadTasks = TaskRegister.addTasks({
+        id: "unload",
+        checkInRequired: false,
+        async run(dimension, location, taskId, task) {
+            if (!WorldSimulationTools.worldStorage) {
+                WorldRegister.sectors.removeAt(location);
+                return task.completeTask(taskId);
+            }
+            await WorldSimulationTools.worldStorage.unloadSector(location);
+            task.completeTask(taskId);
+        },
+    });
+    /**# Build Task
+     * ---
+     */
+    static buildTasks = TaskRegister.addTasks({
+        id: "build_tasks",
+        sort: true,
+        checkInRequired: false,
+        run(dimension, location, taskId, task, simSector) {
+            simSector
+                .sector?.getSection(location[1], location[2], location[3])
+                ?.setInProgress(true);
+            if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+                task.completeTask(taskId);
+                WorldSimulationTools.taskTool.build.section.run(location);
+                return;
+            }
+            const [dim, x, y, z] = location;
+            LockSectors(dim, SnapShots.getSnapShotBounds(x, y, z)).then(() => {
+                task.completeTask(taskId);
+                const snapShot = SnapShots.createSnapShot(location);
+                WorldSimulationTools.taskTool.build.sectionSnapShot.run(...snapShot.transfer());
+                SnapShots.transferSnapShot(snapShot);
+                UnLockSectors(dim, SnapShots.getSnapShotBounds(x, y, z));
+            });
+        },
+    });
+    static unbuildTasks = TaskRegister.addTasks({
+        id: "unbuild_tasks",
+        sort: true,
+        checkInRequired: false,
+        run(dimension, location, taskId, task) {
+            const view = Threads.createBinaryTask(16);
+            setLocationData(view, location);
+            WorldSimulationTools.parent.runBinaryTask("remove-sector", view);
+            dimension.activeSectors.get(location[1], location[2], location[3])._rendered = false;
+            task.completeTask(taskId);
+        },
+    });
+}

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/WorldSimulation/Internal/runActiveSectorUpdate.d.ts

@@ -0,0 +1 @@
+export declare function runActiveSectorUpdate(): void;

package/WorldSimulation/Internal/runActiveSectorUpdate.js

@@ -0,0 +1,106 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldSimulationDimensions } from "./WorldSimulationDimensions";
+import { Circle, Square, Vector3Like } from "@amodx/math";
+import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
+import { WorldSimulationTasks } from "./WorldSimulationTasks";
+const sectorSquare = new Square();
+const tempPosition = Vector3Like.Create();
+const unrender = new Set();
+const render = new Set();
+const removedSectors = [];
+const queue = [];
+const vistedMap = new Set();
+export function runActiveSectorUpdate() {
+    sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
+    for (const [, dimension] of WorldSimulationDimensions._dimensions) {
+        for (let i = dimension.activeSectors._sectors.length - 1; i > -1; i--) {
+            const sector = dimension.activeSectors._sectors[i];
+            sector.generating = false;
+            sector.renderering = false;
+            sector.ticking = false;
+            const [cx, cy, cz] = sector.position;
+            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
+            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
+            for (let g = 0; g < dimension.generators.length; g++) {
+                const generator = dimension.generators[g];
+                generator._maxCircle.center.x =
+                    generator._sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+                generator._maxCircle.center.y =
+                    generator._sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+                if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._maxCircle)) {
+                    removedSectors.push(sector);
+                    dimension.activeSectors._map.delete(WorldSpaces.hash.hashXYZ(cx, cy, cz));
+                    dimension.activeSectors._sectors.splice(i, 1);
+                }
+            }
+        }
+        for (let g = 0; g < dimension.generators.length; g++) {
+            const generator = dimension.generators[g];
+            const sectorPosition = generator._sectorPosition;
+            queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+            generator._renderCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._renderCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            generator._genCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._genCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            generator._maxCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._maxCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            while (queue.length) {
+                const cx = queue.shift();
+                const cy = queue.shift();
+                const cz = queue.shift();
+                const key = WorldSpaces.hash.hashXYZ(cx, cy, cz);
+                if (vistedMap.has(key))
+                    continue;
+                vistedMap.add(key);
+                sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
+                sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
+                sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
+                if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._maxCircle))
+                    continue;
+                if (!dimension.activeSectors._map.has(key)) {
+                    dimension.activeSectors.add(cx, cy, cz);
+                }
+                const sector = dimension.activeSectors._map.get(key);
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._genCircle)) {
+                    sector.generating = true;
+                }
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._renderCircle)) {
+                    render.add(sector);
+                    unrender.delete(sector);
+                    sector.renderering = true;
+                }
+                else {
+                    if (!render.has(sector) && sector._rendered) {
+                        unrender.add(sector);
+                    }
+                }
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._tickCircle)) {
+                    sector.ticking = true;
+                }
+                for (let i = 0; i < MooreNeighborhood2D.length; i++) {
+                    const sectorPOS = WorldSpaces.sector.getPosition(cx + MooreNeighborhood2D[i][0] * WorldSpaces.sector.bounds.x, cy, cz + MooreNeighborhood2D[i][1] * WorldSpaces.sector.bounds.z, tempPosition);
+                    queue.push(sectorPOS.x, sectorPOS.y, sectorPOS.z);
+                }
+            }
+            vistedMap.clear();
+        }
+        for (const sector of unrender) {
+            WorldSimulationTasks.unbuildTasks.add(dimension.id, ...sector.position);
+        }
+        for (const removed of removedSectors) {
+            WorldSimulationTasks.unloadTasks.add(dimension.id, ...removed.position);
+        }
+        removedSectors.length = 0;
+        render.clear();
+        unrender.clear();
+        for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+            dimension.activeSectors._sectors[i].updateNeighbors();
+        }
+    }
+}

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

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

package/{Tasks/IWG → WorldSimulation}/Procedures/InitalLoad.js

@@ -1,6 +1,6 @@
-import { IWG } from "../IWG";
-import { IWGDimensions } from "../Internal/IWGDimensions";
-import { IWGTools } from "../Internal/IWGTools";
+import { WorldSimulation } from "../WorldSimulation";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
 import SaveAllSectors from "./SaveAllSectors";
 /**# InitalLoad
  * ---
@@ -8,30 +8,32 @@ import SaveAllSectors from "./SaveAllSectors";
  */
 export async function InitalLoad(props) {
     return new Promise((resolve) => {
-        const generator = IWG.createGenerator({
+        const generator = WorldSimulation.createGenerator({
             ...props.genData,
             building: false,
-            culling: false
+            culling: false,
         });
-        if (!IWGDimensions._dimensions.has(generator._dimension)) {
-            IWGDimensions.addDimension(generator._dimension);
+        if (!WorldSimulationDimensions._dimensions.has(generator._dimension)) {
+            WorldSimulationDimensions.addDimension(generator._dimension);
         }
-        const dimension = IWGDimensions.getDimension(props.dimension || "main");
+        const dimension = WorldSimulationDimensions.getDimension(props.dimension || 0);
         let done = false;
         generator._building = false;
-        IWG.addGenerator(generator);
+        WorldSimulation.addGenerator(generator);
         let timeOut = null;
         const update = () => {
             if (done)
                 return;
-            IWG.update();
+            WorldSimulation.tick(true);
             timeOut = setTimeout(update, 0);
         };
         update();
         const inte = setInterval(() => {
             let allDone = true;
             for (const [key, task] of dimension.tasks) {
-                if (task.waitingFor > 0 || task.queue.length > 0) {
+                if (!task.generationTask)
+                    continue;
+                if (task.waitingFor > 0 || task._task.size > 0) {
                     allDone = false;
                     break;
                 }
@@ -41,13 +43,13 @@ export async function InitalLoad(props) {
             done = true;
             clearInterval(inte);
             clearTimeout(timeOut);
-            IWG.removeGenerator(generator);
+            WorldSimulation.removeGenerator(generator);
             (async () => {
-                if (IWGTools.worldStorage) {
+                if (WorldSimulationTools.worldStorage) {
                     await SaveAllSectors();
                 }
                 resolve(true);
             })();
-        }, 100);
+        }, 250);
     });
 }