@divinevoxel/vlox 0.0.73 → 0.0.74

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,9 +120,9 @@ 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();
         },
     });

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>;

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,23 +8,23 @@ 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
         });
-        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.update();
             timeOut = setTimeout(update, 0);
         };
         update();
@@ -41,9 +41,9 @@ 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);

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

@@ -1,16 +1,16 @@
-import { WorldRegister } from "../../../World/WorldRegister";
-import { IWGDimensions } from "../Internal/IWGDimensions";
-import { IWGTools } from "../Internal/IWGTools";
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
 /**# Save All Sectors
  * ---
  * Save all sectors that are loaded.
  */
 export default async function SaveAllSectors() {
-    const worldStorage = IWGTools.worldStorage;
+    const worldStorage = WorldSimulationTools.worldStorage;
     if (!worldStorage)
         return;
     const proms = [];
-    for (const [dimensionId] of IWGDimensions._dimensions) {
+    for (const [dimensionId] of WorldSimulationDimensions._dimensions) {
         const dimension = WorldRegister.dimensions.get(dimensionId);
         for (const [key, sector] of dimension.sectors) {
             if (sector.isStored())

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

@@ -1,9 +1,9 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { WorldStorageInterface } from "../../World/Types/WorldStorage.interface";
+import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Internal/Classes/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
-interface IWGInitData {
+interface WorldSimulationInitData {
     parent: Thread;
     threads: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
@@ -11,15 +11,15 @@ interface IWGInitData {
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
  */
-export declare class IWG {
+export declare class WorldSimulation {
     private static _cullGenerators;
     static readonly _generators: Generator[];
-    static addDimension(id: string): void;
+    static addDimension(id: number): void;
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
     };
-    static init(data: IWGInitData): void;
+    static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
     static removeGenerator(generator: Generator): boolean;

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

@@ -1,10 +1,10 @@
-import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { TaskTool } from "../Tools/Tasks/TasksTool";
 import { Generator } from "./Internal/Classes/Generator";
 import { runWorldUpdate } from "./Internal/Functions/runWorldUpdate";
-import { IWGTasks } from "./Internal/IWGTasks";
-import { runBuildUpdate } from "./Internal/Functions/runBuildUpdate";
-import { IWGTools } from "./Internal/IWGTools";
-import { IWGDimensions } from "./Internal/IWGDimensions";
+import { WorldSimulationTasks } from "./Internal/WorldSimulationTasks";
+import { runTickUpdate } from "./Internal/Functions/runTickUpdate";
+import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
+import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
 import { cullSectors } from "./Internal/Functions/cullSectors";
 import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
@@ -13,11 +13,11 @@ let initalized = false;
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
  */
-export class IWG {
+export class WorldSimulation {
     static _cullGenerators = [];
     static _generators = [];
     static addDimension(id) {
-        IWGDimensions.addDimension(id);
+        WorldSimulationDimensions.addDimension(id);
     }
     static Procedures = {
         InitalLoad,
@@ -25,16 +25,16 @@ export class IWG {
     };
     static init(data) {
         initalized = true;
-        IWGTools.parent = data.parent;
-        IWGTools.taskTool = new TaskTool(data.threads);
+        WorldSimulationTools.parent = data.parent;
+        WorldSimulationTools.taskTool = new TaskTool(data.threads);
         if (data.worldStorage)
-            IWGTools.worldStorage = data.worldStorage;
+            WorldSimulationTools.worldStorage = data.worldStorage;
     }
     static createGenerator(data) {
         if (!initalized)
             throw new Error(`IWG must be initalized first before creating generator`);
-        return new Generator(IWGTools.taskTool, {
-            dimension: data.dimension ? data.dimension : "main",
+        return new Generator(WorldSimulationTools.taskTool, {
+            dimension: data.dimension ? data.dimension : 0,
             position: data.position ? data.position : Vector3Like.Create(),
             renderRadius: data.renderRadius ? data.renderRadius : 150,
             generationRadius: data.generationRadius ? data.generationRadius : 250,
@@ -82,17 +82,17 @@ export class IWG {
                 }
             }
         }
-        runBuildUpdate(this._generators);
+        runTickUpdate(this._generators);
         //  IWGTasks.buildTasks.runTask();
         runWorldUpdate(this._generators);
-        IWGTasks.worldLoadTasks.runTask();
-        IWGTasks.worldGenTasks.runTask();
-        IWGTasks.worldDecorateTasks.runTask();
-        IWGTasks.worldSunTasks.runTask();
-        IWGTasks.worldPropagationTasks.runTask();
-        IWGTasks.saveTasks.runTask();
-        IWGTasks.saveAndUnloadTasks.runTask();
+        WorldSimulationTasks.worldLoadTasks.runTask();
+        WorldSimulationTasks.worldGenTasks.runTask();
+        WorldSimulationTasks.worldDecorateTasks.runTask();
+        WorldSimulationTasks.worldSunTasks.runTask();
+        WorldSimulationTasks.worldPropagationTasks.runTask();
+        WorldSimulationTasks.saveTasks.runTask();
+        WorldSimulationTasks.saveAndUnloadTasks.runTask();
         cullSectors(this._generators, this._cullGenerators);
     }
 }
-IWG.addDimension("main");
+WorldSimulation.addDimension(0);

package/{Tasks/IWG → WorldSimulation}/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/{Tasks/IWG → WorldSimulation}/index.js

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Tasks/IWG/Internal/Classes/BuildQueue.d.ts

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

package/Tasks/IWG/Internal/Classes/IWGTaskBase.d.ts

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

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

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

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

@@ -1,6 +0,0 @@
-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/IWGTasks.d.ts

@@ -1,30 +0,0 @@
-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;
-}

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

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