@divinevoxel/vlox 0.0.3 → 0.0.5

package/Tasks/IWG/Internal/Classes/SectorVisistedMap.js

@@ -0,0 +1,24 @@
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+const tempPosition = Vector3Like.Create();
+export class SectorVisistedMap {
+    _map = new Set();
+    get size() {
+        return this._map.size;
+    }
+    _getKey(x, y, z) {
+        return WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
+    }
+    has(x, y, z) {
+        return this._map.has(this._getKey(x, y, z));
+    }
+    add(x, y, z) {
+        this._map.add(this._getKey(x, y, z));
+    }
+    remove(x, y, z) {
+        this._map.delete(this._getKey(x, y, z));
+    }
+    clear() {
+        this._map.clear();
+    }
+}

package/Tasks/IWG/Internal/Functions/cullSectors.d.ts

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

package/Tasks/IWG/Internal/Functions/cullSectors.js

@@ -0,0 +1,112 @@
+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";
+const sectorSquare = new Square();
+export function cullSectors(generatos, cullGenerators) {
+    const time = performance.now();
+    for (const [, dimension] of IWGDimensions._dimensions) {
+        for (let i = dimension.unRenderQueue.nodes.length - 1; i > -1; i--) {
+            const node = dimension.unRenderQueue.nodes[i];
+            const [cx, cy, cz] = node.position;
+            sectorSquare.center.x =
+                node.position[0] + WorldSpaces.sector.bounds.x / 2;
+            sectorSquare.center.y =
+                node.position[2] + WorldSpaces.sector.bounds.z / 2;
+            let inRenderCircle = false;
+            for (const gen of generatos) {
+                if (gen._dimension != dimension.id)
+                    continue;
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._renderCircle)) {
+                    inRenderCircle = true;
+                }
+            }
+            if (inRenderCircle) {
+                dimension.unRenderQueue.removeIndex(i);
+                continue;
+            }
+            const delta = time - node.time;
+            if (delta > 5_000) {
+                dimension.rendered.remove(cx, cy, cz);
+                dimension.inProgress.add(cx, cy, cz);
+                IWGTools.parent
+                    .runTaskAsync("remove-sector", [dimension.id, cx, cy, cz])
+                    .then(() => {
+                    dimension.inProgress.remove(cx, cy, cz);
+                });
+                dimension.unRenderQueue.removeIndex(i);
+            }
+        }
+        for (let i = dimension.unLoadQueue.nodes.length - 1; i > -1; i--) {
+            const node = dimension.unLoadQueue.nodes[i];
+            const [cx, cy, cz] = node.position;
+            sectorSquare.center.x =
+                node.position[0] + WorldSpaces.sector.bounds.x / 2;
+            sectorSquare.center.y =
+                node.position[2] + WorldSpaces.sector.bounds.z / 2;
+            let inMaxCircle = false;
+            for (const gen of generatos) {
+                if (gen._dimension != dimension.id)
+                    continue;
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._maxCircle)) {
+                    inMaxCircle = true;
+                }
+            }
+            if (inMaxCircle) {
+                dimension.unLoadQueue.removeIndex(i);
+                continue;
+            }
+            const delta = time - node.time;
+            if (delta > 5_000) {
+                dimension.unLoadQueue.removeIndex(i);
+                if (IWGTools.worldStorage) {
+                    dimension.inProgress.add(cx, cy, cz);
+                    IWGTools.worldStorage
+                        .unloadSector([dimension.id, cx, cy, cz])
+                        .finally(() => {
+                        dimension.inProgress.remove(cx, cy, cz);
+                    });
+                }
+                else {
+                    WorldRegister.sectors.remove(cx, cy, cz);
+                }
+            }
+        }
+        if (!cullGenerators.length)
+            continue;
+        WorldRegister.setDimension(dimension.id);
+        const worldDimension = WorldRegister.dimensions.get(dimension.id);
+        for (const [, sector] of worldDimension.sectors) {
+            const [cx, cy, cz] = sector.position;
+            sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
+            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
+            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
+            let inRenderCircle = false;
+            let inMaxCircle = false;
+            if (WorldLock.isLocked([dimension.id, cx, cy, cz]))
+                continue;
+            if (dimension.inProgress.has(cx, cy, cz))
+                continue;
+            for (const gen of cullGenerators) {
+                if (gen._dimension != dimension.id)
+                    continue;
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._renderCircle)) {
+                    inRenderCircle = true;
+                }
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._maxCircle)) {
+                    inMaxCircle = true;
+                }
+            }
+            if (inRenderCircle && inMaxCircle)
+                continue;
+            if (!inRenderCircle && !dimension.unRenderQueue.inMap(sector)) {
+                dimension.unRenderQueue.addSector(sector);
+            }
+            if (!inMaxCircle && !dimension.unLoadQueue.inMap(sector)) {
+                dimension.unLoadQueue.addSector(sector);
+            }
+        }
+    }
+}

