@divinevoxel/vlox 0.0.73 → 0.0.74

package/Renderer/MeshManager.js

@@ -1,13 +1,14 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { VoxelEffectRegister } from "../Voxels/Effects/VoxelEffectRegister.js";
+import { CompactedSectionVoxelMesh, } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
 const added = new Set();
+const compacted = new CompactedSectionVoxelMesh();
+const location = [0, 0, 0, 0];
 export class MeshManager {
     static sectorMeshes;
     static runningUpdate = false;
     static updateSection(data) {
-        const location = data[0];
-        const sections = data[1];
-        const effects = data[2];
+        compacted.setData(data);
+        compacted.getLocation(location);
         let sector = MeshRegister.sectors.get(location);
         if (!sector) {
             sector = MeshRegister.sectors.add(location);
@@ -16,30 +17,30 @@ export class MeshManager {
         if (!section) {
             section = sector.addSection(location[1], location[2], location[3]);
         }
+        /*
         added.clear();
         for (const [id, points] of effects) {
-            added.add(id);
-            if (!section.effects.has(id)) {
-                const EffectClass = VoxelEffectRegister.get(id);
-                const newEffect = new EffectClass(section);
-                newEffect.init();
-                newEffect.setPoints(points);
-                section.effects.set(id, newEffect);
-            }
-            else {
-                const effect = section.effects.get(id);
-                effect.setPoints(points);
-            }
+          added.add(id);
+          if (!section.effects.has(id)) {
+            const EffectClass = VoxelEffectRegister.get(id);
+            const newEffect = new EffectClass(section);
+            newEffect.init();
+            newEffect.setPoints(points);
+            section.effects.set(id, newEffect);
+          } else {
+            const effect = section.effects.get(id)!;
+            effect.setPoints(points);
+          }
         }
         for (const [key, effect] of section.effects) {
-            if (!added.has(key)) {
-                effect.dispose();
-                section.effects.delete(key);
-            }
-        }
-        if (sections[0] == 0) {
-            this.sectorMeshes.updateVertexData(section, [location[1], location[2], location[3]], sections);
+          if (!added.has(key)) {
+            effect.dispose();
+            section.effects.delete(key);
+          }
         }
+    
+     */
+        this.sectorMeshes.updateVertexData(section, compacted);
     }
     static removeSector(data) {
         const sector = MeshRegister.sectors.remove(data);

package/Renderer/MeshRegister.d.ts

@@ -1,16 +1,16 @@
 import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
-export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
+export type MeshRegisterDimensions = Map<number, Map<string, SectorMesh>>;
 declare class Sectors {
     static add(location: LocationData): SectorMesh;
     static remove(location: LocationData): false | SectorMesh;
     static get(location: LocationData): false | SectorMesh | undefined;
 }
 declare class Dimensions {
-    static add(id: string): Map<any, any>;
-    static get(id: string): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
-    static remove(id: string): boolean;
+    static add(id: number): Map<any, any>;
+    static get(id: number): Map<string, SectorMesh> | undefined;
+    static getAllMeshes(id: number): Generator<[location: LocationData, substance: string, mesh: any]>;
+    static remove(id: number): boolean;
 }
 export declare class MeshRegister {
     static _dimensions: MeshRegisterDimensions;

package/Renderer/MeshRegister.js

@@ -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,7 +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

@@ -17,6 +17,7 @@ declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents>
     get doRGBPropagation(): boolean;
     get doLight(): boolean;
     get doFlow(): boolean;
+    get doPower(): boolean;
     getSettings(): EngineSettingsData;
     syncSettings(data: EngineSettingsData): void;
     getSettingsCopy(): any;

package/Settings/EngineSettings.js

@@ -10,16 +10,19 @@ class EngineSettingsClass extends TypedEventTarget {
     settings = new EngineSettingsData();
     version = "0.0.72";
     get doSunPropagation() {
-        return this.settings.lighting.sunLightEnabled == true;
+        return this.settings.propagation.sunLightEnabled == true;
     }
     get doRGBPropagation() {
-        return this.settings.lighting.rgbLightEnabled == 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 doPower() {
+        return this.settings.propagation.powerEnabled;
     }
     getSettings() {
         return this.settings;

package/Settings/EngineSettings.types.d.ts

@@ -29,35 +29,21 @@ export interface WorldSettings {
 export declare class WorldSettings {
     min: Vector3Like;
     max: Vector3Like;
+    sectorPower2Size: Vector3Like;
+    sectionPower2Size: Vector3Like;
 }
-export interface SectorSettings {
+export interface PropagationSettings {
 }
-export declare class SectorSettings {
-    power2Size: Vector3Like;
-}
-export interface SectionSettings {
-}
-export declare class SectionSettings {
-    power2Size: Vector3Like;
-}
-export interface FlowSettings {
-}
-export declare class FlowSettings {
-    enable: boolean;
-}
-export interface LightingSettings {
-}
-export declare class LightingSettings {
+export declare class PropagationSettings {
     rgbLightEnabled: boolean;
     sunLightEnabled: boolean;
+    flowEnabled: boolean;
+    powerEnabled: boolean;
 }
 export declare class EngineSettingsData {
     mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
     updating: UpdatingSettings;
     world: WorldSettings;
-    sectors: SectorSettings;
-    sections: SectionSettings;
-    flow: FlowSettings;
-    lighting: LightingSettings;
+    propagation: PropagationSettings;
 }

package/Settings/EngineSettings.types.js

@@ -21,27 +21,19 @@ export class UpdatingSettings {
 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 FlowSettings {
-    enable = true;
-}
-export class LightingSettings {
+export class PropagationSettings {
     rgbLightEnabled = true;
     sunLightEnabled = true;
+    flowEnabled = true;
+    powerEnabled = true;
 }
 export class EngineSettingsData {
     mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
     updating = new UpdatingSettings();
     world = new WorldSettings();
-    sectors = new SectorSettings();
-    sections = new SectionSettings();
-    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;