@divinevoxel/vlox 0.0.72 → 0.0.74

package/Renderer/MeshRegister.js

@@ -9,7 +9,7 @@ class Sectors {
             location[0],
             ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
         ]);
-        dimension.set(WorldSpaces.hash.hashXYZ(location[1], location[2], location[3]), sector);
+        dimension.set(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])), sector);
         return sector;
     }
     static remove(location) {
@@ -79,7 +79,7 @@ class Dimensions {
     }
 }
 export class MeshRegister {
-    static _dimensions = new Map([["main", new Map()]]);
+    static _dimensions = new Map([[0, new Map()]]);
     static dimensions = Dimensions;
     static sectors = Sectors;
     static clearAll() {
@@ -87,6 +87,7 @@ export class MeshRegister {
             this.dimensions.remove(dkey);
         }
         this._dimensions.clear();
-        this._dimensions.set("main", new Map());
+        this._dimensions.set(0, new Map());
     }
 }
+window.MeshRegister = MeshRegister;

package/Settings/EngineSettings.d.ts

@@ -12,11 +12,12 @@ type EngineSettingsEvents = {
 declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents> {
     enviorment: "node" | "browser";
     settings: EngineSettingsData;
+    version: string;
     get doSunPropagation(): boolean;
     get doRGBPropagation(): boolean;
     get doLight(): boolean;
     get doFlow(): boolean;
-    get isClient(): boolean;
+    get doPower(): boolean;
     getSettings(): EngineSettingsData;
     syncSettings(data: EngineSettingsData): void;
     getSettingsCopy(): any;

package/Settings/EngineSettings.js

@@ -8,20 +8,21 @@ import { TypedEventTarget } from "../Util/TypedEventTarget.js";
 class EngineSettingsClass extends TypedEventTarget {
     enviorment = Environment.isNode() ? "node" : "browser";
     settings = new EngineSettingsData();
+    version = "0.0.72";
     get doSunPropagation() {
-        return this.settings.lighting.autoSunLight == true;
+        return this.settings.propagation.sunLightEnabled == true;
     }
     get doRGBPropagation() {
-        return this.settings.lighting.autoRGBLight == true;
+        return this.settings.propagation.rgbLightEnabled == true;
     }
     get doLight() {
         return this.doRGBPropagation || this.doSunPropagation;
     }
     get doFlow() {
-        return this.settings.flow.enable;
+        return this.settings.propagation.flowEnabled;
     }
-    get isClient() {
-        return this.enviorment != "browser";
+    get doPower() {
+        return this.settings.propagation.powerEnabled;
     }
     getSettings() {
         return this.settings;

package/Settings/EngineSettings.types.d.ts

@@ -1,18 +1,27 @@
 import { Vector3Like } from "@amodx/math";
+export interface MesherSettingsData {
+}
+export declare class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight: boolean;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO: boolean;
+    doColors: boolean;
+}
 export interface RenderSettingsData {
 }
 export declare class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound: boolean;
 }
-export interface TextureSettings {
-}
-export declare class TextureSettings {
-    textureSize: number;
-}
 export interface UpdatingSettings {
 }
 export declare class UpdatingSettings {
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism: boolean;
+    /**Updated sector sections are auto rebuilt */
     autoRebuild: boolean;
 }
 export interface WorldSettings {
@@ -20,45 +29,21 @@ export interface WorldSettings {
 export declare class WorldSettings {
     min: Vector3Like;
     max: Vector3Like;
+    sectorPower2Size: Vector3Like;
+    sectionPower2Size: Vector3Like;
 }
-export interface SectorSettings {
-}
-export declare class SectorSettings {
-    power2Size: Vector3Like;
-}
-export interface SectionSettings {
+export interface PropagationSettings {
 }
-export declare class SectionSettings {
-    power2Size: Vector3Like;
-}
-export interface VoxelSettings {
-}
-export declare class VoxelSettings {
-    doColors: boolean;
-}
-export interface FlowSettings {
-}
-export declare class FlowSettings {
-    enable: boolean;
-    baseFlowLimit: number;
-}
-export interface LightingSettings {
-}
-export declare class LightingSettings {
-    doAO: boolean;
-    doSunLight: boolean;
-    doRGBLight: boolean;
-    autoRGBLight: boolean;
-    autoSunLight: boolean;
+export declare class PropagationSettings {
+    rgbLightEnabled: boolean;
+    sunLightEnabled: boolean;
+    flowEnabled: boolean;
+    powerEnabled: boolean;
 }
 export declare class EngineSettingsData {
+    mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
-    textures: TextureSettings;
     updating: UpdatingSettings;
     world: WorldSettings;
-    sectors: SectorSettings;
-    sections: SectionSettings;
-    voxels: VoxelSettings;
-    flow: FlowSettings;
-    lighting: LightingSettings;
+    propagation: PropagationSettings;
 }

package/Settings/EngineSettings.types.js

@@ -1,46 +1,39 @@
 import { Vector3Like } from "@amodx/math";
+export class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight = true;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO = true;
+    doColors = true;
+}
 export class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound = false;
 }
-export class TextureSettings {
-    textureSize = 16;
-}
 export class UpdatingSettings {
-    autoRebuild = true;
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism = true;
+    /**Updated sector sections are auto rebuilt */
+    autoRebuild = false;
 }
 export class WorldSettings {
     min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
     max = Vector3Like.Create(Number.MAX_SAFE_INTEGER, 256, Number.MAX_SAFE_INTEGER);
+    sectorPower2Size = Vector3Like.Create(4, 8, 4);
+    sectionPower2Size = Vector3Like.Create(4, 4, 4);
 }
-export class SectorSettings {
-    power2Size = Vector3Like.Create(4, 8, 4);
-}
-export class SectionSettings {
-    power2Size = Vector3Like.Create(4, 4, 4);
-}
-export class VoxelSettings {
-    doColors = true;
-}
-export class FlowSettings {
-    enable = true;
-    baseFlowLimit = 200;
-}
-export class LightingSettings {
-    doAO = true;
-    doSunLight = true;
-    doRGBLight = true;
-    autoRGBLight = true;
-    autoSunLight = true;
+export class PropagationSettings {
+    rgbLightEnabled = true;
+    sunLightEnabled = true;
+    flowEnabled = true;
+    powerEnabled = true;
 }
 export class EngineSettingsData {
+    mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
-    textures = new TextureSettings();
     updating = new UpdatingSettings();
     world = new WorldSettings();
-    sectors = new SectorSettings();
-    sections = new SectionSettings();
-    voxels = new VoxelSettings();
-    flow = new FlowSettings();
-    lighting = new LightingSettings();
+    propagation = new PropagationSettings();
 }

package/Tasks/Logic/InitTasks.d.ts

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

package/Tasks/Logic/InitTasks.js

@@ -0,0 +1,10 @@
+import { Threads } from "@amodx/threads";
+import { TasksIds } from "../TasksIds";
+import { VoxelUpdateTask } from "../VoxelUpdateTask";
+import { VoxelLogicUpdate } from "./VoxelLogicUpdate";
+export default function () {
+    const tasks = new VoxelUpdateTask();
+    Threads.registerTask(TasksIds.LogicUpdate, async (data, origin) => {
+        VoxelLogicUpdate(tasks, data);
+    });
+}

package/Tasks/Logic/VoxelLogicUpdate.d.ts

@@ -0,0 +1,3 @@
+import { LocationData } from "../../Math";
+import { VoxelUpdateTask } from "../../Tasks/VoxelUpdateTask";
+export declare function VoxelLogicUpdate(task: VoxelUpdateTask, location: LocationData): false | undefined;

package/Tasks/Logic/VoxelLogicUpdate.js

@@ -0,0 +1,71 @@
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { SectionCursor } from "../../World/Cursor/SectionCursor";
+import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
+import { VoxelTagIds } from "../../Voxels/Data/VoxelTag.types";
+import { RGBRemove, RGBUpdate } from "../../Tasks/Propagation";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors";
+const sectionCursor = new SectionCursor();
+export function VoxelLogicUpdate(task, location) {
+    task.setOrigin(location);
+    const sector = WorldRegister.sectors.getAt(location);
+    if (!sector) {
+        console.warn(`Could not run logic update sector at ${location} does not exist`);
+        return false;
+    }
+    const section = sector.getSection(location[1], location[2], location[3]);
+    if (!section) {
+        console.warn(`Could not run logic update sector at ${location}.  Section does not exist`);
+        return false;
+    }
+    const [minY, maxY] = section.getLogicMinMax();
+    const [cx, cy, cz] = section.position;
+    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
+    const startY = minY * slice;
+    const endY = (maxY + 1) * slice;
+    sectionCursor.setSection(section);
+    for (let i = startY; i < endY; i++) {
+        if (!(i % slice)) {
+            const y = i / slice;
+            if (!section.isLogicSliceDirty(y)) {
+                i += slice - 1;
+                continue;
+            }
+        }
+        if (!section.ids[i] || !section.getVoxelLogicDirty(i))
+            continue;
+        const voxel = sectionCursor.getVoxelAtIndex(i);
+        const x = cx + sectionCursor._voxelPosition.x;
+        const y = cy + sectionCursor._voxelPosition.y;
+        const z = cz + sectionCursor._voxelPosition.z;
+        const logic = VoxelLogicRegister.voxels[section.ids[i]];
+        if (!logic)
+            continue;
+        if (logic.hasTag(VoxelTagIds.isLightSource)) {
+            const lightSource = logic.getTagValue(VoxelTagIds.isLightSource, voxel);
+            if (lightSource) {
+                task.rgb.update.push(x, y, z);
+            }
+            else {
+                for (const n of $3dCardinalNeighbors) {
+                    const nx = n[0] + x;
+                    const ny = n[1] + y;
+                    const nz = n[2] + z;
+                    const nVoxel = task.nDataCursor.getVoxel(nx, ny, nz);
+                    if (!nVoxel)
+                        continue;
+                    if (nVoxel.hasRGBLight()) {
+                        task.rgb.remove.push(nx, ny, nz);
+                    }
+                }
+            }
+        }
+    }
+    RGBRemove(task);
+    RGBUpdate(task);
+    section.logicDirtyMap.fill(0);
+    section.logicDirty.fill(0);
+    section.setLogicDirty(false);
+    section.setLogicUpdateInProgress(false);
+    task.bounds.markSectionsAsDirty();
+}

package/Tasks/Propagation/Explosion/ExplosionManager.d.ts

@@ -1,4 +1,4 @@
-import { UpdateTask } from "../../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
 export declare const ExplosionManager: {
-    runExplosion(tasks: UpdateTask, radius: number): void;
+    runExplosion(tasks: VoxelUpdateTask, radius: number): void;
 };

package/Tasks/Propagation/Explosion/ExplosionManager.js

@@ -5,14 +5,13 @@ import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
 import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
 import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate.js";
-import { FlowManager } from "../Flow/FlowManager.js";
 import { VisitedMap } from "../../../Util/VisistedMap";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
 const lightData = new VoxelLightData();
 export const ExplosionManager = {
     runExplosion(tasks, radius) {
         const [dimension, sx, sy, sz] = tasks.origin;
-        FlowManager.setDimension(dimension);
+        //   FlowManager.setDimension(dimension);
         const queue = [];
         const map = new VisitedMap();
         queue.push([sx, sy, 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/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/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/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/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,5 +1,3 @@
-//types
-//data
 import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 import { SectorHeightMap } from "../../../World/Sector/SectorHeightMap.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 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,9 +49,9 @@ 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++) {
@@ -94,9 +93,7 @@ export function RunWorldSun(tasks) {
             if (nVoxel) {
                 const nl = nVoxel.getLight();
                 if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
-                    queue.push(nx);
-                    queue.push(ny);
-                    queue.push(nz);
+                    queue.push(nx, ny, nz);
                     nVoxel.setLight(getMinusOneForSun(sl, nl));
                 }
             }
@@ -106,16 +103,12 @@ export function RunWorldSun(tasks) {
             const nl = nVoxel.getLight();
             if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
                 if (nVoxel.isAir()) {
-                    queue.push(x);
-                    queue.push(y - 1);
-                    queue.push(z);
+                    queue.push(x, y - 1, z);
                     nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
                 }
                 else {
                     if (!nVoxel.isOpaque()) {
-                        queue.push(x);
-                        queue.push(y - 1);
-                        queue.push(z);
+                        queue.push(x, y - 1, z);
                         nVoxel.setLight(getMinusOneForSun(sl, nl));
                     }
                 }

package/Tasks/Propagation/InitTasks.js

@@ -1,13 +1,13 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
-import { UpdateTask } from "../Update/UpdateTask";
+import { VoxelUpdateTask } from "../VoxelUpdateTask";
 import { WorldSpaces } from "../../World/WorldSpaces";
 import { RunWorldSun } from "./Illumanation/WorldSun";
 import { ExplosionManager } from "./Explosion/ExplosionManager";
 import { WorldRGB } from "./Illumanation/WorldRGB";
 export default function InitTasks() {
     Threads.registerTask(TasksIds.Propagation, async (location) => {
-        const task = new UpdateTask();
+        const task = new VoxelUpdateTask();
         task.setOrigin(location);
         WorldRGB(task);
         //  task.setOrigin(location);
@@ -16,7 +16,7 @@ export default function InitTasks() {
     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();
+        const task = new VoxelUpdateTask();
         task.setOrigin([
             location[0],
             sectorPosition.x,
@@ -27,7 +27,7 @@ export default function InitTasks() {
     });
     Threads.registerTask(TasksIds.WorldSun, (location) => {
         const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const task = new UpdateTask();
+        const task = new VoxelUpdateTask();
         task.setOrigin([
             location[0],
             sectorPosition.x,

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 { $3dCardinalNeighbors } 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 = $3dCardinalNeighbors[i][0] + x;
+            const ny = $3dCardinalNeighbors[i][1] + y;
+            const nz = $3dCardinalNeighbors[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (!voxel)
+                continue;
+            const nl = voxel.getPower();
+            if (nl > -1 && nl < sl) {
+                if (voxel._tags["dve_can_carry_power"]) {
+                    queue.push(nx, ny, nz);
+                }
+                voxel.setPower(sl - 1);
+            }
+        }
+        tasks.bounds.update(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 = $3dCardinalNeighbors[i][0] + x;
+            const ny = $3dCardinalNeighbors[i][1] + y;
+            const nz = $3dCardinalNeighbors[i][2] + z;
+            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
+                continue;
+            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (!voxel)
+                continue;
+            const nl = voxel.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.update(x, y, z);
+        voxel.setPower(0);
+    }
+    removeMap.clear();
+}

package/Tasks/Tasks.types.d.ts

@@ -3,13 +3,13 @@ import type { Vec3Array } from "@amodx/math";
 import type { RawVoxelData } from "../Voxels/Types/Voxel.types.js";
 import { SectorData } from "World/index.js";
 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 RunBuildQueue = [dimension: number, 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

@@ -17,5 +17,6 @@ export declare enum TasksIds {
     Explosion = 15,
     VoxelErease = 16,
     VoxelPaint = 17,
-    VoxelUpdate = 18
+    VoxelUpdate = 18,
+    LogicUpdate = 19
 }

package/Tasks/TasksIds.js

@@ -19,4 +19,5 @@ export var TasksIds;
     TasksIds[TasksIds["VoxelErease"] = 16] = "VoxelErease";
     TasksIds[TasksIds["VoxelPaint"] = 17] = "VoxelPaint";
     TasksIds[TasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
+    TasksIds[TasksIds["LogicUpdate"] = 19] = "LogicUpdate";
 })(TasksIds || (TasksIds = {}));

package/Tasks/Update/Common.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+export declare const updateLightTask: (tasks: VoxelUpdateTask) => void;
+export declare const updatePowerTask: (tasks: VoxelUpdateTask) => void;