@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/Propagation/Flow/FlowManager.js

@@ -1,117 +1,110 @@
-import { $3dCardinalNeighbors } from "../../../Math/Constants/CardinalNeighbors.js";
-import { LightData } from "../../../Voxels/LightData.js";
-import { DataTool } from "../../../Tools/Data/DataTool.js";
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { SunRemove, SunUpdate } from "../Illumanation/Functions/SunUpdate.js";
-import { RGBRemove, RGBUpdate } from "../Illumanation/Functions/RGBUpdate.js";
-import { IlluminationManager } from "../Illumanation/IlluminationManager.js";
 import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
+import { WorldCursor } from "../../../World/index.js";
 export class FlowManager {
-    static lightData = LightData;
     static _brush = new BrushTool();
-    static _sDataTool = new DataTool();
-    static _nDataTool = new DataTool();
+    static _sDataTool = new WorldCursor();
+    static _nDataTool = new WorldCursor();
     static _substanceTool = new SubstanceDataTool();
     static setVoxel(tasks, vox, level, levelState, x, y, z) {
-        this.sunCheck(tasks, x, y, z);
-        SunRemove(tasks);
-        this._brush.setId(vox).setXYZ(x, y, z).paint();
-        this._sDataTool.loadInAt(x, y, z);
-        this._sDataTool
-            .setLevel(level)
-            .setLevelState(levelState)
-            .setLight(this.getAbsorbLight(x, y, z))
-            .commit();
-        SunUpdate(tasks);
+        /*    this.sunCheck(tasks, x, y, z);
+           SunRemove(tasks);
+           this._brush.setId(vox).setXYZ(x, y, z).paint();
+           this._sDataTool.loadInAt(x, y, z);
+           this._sDataTool
+             .setLevel(level)
+             .setLevelState(levelState)
+             .setLight(this.getAbsorbLight(x, y, z))
+             .commit();
+       
+           SunUpdate(tasks); */
     }
     static setDimension(dimension) {
-        this._sDataTool.setDimension(dimension);
-        this._nDataTool.setDimension(dimension);
+        // this._sDataTool.setDimension(dimension);
+        //  this._nDataTool.setDimension(dimension);
         //   this._brush.setDimension(dimension);
-        IlluminationManager.setDimension(dimension);
+        // IlluminationManager.setDimension(dimension);
     }
     static removeVoxel(tasks, x, y, z) {
-        for (const n of $3dCardinalNeighbors) {
-            const nx = x + n[0];
-            const ny = y + n[1];
-            const nz = z + n[2];
-            if (!this._nDataTool.loadInAt(nx, ny, nz))
-                continue;
-            const l = this._nDataTool.getLight();
-            if (l <= 0)
-                continue;
-            if (this.lightData.getS(l) > 0) {
+        /*     for (const n of $3dCardinalNeighbors) {
+              const nx = x + n[0];
+              const ny = y + n[1];
+              const nz = z + n[2];
+              if (!this._nDataTool.loadInAt(nx, ny, nz)) continue;
+        
+              const l = this._nDataTool.getLight();
+        
+              if (l <= 0) continue;
+        
+              if (this.lightData.getS(l) > 0) {
                 tasks.sun.update.push(nx, ny, nz);
-            }
-            if (this.lightData.hasRGBLight(l)) {
+              }
+        
+              if (this.lightData.hasRGBLight(l)) {
                 tasks.rgb.update.push(nx, ny, nz);
+              }
             }
-        }
-        this._nDataTool.loadInAt(x, y, z);
-        const currentLight = this._nDataTool.getLight();
-        this._brush.setXYZ(x, y, z).erase();
-        this._nDataTool.clear().loadInAt(x, y, z);
-        this._nDataTool.setLight(currentLight).commit();
-        tasks.rgb.remove.push(x, y, z);
-        RGBRemove(tasks);
-        SunUpdate(tasks);
-        RGBUpdate(tasks);
+            this._nDataTool.loadInAt(x, y, z);
+            const currentLight = this._nDataTool.getLight();
+            this._brush.setXYZ(x, y, z).erase();
+            this._nDataTool.clear().loadInAt(x, y, z);
+            this._nDataTool.setLight(currentLight).commit();
+            tasks.rgb.remove.push(x, y, z);
+            RGBRemove(tasks);
+            SunUpdate(tasks);
+            RGBUpdate(tasks); */
     }
     static getFlowRate(substance) {
         this._substanceTool.setSubstanceFromString(substance);
         return this._substanceTool.getFlowRate();
     }
     static getVoxel(x, y, z) {
-        if (!this._sDataTool.loadInAt(x, y, z))
-            return false;
-        if (!this._sDataTool.isRenderable())
-            return false;
-        const substance = this._sDataTool.getSubstnaceData();
-        if (!substance.isLiquid())
-            return false;
+        /*    if (!this._sDataTool.loadInAt(x, y, z)) return false;
+           if (!this._sDataTool.isRenderable()) return false;
+       
+           const substance = this._sDataTool.getSubstnaceData();
+           if (!substance.isLiquid()) return false; */
         return this._sDataTool;
     }
     static setLevel(level, x, y, z) {
-        this._nDataTool.loadInAt(x, y, z);
-        this._nDataTool.setLevel(level).commit();
+        //   this._nDataTool.loadInAt(x, y, z);
+        //   this._nDataTool.setLevel(level).commit();
     }
     static getLevel(vox, x, y, z) {
-        if (!this._nDataTool.loadInAt(x, y, z))
-            return -2;
-        const voxel = this._nDataTool.getStringId();
-        if (this._nDataTool.isAir()) {
-            return 0;
-        }
-        if (voxel == vox) {
-            return this._nDataTool.getLevel();
-        }
-        return -1;
+        /*    if (!this._nDataTool.loadInAt(x, y, z)) return -2;
+           const voxel = this._nDataTool.getStringId();
+           if (this._nDataTool.isAir()) {
+             return 0;
+           }
+           if (voxel == vox) {
+             return this._nDataTool.getLevel();
+           }
+           return -1; */
     }
     static getLevelState(vox, x, y, z) {
-        if (!this._nDataTool.loadInAt(x, y, z))
-            return -2;
-        const voxel = this._nDataTool.getStringId();
-        if (voxel == vox) {
-            return this._nDataTool.getLevelState();
-        }
-        if (this._nDataTool.isAir()) {
-            return -1;
-        }
-        return -3;
+        /*     if (!this._nDataTool.loadInAt(x, y, z)) return -2;
+            const voxel = this._nDataTool.getStringId();
+            if (voxel == vox) {
+              return this._nDataTool.getLevelState();
+            }
+            if (this._nDataTool.isAir()) {
+              return -1;
+            }
+            return -3; */
     }
     static canFlowOutwardTest(vox, x, y, z) {
-        const level = this.getLevel(vox, x, y - 1, z);
-        if (level == -1) {
-            return true;
-        }
-        return false;
+        /*    const level = this.getLevel(vox, x, y - 1, z);
+           if (level == -1) {
+             return true;
+           }
+           return false; */
     }
     static flowDownTest(vox, x, y, z) {
-        const level = this.getLevel(vox, x, y - 1, z);
-        if (level >= 0) {
-            return true;
-        }
-        return false;
+        /*     const level = this.getLevel(vox, x, y - 1, z);
+            if (level >= 0) {
+              return true;
+            }
+            return false; */
     }
     static wait(ms) {
         return new Promise((resolve, reject) => setTimeout(resolve, ms));
@@ -120,35 +113,30 @@ export class FlowManager {
         0, 0, 0, 0,
     ];
     static getAbsorbLight(x, y, z) {
-        for (const n of $3dCardinalNeighbors) {
-            if (!n[0] && !n[1] && !n[2])
-                continue;
-            if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2]))
-                continue;
-            let l = this._nDataTool.getLight();
-            if (l <= 0)
-                continue;
-            const v = this.lightData.getLightValues(l);
-            for (let i = 0; i < 4; i++) {
+        /*     for (const n of $3dCardinalNeighbors) {
+              if (!n[0] && !n[1] && !n[2]) continue;
+              if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2])) continue;
+              let l = this._nDataTool.getLight();
+              if (l <= 0) continue;
+              const v = this.lightData.getLightValues(l);
+              for (let i = 0; i < 4; i++) {
                 if (this._lightValues[i] < v[i]) {
-                    this._lightValues[i] = v[i];
+                  this._lightValues[i] = v[i];
                 }
+              }
             }
-        }
-        let brightest = this.lightData.setLightValues(this._lightValues);
-        for (let i = 0; i < 4; i++) {
-            this._lightValues[i] = 0;
-        }
-        return this.lightData.minusOneForAll(brightest);
+            let brightest = this.lightData.setLightValues(this._lightValues);
+            for (let i = 0; i < 4; i++) {
+              this._lightValues[i] = 0;
+            } */
+        // return this.lightData.minusOneForAll(2);
     }
     static sunCheck(tasks, x, y, z) {
-        if (!this._nDataTool.loadInAt(x, y - 1, z))
-            return;
-        if (!this._nDataTool.isAir())
-            return;
-        const l = this._nDataTool.getLight();
-        if (this.lightData.getS(l) == 0xf) {
-            tasks.sun.remove.push(x, y - 1, z);
-        }
+        /*     if (!this._nDataTool.loadInAt(x, y - 1, z)) return;
+            if (!this._nDataTool.isAir()) return;
+            const l = this._nDataTool.getLight();
+            if (this.lightData.getS(l) == 0xf) {
+              tasks.sun.remove.push(x, y - 1, z);
+            } */
     }
 }

package/Tasks/Propagation/Flow/{Functions/FlowRemove.d.ts → FlowRemove.d.ts}

@@ -1,2 +1,2 @@
-import { UpdateTask } from "../../../Update/UpdateTask.js";
+import { UpdateTask } from "../../Update/UpdateTask.js";
 export declare function FlowRemove(tasks: UpdateTask): Promise<void>;

package/Tasks/Propagation/Flow/FlowRemove.js

@@ -0,0 +1,157 @@
+function RunRemoveCheck(tasks, vox) {
+    /*   const [dimension, x, y, z] = tasks.origin;
+      const queue = tasks.flow.remove.queue;
+      const cl = FM.getLevel(vox, x, y, z);
+      queue.push([x, y, z]);
+      const n1 = FM.getLevel(vox, x + 1, y, z);
+      const n1s = FM.getLevelState(vox, x + 1, y, z);
+      if ((n1 > -1 && n1 < cl) || n1s == 1) {
+        queue.push([x + 1, y, z]);
+      }
+      const n2 = FM.getLevel(vox, x - 1, y, z);
+      const n2s = FM.getLevelState(vox, x - 1, y, z);
+      if ((n2 > -1 && n2 < cl) || n2s == 1) {
+        queue.push([x - 1, y, z]);
+      }
+      const n3 = FM.getLevel(vox, x, y, z + 1);
+      const n3s = FM.getLevelState(vox, x, y, z + 1);
+      if ((n3 > -1 && n3 < cl) || n3s == 1) {
+        queue.push([x, y, z + 1]);
+      }
+      const n4 = FM.getLevel(vox, x, y, z - 1);
+      const n4s = FM.getLevelState(vox, x, y, z - 1);
+      if ((n4 > -1 && n4 < cl) || n4s == 1) {
+        queue.push([x, y, z - 1]);
+      } */
+}
+export async function FlowRemove(tasks) {
+    /*   const [dimension, x, y, z] = tasks.origin;
+      FM.setDimension(dimension);
+      const vox = FM.getVoxel(x, y, z);
+      if (!vox) return;
+      const voxId = vox.getStringId();
+      const flowRate = vox.getSubstnaceData().getFlowRate();
+      RunRemoveCheck(tasks, voxId);
+      const noRemoveMap = tasks.flow.remove.noRemoveMap;
+      while (tasks.flow.remove.queue.length != 0) {
+        FM.setDimension(dimension);
+        RunRemovePropagation(tasks, voxId);
+        RunFlowReduce(tasks, voxId);
+        await FlowUpdate(tasks, false);
+        noRemoveMap.clear();
+      //  tasks.runRebuildQueue();
+        await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
+      } */
+}
+function RunRemovePropagation(tasks, vox) {
+    /*   const removeQ = tasks.flow.remove.queue;
+      const updateQ = tasks.flow.update.queue;
+      const map = tasks.flow.update.map;
+      const noRemoveMap = tasks.flow.remove.noRemoveMap;
+      for (let i = 0; i < removeQ.length; i++) {
+       const node = removeQ[i];
+       const x = node[0];
+       const y = node[1];
+       const z = node[2];
+       const l = FM.getLevel(vox, x, y, z);
+       const s = FM.getLevelState(vox, x, y, z);
+       map.add(x, y, z);
+       if (noRemoveMap.has(x, y, z)) continue;
+     
+       n1t: if (!map.has(x + 1, y, z)) {
+        const n1 = FM.getLevel(vox, x + 1, y, z);
+        const n1s = FM.getLevelState(vox, x + 1, y, z);
+        if (n1 <= 0 || n1s == 1) break n1t;
+        if (n1 < l && l > 0 && n1 > 0) {
+         removeQ.push([x + 1, y, z]);
+        }
+        if (n1 > l) {
+         updateQ.push([x + 1, y, z]);
+        }
+       }
+       n2t: if (!map.has(x - 1, y, z)) {
+        const n2 = FM.getLevel(vox, x - 1, y, z);
+        const n2s = FM.getLevelState(vox, x - 1, y, z);
+        if (n2 <= 0 || n2s == 1) break n2t;
+        if (n2 < l && l > 0 && n2 > 0) {
+         removeQ.push([x - 1, y, z]);
+        }
+        if (n2 > l) {
+         updateQ.push([x - 1, y, z]);
+        }
+       }
+       n3t: if (!map.has(x, y, z + 1)) {
+        const n3 = FM.getLevel(vox, x, y, z + 1);
+        const n3s = FM.getLevelState(vox, x, y, z + 1);
+        if (n3 <= 0 || n3s == 1) break n3t;
+        if (n3 < l && l > 0 && n3 > 0) {
+         removeQ.push([x, y, z + 1]);
+        }
+        if (n3 > l) {
+         updateQ.push([x, y, z + 1]);
+        }
+       }
+     
+       n4t: if (!map.has(x, y, z - 1)) {
+        const n4 = FM.getLevel(vox, x, y, z - 1);
+        const n4s = FM.getLevelState(vox, x, y, z - 1);
+        if (n4 <= 0 || n4s == 1) break n4t;
+        if (n4 < l && l > 0 && n4 > 0) {
+         removeQ.push([x, y, z - 1]);
+        }
+        if (n4 > l) {
+         updateQ.push([x, y, z - 1]);
+        }
+       }
+     
+       
+       if (!map.has(x, y - 1, z)) {
+        const n5 = FM.getLevel(vox, x, y - 1, z);
+        if (n5 < 0) continue;
+        const n5s = FM.getLevelState(vox, x, y - 1, z);
+        let add = false;
+        if (s == 1 && n5s == 1) {
+         if (l <= 1) {
+          add = true;
+         }
+        }
+        if (s == 0 && l <= 1) {
+         add = true;
+        }
+        if (add) {
+         removeQ.push([x, y - 1, z]);
+        }
+       }
+      }
+      map.clear(); */
+}
+function RunFlowReduce(tasks, vox) {
+    /*   const queue = tasks.flow.remove.queue;
+      const map = tasks.flow.remove.map;
+      const reque: number[][] = [];
+      while (queue.length != 0) {
+        const node = queue.shift();
+        if (!node) {
+          break;
+        }
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        if (map.has(x, y, z)) continue;
+        map.add(x, y, z);
+    
+        const l = FM.getLevel(vox, x, y, z);
+    
+        if (l <= 1) {
+          FM.removeVoxel(tasks, x, y, z);
+          reque.push([x, y, z]);
+        } else {
+          FM.setLevel(l - 1, x, y, z);
+          reque.push([x, y, z]);
+        }
+        tasks.bounds.update(x, y, z);
+      }
+    
+      tasks.flow.remove.queue = reque;
+      map.clear(); */
+}

package/Tasks/Propagation/Flow/{Functions/FlowUpdate.d.ts → FlowUpdate.d.ts}

@@ -1,2 +1,2 @@
-import { UpdateTask } from "../../../Update/UpdateTask.js";
+import { UpdateTask } from "../../Update/UpdateTask.js";
 export declare function FlowUpdate(tasks: UpdateTask, rebuild?: boolean): Promise<void>;

package/Tasks/Propagation/Flow/FlowUpdate.js

@@ -0,0 +1,98 @@
+import { FlowManager as FM } from "./FlowManager.js";
+export async function FlowUpdate(tasks, rebuild = true) {
+    /*   const [dimension, x, y, z] = tasks.origin;
+      FM.setDimension(dimension);
+      const vox = FM.getVoxel(x, y, z);
+      if (!vox) return;
+      const flowRate = vox.getSubstnaceData().getFlowRate();
+      const level = FM.getLevel(vox.getStringId(), x, y, z);
+      if (level < 0) return;
+      const levelState = FM.getLevelState(vox.getStringId(), x, y, z);
+      tasks.flow.update.queue.push([x, y, z, level, levelState]);
+      while (tasks.flow.update.queue.length != 0) {
+        FM.setDimension(dimension);
+        RunFlowPropagation(tasks, vox.getStringId());
+        RunFlowIncrease(tasks, vox.getStringId());
+        if (rebuild) {
+        //  tasks.runRebuildQueue();
+          await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
+        }
+      } */
+}
+function RunFlowPropagation(tasks, vox) {
+    /*   const que = tasks.flow.update.queue;
+      const noRemoveMap = tasks.flow.remove.noRemoveMap;
+      for (let i = 0; i < que.length; i++) {
+        const node = que[i];
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        const l = FM.getLevel(vox, x, y, z);
+        const s = FM.getLevelState(vox, x, y, z);
+        noRemoveMap.add(x, y, z);
+        if (FM.canFlowOutwardTest(vox, x, y, z)) {
+          const n1 = FM.getLevel(vox, x + 1, y, z);
+          if (n1 + 1 < l && n1 >= 0) {
+            let n1l = l - 1;
+            que.push([x + 1, y, z, n1l, 0]);
+          }
+    
+          const n2 = FM.getLevel(vox, x - 1, y, z);
+    
+          if (n2 + 1 < l && n2 >= 0) {
+            let n2l = l - 1;
+            que.push([x - 1, y, z, n2l, 0]);
+          }
+    
+          const n3 = FM.getLevel(vox, x, y, z + 1);
+          if (n3 + 1 < l && n3 >= 0) {
+            let n3l = l - 1;
+            que.push([x, y, z + 1, n3l, 0]);
+          }
+    
+          const n4 = FM.getLevel(vox, x, y, z - 1);
+          if (n4 + 1 < l && n4 >= 0) {
+            let n4l = l - 1;
+            que.push([x, y, z - 1, n4l, 0]);
+          }
+        }
+    
+        const n5 = FM.getLevel(vox, x, y - 1, z);
+        if (n5 <= l && n5 >= 0) {
+          let state = 1;
+          let level = 7;
+          if (l <= 0 && s != 1) {
+            state = 0;
+            level = l - 2;
+          }
+          que.push([x, y - 1, z, level, state]);
+        }
+      } */
+}
+function RunFlowIncrease(tasks, vox) {
+    const que = tasks.flow.update.queue;
+    const map = tasks.flow.update.map;
+    const reque = [];
+    while (que.length != 0) {
+        const node = que.shift();
+        if (!node) {
+            break;
+        }
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        const level = node[3];
+        const levelState = node[4];
+        if (map.has(x, y, z))
+            continue;
+        map.add(x, y, z);
+        if (level > -1) {
+            FM.setVoxel(tasks, vox, level, levelState, x, y, z);
+            reque.push([x, y, z, -1]);
+        }
+        tasks.bounds.update(x, y, z);
+    }
+    //@ts-ignore
+    tasks.queues.flow.update.queue = reque;
+    map.clear();
+}

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

@@ -0,0 +1,2 @@
+import { UpdateTask } from "../../../Tasks/Update/UpdateTask";
+export declare function WorldFlow(task: UpdateTask): false | undefined;

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -0,0 +1,151 @@
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate";
+import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate";
+const flowUpdateChecks = [
+    [0, -1, 0],
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+const queue = [];
+const floodOutChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+function Flood(task, voxel) {
+    const voxelId = voxel.id;
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const voxel = task.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const level = voxel.getLevel();
+        if (level <= 1)
+            continue;
+        const levelState = voxel.getLevelState();
+        const hasBottomVoxel = !task.nDataCursor.getVoxel(x, y - 1, z)?.isAir() || false;
+        if (hasBottomVoxel && !levelState) {
+            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 downVoxel = task.nDataCursor.getVoxel(nx, ny - 1, nz);
+                const downAir = downVoxel?.isAir() || false;
+                const downSameVoxel = downVoxel?.getId() == voxelId;
+                let nVoxel = task.nDataCursor.getVoxel(nx, ny, nz);
+                if (!nVoxel)
+                    continue;
+                const nLevel = nVoxel.isAir() ? 0 : nVoxel.getLevel();
+                const nState = nVoxel.getLevelState();
+                if (nLevel < level &&
+                    (nVoxel.id == voxelId || nVoxel.isAir()) &&
+                    nState == 0) {
+                    if (downAir && !downSameVoxel) {
+                        nVoxel.setId(voxelId);
+                        nVoxel.updateHeightMap(0);
+                        nVoxel.setLevel(7);
+                        nVoxel.setLevelState(1);
+                    }
+                    else if (!downSameVoxel) {
+                        nVoxel.setId(voxelId);
+                        nVoxel.updateHeightMap(0);
+                        nVoxel.setLevel(level - 1);
+                        nVoxel.setLevelState(0);
+                    }
+                    if (nVoxel.hasSunLight()) {
+                        task.sun.remove.push(nx, ny, nz);
+                    }
+                    if (nVoxel.hasRGBLight()) {
+                        task.rgb.remove.push(nx, ny, nz);
+                    }
+                    queue.push(nx, ny, nz);
+                }
+            }
+            continue;
+        }
+        if (!WorldSpaces.world.inBounds(x, y - 1, z) && levelState != 1)
+            continue;
+        let nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
+        const nLevel = nVoxel.isAir()
+            ? 0
+            : nVoxel.getId() == voxelId
+                ? nVoxel.getLevel()
+                : -1;
+        const nState = nVoxel.getLevelState();
+        const nAir = nVoxel.isAir();
+        if (nLevel < 0 || nState == 1)
+            continue;
+        let state = nState;
+        if (nAir) {
+            const down = task.nDataCursor.getVoxel(x, y - 2, z);
+            if (down && !down.isAir()) {
+                state = 0;
+            }
+        }
+        nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
+        if (nVoxel.hasSunLight()) {
+            task.sun.remove.push(x, y - 1, z);
+        }
+        if (nVoxel.hasRGBLight()) {
+            task.rgb.remove.push(x, y - 1, z);
+        }
+        nVoxel.setId(voxelId);
+        nVoxel.updateHeightMap(0);
+        nVoxel.setLevel(7);
+        nVoxel.setLevelState(state);
+        queue.push(x, y - 1, z);
+    }
+}
+export function WorldFlow(task) {
+    if (!EngineSettings.doFlow())
+        return false;
+    const sector = WorldRegister.sectors.get(task.origin[0], task.origin[1], task.origin[2], task.origin[3]);
+    if (!sector) {
+        console.error(`Tried running world flow on a sector that does not exist ${task.origin.toString()}`);
+        return false;
+    }
+    let maxX = WorldSpaces.section.bounds.x + sector.position[0];
+    let maxZ = WorldSpaces.section.bounds.z + sector.position[2];
+    for (let i = sector.sections.length - 1; i >= 0; i--) {
+        const section = sector.sections[i];
+        if (!section)
+            continue;
+        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        const cx = sector.position[0];
+        const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
+        const cz = sector.position[2];
+        if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+            continue;
+        for (let y = cy + maxY; y >= cy + minY; y--) {
+            for (let z = cz; z < maxZ; z++) {
+                for (let x = cx; x < maxX; x++) {
+                    const voxel = task.nDataCursor.getVoxel(x, y, z);
+                    if (!voxel || voxel.isAir())
+                        continue;
+                    if (voxel.getSubstanceData().isLiquid()) {
+                        for (let i = 0; i < 5; i++) {
+                            const nVoxel = task.nDataCursor.getVoxel(x + flowUpdateChecks[i][0], y + flowUpdateChecks[i][1], z + flowUpdateChecks[i][2]);
+                            if (nVoxel && nVoxel.isAir()) {
+                                queue.push(x, y, z);
+                                Flood(task, voxel);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    SunRemove(task);
+    RGBRemove(task);
+    SunUpdate(task);
+    RGBUpdate(task);
+}