@divinevoxel/vlox 0.0.73 → 0.0.75

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

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

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

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

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

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

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

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

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -1,6 +1,4 @@
-//types
-//data
-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,11 +13,11 @@ const FloodOutPositions = [
 const queue = [];
 const lightData = new VoxelLightData();
 export function RunWorldSun(tasks) {
-    const [dimension, cx, cy, cz] = tasks.origin;
+    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 = WorldSpaces.world.bounds.MaxY;
+    const maxY = cy + WorldSpaces.sector.bounds.y;
     const maxZ = cz + WorldSpaces.sector.bounds.z;
     const sectorCursor = tasks.nDataCursor.getSector(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
     if (!sectorCursor) {
@@ -29,7 +27,7 @@ export function RunWorldSun(tasks) {
     const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
     const section = sectorCursor.getSection(cx, minY, cz);
     const sectionY = section.getPosition()[1] + WorldSpaces.section.bounds.y;
-    //fill
+    //fill to relative max y
     for (let iy = minY; iy < sectionY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
@@ -43,6 +41,7 @@ export function RunWorldSun(tasks) {
             }
         }
     }
+    //fill rest
     for (let iy = sectionY; iy < maxY; iy += WorldSpaces.section.bounds.y) {
         const section = sectorCursor.getSection(cx, iy, cz);
         const length = section.light.length;
@@ -50,17 +49,17 @@ export function RunWorldSun(tasks) {
             section.light[i] = lightData.setS(0xf, section.light[i]);
         }
     }
+    //accumulate
     const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
     let index = queue.length;
-    //accumulate
     for (let iy = minY; iy <= maxAcculamteY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
                 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];
@@ -93,30 +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)) {
-                    queue.push(nx);
-                    queue.push(ny);
-                    queue.push(nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                if (nl > -1 &&
+                    isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
+                    queue.push(nx, ny, nz);
+                    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);
-                    queue.push(y - 1);
-                    queue.push(z);
-                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                    queue.push(x, y - 1, z);
+                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
                 }
                 else {
                     if (!nVoxel.isOpaque()) {
-                        queue.push(x);
-                        queue.push(y - 1);
-                        queue.push(z);
-                        nVoxel.setLight(getMinusOneForSun(sl, nl));
+                        queue.push(x, y - 1, z);
+                        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 { UpdateTask } from "../Update/UpdateTask";
-import { WorldSpaces } from "../../World/WorldSpaces";
+import { VoxelUpdateTask } from "../VoxelUpdateTask";
 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 UpdateTask();
-        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 UpdateTask();
-        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 UpdateTask();
-        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);
     });
 }

package/Tasks/Propagation/Power/PowerUpdate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+export declare function PowerUpdate(tasks: VoxelUpdateTask): void;
+export declare function PowerRemove(tasks: VoxelUpdateTask): void;

package/Tasks/Propagation/Power/PowerUpdate.js

@@ -0,0 +1,80 @@
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
+//@todo change array to not use push and shift
+export function PowerUpdate(tasks) {
+    const queue = tasks.power.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.getPower();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 6; i++) {
+            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);
+            if (!voxel)
+                continue;
+            const nl = voxel.getPower();
+            if (nl > -1 && nl < sl) {
+                if (voxel.tags["dve_can_carry_power"]) {
+                    queue.push(nx, ny, nz);
+                }
+                voxel.setPower(sl - 1);
+            }
+        }
+        tasks.bounds.updateDisplay(x, y, z);
+    }
+}
+export function PowerRemove(tasks) {
+    const remove = tasks.power.remove;
+    const update = tasks.power.update;
+    const removeMap = tasks.power.removeMap;
+    const updateMap = tasks.power.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.isAir() ? voxel.getLevel() : voxel.getPower();
+        if (sl <= 0)
+            continue;
+        for (let i = 0; i < 6; i++) {
+            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);
+            if (!voxel)
+                continue;
+            const nl = voxel.isAir() ? voxel.getLevel() : voxel.getPower();
+            if (nl > 0 && nl < sl) {
+                remove.push(nx, ny, nz);
+                if (voxel.isPowerSource()) {
+                    update.push(nx, ny, nz);
+                }
+            }
+            else {
+                if (nl > 0 && nl > sl && !updateMap.has(nx, ny, nz)) {
+                    updateMap.add(nx, ny, nz);
+                    update.push(nx, ny, nz);
+                }
+            }
+        }
+        tasks.bounds.updateDisplay(x, y, z);
+        voxel.setPower(0);
+    }
+    removeMap.clear();
+}

