@divinevoxel/vlox 0.0.71 → 0.0.73

package/Settings/EngineSettings.types.d.ts

@@ -1,18 +1,27 @@
 import { Vector3Like } from "@amodx/math";
+export interface MesherSettingsData {
+}
+export declare class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight: boolean;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO: boolean;
+    doColors: boolean;
+}
 export interface RenderSettingsData {
 }
 export declare class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound: boolean;
 }
-export interface TextureSettings {
-}
-export declare class TextureSettings {
-    textureSize: number;
-}
 export interface UpdatingSettings {
 }
 export declare class UpdatingSettings {
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism: boolean;
+    /**Updated sector sections are auto rebuilt */
     autoRebuild: boolean;
 }
 export interface WorldSettings {
@@ -31,34 +40,24 @@ export interface SectionSettings {
 export declare class SectionSettings {
     power2Size: Vector3Like;
 }
-export interface VoxelSettings {
-}
-export declare class VoxelSettings {
-    doColors: boolean;
-}
 export interface FlowSettings {
 }
 export declare class FlowSettings {
     enable: boolean;
-    baseFlowLimit: number;
 }
 export interface LightingSettings {
 }
 export declare class LightingSettings {
-    doAO: boolean;
-    doSunLight: boolean;
-    doRGBLight: boolean;
-    autoRGBLight: boolean;
-    autoSunLight: boolean;
+    rgbLightEnabled: boolean;
+    sunLightEnabled: boolean;
 }
 export declare class EngineSettingsData {
+    mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
-    textures: TextureSettings;
     updating: UpdatingSettings;
     world: WorldSettings;
     sectors: SectorSettings;
     sections: SectionSettings;
-    voxels: VoxelSettings;
     flow: FlowSettings;
     lighting: LightingSettings;
 }

package/Settings/EngineSettings.types.js

@@ -1,13 +1,22 @@
 import { Vector3Like } from "@amodx/math";
+export class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight = true;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO = true;
+    doColors = true;
+}
 export class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound = false;
 }
