@divinevoxel/vlox 0.0.73 → 0.0.75

package/Stats/EngineStats.js

@@ -0,0 +1,27 @@
+class GeomtryStats {
+    /**The total geomtry faces */
+    faces = 0;
+}
+class PaletteStats {
+    /**The final voxel palette id size. */
+    paletteSize = 0;
+}
+/**
+ * Stores data from the results of the engine building data and other things.
+ */
+export class EngineStats {
+    /** Stats to do with the vlox model system. */
+    static geomtry = new GeomtryStats();
+    /** Stats to do with the vloxel palette system. */
+    static palette = new PaletteStats();
+    static log() {
+        let output = "DVE Stats\n";
+        //geomtry
+        output += "Geomtry\n";
+        output += `Faces: ${this.geomtry.faces}\n`;
+        //palettes
+        output += "Palette\n";
+        output += `Paltte Size: ${this.palette.paletteSize}\n`;
+        return output;
+    }
+}

package/Tasks/Paint/Common.d.ts

@@ -0,0 +1,7 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { VoxelUpdateData } from "../../Tasks/Tasks.types.js";
+export declare const updatePowerTask: (tasks: VoxelUpdateTask) => void;
+export declare const canUpdate: (x: number, y: number, z: number, data: VoxelUpdateData) => boolean;
+/**Checks if the given voxel needs a light update and adds it to the needed queues */
+export declare const checkLightUpdate: (x: number, y: number, z: number, tasks: VoxelUpdateTask) => void;
+export declare const updateArea: (tasks: VoxelUpdateTask, sx: number, sy: number, sz: number, ex: number, ey: number, ez: number) => void;

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, y, z, x, y, z);
+    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.d.ts

@@ -0,0 +1 @@
+export default function (): void;

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/FlowManager.d.ts

@@ -1,13 +1,13 @@
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { UpdateTask } from "../../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
 import { WorldCursor } from "../../../World/index.js";
 export declare class FlowManager {
     static _brush: BrushTool;
     static _sDataTool: WorldCursor;
     static _nDataTool: WorldCursor;
-    static setVoxel(tasks: UpdateTask, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
+    static setVoxel(tasks: VoxelUpdateTask, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
     static setDimension(dimension: string): void;
-    static removeVoxel(tasks: UpdateTask, x: number, y: number, z: number): void;
+    static removeVoxel(tasks: VoxelUpdateTask, x: number, y: number, z: number): void;
     static getFlowRate(substance: string): number;
     static getVoxel(x: number, y: number, z: number): WorldCursor;
     static setLevel(level: number, x: number, y: number, z: number): void;
@@ -18,5 +18,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): void;
-    static sunCheck(tasks: UpdateTask, x: number, y: number, z: number): void;
+    static sunCheck(tasks: VoxelUpdateTask, x: number, y: number, z: number): void;
 }

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

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

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

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

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.d.ts

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

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();