package/Tasks/IWG/Internal/Functions/getSectorState.d.ts

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

package/Tasks/IWG/Internal/Functions/getSectorState.js

@@ -0,0 +1,42 @@
+import { WorldRegister } from "../../../../World/WorldRegister";
+import { SectorStateStructIds } from "../../../../World/Sector/SectorStructIds";
+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) {
+    state.resset();
+    const [cx, cy, cz] = sector.position;
+    Sector.StateStruct.setData(sector.sectorState);
+    for (let i = 0; i < $2dMooreNeighborhood.length; i++) {
+        const sectorPOS = WorldSpaces.sector.getPosition(cx + $2dMooreNeighborhood[i][0] * WorldSpaces.sector.bounds.x, cy, cz + $2dMooreNeighborhood[i][1] * WorldSpaces.sector.bounds.z, tempPosition);
+        if (!segment.vistedMap.has(sectorPOS.x, cy, sectorPOS.z)) {
+            segment.queue.push(sectorPOS.x, cy, sectorPOS.z);
+        }
+        const sector = WorldRegister.sectors.get(sectorPOS.x, cy, sectorPOS.z);
+        if (!sector) {
+            state.genAlldone = false;
+            state.nWorldGenAllDone = false;
+            state.nPropagtionAllDone = false;
+            state.nSunAllDone = false;
+            state.nDecorAllDone = false;
+            state.allLoaded = false;
+            break;
+        }
+        Sector.StateStruct.setData(sector.sectorState);
+        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+            state.nWorldGenAllDone = false;
+        }
+        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+            state.nDecorAllDone = false;
+        }
+        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+            state.nSunAllDone = false;
+        }
+        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+            state.nPropagtionAllDone = false;
+        }
+    }
+    return state;
+}

package/Tasks/IWG/Internal/Functions/runBuildUpdate.d.ts

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

package/Tasks/IWG/Internal/Functions/runBuildUpdate.js

@@ -0,0 +1,52 @@
+import { Circle, Square } from "@amodx/math";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { SectorState } from "../Classes/SectorState";
+import { WorldRegister } from "../../../../World/WorldRegister";
+import { getSectorState } from "./getSectorState";
+import { IWGTasks } from "../IWGTasks";
+import { IWGDimensions } from "../IWGDimensions";
+const stateCursor = new SectorState();
+const sectorSquare = new Square();
+export function runBuildUpdate(generators) {
+    for (const generator of generators) {
+        if (!generator._building)
+            continue;
+        const segment = IWGDimensions._dimensions.get(generator._dimension);
+        if (!segment)
+            throw new Error(`No segment for dimensions ${generator._dimension} found.`);
+        const queue = segment.queue;
+        const visitedMap = segment.vistedMap;
+        const sectorPosition = generator._sectorPosition;
+        queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        generator._renderCircle.center.x = sectorPosition.x;
+        generator._renderCircle.center.y = sectorPosition.z;
+        while (queue.length) {
+            const cx = queue.shift();
+            const cy = queue.shift();
+            const cz = queue.shift();
+            if (visitedMap.has(cx, cy, cz))
+                continue;
+            visitedMap.add(cx, cy, cz);
+            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._renderCircle))
+                continue;
+            WorldRegister.setDimension(generator._dimension);
+            const sector = WorldRegister.sectors.get(cx, cy, cz);
+            if (!sector)
+                continue;
+            const state = getSectorState(sector, stateCursor, segment);
+            if (state.nWorldGenAllDone &&
+                state.nSunAllDone &&
+                state.nPropagtionAllDone) {
+                if (segment.rendered.has(cx, cy, cz))
+                    continue;
+                IWGTasks.buildTasks.add(generator._dimension, cx, cy, cz);
+            }
+        }
+    }
+    for (const [, dimension] of IWGDimensions._dimensions) {
+        dimension.vistedMap.clear();
+    }
+}

