@divinevoxel/vlox 0.0.73 → 0.0.74

package/Tasks/Update/Common.js

@@ -0,0 +1,41 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+export const updateLightTask = (tasks) => {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of $3dCardinalNeighbors) {
+        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 (doRGB) {
+            if (nVoxel.hasRGBLight()) {
+                tasks.rgb.update.push(nx, ny, nz);
+            }
+        }
+        if (doSun) {
+            if (nVoxel.hasSunLight()) {
+                tasks.sun.update.push(nx, ny, nz);
+            }
+        }
+    }
+};
+export const updatePowerTask = (tasks) => {
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of $3dCardinalNeighbors) {
+        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);
+        }
+    }
+};

package/Tasks/Update/EreaseUpdate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { LocationData } from "../../Math/index.js";
+export declare function EreaseAndUpdate(location: LocationData): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/EreaseUpdate.js

@@ -0,0 +1,66 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
+import { updateLightTask } from "./Common.js";
+import { PowerRemove, PowerUpdate } from "../Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export async function EreaseAndUpdate(location) {
+    const [dimension, x, y, z] = location;
+    tasks.setOrigin(location);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    const substanceData = voxel.getSubstanceData();
+    const foundPower = voxel.getPower();
+    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
+        if (substanceData["dve_is_liquid"]) {
+            FlowRemove(tasks);
+            return tasks;
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const light = voxel.getLight();
+    const isLightSource = voxel.isLightSource();
+    voxel.setSecondary(true).setId(0).setSecondary(false);
+    voxel
+        .setLight(light > 0 ? light : 0)
+        .setId(0)
+        .setLevel(0)
+        .setLevelState(0)
+        .setState(0)
+        .setMod(0)
+        .updateVoxel(1);
+    if (ES.doLight) {
+        if (ES.doRGBPropagation && isLightSource) {
+            tasks.rgb.remove.push(x, y, z);
+            RGBRemove(tasks);
+        }
+        updateLightTask(tasks);
+        if (ES.doRGBPropagation) {
+            RGBUpdate(tasks);
+        }
+        if (ES.doSunPropagation) {
+            SunUpdate(tasks);
+        }
+    }
+    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.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
+    return tasks;
+}

package/Tasks/Update/InitTasks.d.ts

@@ -1,5 +1,5 @@
 import { Thread } from "@amodx/threads";
-import { UpdateTask } from "./UpdateTask";
+import { VoxelUpdateTask } from "../VoxelUpdateTask";
 export default function (props: {
-    onDone(taks: UpdateTask, origin: Thread): void;
+    onDone(taks: VoxelUpdateTask, origin: Thread): void;
 }): void;

package/Tasks/Update/InitTasks.js

@@ -1,6 +1,8 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
-import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
+import { VoxelUpdate } from "./VoxelUpdate";
+import { EreaseAndUpdate } from "./EreaseUpdate";
+import { PaintAndUpdate } from "./PaintUpdate";
 export default function (props) {
     Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
         const tasks = await VoxelUpdate(data);

package/Tasks/Update/PaintUpdate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTasks } from "../Tasks.types.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/PaintUpdate.js

@@ -0,0 +1,89 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
+import { updateLightTask, updatePowerTask } from "./Common.js";
+import { PowerUpdate } from "../../Tasks/Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export async function PaintAndUpdate(data) {
+    const [dimension, x, y, z] = data[0];
+    tasks.setOrigin(data[0]);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    const raw = data[1];
+    const isOpaque = voxel.isOpaque();
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    lighttest: if (ES.doLight) {
+        const light = voxel.getLight();
+        if (light <= 0)
+            break lighttest;
+        if (doSun) {
+            if (voxel.hasSunLight()) {
+                tasks.sun.remove.push(x, y, z);
+                SunRemove(tasks);
+            }
+        }
+        if (doRGB) {
+            if (voxel.hasRGBLight() && isOpaque) {
+                tasks.rgb.remove.push(x, y, z);
+                RGBRemove(tasks);
+            }
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const id = raw[0];
+    if (id < 0)
+        return false;
+    voxel.setId(id);
+    voxel.setLevel(raw[2]);
+    voxel.setState(raw[3]);
+    voxel.setMod(raw[4]);
+    voxel.process();
+    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
+        voxel.setSecondary(true);
+        voxel.setId(raw[5]);
+        voxel.setSecondary(false);
+    }
+    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+        voxel.setLight(voxel.getLightSourceValue());
+    }
+    voxel.updateVoxel(0);
+    if (ES.doLight) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.rgb.update.push(x, y, z);
+            RGBUpdate(tasks);
+        }
+        if (doSun) {
+            SunUpdate(tasks);
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doFlow) {
+        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
+            FlowUpdate(tasks);
+        }
+    }
+    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);
+        }
+    }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
+    return tasks;
+}