package/Tasks/Tasks.types.d.ts

@@ -1,15 +1,31 @@
-import type { LocationData } from "../Math/index.js";
 import type { Vec3Array } from "@amodx/math";
-import type { RawVoxelData } from "../Voxels/Types/Voxel.types.js";
-import { SectorData } from "World/index.js";
+import type { VoxelPathData } from "../Templates/Path/VoxelPath.types.js";
+import type { EraseVoxel } from "./Paint/Erase/EraseVoxel.js";
+import type EraseVoxelTemplate from "./Paint/Erase/EraseVoxelTemplate.js";
+import type EraseVoxelPath from "./Paint/Erase/EraseVoxelPath.js";
+import { PaintVoxel } from "./Paint/Paint/PaintVoxel.js";
+import PaintVoxelTemplate from "./Paint/Paint/PaintVoxelTemplate.js";
+export type VoxelUpdateData = {
+    /**An array of allowed areas to update in. If not set will be ignored.*/
+    includedAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**An array of excluded areas to update in. If not set will be ignored.*/
+    excludeAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**Define what happens when painting a voxel and must replace it. Default is destory which will replace the voxel. Keep will keep the current voxel and not update. */
+    paintMode?: "keep" | "destory";
+};
+export type PaintVoxelTask = Parameters<typeof PaintVoxel>;
+export type PaintVoxelTemplateTask = Parameters<typeof PaintVoxelTemplate>;
+export type PaintVoxelPathTask = [
+    dimension: number,
+    start: Vec3Array,
+    pathData: VoxelPathData,
+    data: VoxelUpdateData
+];
+export type EraseVoxelTask = Parameters<typeof EraseVoxel>;
+export type EraseVoxelTemplateTask = Parameters<typeof EraseVoxelTemplate>;
+export type EraseVoxelPathTask = Parameters<typeof EraseVoxelPath>;
 export type WorldLockTasks = [
-    dimension: string,
+    dimension: number,
     start: Vec3Array,
     end: Vec3Array
 ];
-export type VoxelUpdateTasks = [location: LocationData, raw: RawVoxelData];
-export type RunRebuildTasks = [buildQueue: string];
-export type RunBuildQueue = [dimension: string, sections: Vec3Array[]];
-export type GenerateTasks = [location: LocationData, data: any];
-export type ExplosionTasks = [location: LocationData, radius: number];
-export type LoadSectorDataTasks = [location: LocationData, sector: SectorData];

package/Tasks/TasksIds.d.ts

@@ -1,21 +1,15 @@
 export declare enum TasksIds {
-    BuildSection = 0,
-    BuildSector = 1,
-    Generate = 2,
-    Decorate = 3,
-    RGBlightUpdate = 4,
-    RGBlightRemove = 5,
-    WorldSun = 6,
-    SunLightUpdate = 7,
-    SunLightRemove = 8,
-    Propagation = 9,
-    AnalyzerUpdate = 10,
-    FlowUpdate = 11,
-    FlowRemove = 12,
-    ConstructEntity = 13,
-    ConstructItem = 14,
-    Explosion = 15,
-    VoxelErease = 16,
-    VoxelPaint = 17,
-    VoxelUpdate = 18
+    BuildSection = "BuildSection",
+    BuildSectionSnapShot = "BuildSectionSnapShot",
+    BuildSector = "BuildSector",
+    Generate = "Generate",
+    Decorate = "Decorate",
+    WorldSun = "WorldSun",
+    WorldPropagation = "Propagation",
+    PaintVoxel = "PaintVoxel",
+    PaintVoxelTemplate = "PaintVoxelTemplate",
+    PaintVoxelPath = "PaintVoxelPath",
+    EraseVoxel = "EraseVoxel",
+    EraseVoxelTemplate = "EraseVoxelTemplate",
+    EraseVoxelPath = "EraseVoxelPath"
 }

package/Tasks/TasksIds.js