package/Tasks/IWG/Internal/Functions/runWorldUpdate.d.ts

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

package/Tasks/IWG/Internal/Functions/runWorldUpdate.js

@@ -0,0 +1,71 @@
+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 { SectorStateStructIds } from "../../../../World/Sector/SectorStructIds";
+import { WorldLock } from "../../../../World/Lock/WorldLock";
+import { IWGTasks } from "../IWGTasks";
+import { IWGDimensions } from "../IWGDimensions";
+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);
+        if (!segment)
+            throw new Error(`No segment for dimensions ${generator._dimension} found.`);
+        const queue = segment.queue;
+        const vistedMap = segment.vistedMap;
+        const sectorPosition = generator._sectorPosition;
+        queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        generator._genCircle.center.x = sectorPosition.x;
+        generator._genCircle.center.y = sectorPosition.z;
+        while (queue.length) {
+            const cx = queue.shift();
+            const cy = queue.shift();
+            const cz = queue.shift();
+            if (WorldLock.isLocked([generator._dimension, cx, cy, cz]) ||
+                segment.inProgress.has(cx, cy, cz) ||
+                vistedMap.has(cx, cy, cz))
+                continue;
+            vistedMap.add(cx, cy, cz);
+            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._genCircle))
+                continue;
+            WorldRegister.setDimension(generator._dimension);
+            const sector = WorldRegister.sectors.get(cx, cy, cz);
+            if (!sector) {
+                IWGTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            const state = getSectorState(sector, stateCursor, segment);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (state.allLoaded &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+                IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nWorldGenAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+                IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nDecorAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+                IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nPropagtionAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+                IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+        }
+    }
+    for (const [key, dimension] of IWGDimensions._dimensions) {
+        dimension.vistedMap.clear();
+    }
+}

package/Tasks/IWG/Internal/IWGDimensions.d.ts

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

package/Tasks/IWG/Internal/IWGDimensions.js

@@ -0,0 +1,17 @@
+import { DimensionSegment } from "./Classes/DimensionSegment";
+import { TaskRegister } from "./TaskRegister";
+export class IWGDimensions {
+    static _dimensions = new Map();
+    static addDimension(dimensionId) {
+        const segment = new DimensionSegment(dimensionId);
+        TaskRegister.addToDimension(segment);
+        this._dimensions.set(dimensionId, segment);
+    }
+    static getDimension(dimensionId) {
+        const dimension = this._dimensions.get(dimensionId);
+        if (!dimension) {
+            throw new Error(`Dimension with id [${dimensionId}] is not registered`);
+        }
+        return dimension;
+    }
+}

package/Tasks/IWG/Internal/IWGTasks.d.ts

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

package/Tasks/IWG/Internal/IWGTasks.js