-export class TextureSettings {
-    textureSize = 16;
-}
 export class UpdatingSettings {
-    autoRebuild = true;
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism = true;
+    /**Updated sector sections are auto rebuilt */
+    autoRebuild = false;
 }
 export class WorldSettings {
     min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
@@ -19,28 +28,20 @@ export class SectorSettings {
 export class SectionSettings {
     power2Size = Vector3Like.Create(4, 4, 4);
 }
-export class VoxelSettings {
-    doColors = true;
-}
 export class FlowSettings {
     enable = true;
-    baseFlowLimit = 200;
 }
 export class LightingSettings {
-    doAO = true;
-    doSunLight = true;
-    doRGBLight = true;
-    autoRGBLight = true;
-    autoSunLight = true;
+    rgbLightEnabled = true;
+    sunLightEnabled = true;
 }
 export class EngineSettingsData {
+    mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
-    textures = new TextureSettings();
     updating = new UpdatingSettings();
     world = new WorldSettings();
     sectors = new SectorSettings();
     sections = new SectionSettings();
-    voxels = new VoxelSettings();
     flow = new FlowSettings();
     lighting = new LightingSettings();
 }

package/Tasks/IWG/IWG.d.ts

@@ -1,5 +1,5 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { WorldStorageInterface } from "../../World/Storage/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";
@@ -23,6 +23,7 @@ export declare class IWG {
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
     static removeGenerator(generator: Generator): boolean;
+    static tick(): void;
     static update(): void;
 }
 export {};

package/Tasks/IWG/IWG.js

@@ -29,10 +29,11 @@ export class IWG {
         IWGTools.taskTool = new TaskTool(data.threads);
         if (data.worldStorage)
             IWGTools.worldStorage = data.worldStorage;
-        console.warn("load the thing", IWGTools.worldStorage, data.worldStorage);
     }
     static createGenerator(data) {
-        return new Generator({
+        if (!initalized)
+            throw new Error(`IWG must be initalized first before creating generator`);
+        return new Generator(IWGTools.taskTool, {
             dimension: data.dimension ? data.dimension : "main",
             position: data.position ? data.position : Vector3Like.Create(),
             renderRadius: data.renderRadius ? data.renderRadius : 150,
@@ -53,6 +54,11 @@ export class IWG {
         }
         return false;
     }
+    static tick() {
+        for (const gen of this._generators) {
+            gen.tick();
+        }
+    }
     static update() {
         if (!initalized) {
             throw new Error(`IWG must be initalized.`);
@@ -77,7 +83,7 @@ export class IWG {
             }
         }
         runBuildUpdate(this._generators);
-        IWGTasks.buildTasks.runTask();
+        //  IWGTasks.buildTasks.runTask();
         runWorldUpdate(this._generators);
         IWGTasks.worldLoadTasks.runTask();
         IWGTasks.worldGenTasks.runTask();

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

@@ -0,0 +1,11 @@
+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/BuildQueue.js

@@ -0,0 +1,49 @@
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+export class BuildQueue {
+    tasks;
+    hash = new Set();
+    sections = [];
+    constructor(tasks) {
+        this.tasks = tasks;
+    }
+    add(data) {
+        const key = WorldSpaces.hash.hashXYZ(data[1], data[2], data[3]);
+        if (this.hash.has(key))
+            return false;
+        this.hash.add(key);
+        this.sections.push(data);
+    }
+    sort(x, y, z) {
+        const sections = this.sections;
+        const sx = x, sy = y, sz = z;
+        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
+        while (i > 1) {
+            for (j = 1; j < i; j++) {
+                (ax = sections[j - 1][1]),
+                    (ay = sections[j - 1][2]),
+                    (az = sections[j - 1][3]);
+                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
+                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
+                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
+                if (distA > distB) {
+                    temp = sections[j - 1];
+                    sections[j - 1] = sections[j];
+                    sections[j] = temp;
+                }
+            }
+            i--;
+        }
+    }
+    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]);
+            this.hash.delete(WorldSpaces.hash.hashXYZ(x, y, z));
+            count++;
+            if (count > limit)
+                break;
+        }
+    }
+}

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

@@ -1,5 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
+import { BuildQueue } from "./BuildQueue";
+import { TaskTool } from "../../../../Tools/Tasks/TasksTool";
 export interface GeneratorData {
     dimension: string;
     building?: boolean;
@@ -10,6 +12,7 @@ export interface GeneratorData {
     maxRadius: number;
 }
 export declare class Generator {
+    taskTool: TaskTool;
     position: Vector3Like;
     _dimension: string;
     _building: boolean;
@@ -22,6 +25,8 @@ export declare class Generator {
     _genCircle: Circle;
     _renderCircle: Circle;
     _maxCircle: Circle;
-    constructor(data: GeneratorData);
+    buildQueue: BuildQueue;
+    constructor(taskTool: TaskTool, data: GeneratorData);
     update(): void;
+    tick(): void;
 }

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

@@ -1,7 +1,9 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
 import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { BuildQueue } from "./BuildQueue";
 export class Generator {
+    taskTool;
     position;
     _dimension = "main";
     _building = true;
@@ -14,7 +16,10 @@ export class Generator {
     _genCircle = new Circle({ x: 0, y: 0 }, 0);
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
-    constructor(data) {
+    buildQueue;
+    constructor(taskTool, data) {
+        this.taskTool = taskTool;
+        console.warn("make generator", taskTool);
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -23,10 +28,11 @@ export class Generator {
         this._renderCircle.radius = data.renderRadius;
         this._genCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
+        this.buildQueue = new BuildQueue(taskTool);
     }
     update() {
         this._positonChanged = false;
-        WorldSpaces.section.getPosition(this.position.x, this.position.y, this.position.z, this._sectorPosition);
+        WorldSpaces.section.getPosition(this.position.x, 0, this.position.z, this._sectorPosition);
         if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
             this._positonChanged = true;
             Vector3Like.Copy(this._cachedPosition, this._sectorPosition);
@@ -38,4 +44,10 @@ export class Generator {
         this._maxCircle.center.x = this._sectorPosition.x;
         this._maxCircle.center.y = this._sectorPosition.z;
     }
+    tick() {
+        if (this._building) {
+            this.buildQueue.sort(this.position.x, this.position.y, this.position.z);
+            this.buildQueue.run(25);
+        }
+    }
 }

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

@@ -47,12 +47,12 @@ export class IWGTaskBase {
                 const z = task.queue.shift();
                 task.waitingFor++;
                 if (this.data.propagationBlocking) {
-                    dimension.inProgress.add(x, 0, z);
+                    dimension.inProgress.add(x, y, z);
                 }
                 this.data.run([dimension.id, x, y, z], () => {
                     task.vistedMap.remove(x, y, z);
                     if (this.data.propagationBlocking) {
-                        dimension.inProgress.remove(x, 0, z);
+                        dimension.inProgress.remove(x, y, z);
                     }
                     task.waitingFor--;
                 }, dimension);

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

@@ -1,5 +1,4 @@
 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";
@@ -8,7 +7,6 @@ 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)) {
@@ -24,17 +22,16 @@ export function getSectorState(sector, state, segment) {
             state.allLoaded = false;
             break;
         }
-        Sector.StateStruct.setData(sector.sectorState);
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
             state.nWorldGenAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
             state.nDecorAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
             state.nSunAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
             state.nPropagtionAllDone = false;
         }
     }

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

@@ -3,10 +3,25 @@ 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();
+function run(dimenion, sector, location, generator) {
+    let rendered = true;
+    if (!dimenion.rendered.has(location[1], location[2], location[3])) {
+        rendered = false;
+        dimenion.rendered.add(location[1], location[2], location[3]);
+    }
+    for (const section of sector.getRenerableSections()) {
+        if (rendered && (section.isInProgress() || !section.isDirty()))
+            continue;
+        section.setInProgress(true);
+        generator.buildQueue.add([
+            location[0],
+            ...section.getPosition(),
+        ]);
+    }
+}
 export function runBuildUpdate(generators) {
     for (const generator of generators) {
         if (!generator._building)
@@ -39,9 +54,13 @@ export function runBuildUpdate(generators) {
             if (state.nWorldGenAllDone &&
                 state.nSunAllDone &&
                 state.nPropagtionAllDone) {
+                if (sector.anySectionDirty()) {
+                    run(segment, sector, [generator._dimension, cx, cy, cz], generator);
+                    continue;
+                }
                 if (segment.rendered.has(cx, cy, cz))
                     continue;
-                IWGTasks.buildTasks.add(generator._dimension, cx, cy, cz);
+                run(segment, sector, [generator._dimension, cx, cy, cz], generator);
             }
         }
     }

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

@@ -3,7 +3,6 @@ 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";
@@ -41,24 +40,24 @@ export function runWorldUpdate(generators) {
                 continue;
             }
             const state = getSectorState(sector, stateCursor, segment);
-            Sector.StateStruct.setBuffer(sector.buffer);
+            sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
             if (state.allLoaded &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
                 IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nWorldGenAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
                 IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nDecorAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
                 IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nPropagtionAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
                 IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }

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

@@ -27,8 +27,4 @@ export declare class IWGTasks {
      * ---
      */
     static readonly saveAndUnloadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Build Task
-     * ---
-     */
-    static readonly buildTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
 }

package/Tasks/IWG/Internal/IWGTasks.js

@@ -1,6 +1,5 @@
 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 {
@@ -38,15 +37,13 @@ export class IWGTasks {
         id: "generate",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             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))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
                 return onDone();
             IWGTools.taskTool.generate.run([location, []], null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldGenDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
                 onDone();
             });
         },
@@ -58,15 +55,13 @@ export class IWGTasks {
         id: "decorate",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             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))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
                 return onDone();
             IWGTools.taskTool.decorate.run([location, []], null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldDecorDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
                 onDone();
             });
         },
@@ -78,15 +73,13 @@ export class IWGTasks {
         id: "wolrd_sun",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             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))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
                 return onDone();
             IWGTools.taskTool.worldSun.run(location, null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldSunDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldSunDone, true);
                 onDone();
             });
         },
