@divinevoxel/vlox 0.0.74 → 0.0.76

package/Tasks/Paint/Common.js

@@ -0,0 +1,200 @@
+import { CardinalNeighbors3D } from "../../Math/CardinalNeighbors.js";
+import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
+import { RGBRemove, RGBUpdate, SunRemove, SunUpdate, } from "../Propagation/index.js";
+export const updatePowerTask = (tasks) => {
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of CardinalNeighbors3D) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        if (nVoxel.getPower() > 0) {
+            tasks.power.update.push(nx, ny, nz);
+        }
+    }
+};
+const lightData = new VoxelLightData();
+export const canUpdate = (x, y, z, data) => {
+    const { includedAreas, excludeAreas } = data;
+    // Check if includedAreas is set and not empty
+    if (includedAreas && includedAreas.length > 0) {
+        let insideIncluded = false;
+        for (let i = 0; i < includedAreas.length; i++) {
+            const min = includedAreas[i][0];
+            const max = includedAreas[i][1];
+            if (x >= min[0] &&
+                x <= max[0] &&
+                y >= min[1] &&
+                y <= max[1] &&
+                z >= min[2] &&
+                z <= max[2]) {
+                insideIncluded = true;
+                break;
+            }
+        }
+        if (!insideIncluded)
+            return false;
+    }
+    // Check if excludeAreas is set and not empty
+    if (excludeAreas && excludeAreas.length > 0) {
+        for (let i = 0; i < excludeAreas.length; i++) {
+            const min = excludeAreas[i][0];
+            const max = excludeAreas[i][1];
+            if (x >= min[0] &&
+                x <= max[0] &&
+                y >= min[1] &&
+                y <= max[1] &&
+                z >= min[2] &&
+                z <= max[2]) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+/**Checks if the given voxel needs a light update and adds it to the needed queues */
+export const checkLightUpdate = (x, y, z, tasks) => {
+    let needSunRemove = false;
+    let needSunUpdate = false;
+    let needRGBRemove = false;
+    let needRGBUpdate = false;
+    const voxel = tasks.nDataCursor.getVoxel(x, y, z);
+    const lightValue = voxel.getLight();
+    const sunValue = lightData.getS(lightValue);
+    if (sunValue == 15) {
+        const voxel = tasks.nDataCursor.getVoxel(x, y + 1, z);
+        if (voxel) {
+            const light = voxel.getLight();
+            const v = lightData.getS(light);
+            if (light < 0 || v != 15) {
+                needSunRemove = true;
+            }
+        }
+    }
+    const redValue = lightData.getR(lightValue);
+    const greenValue = lightData.getG(lightValue);
+    const blueValue = lightData.getB(lightValue);
+    const hasSunLight = sunValue > 0;
+    const hasRGBLight = voxel.hasRGBLight();
+    let foundHigherSun = false;
+    let foundHigherRed = false;
+    let foundHigherGreen = false;
+    let foundHigherBlue = false;
+    let lowestSunValue = Infinity;
+    let lowestRedValue = Infinity;
+    let lowestGreenValue = Infinity;
+    let lowestBlueValue = Infinity;
+    for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+        const n = CardinalNeighbors3D[i];
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        const nLight = nVoxel.getLight();
+        if (nLight === -1)
+            continue;
+        if (hasSunLight) {
+            const nSunValue = lightData.getS(nLight);
+            if (nSunValue < lowestSunValue) {
+                lowestSunValue = nSunValue;
+            }
+            if (nSunValue > sunValue) {
+                foundHigherSun = true;
+            }
+        }
+        if (hasRGBLight) {
+            const nRedValue = lightData.getR(nLight);
+            if (nRedValue > lowestRedValue) {
+                lowestRedValue = nRedValue;
+            }
+            if (nRedValue > redValue) {
+                foundHigherRed = true;
+            }
+            const nGreenValue = lightData.getG(nLight);
+            if (nGreenValue < lowestGreenValue) {
+                lowestGreenValue = nGreenValue;
+            }
+            if (nGreenValue > greenValue) {
+                foundHigherGreen = true;
+            }
+            const nBlueValue = lightData.getB(nLight);
+            if (nBlueValue > lowestBlueValue) {
+                lowestBlueValue = nBlueValue;
+            }
+            if (nBlueValue < blueValue) {
+                foundHigherBlue = true;
+            }
+        }
+    }
+    if (hasSunLight) {
+        //sun
+        if (sunValue != 15 && sunValue != 0 && !foundHigherSun) {
+            needSunRemove = true;
+        }
+        if ((foundHigherSun || sunValue == 15) &&
+            lowestSunValue < sunValue - VoxelLightData.SunFallOffValue) {
+            needSunUpdate = true;
+        }
+    }
+    if (hasRGBLight) {
+        //red
+        if (redValue != 15 && !foundHigherRed) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherRed || redValue == 15) && lowestRedValue < redValue - 1) {
+            needRGBUpdate = true;
+        }
+        //green
+        if (greenValue != 15 && !foundHigherGreen) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherGreen || greenValue == 15) &&
+            lowestGreenValue < greenValue - 1) {
+            needRGBUpdate = true;
+        }
+        //blue
+        if (blueValue != 15 && !foundHigherBlue) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherBlue || blueValue == 15) &&
+            lowestBlueValue < blueValue - 1) {
+            needRGBUpdate = true;
+        }
+    }
+    if (needSunRemove) {
+        tasks.sun.remove.push(x, y, z);
+    }
+    if (needSunUpdate && !needSunRemove) {
+        tasks.sun.update.push(x, y, z);
+    }
+    if (needRGBRemove) {
+        tasks.rgb.remove.push(x, y, z);
+    }
+    if (needRGBUpdate && !needRGBRemove) {
+        tasks.rgb.update.push(x, y, z);
+    }
+};
+export const updateArea = (tasks, sx, sy, sz, ex, ey, ez) => {
+    for (let x = sx - 1; x < ex + 1; x++) {
+        for (let y = sy - 1; y < ey + 1; y++) {
+            for (let z = sz - 1; z < ez + 1; z++) {
+                const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+                if (!voxel)
+                    continue;
+                voxel.updateVoxel(2);
+                checkLightUpdate(x, y, z, tasks);
+                tasks.bounds.updateDisplay(x, y, z);
+            }
+        }
+    }
+    SunRemove(tasks);
+    RGBRemove(tasks);
+    SunUpdate(tasks);
+    RGBUpdate(tasks);
+    tasks.bounds.markDisplayDirty();
+};

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

@@ -0,0 +1,3 @@
+import { VoxelUpdateData } from "../../../Tasks/Tasks.types.js";
+import type { LocationData } from "../../../Math/Location";
+export declare function EraseVoxel(location: LocationData, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Erase/EraseVoxel.js

@@ -0,0 +1,31 @@
+import { EngineSettings as ES } from "../../../Settings/EngineSettings.js";
+import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
+import { canUpdate, updateArea } from "../Common.js";
+import { PowerRemove, PowerUpdate, } from "../../Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export function EraseVoxel(location, 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;
+    const foundPower = voxel.getPower();
+    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, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doPower) {
+        if (foundPower > -1) {
+            voxel.setLevel(foundPower);
+            tasks.power.remove.push(x, y, z);
+            PowerRemove(tasks);
+            PowerUpdate(tasks);
+        }
+    }
+    tasks.bounds.markDisplayDirty();
+}

package/Tasks/Paint/Erase/EraseVoxelPath.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 EraseVoxelPath(dimension: number, [ox, oy, oz]: Vec3Array, voxelPathData: VoxelPathData, updateData: VoxelUpdateData): void;

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 - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
+    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;