@divinevoxel/vlox 0.0.74 → 0.0.75

package/Tasks/Paint/Erase/EraseVoxelPath.js

@@ -0,0 +1,80 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { Vector3Like } from "@amodx/math";
+import { VoxelPath } from "../../../Templates/Path/VoxelPath";
+const tasks = new VoxelUpdateTask();
+const min = Vector3Like.Create();
+const max = Vector3Like.Create();
+const updateBounds = (x, y, z) => {
+    if (x < min.x)
+        min.x = x;
+    if (y < min.y)
+        min.y = y;
+    if (z < min.z)
+        min.z = z;
+    if (x > max.x)
+        max.x = x;
+    if (y > max.y)
+        max.y = y;
+    if (z > max.z)
+        max.z = z;
+};
+export default function EraseVoxelPath(dimension, [ox, oy, oz], voxelPathData, updateData) {
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const path = new VoxelPath(voxelPathData);
+    for (let i = 0; i < path.segments.length; i++) {
+        const { start, end, voxel } = path.segments[i];
+        min.x = Infinity;
+        min.y = Infinity;
+        min.z = Infinity;
+        max.x = -Infinity;
+        max.y = -Infinity;
+        max.z = -Infinity;
+        const [sx, sy, sz] = start;
+        const [ex, ey, ez] = end;
+        const dx = ex - sx;
+        const dy = ey - sy;
+        const dz = ez - sz;
+        const steps = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+        if (steps === 0) {
+            if (!canUpdate(sx, sy, sz, updateData))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(sx, sy, sz);
+            if (!voxel)
+                continue;
+            voxel.ids[voxel._index] = 0;
+            voxel.level[voxel._index] = 0;
+            voxel.secondary[voxel._index] = 0;
+            voxel.light[voxel._index] = 0;
+            voxel.updateVoxel(1);
+            updateArea(tasks, sx, sy, sz, sx, sy, sz);
+            continue;
+        }
+        const stepX = dx / steps;
+        const stepY = dy / steps;
+        const stepZ = dz / steps;
+        let x = sx;
+        let y = sy;
+        let z = sz;
+        for (let step = 0; step <= steps; step++) {
+            const vx = Math.floor(x);
+            const vy = Math.floor(y);
+            const vz = Math.floor(z);
+            x += stepX;
+            y += stepY;
+            z += stepZ;
+            if (!canUpdate(vx, vy, vz, updateData))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(vx, vy, vz);
+            if (!voxel)
+                continue;
+            voxel.ids[voxel._index] = 0;
+            voxel.level[voxel._index] = 0;
+            voxel.secondary[voxel._index] = 0;
+            voxel.light[voxel._index] = 0;
+            voxel.updateVoxel(1);
+            updateBounds(vx, vy, vz);
+        }
+        updateArea(tasks, min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+}

package/Tasks/Paint/Erase/EraseVoxelTemplate.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types";
+import { Vec3Array } from "@amodx/math";
+import { IVoxelTemplateData } from "Templates/VoxelTemplates.types";
+export default function EraseVoxelTemplate(dimension: number, [ox, oy, oz]: Vec3Array, templateData: IVoxelTemplateData<any>, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Erase/EraseVoxelTemplate.js

@@ -0,0 +1,34 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+const tasks = new VoxelUpdateTask();
+const raw = [0, 0, 0, 0];
+export default function EraseVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {
+    const voxelTemplate = VoxelTemplateRegister.create(templateData);
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const { x: sx, y: sy, z: sz } = voxelTemplate.bounds.size;
+    for (let x = 0; x < sx; x++) {
+        for (let y = 0; y < sy; y++) {
+            for (let z = 0; z < sz; z++) {
+                const tx = ox + x;
+                const ty = oy + y;
+                const tz = oz + z;
+                if (!voxelTemplate.isIncluded(voxelTemplate.getIndex(x, y, z)))
+                    continue;
+                if (!canUpdate(tx, ty, tz, updateData))
+                    continue;
+                if (!tasks.sDataCursor.inBounds(tx, ty, tz))
+                    continue;
+                const voxel = tasks.sDataCursor.getVoxel(tx, ty, tz);
+                if (!voxel || voxel.isAir())
+                    continue;
+                voxel.ids[voxel._index] = 0;
+                voxel.level[voxel._index] = 0;
+                voxel.secondary[voxel._index] = 0;
+                voxel.light[voxel._index] = 0;
+                voxel.updateVoxel(1);
+            }
+        }
+    }
+    updateArea(tasks, ox, oy, oz, ox + sx, oy + sy, oz + sz);
+}

package/Tasks/Paint/InitTasks.js

@@ -0,0 +1,16 @@
+import { Threads } from "@amodx/threads";
+import { TasksIds } from "../TasksIds";
+import { EraseVoxel } from "./Erase/EraseVoxel";
+import { PaintVoxel } from "./Paint/PaintVoxel";
+import PaintVoxelTemplate from "./Paint/PaintVoxelTemplate";
+import EraseVoxelTemplate from "./Erase/EraseVoxelTemplate";
+import PaintVoxelPath from "./Paint/PaintVoxelPath";
+import EraseVoxelPath from "./Erase/EraseVoxelPath";
+export default function () {
+    Threads.registerTask(TasksIds.PaintVoxel, (data) => PaintVoxel(...data));
+    Threads.registerTask(TasksIds.PaintVoxelTemplate, (data) => PaintVoxelTemplate(...data));
+    Threads.registerTask(TasksIds.PaintVoxelPath, (data) => PaintVoxelPath(...data));
+    Threads.registerTask(TasksIds.EraseVoxel, (data) => EraseVoxel(...data));
+    Threads.registerTask(TasksIds.EraseVoxelTemplate, (data) => EraseVoxelTemplate(...data));
+    Threads.registerTask(TasksIds.EraseVoxelPath, (data) => EraseVoxelPath(...data));
+}

package/Tasks/Paint/Paint/PaintVoxel.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types.js";
+import type { LocationData } from "../../../Math/Location";
+import { RawVoxelData } from "../../../Voxels/Types/Voxel.types.js";
+export declare function PaintVoxel(location: LocationData, raw: RawVoxelData, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Paint/PaintVoxel.js

@@ -0,0 +1,29 @@
+import { EngineSettings as ES } from "../../../Settings/EngineSettings.js";
+import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
+import { canUpdate, updateArea, updatePowerTask } from "../Common.js";
+import { PowerUpdate } from "../../Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export function PaintVoxel(location, raw, updateData) {
+    const [dimension, x, y, z] = location;
+    if (!canUpdate(x, y, z, updateData))
+        return;
+    tasks.setOriginAt(location);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return;
+    raw[1] = 0;
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    voxel.setRaw(raw);
+    voxel.updateVoxel(0);
+    updateArea(tasks, x, y, z, x, y, z);
+    if (ES.doPower) {
+        if (voxel.tags["dve_can_be_powered"] ||
+            voxel.tags["dve_is_power_source"] ||
+            voxel.tags["dve_can_carry_power"] ||
+            voxel.tags["dve_can_hold_power"]) {
+            updatePowerTask(tasks);
+            tasks.power.update.push(x, y, z);
+            PowerUpdate(tasks);
+        }
+    }
+}

package/Tasks/Paint/Paint/PaintVoxelPath.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types";
+import { Vec3Array } from "@amodx/math";
+import { VoxelPathData } from "../../../Templates/Path/VoxelPath.types";
+export default function PaintVoxelPath(dimension: number, [ox, oy, oz]: Vec3Array, voxelPathData: VoxelPathData, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Paint/PaintVoxelPath.js

@@ -0,0 +1,78 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { PaintVoxelData } from "../../../Voxels/Types/PaintVoxelData";
+import { VoxelPath } from "../../../Templates/Path/VoxelPath";
+import { Vector3Like } from "@amodx/math";
+const tasks = new VoxelUpdateTask();
+const min = Vector3Like.Create();
+const max = Vector3Like.Create();
+const updateBounds = (x, y, z) => {
+    if (x < min.x)
+        min.x = x;
+    if (y < min.y)
+        min.y = y;
+    if (z < min.z)
+        min.z = z;
+    if (x > max.x)
+        max.x = x;
+    if (y > max.y)
+        max.y = y;
+    if (z > max.z)
+        max.z = z;
+};
+export default function PaintVoxelPath(dimension, [ox, oy, oz], voxelPathData, updateData) {
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const path = new VoxelPath(voxelPathData);
+    for (let i = 0; i < path.segments.length; i++) {
+        const { start, end, voxel } = path.segments[i];
+        const rawVoxel = PaintVoxelData.ToRaw(voxel);
+        min.x = Infinity;
+        min.y = Infinity;
+        min.z = Infinity;
+        max.x = -Infinity;
+        max.y = -Infinity;
+        max.z = -Infinity;
+        const [sx, sy, sz] = start;
+        const [ex, ey, ez] = end;
+        const dx = ex - sx;
+        const dy = ey - sy;
+        const dz = ez - sz;
+        const steps = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+        if (steps === 0) {
+            if (!canUpdate(sx, sy, sz, updateData))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(sx, sy, sz);
+            if (!voxel)
+                continue;
+            voxel.setLight(0);
+            voxel.setRaw(rawVoxel);
+            voxel.updateVoxel(0);
+            updateArea(tasks, sx, sy, sz, sx, sy, sz);
+            continue;
+        }
+        const stepX = dx / steps;
+        const stepY = dy / steps;
+        const stepZ = dz / steps;
+        let x = sx;
+        let y = sy;
+        let z = sz;
+        for (let step = 0; step <= steps; step++) {
+            const vx = Math.floor(x);
+            const vy = Math.floor(y);
+            const vz = Math.floor(z);
+            x += stepX;
+            y += stepY;
+            z += stepZ;
+            if (!canUpdate(vx, vy, vz, updateData))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(vx, vy, vz);
+            if (!voxel)
+                continue;
+            voxel.setLight(0);
+            voxel.setRaw(rawVoxel);
+            voxel.updateVoxel(0);
+            updateBounds(vx, vy, vz);
+        }
+        updateArea(tasks, min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+}

package/Tasks/Paint/Paint/PaintVoxelTemplate.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types";
+import { Vec3Array } from "@amodx/math";
+import { IVoxelTemplateData } from "../../../Templates/VoxelTemplates.types";
+export default function PaintVoxelTemplate(dimension: number, [ox, oy, oz]: Vec3Array, templateData: IVoxelTemplateData<any>, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Paint/PaintVoxelTemplate.js

@@ -0,0 +1,36 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+const tasks = new VoxelUpdateTask();
+const raw = [0, 0, 0, 0];
+export default function PaintVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {
+    const voxelTemplate = VoxelTemplateRegister.create(templateData);
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const { x: sx, y: sy, z: sz } = voxelTemplate.bounds.size;
+    for (let x = 0; x < sx; x++) {
+        for (let y = 0; y < sy; y++) {
+            for (let z = 0; z < sz; z++) {
+                const tx = ox + x;
+                const ty = oy + y;
+                const tz = oz + z;
+                const index = voxelTemplate.getIndex(x, y, z);
+                if (voxelTemplate.isAir(index))
+                    continue;
+                if (!canUpdate(tx, ty, tz, updateData))
+                    continue;
+                if (!tasks.sDataCursor.inBounds(tx, ty, tz))
+                    continue;
+                const voxel = tasks.sDataCursor.getVoxel(tx, ty, tz);
+                if (!voxel)
+                    continue;
+                voxelTemplate.getRaw(index, raw);
+                if (raw[0] == 0)
+                    continue;
+                raw[1] = 0;
+                voxel.setRaw(raw);
+                voxel.updateVoxel(0);
+            }
+        }
+    }
+    updateArea(tasks, ox, oy, oz, ox + sx, oy + sy, oz + sz);
+}

package/Tasks/Propagation/Flow/FlowUpdate.js

@@ -90,7 +90,7 @@ function RunFlowIncrease(tasks, vox) {
             FM.setVoxel(tasks, vox, level, levelState, x, y, z);
             reque.push([x, y, z, -1]);
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
     //@ts-ignore
     tasks.queues.flow.update.queue = reque;

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -38,7 +38,7 @@ function Flood(task, voxel) {
                 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;
+                const downSameVoxel = downVoxel?.getVoxelId() == voxelId;
                 let nVoxel = task.nDataCursor.getVoxel(nx, ny, nz);
                 if (!nVoxel)
                     continue;
@@ -75,7 +75,7 @@ function Flood(task, voxel) {
         let nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
         const nLevel = nVoxel.isAir()
             ? 0
-            : nVoxel.getId() == voxelId
+            : nVoxel.getVoxelId() == voxelId
                 ? nVoxel.getLevel()
                 : -1;
         const nState = nVoxel.getLevelState();

package/Tasks/Propagation/Illumanation/CommonFunctions.d.ts

@@ -47,7 +47,7 @@ export declare function getFullSunLight(sl: number): number;
  * @param n1
  * @param n2
  */
-export declare function isLessThanForSunAdd(n1: number, n2: number): boolean;
+export declare function isLessThanForSunAdd(n1: number, n2: number, SRS: number): boolean;
 /**# Is Less Than For Sun AddDown
  *
  * Used to calculate sun light addition.
@@ -55,22 +55,22 @@ export declare function isLessThanForSunAdd(n1: number, n2: number): boolean;
  * @param n1
  * @param n2
  */
-export declare function isLessThanForSunAddDown(n1: number, n2: number): boolean;
-export declare function isLessThanForSunAddUp(n1: number, n2: number): boolean;
+export declare function isLessThanForSunAddDown(n1: number, n2: number, SRS: number): boolean;
+export declare function isLessThanForSunAddUp(n1: number, n2: number, SRS: number): boolean;
 /**# Get Sun Light For Under Voxel
  * ---
  * Gets the sun light value for sun light addition when setting the
  * down neighbor.
  * @param currentVoxel
  */
-export declare function getSunLightForUnderVoxel(sl: number, nl: number): number;
+export declare function getSunLightForUnderVoxel(sl: number, nl: number, SRS: number): number;
 /**# Get Minus One For Sun
  * ---
  * Returns the sun light level passed to it minus one.
  * Used for sun light addition on all neighbors expect the down one.
  * @param sl - source light value
  */
-export declare function getMinusOneForSun(sl: number, nl: number): number;
+export declare function getMinusOneForSun(sl: number, nl: number, SRS: number): number;
 /**# Is Less Than For Sun Remove
  * ---
  * Compares two encoded light values sun light values.
@@ -101,4 +101,4 @@ export declare function sunLightCompareForDownSunRemove(n1: number, sl: number):
  * @param sl - source light value
  */
 export declare function removeSunLight(sl: number): number;
-export declare function minusOneForAll(sl: number): number;
+export declare function minusOneForAll(sl: number, SRS: number): number;

package/Tasks/Propagation/Illumanation/CommonFunctions.js

@@ -1,4 +1,3 @@
-let SRS = 2;
 function getS(value) {
     return value & 0xf;
 }
@@ -135,7 +134,7 @@ export function getFullSunLight(sl) {
  * @param n1
  * @param n2
  */
-export function isLessThanForSunAdd(n1, n2) {
+export function isLessThanForSunAdd(n1, n2, SRS) {
     let sl1 = getS(n1);
     let sl2 = getS(n2);
     return sl1 + SRS < sl2;
@@ -147,7 +146,7 @@ export function isLessThanForSunAdd(n1, n2) {
  * @param n1
  * @param n2
  */
-export function isLessThanForSunAddDown(n1, n2) {
+export function isLessThanForSunAddDown(n1, n2, SRS) {
     let sl1 = getS(n1);
     let sl2 = getS(n2);
     if (sl2 == 0xf) {
@@ -155,7 +154,7 @@ export function isLessThanForSunAddDown(n1, n2) {
     }
     return sl1 + SRS < sl2;
 }
-export function isLessThanForSunAddUp(n1, n2) {
+export function isLessThanForSunAddUp(n1, n2, SRS) {
     let sl1 = getS(n1);
     let sl2 = getS(n2);
     if (sl1 == sl2)
@@ -170,7 +169,7 @@ export function isLessThanForSunAddUp(n1, n2) {
  * down neighbor.
  * @param currentVoxel
  */
-export function getSunLightForUnderVoxel(sl, nl) {
+export function getSunLightForUnderVoxel(sl, nl, SRS) {
     let s = getS(sl);
     let sn = getS(nl);
     if (s == 15) {
@@ -195,7 +194,7 @@ export function getSunLightForUnderVoxel(sl, nl) {
  * Used for sun light addition on all neighbors expect the down one.
  * @param sl - source light value
  */
-export function getMinusOneForSun(sl, nl) {
+export function getMinusOneForSun(sl, nl, SRS) {
     let s = getS(sl) - SRS;
     if (s < 0)
         s = 0;
@@ -259,7 +258,7 @@ export function sunLightCompareForDownSunRemove(n1, sl) {
 export function removeSunLight(sl) {
     return setS(0, sl);
 }
-export function minusOneForAll(sl) {
+export function minusOneForAll(sl, SRS) {
     let s = getS(sl) - SRS;
     let r = getR(sl) - 1;
     let g = getG(sl) - 1;

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
 import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeRGBLight, } from "./CommonFunctions";
 //@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
@@ -14,9 +14,9 @@ export function RGBUpdate(tasks) {
         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;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -28,7 +28,7 @@ export function RGBUpdate(tasks) {
                 voxel.setLight(getMinusOneForRGB(sl, nl));
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function RGBRemove(tasks) {
@@ -50,9 +50,9 @@ export function RGBRemove(tasks) {
         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;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -75,7 +75,7 @@ export function RGBRemove(tasks) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setLight(removeRGBLight(sl));
     }
     removeMap.clear();

package/Tasks/Propagation/Illumanation/SunUpdate.js

@@ -1,3 +1,4 @@
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
 import { isLessThanForSunAdd, getMinusOneForSun, isLessThanForSunAddDown, getSunLightForUnderVoxel, removeSunLight, isLessThanForSunRemove, isGreaterOrEqualThanForSunRemove, sunLightCompareForDownSunRemove, } from "./CommonFunctions";
 const FloodOutPositions = [
     [1, 0, 0],
@@ -27,9 +28,9 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
                     queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                 }
             }
         }
@@ -37,21 +38,21 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
                     if (nVoxel.isAir()) {
                         queue.push(x, y - 1, z);
-                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
                     }
                     else {
                         if (!nVoxel.isOpaque()) {
                             queue.push(x, y - 1, z);
-                            nVoxel.setLight(getMinusOneForSun(sl, nl));
+                            nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                         }
                     }
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function SunRemove(tasks, clearUpdateMap = true) {
@@ -109,7 +110,7 @@ export function SunRemove(tasks, clearUpdateMap = true) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setLight(removeSunLight(sl));
     }
     removeMap.clear();

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors.js";
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 import { SectorHeightMap } from "../../../World/Sector/SectorHeightMap.js";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
@@ -15,7 +15,7 @@ const lightData = new VoxelLightData();
 export function RunWorldSun(tasks) {
     const [, cx, cy, cz] = tasks.origin;
     const RmaxY = SectorHeightMap.getRelative(tasks.origin);
-    const AmaxY = SectorHeightMap.getAbsolute(tasks.origin);
+    const AmaxY = SectorHeightMap.getAbsolute(...tasks.origin);
     const maxX = cx + WorldSpaces.sector.bounds.x;
     const maxY = cy + WorldSpaces.sector.bounds.y;
     const maxZ = cz + WorldSpaces.sector.bounds.z;
@@ -58,8 +58,8 @@ export function RunWorldSun(tasks) {
                 const l = sectorCursor.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];
+                for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                    const n = CardinalNeighbors3D[i];
                     const nx = ix + n[0];
                     const ny = iy + n[1];
                     const nz = iz + n[2];
@@ -92,24 +92,26 @@ export function RunWorldSun(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
+                if (nl > -1 &&
+                    isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
                     queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                 }
             }
         }
         const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
         if (nVoxel) {
             const nl = nVoxel.getLight();
-            if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
+            if (nl > -1 &&
+                isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
                 if (nVoxel.isAir()) {
                     queue.push(x, y - 1, z);
-                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
                 }
                 else {
                     if (!nVoxel.isOpaque()) {
                         queue.push(x, y - 1, z);
-                        nVoxel.setLight(getMinusOneForSun(sl, nl));
+                        nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                     }
                 }
             }

package/Tasks/Propagation/InitTasks.js

@@ -1,39 +1,27 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { VoxelUpdateTask } from "../VoxelUpdateTask";
-import { WorldSpaces } from "../../World/WorldSpaces";
 import { RunWorldSun } from "./Illumanation/WorldSun";
-import { ExplosionManager } from "./Explosion/ExplosionManager";
 import { WorldRGB } from "./Illumanation/WorldRGB";
+import { WorldRegister } from "../../World/WorldRegister";
+import { Sector } from "../../World";
+import { getLocationData } from "../../Util/LocationData";
 export default function InitTasks() {
-    Threads.registerTask(TasksIds.Propagation, async (location) => {
-        const task = new VoxelUpdateTask();
-        task.setOrigin(location);
+    const task = new VoxelUpdateTask();
+    Threads.registerBinaryTask(TasksIds.WorldPropagation, (view) => {
+        const location = getLocationData(view);
+        task.setOrigin(...location);
         WorldRGB(task);
-        //  task.setOrigin(location);
-        // WorldFlow(task);
+        WorldRegister.sectors
+            .get(...location)
+            .setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
     });
-    Threads.registerTask(TasksIds.Explosion, async (data) => {
-        const location = data[0];
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const task = new VoxelUpdateTask();
-        task.setOrigin([
-            location[0],
-            sectorPosition.x,
-            sectorPosition.y,
-            sectorPosition.z,
-        ]);
-        ExplosionManager.runExplosion(task, data[1]);
-    });
-    Threads.registerTask(TasksIds.WorldSun, (location) => {
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const task = new VoxelUpdateTask();
-        task.setOrigin([
-            location[0],
-            sectorPosition.x,
-            sectorPosition.y,
-            sectorPosition.z,
-        ]);
+    Threads.registerBinaryTask(TasksIds.WorldSun, (view) => {
+        const location = getLocationData(view);
+        task.setOrigin(...location);
         RunWorldSun(task);
+        WorldRegister.sectors
+            .get(...location)
+            .setBitFlag(Sector.FlagIds.isWorldSunDone, true);
     });
 }