@@ -98,15 +91,13 @@ export class IWGTasks {
         id: "propagation",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             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))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
                 return onDone();
             IWGTools.taskTool.propagation.run(location, null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldPropagationDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
                 onDone();
             });
         },
@@ -135,14 +126,4 @@ export class IWGTasks {
             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

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

package/Tasks/IWG/Procedures/SaveAllSectors.js

@@ -13,6 +13,8 @@ export default async function SaveAllSectors() {
     for (const [dimensionId] of IWGDimensions._dimensions) {
         const dimension = WorldRegister.dimensions.get(dimensionId);
         for (const [key, sector] of dimension.sectors) {
+            if (sector.isStored())
+                continue;
             proms.push(worldStorage.saveSector([dimensionId, ...sector.position]));
         }
     }

package/Tasks/Propagation/Flow/FlowManager.d.ts

@@ -1,12 +1,10 @@
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 import { UpdateTask } from "../../Update/UpdateTask.js";
 import { WorldCursor } from "../../../World/index.js";
 export declare class FlowManager {
     static _brush: BrushTool;
     static _sDataTool: WorldCursor;
     static _nDataTool: WorldCursor;
-    static _substanceTool: SubstanceDataTool;
     static setVoxel(tasks: UpdateTask, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
     static setDimension(dimension: string): void;
     static removeVoxel(tasks: UpdateTask, x: number, y: number, z: number): void;