package/Tasks/Update/VoxelUpdate.d.ts

@@ -1,6 +1,3 @@
 import { VoxelUpdateTasks } from "../Tasks.types.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { LocationData } from "../../Math/index.js";
-export declare function EreaseAndUpdate(location: LocationData): Promise<false | UpdateTask>;
-export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
-export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -1,152 +1,10 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
-import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
-const tasks = new UpdateTask();
-const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    const [dimension, x, y, z] = tasks.origin;
-    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
-    for (const n of $3dCardinalNeighbors) {
-        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 (doRGB) {
-            if (nVoxel.hasRGBLight()) {
-                tasks.rgb.update.push(nx, ny, nz);
-            }
-        }
-        if (doSun) {
-            if (nVoxel.hasSunLight()) {
-                tasks.sun.update.push(nx, ny, nz);
-            }
-        }
-    }
-};
-export async function EreaseAndUpdate(location) {
-    const [dimension, x, y, z] = location;
-    tasks.setOrigin(location);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const substanceData = voxel.getSubstanceData();
-    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData["dve_is_liquid"]) {
-            FlowRemove(tasks);
-            return tasks;
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const light = voxel.getLight();
-    const isLightSource = voxel.isLightSource();
-    voxel.setSecondary(true).setId(0).setSecondary(false);
-    voxel
-        .setLight(light > 0 ? light : 0)
-        .setId(0)
-        .setLevel(0)
-        .setLevelState(0)
-        .setState(0)
-        .setMod(0)
-        .updateVoxel(1);
-    if (ES.doLight) {
-        if (ES.doRGBPropagation && isLightSource) {
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-        }
-        updateLightTask(tasks);
-        if (ES.doRGBPropagation) {
-            RGBUpdate(tasks);
-        }
-        if (ES.doSunPropagation) {
-            SunUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
-export async function PaintAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const raw = data[1];
-    const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    lighttest: if (ES.doLight) {
-        const light = voxel.getLight();
-        if (light <= 0)
-            break lighttest;
-        if (doSun) {
-            if (voxel.hasSunLight()) {
-                tasks.sun.remove.push(x, y, z);
-                SunRemove(tasks);
-            }
-        }
-        if (doRGB) {
-            if (voxel.hasRGBLight() && isOpaque) {
-                tasks.rgb.remove.push(x, y, z);
-                RGBRemove(tasks);
-            }
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const id = raw[0];
-    if (id < 0)
-        return false;
-    voxel.setId(id);
-    voxel.setLevel(raw[2]);
-    voxel.setState(raw[3]);
-    voxel.setMod(raw[4]);
-    voxel.process();
-    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
-        voxel.setSecondary(true);
-        voxel.setId(raw[5]);
-        voxel.setSecondary(false);
-    }
-    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
-        voxel.setLight(voxel.getLightSourceValue());
-    }
-    voxel.updateVoxel(0);
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            SunUpdate(tasks);
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow) {
-        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
+import { updateLightTask } from "./Common.js";
+const tasks = new VoxelUpdateTask();
 export async function VoxelUpdate(data) {
     const [dimension, x, y, z] = data[0];
     tasks.setOrigin(data[0]);

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,20 +12,21 @@ export declare class TaskMap {
     clear(): void;
 }
 declare class UpdatedBounds {
-    _task: UpdateTask;
+    _task: VoxelUpdateTask;
     min: Vector3Like;
     max: Vector3Like;
-    dimension: string;
-    constructor(_task: UpdateTask);
-    start(dimension?: string): void;
+    dimension: number;
+    constructor(_task: VoxelUpdateTask);
+    start(dimension?: number): void;
     update(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
     markSectionsAsDirty(): void;
 }
-export declare class UpdateTask {
+export declare class VoxelUpdateTask {
     flow: FlowQueues;
     rgb: LightQueue;
     sun: LightQueue;
+    power: PowerQueue;
     bounds: UpdatedBounds;
     sDataCursor: WorldCursor;
     nDataCursor: WorldCursor;
@@ -52,4 +53,11 @@ declare class LightQueue {
     updateMap: TaskMap;
     clear(): void;
 }
+declare class PowerQueue {
+    update: number[];
+    remove: number[];
+    removeMap: TaskMap;
+    updateMap: TaskMap;
+    clear(): void;
+}
 export {};

package/Tasks/{Update/UpdateTask.js → VoxelUpdateTask.js}

@@ -1,7 +1,7 @@
-import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldCursor } from "../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../World/WorldSpaces";
-import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSpaces } from "../World/WorldSpaces";
+import { WorldRegister } from "../World/WorldRegister";
 export class TaskMap {
     _map = [];
     get size() {
@@ -35,12 +35,12 @@ class UpdatedBounds {
     _task;
     min = Vector3Like.Clone(InfinityVec3);
     max = Vector3Like.Clone(NegativeInfinityVec3);
-    dimension = "main";
+    dimension = 0;
     constructor(_task) {
         this._task = _task;
     }
     start(dimension) {
-        this.dimension = dimension || "main";
+        this.dimension = dimension || 0;
         Vector3Like.Copy(this.min, InfinityVec3);
         Vector3Like.Copy(this.max, NegativeInfinityVec3);
     }
@@ -97,16 +97,17 @@ class UpdatedBounds {
                     if (!sector)
                         continue;
                     const section = sector.getSection(x, y, z);
-                    section.setDirty(true);
+                    section.setDisplayDirty(true);
                 }
             }
         }
     }
 }
-export class UpdateTask {
+export class VoxelUpdateTask {
     flow = new FlowQueues();
     rgb = new LightQueue();
     sun = new LightQueue();
+    power = new PowerQueue();
     bounds = new UpdatedBounds(this);
     sDataCursor = new WorldCursor();
     nDataCursor = new WorldCursor();
@@ -161,3 +162,15 @@ class LightQueue {
         this.updateMap.clear();
     }
 }
+class PowerQueue {
+    update = [];
+    remove = [];
+    removeMap = new TaskMap();
+    updateMap = new TaskMap();
+    clear() {
+        this.update.length = 0;
+        this.remove.length = 0;
+        this.removeMap.clear();
+        this.updateMap.clear();
+    }
+}

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -1,11 +1,11 @@
 import type { Vec3Array } from "@amodx/math";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
-import { UpdateTask } from "../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 export declare class WorldGenBrush extends BrushTool {
     constructor();
     requestsId: "";
-    tasks: UpdateTask;
-    start(dimension: string, x: number, y: number, z: number): this;
+    tasks: VoxelUpdateTask;
+    start(dimension: number, x: number, y: number, z: number): this;
     paint(): this;
     getUpdatedSections(): Vec3Array[];
     update(): false | undefined;

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -3,7 +3,7 @@ import { BrushTool } from "../../Tools/Brush/Brush.js";
 import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { UpdateTask } from "../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 const lightData = new VoxelLightData();
@@ -13,7 +13,7 @@ export class WorldGenBrush extends BrushTool {
         WorldGeneration._brushes.push(this);
     }
     requestsId;
-    tasks = new UpdateTask();
+    tasks = new VoxelUpdateTask();
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
         this.tasks.setOrigin([dimension, x, y, z]);

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -4,7 +4,7 @@ export declare class WorldGenRegister {
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
-        dimension: string;
+        dimension: number;
         sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;

package/Templates/Functions/CreateTemplate.d.ts

@@ -1,3 +1,3 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelTemplate } from "../VoxelTemplate";
-export default function CreateTemplate(dimension: string, start: Vec3Array, end: Vec3Array): VoxelTemplate;
+export default function CreateTemplate(dimension: number, start: Vec3Array, end: Vec3Array): VoxelTemplate;

package/Tools/Brush/AdvancedBrushTool.js

@@ -1,7 +1,7 @@
 import { BrushTool } from "./Brush.js";
 export class AdvancedBrush extends BrushTool {
     tasks;
-    _location = ["main", 0, 0, 0];
+    _location = [0, 0, 0, 0];
     constructor(tasks) {
         super();
         this.tasks = tasks;

package/Tools/Brush/Brush.d.ts

@@ -3,7 +3,7 @@ import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 export declare class BrushTool {
     data: PaintVoxelData;
-    dimension: string;
+    dimension: number;
     x: number;
     y: number;
     z: number;
@@ -29,6 +29,6 @@ export declare class BrushTool {
     _erase(): void;
     paint(): this;
     erase(): this;
-    start(dimension: string, x: number, y: number, z: number): this;
+    start(dimension: number, x: number, y: number, z: number): this;
     stop(): this;
 }

package/Tools/Brush/Brush.js

@@ -15,7 +15,7 @@ export class BrushTool {
         levelState: 0,
         mod: 0,
     };
-    dimension = "main";
+    dimension = 0;
     x = 0;
     y = 0;
     z = 0;

package/Tools/Tasks/TasksTool.d.ts

@@ -24,6 +24,7 @@ declare class VoxelTasks {
     update: TaskToolTask<VoxelUpdateTasks>;
     paint: TaskToolTask<VoxelUpdateTasks>;
     erease: TaskToolTask<LocationData>;
+    logic: TaskToolTask<LocationData>;
     constructor(tool: TaskTool);
 }
 declare class BuildTask {

package/Tools/Tasks/TasksTool.js

@@ -62,11 +62,13 @@ class VoxelTasks {
     update;
     paint;
     erease;
+    logic;
     constructor(tool) {
         this.tool = tool;
         this.update = new TaskToolTask(TasksIds.VoxelUpdate, tool.threads);
         this.paint = new TaskToolTask(TasksIds.VoxelPaint, tool.threads);
         this.erease = new TaskToolTask(TasksIds.VoxelErease, tool.threads);
+        this.logic = new TaskToolTask(TasksIds.LogicUpdate, tool.threads);
     }
 }
 class BuildTask {

package/Util/Binary/BinaryBuffer.d.ts

@@ -1,17 +1,22 @@
-export type BinaryBufferTypes = 
-/**If the buffer compressed to a single value the type will be a vlaue */
-"value" | "1-bit" | "2-bit" | "4-bit" | "8-bit" | "16-bit";
+export declare enum BinaryBufferTypes {
+    Value = 0,
+    BitArray = 1,
+    HalfNibbleArray = 2,
+    NibbleArray = 4,
+    ByteArray = 8,
+    ShortArray = 16
+}
 export interface BinaryBufferData {
-    type?: BinaryBufferTypes;
-    buffer: number | Uint8Array | Uint16Array;
+    type: BinaryBufferTypes;
+    buffer: number | ArrayBufferLike;
 }
 export interface BinaryBuffer extends BinaryBufferData {
 }
 export declare class BinaryBuffer {
-    static BytePaletteMax: number;
-    static NibblePaletteMax: number;
-    static HalfNibblePaletteMax: number;
-    static BitPaletteMax: number;
+    static ByteArrayMax: number;
+    static NibbleArrayMax: number;
+    static HalfNibbleArrayMax: number;
+    static BitArrayMax: number;
     static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
     static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
     static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
@@ -20,10 +25,11 @@ export declare class BinaryBuffer {
     static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
     static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
     static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
+    bufferView: Uint8Array | Uint16Array;
     constructor(data: BinaryBufferData);
     getValue(index: number): number;
     toJSON(): {
-        type?: BinaryBufferTypes | undefined;
-        buffer: number | Uint16Array | Uint8Array;
+        buffer: number | ArrayBufferLike;
+        type: BinaryBufferTypes;
     };
 }