@divinevoxel/vlox 0.0.74 → 0.0.76

package/WorldSimulation/Voxels/Behaviors/Types/FarmlandVoxelBehavior.js

@@ -0,0 +1,73 @@
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+const levelChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+VoxelBehaviorsRegister.register({
+    type: "dve_farmland",
+    onTick(simulation, voxel, x, y, z) {
+        let currentLevel = voxel.getLevel();
+        let foundHigherLevel = false;
+        let maxLevel = -1;
+        for (let i = 0; i < 4; i++) {
+            const nx = levelChecks[i][0] + x;
+            const ny = levelChecks[i][1] + y;
+            const nz = levelChecks[i][2] + z;
+            const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel)
+                continue;
+            if (!nVoxel.isSameVoxel(voxel) && !nVoxel.substanceTags["dve_is_liquid"])
+                continue;
+            const nLevel = nVoxel.getLevel();
+            if (currentLevel < nLevel) {
+                foundHigherLevel = true;
+            }
+            if (maxLevel < nLevel) {
+                maxLevel = nLevel;
+            }
+        }
+        maxLevel = Math.max(0, maxLevel - 1);
+        if (!foundHigherLevel) {
+            if (currentLevel == 0) {
+                if (Math.random() > 0.1)
+                    return;
+                const upVoxel = simulation.nDataCursor.getVoxel(x, y + 1, z);
+                if (upVoxel && upVoxel.tags["dve_simulation_behavior"] == "dve_crop") {
+                    return;
+                }
+                //turn to dirt
+                voxel.setStringId("dve_dirt");
+                voxel.setState(0);
+                voxel.setMod(0);
+                simulation.bounds.updateDisplay(x, y, z);
+                return;
+            }
+            const newLevel = currentLevel - 1;
+            if (newLevel == 0) {
+                voxel.setState(voxel.schema.state
+                    .startEncoding(voxel.getState())
+                    .setValue("moist", "false")
+                    .getEncoded());
+                simulation.bounds.updateDisplay(x, y, z);
+            }
+            voxel.setLevel(newLevel);
+            return;
+        }
+        if (foundHigherLevel) {
+            if (currentLevel < maxLevel) {
+                const newLevel = currentLevel + 1;
+                if (currentLevel == 0) {
+                    voxel.setState(voxel.schema.state
+                        .startEncoding(voxel.getState())
+                        .setValue("moist", "true")
+                        .getEncoded());
+                    simulation.bounds.updateDisplay(x, y, z);
+                }
+                voxel.setLevel(newLevel);
+                return;
+            }
+        }
+    },
+});

package/WorldSimulation/Voxels/Behaviors/Types/LiquidVoxelBehavior.d.ts

@@ -0,0 +1 @@
+export {};

package/WorldSimulation/Voxels/Behaviors/Types/LiquidVoxelBehavior.js

@@ -0,0 +1,21 @@
+import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+VoxelBehaviorsRegister.register({
+    type: "dve_liquid",
+    onPaint(simulation, voxel, x, y, z) {
+        simulation.scheduleUpdate("dve_liquid", x, y, z, 0);
+    },
+    onErase(simulation, voxel, x, y, z) {
+        voxel.setLevelState(2);
+        for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
+            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel || !nVoxel.substanceTags["dve_is_liquid"])
+                continue;
+            simulation.scheduleUpdate("dve_liquid", nx, ny, nz, 0);
+        }
+        simulation.scheduleUpdate("dve_liquid", x, y, z, 10);
+    },
+});

package/WorldSimulation/Voxels/Behaviors/Types/index.d.ts

@@ -0,0 +1,4 @@
+import "./DefaultVoxelBehavior";
+import "./LiquidVoxelBehavior";
+import "./FarmlandVoxelBehavior";
+import "./CropVoxelBehavior";

package/WorldSimulation/Voxels/Behaviors/Types/index.js

@@ -0,0 +1,4 @@
+import "./DefaultVoxelBehavior";
+import "./LiquidVoxelBehavior";
+import "./FarmlandVoxelBehavior";
+import "./CropVoxelBehavior";

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.d.ts