@@ -1,22 +1,16 @@
 export var TasksIds;
 (function (TasksIds) {
-    TasksIds[TasksIds["BuildSection"] = 0] = "BuildSection";
-    TasksIds[TasksIds["BuildSector"] = 1] = "BuildSector";
-    TasksIds[TasksIds["Generate"] = 2] = "Generate";
-    TasksIds[TasksIds["Decorate"] = 3] = "Decorate";
-    TasksIds[TasksIds["RGBlightUpdate"] = 4] = "RGBlightUpdate";
-    TasksIds[TasksIds["RGBlightRemove"] = 5] = "RGBlightRemove";
-    TasksIds[TasksIds["WorldSun"] = 6] = "WorldSun";
-    TasksIds[TasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
-    TasksIds[TasksIds["SunLightRemove"] = 8] = "SunLightRemove";
-    TasksIds[TasksIds["Propagation"] = 9] = "Propagation";
-    TasksIds[TasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
-    TasksIds[TasksIds["FlowUpdate"] = 11] = "FlowUpdate";
-    TasksIds[TasksIds["FlowRemove"] = 12] = "FlowRemove";
-    TasksIds[TasksIds["ConstructEntity"] = 13] = "ConstructEntity";
-    TasksIds[TasksIds["ConstructItem"] = 14] = "ConstructItem";
-    TasksIds[TasksIds["Explosion"] = 15] = "Explosion";
-    TasksIds[TasksIds["VoxelErease"] = 16] = "VoxelErease";
-    TasksIds[TasksIds["VoxelPaint"] = 17] = "VoxelPaint";
-    TasksIds[TasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
+    TasksIds["BuildSection"] = "BuildSection";
+    TasksIds["BuildSectionSnapShot"] = "BuildSectionSnapShot";
+    TasksIds["BuildSector"] = "BuildSector";
+    TasksIds["Generate"] = "Generate";
+    TasksIds["Decorate"] = "Decorate";
+    TasksIds["WorldSun"] = "WorldSun";
+    TasksIds["WorldPropagation"] = "Propagation";
+    TasksIds["PaintVoxel"] = "PaintVoxel";
+    TasksIds["PaintVoxelTemplate"] = "PaintVoxelTemplate";
+    TasksIds["PaintVoxelPath"] = "PaintVoxelPath";
+    TasksIds["EraseVoxel"] = "EraseVoxel";
+    TasksIds["EraseVoxelTemplate"] = "EraseVoxelTemplate";
+    TasksIds["EraseVoxelPath"] = "EraseVoxelPath";
 })(TasksIds || (TasksIds = {}));

package/Tasks/{Update/UpdateTask.d.ts → VoxelUpdateTask.d.ts}

@@ -1,6 +1,6 @@
-import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldCursor } from "../World/Cursor/WorldCursor";
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { LocationData } from "../../Math";
+import { LocationData } from "../Math";
 export declare class TaskMap {
     _map: boolean[];
     get size(): number;
@@ -12,25 +12,27 @@ export declare class TaskMap {
     clear(): void;
 }
 declare class UpdatedBounds {
-    _task: UpdateTask;
-    min: Vector3Like;
-    max: Vector3Like;
-    dimension: string;
-    constructor(_task: UpdateTask);
-    start(dimension?: string): void;
-    update(x: number, y: number, z: number): void;
+    _task: VoxelUpdateTask;
+    displayMin: Vector3Like;
+    displayMax: Vector3Like;
+    dimension: number;
+    constructor(_task: VoxelUpdateTask);
+    start(dimension?: number): void;
+    updateDisplay(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
-    markSectionsAsDirty(): void;
+    markDisplayDirty(): false | undefined;
 }
-export declare class UpdateTask {
+export declare class VoxelUpdateTask {
     flow: FlowQueues;
     rgb: LightQueue;
     sun: LightQueue;
+    power: PowerQueue;
     bounds: UpdatedBounds;
     sDataCursor: WorldCursor;
     nDataCursor: WorldCursor;
     origin: LocationData;
-    setOrigin(origin: LocationData): void;
+    setOrigin(dimension: number, x: number, y: number, z: number): void;
+    setOriginAt(origin: LocationData): void;
     clear(): void;
 }
 declare class FlowQueues {
@@ -52,4 +54,11 @@ declare class LightQueue {
     updateMap: TaskMap;
     clear(): void;
 }
+declare class PowerQueue {
+    update: number[];
+    remove: number[];
+    removeMap: TaskMap;
+    updateMap: TaskMap;
+    clear(): void;
+}
 export {};