@divinevoxel/vlox 0.0.2 → 0.0.4

package/{Propagation → Tasks/Propagation}/Explosion/ExplosionManager.js

@@ -1,27 +1,25 @@
 //data
-import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
+import { $3dCardinalNeighbors } from "../../../Math/Constants/CardinalNeighbors.js";
 //objects
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { LightData } from "../../Data/LightData.js";
+import { DataTool } from "../../../Tools/Data/DataTool.js";
+import { LightData } from "../../../Voxels/LightData.js";
 //functions
 import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
 import { RGBRemove, RGBUpdate } from "../Illumanation/Functions/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Illumanation/Functions/SunUpdate.js";
 import { FlowManager } from "../Flow/FlowManager.js";
+import { VisitedMap } from "../../../Util/VisistedMap";
 const dataTool = new DataTool();
 const nDataTool = new DataTool();
 export const ExplosionManager = {
-    runExplosion(tasks) {
-        tasks.start();
+    runExplosion(tasks, radius) {
         const [dimension, sx, sy, sz] = tasks.origin;
         FlowManager.setDimension(dimension);
-        tasks.setPriority(0);
-        const queue = tasks.queues.queue;
-        const map = tasks.queues.map;
+        const queue = [];
+        const map = new VisitedMap();
         queue.push([sx, sy, sz]);
         dataTool.setDimension(dimension);
         nDataTool.setDimension(dimension);
-        const radius = tasks.getData();
         while (queue.length) {
             const node = queue.shift();
             if (!node)
@@ -93,15 +91,15 @@ export const ExplosionManager = {
                             const l = nDataTool.getLight();
                             if (l > 0) {
                                 if (LightData.getS(l) > 0) {
-                                    tasks.queues.sun.remove.push(nx, ny, nz);
+                                    tasks.sun.remove.push(nx, ny, nz);
                                 }
                                 if (LightData.hasRGBLight(l)) {
-                                    tasks.queues.rgb.remove.push(nx, ny, nz);
+                                    tasks.rgb.remove.push(nx, ny, nz);
                                 }
                             }
                         }
                     }
-                    tasks.addNeighborsToRebuildQueue(x, y, z);
+                    tasks.bounds.update(x, y, z);
                     if (dataTool.getHardness() > 10_000 ||
                         dataTool.getSubstnaceData().isLiquid()) {
                         continue;
@@ -114,7 +112,6 @@ export const ExplosionManager = {
         SunRemove(tasks);
         RGBUpdate(tasks);
         SunUpdate(tasks);
-        tasks.runRebuildQueue();
-        tasks.stop();
+        // tasks.runRebuildQueue();
     },
 };

package/{Propagation → Tasks/Propagation}/Flow/FlowManager.d.ts

@@ -1,7 +1,7 @@
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { BrushTool } from "../../Tools/Brush/Brush.js";
-import type { FlowTaskRequests } from "../../Contexts/Constructor/Tasks/TasksRequest";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { DataTool } from "../../../Tools/Data/DataTool.js";
+import { BrushTool } from "../../../Tools/Brush/Brush.js";
+import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
+import { UpdateTask } from "../../Update/UpdateTask.js";
 export declare class FlowManager {
     static lightData: {
         SRS: number;
@@ -49,9 +49,9 @@ export declare class FlowManager {
     static _sDataTool: DataTool;
     static _nDataTool: DataTool;
     static _substanceTool: SubstanceDataTool;
-    static setVoxel(tasks: FlowTaskRequests, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
+    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: FlowTaskRequests, x: number, y: number, z: number): void;
+    static removeVoxel(tasks: UpdateTask, x: number, y: number, z: number): void;
     static getFlowRate(substance: string): number;
     static getVoxel(x: number, y: number, z: number): false | DataTool;
     static setLevel(level: number, x: number, y: number, z: number): void;
@@ -62,5 +62,5 @@ export declare class FlowManager {
     static wait(ms: number): Promise<unknown>;
     static _lightValues: [s: number, r: number, g: number, b: number];
     static getAbsorbLight(x: number, y: number, z: number): number;
-    static sunCheck(tasks: FlowTaskRequests, x: number, y: number, z: number): void;
+    static sunCheck(tasks: UpdateTask, x: number, y: number, z: number): void;
 }

package/{Propagation → Tasks/Propagation}/Flow/FlowManager.js

@@ -1,11 +1,11 @@
-import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
-import { LightData } from "../../Data/LightData.js";
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { BrushTool } from "../../Tools/Brush/Brush.js";
+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 { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 export class FlowManager {
     static lightData = LightData;
     static _brush = new BrushTool();
@@ -27,7 +27,7 @@ export class FlowManager {
     static setDimension(dimension) {
         this._sDataTool.setDimension(dimension);
         this._nDataTool.setDimension(dimension);
-        this._brush.setDimension(dimension);
+        //   this._brush.setDimension(dimension);
         IlluminationManager.setDimension(dimension);
     }
     static removeVoxel(tasks, x, y, z) {
@@ -41,10 +41,10 @@ export class FlowManager {
             if (l <= 0)
                 continue;
             if (this.lightData.getS(l) > 0) {
-                tasks.queues.sun.update.push(nx, ny, nz);
+                tasks.sun.update.push(nx, ny, nz);
             }
             if (this.lightData.hasRGBLight(l)) {
-                tasks.queues.rgb.update.push(nx, ny, nz);
+                tasks.rgb.update.push(nx, ny, nz);
             }
         }
         this._nDataTool.loadInAt(x, y, z);
@@ -52,7 +52,7 @@ export class FlowManager {
         this._brush.setXYZ(x, y, z).erase();
         this._nDataTool.clear().loadInAt(x, y, z);
         this._nDataTool.setLight(currentLight).commit();
-        tasks.queues.rgb.remove.push(x, y, z);
+        tasks.rgb.remove.push(x, y, z);
         RGBRemove(tasks);
         SunUpdate(tasks);
         RGBUpdate(tasks);
@@ -148,7 +148,7 @@ export class FlowManager {
             return;
         const l = this._nDataTool.getLight();
         if (this.lightData.getS(l) == 0xf) {
-            tasks.queues.sun.remove.push(x, y - 1, z);
+            tasks.sun.remove.push(x, y - 1, z);
         }
     }
 }

package/Tasks/Propagation/Flow/Functions/FlowRemove.d.ts

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

package/{Propagation → Tasks/Propagation}/Flow/Functions/FlowRemove.js

@@ -1,9 +1,9 @@
 import { FlowUpdate } from "./FlowUpdate.js";
 import { FlowManager as FM } from "../FlowManager.js";
-import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../../../Settings/EngineSettings.js";
 function RunRemoveCheck(tasks, vox) {
     const [dimension, x, y, z] = tasks.origin;
-    const queue = tasks.queues.flow.remove.queue;
+    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);
@@ -36,22 +36,22 @@ export async function FlowRemove(tasks) {
     const voxId = vox.getStringId();
     const flowRate = vox.getSubstnaceData().getFlowRate();
     RunRemoveCheck(tasks, voxId);
-    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
-    while (tasks.queues.flow.remove.queue.length != 0) {
+    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();
+        //  tasks.runRebuildQueue();
         await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
     }
 }
 function RunRemovePropagation(tasks, vox) {
-    const removeQ = tasks.queues.flow.remove.queue;
-    const updateQ = tasks.queues.flow.update.queue;
-    const map = tasks.queues.flow.update.map;
-    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
+    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];
@@ -60,9 +60,9 @@ function RunRemovePropagation(tasks, vox) {
         const l = FM.getLevel(vox, x, y, z);
         const s = FM.getLevelState(vox, x, y, z);
         map.add(x, y, z);
-        if (noRemoveMap.inMap(x, y, z))
+        if (noRemoveMap.has(x, y, z))
             continue;
-        n1t: if (!map.inMap(x + 1, y, z)) {
+        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)
@@ -74,7 +74,7 @@ function RunRemovePropagation(tasks, vox) {
                 updateQ.push([x + 1, y, z]);
             }
         }
-        n2t: if (!map.inMap(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)
@@ -86,7 +86,7 @@ function RunRemovePropagation(tasks, vox) {
                 updateQ.push([x - 1, y, z]);
             }
         }
-        n3t: if (!map.inMap(x, y, z + 1)) {
+        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)
@@ -98,7 +98,7 @@ function RunRemovePropagation(tasks, vox) {
                 updateQ.push([x, y, z + 1]);
             }
         }
-        n4t: if (!map.inMap(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)
@@ -110,7 +110,7 @@ function RunRemovePropagation(tasks, vox) {
                 updateQ.push([x, y, z - 1]);
             }
         }
-        if (!map.inMap(x, y - 1, z)) {
+        if (!map.has(x, y - 1, z)) {
             const n5 = FM.getLevel(vox, x, y - 1, z);
             if (n5 < 0)
                 continue;
@@ -132,8 +132,8 @@ function RunRemovePropagation(tasks, vox) {
     map.clear();
 }
 function RunFlowReduce(tasks, vox) {
-    const queue = tasks.queues.flow.remove.queue;
-    const map = tasks.queues.flow.remove.map;
+    const queue = tasks.flow.remove.queue;
+    const map = tasks.flow.remove.map;
     const reque = [];
     while (queue.length != 0) {
         const node = queue.shift();
@@ -143,7 +143,7 @@ function RunFlowReduce(tasks, vox) {
         const x = node[0];
         const y = node[1];
         const z = node[2];
-        if (map.inMap(x, y, z))
+        if (map.has(x, y, z))
             continue;
         map.add(x, y, z);
         const l = FM.getLevel(vox, x, y, z);
@@ -155,8 +155,8 @@ function RunFlowReduce(tasks, vox) {
             FM.setLevel(l - 1, x, y, z);
             reque.push([x, y, z]);
         }
-        tasks.addToRebuildQueue(x, y, z);
+        tasks.bounds.update(x, y, z);
     }
-    tasks.queues.flow.remove.queue = reque;
+    tasks.flow.remove.queue = reque;
     map.clear();
 }

package/Tasks/Propagation/Flow/Functions/FlowUpdate.d.ts

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

package/{Propagation → Tasks/Propagation}/Flow/Functions/FlowUpdate.js

@@ -1,5 +1,5 @@
 import { FlowManager as FM } from "../FlowManager.js";
-import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../../../Settings/EngineSettings.js";
 export async function FlowUpdate(tasks, rebuild = true) {
     const [dimension, x, y, z] = tasks.origin;
     FM.setDimension(dimension);
@@ -11,20 +11,20 @@ export async function FlowUpdate(tasks, rebuild = true) {
     if (level < 0)
         return;
     const levelState = FM.getLevelState(vox.getStringId(), x, y, z);
-    tasks.queues.flow.update.queue.push([x, y, z, level, levelState]);
-    while (tasks.queues.flow.update.queue.length != 0) {
+    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();
+            //  tasks.runRebuildQueue();
             await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
         }
     }
 }
 function RunFlowPropagation(tasks, vox) {
-    const que = tasks.queues.flow.update.queue;
-    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
+    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];
@@ -68,8 +68,8 @@ function RunFlowPropagation(tasks, vox) {
     }
 }
 function RunFlowIncrease(tasks, vox) {
-    const que = tasks.queues.flow.update.queue;
-    const map = tasks.queues.flow.update.map;
+    const que = tasks.flow.update.queue;
+    const map = tasks.flow.update.map;
     const reque = [];
     while (que.length != 0) {
         const node = que.shift();
@@ -81,14 +81,14 @@ function RunFlowIncrease(tasks, vox) {
         const z = node[2];
         const level = node[3];
         const levelState = node[4];
-        if (map.inMap(x, y, z))
+        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.addToRebuildQueue(x, y, z);
+        tasks.bounds.update(x, y, z);
     }
     //@ts-ignore
     tasks.queues.flow.update.queue = reque;

package/Tasks/Propagation/Illumanation/Functions/RGBUpdate.d.ts

@@ -0,0 +1,3 @@
+import { UpdateTask } from "../../../Update/UpdateTask";
+export declare function RGBUpdate(tasks: UpdateTask): void;
+export declare function RGBRemove(tasks: UpdateTask): void;

package/Tasks/Propagation/Illumanation/Functions/RGBUpdate.js

@@ -0,0 +1,82 @@
+import { $3dCardinalNeighbors } from "../../../../Math/Constants/CardinalNeighbors";
+import { LightData } from "../../../../Voxels/LightData";
+//@todo change array to not use push and shift
+export function RGBUpdate(tasks) {
+    const queue = tasks.rgb.update;
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const sl = voxel.getLight();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 6; i++) {
+            const nx = $3dCardinalNeighbors[i][0] + x;
+            const ny = $3dCardinalNeighbors[i][1] + y;
+            const nz = $3dCardinalNeighbors[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (!voxel)
+                continue;
+            const nl = voxel.getLight();
+            if (nl > -1 && LightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(nx, ny, nz);
+                voxel.setLight(LightData.getMinusOneForRGB(sl, nl));
+            }
+        }
+        tasks.bounds.update(x, y, z);
+    }
+}
+export function RGBRemove(tasks) {
+    const remove = tasks.rgb.remove;
+    const update = tasks.rgb.update;
+    const removeMap = tasks.rgb.removeMap;
+    const updateMap = tasks.sun.updateMap;
+    while (remove.length) {
+        const x = remove.shift();
+        const y = remove.shift();
+        const z = remove.shift();
+        if (removeMap.has(x, y, z))
+            continue;
+        removeMap.add(x, y, z);
+        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const sl = voxel.getLight();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 6; i++) {
+            const nx = $3dCardinalNeighbors[i][0] + x;
+            const ny = $3dCardinalNeighbors[i][1] + y;
+            const nz = $3dCardinalNeighbors[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (!voxel)
+                continue;
+            const nl = voxel.getLight();
+            const n1HasRGB = LightData.hasRGBLight(nl);
+            if (n1HasRGB && LightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(nx, ny, nz);
+                if (voxel.isLightSource()) {
+                    update.push(nx, ny, nz);
+                }
+            }
+            else {
+                if (n1HasRGB &&
+                    LightData.isGreaterOrEqualThanForRGBRemove(nl, sl) &&
+                    !updateMap.has(nx, ny, nz)) {
+                    updateMap.add(nx, ny, nz);
+                    update.push(nx, ny, nz);
+                }
+            }
+        }
+        tasks.bounds.update(x, y, z);
+        voxel.setLight(LightData.removeRGBLight(sl));
+    }
+    removeMap.clear();
+}

package/Tasks/Propagation/Illumanation/Functions/SunUpdate.d.ts

@@ -0,0 +1,3 @@
+import { UpdateTask } from "../../../Update/UpdateTask";
+export declare function SunUpdate(tasks: UpdateTask): void;
+export declare function SunRemove(tasks: UpdateTask, clearUpdateMap?: boolean): void;

package/Tasks/Propagation/Illumanation/Functions/SunUpdate.js

@@ -0,0 +1,116 @@
+import { LightData } from "../../../../Voxels/LightData";
+const FloodOutPositions = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [0, 1, 0],
+];
+export function SunUpdate(tasks) {
+    const queue = tasks.sun.update;
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const sl = voxel.getLight();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 5; i++) {
+            const nx = FloodOutPositions[i][0] + x;
+            const ny = FloodOutPositions[i][1] + y;
+            const nz = FloodOutPositions[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > -1 && LightData.isLessThanForSunAdd(nl, sl)) {
+                    queue.push(nx, ny, nz);
+                    nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                }
+            }
+        }
+        if (tasks.nDataCursor.inBounds(x, y - 1, z)) {
+            const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > -1 && LightData.isLessThanForSunAddDown(nl, sl)) {
+                    if (nVoxel.isAir()) {
+                        queue.push(x, y - 1, z);
+                        nVoxel.setLight(LightData.getSunLightForUnderVoxel(sl, nl));
+                    }
+                    else {
+                        if (!nVoxel.isOpaque()) {
+                            queue.push(x, y - 1, z);
+                            nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                        }
+                    }
+                }
+            }
+        }
+        tasks.bounds.update(x, y, z);
+    }
+}
+export function SunRemove(tasks, clearUpdateMap = true) {
+    const remove = tasks.sun.remove;
+    const update = tasks.sun.update;
+    const removeMap = tasks.sun.removeMap;
+    const updateMap = tasks.sun.updateMap;
+    while (remove.length) {
+        const x = remove.shift();
+        const y = remove.shift();
+        const z = remove.shift();
+        if (removeMap.has(x, y, z))
+            continue;
+        removeMap.add(x, y, z);
+        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const sl = voxel.getLight();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 5; i++) {
+            const nx = FloodOutPositions[i][0] + x;
+            const ny = FloodOutPositions[i][1] + y;
+            const nz = FloodOutPositions[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (LightData.isLessThanForSunRemove(nl, sl)) {
+                        remove.push(nx, ny, nz);
+                    }
+                    else if (LightData.isGreaterOrEqualThanForSunRemove(nl, sl) &&
+                        !updateMap.has(nx, ny, nz)) {
+                        updateMap.add(nx, ny, nz);
+                        update.push(nx, ny, nz);
+                    }
+                }
+            }
+        }
+        if (tasks.nDataCursor.inBounds(x, y - 1, z)) {
+            const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (LightData.sunLightCompareForDownSunRemove(nl, sl)) {
+                        remove.push(x, y - 1, z);
+                    }
+                    else if (LightData.isGreaterOrEqualThanForSunRemove(nl, sl) &&
+                        !updateMap.has(x, y - 1, z)) {
+                        updateMap.add(x, y - 1, z);
+                        update.push(x, y - 1, z);
+                    }
+                }
+            }
+        }
+        tasks.bounds.update(x, y, z);
+        voxel.setLight(LightData.removeSunLight(sl));
+    }
+    removeMap.clear();
+}

package/Tasks/Propagation/Illumanation/Functions/WorldSun.d.ts

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

package/Tasks/Propagation/Illumanation/Functions/WorldSun.js

@@ -0,0 +1,115 @@
+//types
+//data
+import { WorldBounds } from "../../../../Data/World/WorldBounds.js";
+import { WorldRegister } from "../../../../Data/World/WorldRegister.js";
+import { $3dCardinalNeighbors } from "../../../../Math/Constants/CardinalNeighbors.js";
+import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
+import { IlluminationManager as IM } from "../IlluminationManager.js";
+import { HeightMapTool } from "../../../../Tools/Data/WorldData/HeightMapTool.js";
+import { LightData } from "../../../../Voxels/LightData";
+import { WorldCursor } from "../../../../Data/Cursor/World/WorldCursor";
+const worldCursor = new WorldCursor();
+const heightMapTool = new HeightMapTool();
+const FloodOutPositions = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [0, 1, 0],
+];
+const queue = [];
+export function RunWorldSun(tasks) {
+    IM.setDimension(tasks.origin[0]);
+    WorldRegister.instance.setDimension(tasks.origin[0]);
+    if (!WorldRegister.instance.column.get(tasks.origin[1], tasks.origin[2], tasks.origin[2]))
+        return false;
+    const [dimension, cx, cy, cz] = tasks.origin;
+    IM._sDataTool.setDimension(dimension);
+    const RmaxY = heightMapTool.column.getRelative(tasks.origin);
+    const AmaxY = heightMapTool.column.getAbsolute(tasks.origin);
+    const maxX = cx + WorldSpaces.chunk._bounds.x;
+    const maxY = WorldBounds.bounds.MaxY;
+    const maxZ = cz + WorldSpaces.chunk._bounds.z;
+    worldCursor.setFocalPoint(...tasks.origin);
+    const columnCursor = worldCursor.getColumn(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
+    if (!columnCursor)
+        return;
+    const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
+    //fill
+    for (let iy = minY; iy < maxY; iy++) {
+        for (let iz = cz; iz < maxZ; iz++) {
+            for (let ix = cx; ix < maxX; ix++) {
+                const voxel = columnCursor.getVoxel(ix, iy, iz);
+                if (!voxel)
+                    continue;
+                const l = voxel.getLight();
+                if (l < 0)
+                    continue;
+                voxel.setLight(LightData.setS(0xf, l));
+            }
+        }
+    }
+    const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
+    //accumulate
+    for (let iy = minY; iy <= maxAcculamteY; iy++) {
+        for (let iz = cz; iz < maxZ; iz++) {
+            for (let ix = cx; ix < maxX; ix++) {
+                const l = columnCursor.getVoxel(ix, iy, iz)?.getLight();
+                if (l && l < 0 && LightData.getS(l) != 0xf)
+                    continue;
+                for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+                    const n = $3dCardinalNeighbors[i];
+                    const nx = ix + n[0];
+                    const ny = iy + n[1];
+                    const nz = iz + n[2];
+                    const nVoxel = worldCursor.getVoxel(nx, ny, nz);
+                    if (!nVoxel)
+                        continue;
+                    const nl = nVoxel.getLight();
+                    if (nl > -1 && LightData.getS(nl) < 0xf) {
+                        queue.push(ix, iy, iz);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    //flood
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const sl = worldCursor.getVoxel(x, y, z)?.getLight();
+        if (!sl || sl < 0)
+            continue;
+        for (let i = 0; i < 5; i++) {
+            const nx = x + FloodOutPositions[i][0];
+            const ny = y + FloodOutPositions[i][1];
+            const nz = z + FloodOutPositions[i][2];
+            const nVoxel = worldCursor.getVoxel(nx, ny, nz);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > -1 && LightData.isLessThanForSunAdd(nl, sl)) {
+                    queue.push(nx, ny, nz);
+                    nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                }
+            }
+        }
+        const nVoxel = worldCursor.getVoxel(x, y - 1, z);
+        if (nVoxel) {
+            const nl = nVoxel.getLight();
+            if (nl > -1 && LightData.isLessThanForSunAddDown(nl, sl)) {
+                if (nVoxel.isAir()) {
+                    queue.push(x, y - 1, z);
+                    nVoxel.setLight(LightData.getSunLightForUnderVoxel(sl, nl));
+                }
+                else {
+                    if (!nVoxel.isOpaque()) {
+                        queue.push(x, y - 1, z);
+                        nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                    }
+                }
+            }
+        }
+    }
+}

package/{Propagation → Tasks/Propagation}/Illumanation/IlluminationManager.d.ts

@@ -1,4 +1,4 @@
-import { DataTool } from "../../Tools/Data/DataTool.js";
+import { DataTool } from "../../../Tools/Data/DataTool.js";
 export declare const IlluminationManager: {
     lightData: {
         SRS: number;