@divinevoxel/vlox 0.0.73 → 0.0.74

package/World/WorldSpaces.js

@@ -140,17 +140,17 @@ export class WorldSpaces {
 EngineSettings.addEventListener("synced", (event) => {
     const { settings } = event.detail.settings;
     WorldBounds.setWorldBounds(settings.world.min.x, settings.world.min.y, settings.world.min.z, settings.world.max.x, settings.world.max.y, settings.world.max.z);
-    SectorSpace.power2Axes.x = settings.sectors.power2Size.x;
-    SectorSpace.power2Axes.y = settings.sectors.power2Size.y;
-    SectorSpace.power2Axes.z = settings.sectors.power2Size.z;
+    SectorSpace.power2Axes.x = settings.world.sectorPower2Size.x;
+    SectorSpace.power2Axes.y = settings.world.sectorPower2Size.y;
+    SectorSpace.power2Axes.z = settings.world.sectorPower2Size.z;
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
     SectorSpace.volumne =
         SectorSpace.bounds.x * SectorSpace.bounds.y * SectorSpace.bounds.z;
-    SectionSpace.power2Axes.x = settings.sections.power2Size.x;
-    SectionSpace.power2Axes.y = settings.sections.power2Size.y;
-    SectionSpace.power2Axes.z = settings.sections.power2Size.z;
+    SectionSpace.power2Axes.x = settings.world.sectionPower2Size.x;
+    SectionSpace.power2Axes.y = settings.world.sectionPower2Size.y;
+    SectionSpace.power2Axes.z = settings.world.sectionPower2Size.z;
     SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
     SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;

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

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

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

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

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

@@ -1,11 +1,12 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { BuildQueue } from "./BuildQueue";
+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;
@@ -17,9 +18,9 @@ export class Generator {
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
     buildQueue;
+    logicQueue;
     constructor(taskTool, data) {
         this.taskTool = taskTool;
-        console.warn("make generator", taskTool);
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -29,6 +30,7 @@ export class Generator {
         this._genCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
         this.buildQueue = new BuildQueue(taskTool);
+        this.logicQueue = new LogicQueue(taskTool);
     }
     update() {
         this._positonChanged = false;
@@ -47,7 +49,9 @@ export class Generator {
     tick() {
         if (this._building) {
             this.buildQueue.sort(this.position.x, this.position.y, this.position.z);
-            this.buildQueue.run(25);
+            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/{Tasks/IWG/Internal/Classes/BuildQueue.js → WorldSimulation/Internal/Classes/TickQueue.js}

@@ -1,17 +1,23 @@
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-export class BuildQueue {
+import { WorldSpaces } from "../../../World/WorldSpaces";
+const pool = [];
+export class TickQueue {
     tasks;
     hash = new Set();
     sections = [];
     constructor(tasks) {
         this.tasks = tasks;
     }
-    add(data) {
-        const key = WorldSpaces.hash.hashXYZ(data[1], data[2], data[3]);
+    add(dimension, x, y, z) {
+        const key = WorldSpaces.hash.hashXYZ(x, y, z);
         if (this.hash.has(key))
             return false;
         this.hash.add(key);
-        this.sections.push(data);
+        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;
@@ -33,15 +39,18 @@ export class BuildQueue {
             }
             i--;
         }
+        return sections;
     }
     run(limit = 25) {
         let count = 0;
         while (this.sections.length) {
             const vec = this.sections.shift();
-            const [dimension, x, y, z] = vec;
-            this.tasks.build.section.run([dimension, x, y, z]);
+            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;

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,32 +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 { IWGDimensions } from "../IWGDimensions";
+import { WorldSimulationDimensions } from "../WorldSimulationDimensions";
 const stateCursor = new SectorState();
 const sectorSquare = new Square();
-function run(dimenion, sector, location, generator) {
+function buildCheck(dimenion, sector, generator, x, y, z) {
     let rendered = true;
-    if (!dimenion.rendered.has(location[1], location[2], location[3])) {
+    if (!dimenion.rendered.has(x, y, z)) {
         rendered = false;
-        dimenion.rendered.add(location[1], location[2], location[3]);
+        dimenion.rendered.add(x, y, z);
     }
     for (const section of sector.getRenerableSections()) {
-        if (rendered && (section.isInProgress() || !section.isDirty()))
+        if (rendered && (section.isInProgress() || !section.isDisplayDirty()))
             continue;
         section.setInProgress(true);
-        generator.buildQueue.add([
-            location[0],
-            ...section.getPosition(),
-        ]);
+        generator.buildQueue.add(dimenion.id, ...section.position);
     }
 }
-export function runBuildUpdate(generators) {
+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;
@@ -54,17 +61,20 @@ export function runBuildUpdate(generators) {
             if (state.nWorldGenAllDone &&
                 state.nSunAllDone &&
                 state.nPropagtionAllDone) {
-                if (sector.anySectionDirty()) {
-                    run(segment, sector, [generator._dimension, cx, cy, cz], generator);
+                if (!segment.rendered.has(cx, cy, cz)) {
+                    buildCheck(segment, sector, generator, cx, cy, cz);
                     continue;
                 }
-                if (segment.rendered.has(cx, cy, cz))
-                    continue;
-                run(segment, sector, [generator._dimension, cx, cy, cz], generator);
+                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;
+}