@@ -0,0 +1,154 @@
+import { WorldRegister } from "../../../World/WorldRegister";
+import { Sector } from "../../../World/index";
+import { SectorStateStructIds } from "../../../World/Sector/SectorStructIds";
+import { IWGTools } from "./IWGTools";
+import { TaskRegister } from "./TaskRegister";
+export class IWGTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static worldLoadTasks = TaskRegister.addTasks({
+        id: "load",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const [dimension, x, y, z] = location;
+            WorldRegister.setDimension(location[0]);
+            const sector = WorldRegister.sectors.get(x, y, z);
+            if (sector)
+                return onDone();
+            if (!IWGTools.worldStorage) {
+                WorldRegister.sectors.new(x, y, z);
+                return onDone();
+            }
+            const loaded = await IWGTools.worldStorage.loadSector([
+                dimension,
+                x,
+                y,
+                z,
+            ]);
+            if (!loaded) {
+                WorldRegister.setDimension(location[0]);
+                WorldRegister.sectors.new(x, y, z);
+            }
+            onDone();
+        },
+    });
+    /**# Generate Sectors
+     * ---
+     */
+    static worldGenTasks = TaskRegister.addTasks({
+        id: "generate",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            WorldRegister.setDimension(location[0]);
+            const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone))
+                return onDone();
+            IWGTools.taskTool.generate.run([location, []], null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldGenDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# Decorate Sectors
+     * ---
+     */
+    static worldDecorateTasks = TaskRegister.addTasks({
+        id: "decorate",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            WorldRegister.setDimension(location[0]);
+            const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone))
+                return onDone();
+            IWGTools.taskTool.decorate.run([location, []], null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldDecorDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# World Sun
+     * ---
+     */
+    static worldSunTasks = TaskRegister.addTasks({
+        id: "wolrd_sun",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            WorldRegister.setDimension(location[0]);
+            const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone))
+                return onDone();
+            IWGTools.taskTool.worldSun.run(location, null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldSunDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# World Propagation
+     * ---
+     */
+    static worldPropagationTasks = TaskRegister.addTasks({
+        id: "propagation",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            WorldRegister.setDimension(location[0]);
+            const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone))
+                return onDone();
+            IWGTools.taskTool.propagation.run(location, null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldPropagationDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# Save Sector
+     * ---
+     */
+    static saveTasks = TaskRegister.addTasks({
+        id: "save",
+        async run(location, onDone) {
+            if (!IWGTools.worldStorage)
+                return onDone();
+            await IWGTools.worldStorage.saveSector(location);
+            onDone();
+        },
+    });
+    /**# Save & Unload Sector
+     * ---
+     */
+    static saveAndUnloadTasks = TaskRegister.addTasks({
+        id: "save_and_unload",
+        async run(location, onDone) {
+            if (!IWGTools.worldStorage)
+                return onDone();
+            await IWGTools.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/Tasks/IWG/Internal/IWGTools.d.ts

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

package/Tasks/IWG/Internal/IWGTools.js

@@ -0,0 +1,5 @@
+export class IWGTools {
+    static taskTool;
+    static worldStorage = null;
+    static parent;
+}

package/Tasks/IWG/Internal/TaskRegister.d.ts

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

package/Tasks/IWG/Internal/TaskRegister.js

@@ -0,0 +1,14 @@
+import { IWGTaskBase } from "./Classes/IWGTaskBase";
+export class TaskRegister {
+    static tasks = [];
+    static addTasks(data) {
+        const newTask = new IWGTaskBase(data);
+        this.tasks.push(newTask);
+        return newTask;
+    }
+    static addToDimension(dimension) {
+        for (const task of this.tasks) {
+            dimension.addTask(task.data.id);
+        }
+    }
+}

package/Tasks/IWG/Procedures/InitalLoad.d.ts

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

package/Tasks/IWG/Procedures/InitalLoad.js

@@ -0,0 +1,53 @@
+import { IWG } from "../IWG";
+import { IWGDimensions } from "../Internal/IWGDimensions";
+import { IWGTools } from "../Internal/IWGTools";
+import SaveAllSectors from "./SaveAllSectors";
+/**# InitalLoad
+ * ---
+ * Load the world without building.
+ */
+export async function InitalLoad(props) {
+    return new Promise((resolve) => {
+        const generator = IWG.createGenerator({
+            ...props.genData,
+            building: false,
+            culling: false
+        });
+        if (!IWGDimensions._dimensions.has(generator._dimension)) {
+            IWGDimensions.addDimension(generator._dimension);
+        }
+        const dimension = IWGDimensions.getDimension(props.dimension || "main");
+        let done = false;
+        generator._building = false;
+        IWG.addGenerator(generator);
+        let timeOut = null;
+        const update = () => {
+            if (done)
+                return;
+            IWG.update();
+            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) {
+                    allDone = false;
+                    break;
+                }
+            }
+            if (!allDone)
+                return;
+            done = true;
+            clearInterval(inte);
+            clearTimeout(timeOut);
+            IWG.removeGenerator(generator);
+            (async () => {
+                if (IWGTools.worldStorage) {
+                    await SaveAllSectors();
+                }
+                resolve(true);
+            })();
+        }, 100);
+    });
+}

package/Tasks/IWG/Procedures/SaveAllSectors.d.ts

@@ -0,0 +1,5 @@
+/**# Save All Sectors
+ * ---
+ * Save all sectors that are loaded.
+ */
+export default function SaveAllSectors(): Promise<void>;