@@ -0,0 +1,18 @@
+import { DimensionSimulation } from "../../Dimensions/DimensionSimulation";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+export interface VoxelBehaviorsData {
+    type: string;
+    inherits?: string;
+    onInteract?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onPaint?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onErase?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onTick?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+}
+export declare class VoxelBehavior {
+    data: VoxelBehaviorsData;
+    constructor(data: VoxelBehaviorsData);
+    onInteract(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onPaint(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onErase(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onTick(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.js

@@ -0,0 +1,30 @@
+export class VoxelBehavior {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    onInteract(simulation, x, y, z) {
+        if (!this.data.onInteract)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onInteract(simulation, voxel, x, y, z);
+    }
+    onPaint(simulation, x, y, z) {
+        if (!this.data.onPaint)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onPaint(simulation, voxel, x, y, z);
+    }
+    onErase(simulation, x, y, z) {
+        if (!this.data.onErase)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onErase(simulation, voxel, x, y, z);
+    }
+    onTick(simulation, x, y, z) {
+        if (!this.data.onTick)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onTick(simulation, voxel, x, y, z);
+    }
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviorsRegister.d.ts

@@ -0,0 +1,6 @@
+import { VoxelBehavior, VoxelBehaviorsData } from "./VoxelBehaviors";
+export declare class VoxelBehaviorsRegister {
+    static behaviors: Map<string, VoxelBehavior>;
+    static register(data: VoxelBehaviorsData): void;
+    static get(type: string): VoxelBehavior;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviorsRegister.js

@@ -0,0 +1,25 @@
+import { VoxelBehavior } from "./VoxelBehaviors";
+export class VoxelBehaviorsRegister {
+    static behaviors = new Map();
+    static register(data) {
+        if (!data.inherits && data.type != "dve_default")
+            data.inherits = "dve_default";
+        if (data.inherits) {
+            const otherType = this.get(data.inherits);
+            for (const key in otherType) {
+                if (key == "type" || key == "inherits")
+                    continue;
+                if (!data[key] && otherType[key]) {
+                    data[key] = otherType[key];
+                }
+            }
+        }
+        this.behaviors.set(data.type, new VoxelBehavior(data));
+    }
+    static get(type) {
+        const behavior = this.behaviors.get(type);
+        if (!behavior)
+            throw new Error(`Voxel behavior ${type} does not exist`);
+        return behavior;
+    }
+}

package/WorldSimulation/Voxels/Behaviors/VoxelUpdate.d.ts

@@ -0,0 +1,10 @@
+import { VoxelFaceNames } from "../../../Math";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+export interface VoxelUpdate {
+    priority: number;
+    source: VoxelCursorInterface;
+    direction: VoxelFaceNames;
+    x: number;
+    y: number;
+    z: number;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelUpdate.js

@@ -0,0 +1 @@
+export {};

package/WorldSimulation/Voxels/Behaviors/index.d.ts

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelBehaviorsRegister";
+export * from "./VoxelBehaviors";
+export * from "./VoxelUpdate";

package/WorldSimulation/Voxels/Behaviors/index.js

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelBehaviorsRegister";
+export * from "./VoxelBehaviors";
+export * from "./VoxelUpdate";

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.d.ts

@@ -0,0 +1 @@
+export {};

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.js

@@ -0,0 +1,163 @@
+import { VoxelTickUpdateRegister } from "../VoxelTickUpdateRegister";
+import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+const floodOutChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+const determineLevelChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [0, 1, 0],
+];
+function determineLiquidLevel(simulation, sourceVoxel, x, y, z) {
+    const originalLevel = sourceVoxel.getLevel();
+    if (sourceVoxel.getLevelState() == 1) {
+        const upVoxel = simulation.nDataCursor.getVoxel(x, y + 1, z);
+        if (!upVoxel || !upVoxel.isSameVoxel(sourceVoxel))
+            return Infinity;
+        return 7;
+    }
+    if (originalLevel == 7)
+        return 7;
+    let highestNeighborLevel = -1;
+    let foundHigherLevel = false;
+    for (let i = 0; i < determineLevelChecks.length; i++) {
+        const nx = x + determineLevelChecks[i][0];
+        const ny = y + determineLevelChecks[i][1];
+        const nz = z + determineLevelChecks[i][2];
+        const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+        if (!voxel || !voxel.isSameVoxel(sourceVoxel))
+            continue;
+        const neighborLevel = voxel.getLevel();
+        if (neighborLevel > originalLevel) {
+            foundHigherLevel = true;
+        }
+        if (neighborLevel > highestNeighborLevel) {
+            highestNeighborLevel = neighborLevel;
+        }
+    }
+    if (!foundHigherLevel) {
+        return Infinity;
+    }
+    if (highestNeighborLevel <= originalLevel) {
+        return originalLevel;
+    }
+    return Math.max(0, highestNeighborLevel - 1);
+}
+VoxelTickUpdateRegister.registerType({
+    type: "dve_liquid",
+    run(simulation, voxel, update) {
+        const { x, y, z } = update;
+        const liquidUpdateRate = 3;
+        const currentLevel = voxel.getLevel();
+        const levelState = voxel.getLevelState();
+        if (levelState == 1 && currentLevel < 7) {
+            voxel.setLevel(currentLevel + 1);
+            voxel.updateVoxel(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+            return;
+        }
+        if (levelState == 2) {
+            voxel.setLevelState(0);
+            voxel.updateVoxel(0);
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const nx = x + CardinalNeighbors3D[i][0];
+                const ny = y + CardinalNeighbors3D[i][1];
+                const nz = z + CardinalNeighbors3D[i][2];
+                const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                if (!voxel || !voxel.substanceTags["dve_is_liquid"])
+                    continue;
+                simulation.scheduleUpdate("dve_liquid", nx, ny, nz, 0);
+            }
+            return;
+        }
+        if (currentLevel == 0) {
+            const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+            if (downVoxel &&
+                downVoxel.isSameVoxel(voxel) &&
+                downVoxel.getLevelState() == 1) {
+                simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
+            }
+            voxel.setAir();
+            voxel.setLevel(0);
+            voxel.updateVoxel(1);
+            simulation.bounds.updateDisplay(x, y, z);
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const nx = x + CardinalNeighbors3D[i][0];
+                const ny = y + CardinalNeighbors3D[i][1];
+                const nz = z + CardinalNeighbors3D[i][2];
+                const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                voxel?.updateVoxel(2);
+            }
+            return;
+        }
+        const finalLevel = determineLiquidLevel(simulation, voxel, x, y, z);
+        if (finalLevel == Infinity) {
+            const newLevel = currentLevel - 1;
+            voxel.setLevel(newLevel);
+            voxel.updateVoxel(0);
+            if (levelState == 1)
+                voxel.setLevelState(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+            for (let i = 0; i < 4; i++) {
+                const nx = floodOutChecks[i][0] + x;
+                const ny = floodOutChecks[i][1] + y;
+                const nz = floodOutChecks[i][2] + z;
+                const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                if (!nVoxel || !nVoxel.isSameVoxel(voxel))
+                    continue;
+                const nState = nVoxel.getLevelState();
+                if (nState == 2)
+                    continue;
+                if (nVoxel.getLevel() > newLevel) {
+                    simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
+                }
+            }
+            return;
+        }
+        if (currentLevel < finalLevel) {
+            voxel.setLevel(currentLevel + 1);
+            voxel.updateVoxel(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+        }
+        const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+        if (!downVoxel || downVoxel.isAir() || downVoxel.isSameVoxel(voxel)) {
+            if (downVoxel) {
+                downVoxel.setId(voxel.getId());
+                downVoxel.setLevel(0);
+                downVoxel.setLevelState(1);
+                downVoxel.updateVoxel(0);
+                simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
+            }
+            return;
+        }
+        for (let i = 0; i < 4; i++) {
+            const nx = floodOutChecks[i][0] + x;
+            const ny = floodOutChecks[i][1] + y;
+            const nz = floodOutChecks[i][2] + z;
+            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel || !(nVoxel.isSameVoxel(voxel) || nVoxel.isAir()))
+                continue;
+            const vLevel = nVoxel.getLevel();
+            const nState = nVoxel.getLevelState();
+            if (nState == 2)
+                continue;
+            if (vLevel + 1 < currentLevel) {
+                nVoxel.setId(voxel.getId());
+                nVoxel.setLevel(vLevel + 1);
+                nVoxel.updateVoxel(0);
+                simulation.bounds.updateDisplay(nx, ny, nz);
+                if (currentLevel - 1 > 0) {
+                    simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
+                }
+            }
+        }
+    },
+});

package/WorldSimulation/Voxels/Ticks/Types/index.d.ts

@@ -0,0 +1 @@
+import "./LiquidVoxelUpdate";

package/WorldSimulation/Voxels/Ticks/Types/index.js

@@ -0,0 +1 @@
+import "./LiquidVoxelUpdate";

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdate.d.ts

@@ -0,0 +1,8 @@
+export declare class VoxelTickUpdate<Data extends any = null> {
+    type: string;
+    x: number;
+    y: number;
+    z: number;
+    data: Data;
+    constructor(type: string, x: number, y: number, z: number, data: Data);
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdate.js

@@ -0,0 +1,14 @@
+export class VoxelTickUpdate {
+    type;
+    x;
+    y;
+    z;
+    data;
+    constructor(type, x, y, z, data) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.data = data;
+    }
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateRegister.d.ts

@@ -0,0 +1,6 @@
+import { VoxelTickUpdateType, VoxelTickUpdateTypeData } from "./VoxelTickUpdateType";
+export declare class VoxelTickUpdateRegister {
+    static _types: Map<string, VoxelTickUpdateType<null>>;
+    static getUpdateType(id: string): VoxelTickUpdateType<null>;
+    static registerType(data: VoxelTickUpdateTypeData): void;
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateRegister.js

@@ -0,0 +1,13 @@
+import { VoxelTickUpdateType } from "./VoxelTickUpdateType";
+export class VoxelTickUpdateRegister {
+    static _types = new Map();
+    static getUpdateType(id) {
+        const type = this._types.get(id);
+        if (!type)
+            throw new Error(`Voxel update type ${id} does not exist`);
+        return type;
+    }
+    static registerType(data) {
+        this._types.set(data.type, new VoxelTickUpdateType(data));
+    }
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateType.d.ts

@@ -0,0 +1,12 @@
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+import { VoxelTickUpdate } from "./VoxelTickUpdate";
+import { DimensionSimulation } from "../../Dimensions/DimensionSimulation";
+export interface VoxelTickUpdateTypeData<Data extends any = null> {
+    type: string;
+    run(runData: DimensionSimulation, voxel: VoxelCursorInterface, update: VoxelTickUpdate<Data>): void;
+}
+export declare class VoxelTickUpdateType<Data extends any = null> {
+    data: VoxelTickUpdateTypeData<Data>;
+    constructor(data: VoxelTickUpdateTypeData<Data>);
+    run(runData: DimensionSimulation, update: VoxelTickUpdate<Data>): void;
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateType.js

@@ -0,0 +1,10 @@
+export class VoxelTickUpdateType {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    run(runData, update) {
+        const voxel = runData.getVoxelForUpdate(update.x, update.y, update.z);
+        this.data.run(runData, voxel, update);
+    }
+}

package/WorldSimulation/Voxels/Ticks/index.d.ts

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelTickUpdate";
+export * from "./VoxelTickUpdateRegister";
+export * from "./VoxelTickUpdateType";

package/WorldSimulation/Voxels/Ticks/index.js

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelTickUpdate";
+export * from "./VoxelTickUpdateRegister";
+export * from "./VoxelTickUpdateType";

package/WorldSimulation/WorldSimulation.d.ts

@@ -1,11 +1,12 @@
 import { Thread, ThreadPool } from "@amodx/threads";
 import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
-import { Generator, GeneratorData } from "./Internal/Classes/Generator";
+import { Generator, GeneratorData } from "./Dimensions/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 interface WorldSimulationInitData {
     parent: Thread;
-    threads: Thread | ThreadPool;
+    generators: Thread | ThreadPool;
+    meshers: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
 }
 /**# Infinite World Generation IWG
@@ -22,8 +23,8 @@ export declare class WorldSimulation {
     static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
+    static getDimension(id: number): import("./Dimensions/DimensionSegment").DimensionSegment;
     static removeGenerator(generator: Generator): boolean;
-    static tick(): void;
-    static update(): void;
+    static tick(generationOnly?: boolean): void;
 }
 export {};

package/WorldSimulation/WorldSimulation.js

@@ -1,14 +1,12 @@
 import { TaskTool } from "../Tools/Tasks/TasksTool";
-import { Generator } from "./Internal/Classes/Generator";
-import { runWorldUpdate } from "./Internal/Functions/runWorldUpdate";
+import { Generator } from "./Dimensions/Generator";
 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";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
+import { runActiveSectorUpdate } from "./Internal/runActiveSectorUpdate";
 let initalized = false;
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
@@ -26,17 +24,18 @@ export class WorldSimulation {
     static init(data) {
         initalized = true;
         WorldSimulationTools.parent = data.parent;
-        WorldSimulationTools.taskTool = new TaskTool(data.threads);
+        WorldSimulationTools.taskTool = new TaskTool(data.meshers, data.generators);
         if (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(WorldSimulationTools.taskTool, {
+        return new Generator({
             dimension: data.dimension ? data.dimension : 0,
             position: data.position ? data.position : Vector3Like.Create(),
             renderRadius: data.renderRadius ? data.renderRadius : 150,
+            tickRadius: data.tickRadius ? data.tickRadius : 150,
             generationRadius: data.generationRadius ? data.generationRadius : 250,
             maxRadius: data.maxRadius ? data.maxRadius : 300,
             building: data.building ? data.building : undefined,
@@ -44,8 +43,13 @@ export class WorldSimulation {
     }
     static addGenerator(generator) {
         this._generators.push(generator);
+        WorldSimulationDimensions.getDimension(generator._dimension).addGenerator(generator);
+    }
+    static getDimension(id) {
+        return WorldSimulationDimensions.getDimension(id);
     }
     static removeGenerator(generator) {
+        WorldSimulationDimensions.getDimension(generator._dimension).removeGenerator(generator);
         for (let i = 0; i < this._generators.length; i++) {
             if (this._generators[i] == generator) {
                 this._generators.splice(i, 1);
@@ -54,45 +58,37 @@ export class WorldSimulation {
         }
         return false;
     }
-    static tick() {
-        for (const gen of this._generators) {
-            gen.tick();
-        }
-    }
-    static update() {
-        if (!initalized) {
-            throw new Error(`IWG must be initalized.`);
+    static tick(generationOnly = false) {
+        for (const [, dimension] of WorldSimulationDimensions._dimensions) {
+            dimension.incrementTick();
+            for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+                dimension.activeSectors._sectors[i].tickUpdate();
+                dimension.activeSectors._sectors[i].generateUpdate();
+            }
         }
-        if (this._cullGenerators.length)
-            this._cullGenerators.length = 0;
+        let needActiveSectorUpdate = false;
         for (const gen of this._generators) {
             gen.update();
-            if (!gen._culling)
-                continue;
-            if (gen._positonChanged) {
-                if (!gen._waitingForCull) {
-                    gen._waitingForCull = true;
-                    gen._cullTime = performance.now();
-                }
-                else {
-                    if (performance.now() - gen._cullTime > 4000) {
-                        gen._waitingForCull = false;
-                        this._cullGenerators.push(gen);
-                    }
-                }
+            if (gen._dirty || gen._isNew) {
+                gen._isNew = false;
+                gen._dirty = false;
+                needActiveSectorUpdate = true;
             }
         }
-        runTickUpdate(this._generators);
-        //  IWGTasks.buildTasks.runTask();
-        runWorldUpdate(this._generators);
+        if (needActiveSectorUpdate) {
+            runActiveSectorUpdate();
+        }
         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);
+        if (generationOnly)
+            return;
+        WorldSimulationTasks.buildTasks.runTask(125);
+        WorldSimulationTasks.saveTasks.runTask(50);
+        WorldSimulationTasks.unloadTasks.runTask(50);
+        WorldSimulationTasks.unbuildTasks.runTask();
     }
 }
 WorldSimulation.addDimension(0);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
   "devDependencies": {},
   "scripts": {
-    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ../../LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
+    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
     "compile": "cd src && npx tsc --watch"
   },
   "keywords": [],

package/Contexts/Constructor/DivineVoxelEngineConstructor.d.ts

@@ -1,10 +0,0 @@
-import { Threads } from "@amodx/threads/";
-import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
-export type DivineVoxelEngineConstructorInitData = {};
-export declare class DivineVoxelEngineConstructor {
-    static environment: "node" | "browser";
-    static instance: DivineVoxelEngineConstructor;
-    TC: typeof Threads;
-    threads: ConstructorThreadManager;
-    constructor();
-}