@divinevoxel/vlox 0.0.75 → 0.0.77

package/WorldSimulation/Dimensions/DimensionSimulation.js

@@ -1,4 +1,5 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { VoxelFaces } from "../../Math";
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { WorldRegister } from "../../World/WorldRegister";
 import { Vector3Like } from "@amodx/math";
@@ -62,6 +63,7 @@ class UpdatedBounds {
                 }
             }
         }
+        return true;
     }
 }
 export class DimensionSimulation {
@@ -69,10 +71,20 @@ export class DimensionSimulation {
     cursor = new WorldCursor();
     nDataCursor = new WorldCursor();
     sDataCursor = new WorldCursor();
+    tickCursor = {
+        [VoxelFaces.Up]: new WorldCursor(),
+        [VoxelFaces.Down]: new WorldCursor(),
+        [VoxelFaces.North]: new WorldCursor(),
+        [VoxelFaces.South]: new WorldCursor(),
+        [VoxelFaces.East]: new WorldCursor(),
+        [VoxelFaces.West]: new WorldCursor(),
+    };
     bounds = new UpdatedBounds();
+    brush;
     updateQueue = new PriorityQueue();
     constructor(dimension) {
         this.dimension = dimension;
+        this.brush = dimension.getBrush();
     }
     setOrigin(x, y, z) {
         this.cursor.setFocalPoint(this.dimension.id, x, y, z);

package/WorldSimulation/Dimensions/Generator.d.ts

@@ -14,6 +14,7 @@ export declare class Generator {
     position: Vector3Like;
     _dimension: number;
     _building: boolean;
+    _generating: boolean;
     _isNew: boolean;
     _dirty: boolean;
     _waitingForCull: boolean;

package/WorldSimulation/Dimensions/Generator.js

@@ -5,6 +5,7 @@ export class Generator {
     position;
     _dimension = 0;
     _building = true;
+    _generating = true;
     _isNew = true;
     _dirty = true;
     _waitingForCull = false;

package/WorldSimulation/Dimensions/SimulationSector.d.ts

@@ -4,6 +4,7 @@ import { Sector } from "../../World/Sector";
 import { TickQueue } from "../Tick/TickQueue";
 import { DimensionSegment } from "./DimensionSegment";
 import { Thread } from "@amodx/threads";
+import { SectionCursor } from "../../World/Cursor/SectionCursor";
 export declare class SimulationSector {
     dimension: DimensionSegment;
     position: Vec3Array;
@@ -14,9 +15,11 @@ export declare class SimulationSector {
     sector: Sector | null;
     _rendered: boolean;
     _genAllDone: boolean;
+    _firstTick: boolean;
     /**An array of the last tick each section was built at */
-    _displayTicks: Uint32Array;
+    _displayTicks: Uint32Array<ArrayBuffer>;
     tickQueue: TickQueue;
+    sectionCursor: SectionCursor;
     neighbors: SimulationSector[];
     fullNeighbors: boolean;
     readonly maxNeighbors: number;

package/WorldSimulation/Dimensions/SimulationSector.js

@@ -5,9 +5,11 @@ import { WorldSpaces } from "../../World/WorldSpaces";
 import { WorldRegister } from "../../World/WorldRegister";
 import { WorldSimulationTasks } from "../Internal/WorldSimulationTasks";
 import { TickQueue } from "../Tick/TickQueue";
+import { VoxelBehaviorsRegister } from "../Voxels/Behaviors";
 import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
 import { WorldDataSyncIds } from "../../World/Types/WorldDataSyncIds";
 import { EngineSettings } from "../../Settings/EngineSettings";
+import { SectionCursor } from "../../World/Cursor/SectionCursor";
 const tempPosition = Vector3Like.Create();
 export class SimulationSector {
     dimension;
@@ -19,9 +21,11 @@ export class SimulationSector {
     sector = null;
     _rendered = false;
     _genAllDone = false;
+    _firstTick = false;
     /**An array of the last tick each section was built at */
     _displayTicks = new Uint32Array(WorldSpaces.sector.sectionVolumne);
     tickQueue;
+    sectionCursor = new SectionCursor();
     neighbors = [];
     fullNeighbors = false;
     maxNeighbors = MooreNeighborhood2D.length - 1;
@@ -114,48 +118,74 @@ export class SimulationSector {
             }
             this._rendered = true;
         }
-        /*   if (this.ticking) {
-          this.dimension.simulation.setOrigin(...this.position);
-          this.dimension.simulation.bounds.start();
-          this.tickQueue.run();
-    
-          const [min, max] = sector.getMinMax();
-          if (min == Math.abs(Infinity) || max == Math.abs(Infinity)) return true;
-    
-          const height = max - min + 1;
-          let attempts = 100;
-          let ticks = 20;
-          while (attempts) {
-            const randomX =
-              Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
-              this.sector.position[0];
-            const randomY =
-              Math.floor(height * Math.random()) + min + this.sector.position[1];
-            const randomZ =
-              Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
-              this.sector.position[2];
-            const voxel = this.dimension.simulation.nDataCursor.getVoxel(
-              randomX,
-              randomY,
-              randomZ
-            );
-            if (!voxel || voxel.isAir()) {
-              attempts--;
-              continue;
+        if (this.ticking) {
+            this.dimension.simulation.setOrigin(...this.position);
+            this.dimension.simulation.bounds.start(this.dimension.id);
+            this.tickQueue.run();
+            const [min, max] = sector.getMinMax();
+            if (min == Math.abs(Infinity) || max == Math.abs(Infinity))
+                return true;
+            const height = max - min + 1;
+            let attempts = 100;
+            let ticks = 20;
+            while (attempts) {
+                const randomX = Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
+                    this.sector.position[0];
+                const randomY = Math.floor(height * Math.random()) + min + this.sector.position[1];
+                const randomZ = Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
+                    this.sector.position[2];
+                const voxel = this.dimension.simulation.nDataCursor.getVoxel(randomX, randomY, randomZ);
+                if (!voxel || voxel.isAir()) {
+                    attempts--;
+                    continue;
+                }
+                const behavior = VoxelBehaviorsRegister.get(voxel.tags["dve_simulation_behavior"]);
+                behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
+                ticks--;
+                if (!ticks)
+                    break;
             }
-    
-            const behavior = VoxelBehaviorsRegister.get(
-              voxel.tags["dve_simulation_behavior"]
-            );
-            behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
-    
-            ticks--;
-    
-            if (!ticks) break;
-          }
-    
-          this.dimension.simulation.bounds.markDisplayDirty();
-        } */
+            let allNeighborsTicking = true;
+            for (const neighbors of this.neighbors) {
+                if (!neighbors.ticking || !neighbors._genAllDone) {
+                    allNeighborsTicking = false;
+                    break;
+                }
+            }
+            if (!this._firstTick && this.renderering && allNeighborsTicking) {
+                for (const section of sector.sections) {
+                    this.sectionCursor.setSection(section);
+                    const [minY, maxY] = section.getMinMax();
+                    if (minY == Infinity && maxY == -Infinity) {
+                        continue;
+                    }
+                    const { x: cx, y: cy, z: cz } = this.sectionCursor._sectionPosition;
+                    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
+                    const startY = minY * slice;
+                    const endY = (maxY + 1) * slice;
+                    //  console.warn([startY,endY],{...this.sectionCursor._voxelPosition})
+                    for (let i = startY; i < endY; i++) {
+                        if (!(i % slice)) {
+                            const y = i / slice;
+                            if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
+                                i += slice - 1;
+                                continue;
+                            }
+                        }
+                        if (!section.ids[i] || section.getBuried(i))
+                            continue;
+                        const voxel = this.sectionCursor.getVoxelAtIndex(i);
+                        const x = cx + this.sectionCursor._voxelPosition.x;
+                        const y = cy + this.sectionCursor._voxelPosition.y;
+                        const z = cz + this.sectionCursor._voxelPosition.z;
+                        const behavior = VoxelBehaviorsRegister.get(voxel.tags["dve_simulation_behavior"]);
+                        behavior.needUpdate(this.dimension.simulation, x, y, z);
+                    }
+                }
+                this._firstTick = true;
+            }
+            this.dimension.simulation.bounds.markDisplayDirty();
+        }
         return true;
     }
     generateUpdate() {

package/WorldSimulation/Internal/WorldSimulationTasks.js

@@ -171,8 +171,11 @@ export class WorldSimulationTasks {
                 .sector?.getSection(location[1], location[2], location[3])
                 ?.setInProgress(true);
             if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
-                task.completeTask(taskId);
-                WorldSimulationTools.taskTool.build.section.run(location);
+                WorldSimulationTools.taskTool.build.section
+                    .runAsync(location)
+                    .then(() => {
+                    task.completeTask(taskId);
+                });
                 return;
             }
             const [dim, x, y, z] = location;

package/WorldSimulation/Procedures/BuildOnly.d.ts

@@ -0,0 +1,10 @@
+import { GeneratorData } from "../Dimensions/Generator";
+/**# InitalLoad
+ * ---
+ * Load the world without building.
+ */
+export declare function BuildOnly(props: {
+    dimension?: number;
+    logTasks?: true;
+    genData: Partial<GeneratorData>;
+}): Promise<unknown>;

package/WorldSimulation/Procedures/BuildOnly.js

@@ -0,0 +1,55 @@
+import { WorldSimulation } from "../WorldSimulation";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
+import SaveAllSectors from "./SaveAllSectors";
+/**# InitalLoad
+ * ---
+ * Load the world without building.
+ */
+export async function BuildOnly(props) {
+    return new Promise((resolve) => {
+        const generator = WorldSimulation.createGenerator({
+            ...props.genData,
+            building: false,
+            culling: false,
+        });
+        if (!WorldSimulationDimensions._dimensions.has(generator._dimension)) {
+            WorldSimulationDimensions.addDimension(generator._dimension);
+        }
+        const dimension = WorldSimulationDimensions.getDimension(props.dimension || 0);
+        let done = false;
+        generator._building = false;
+        WorldSimulation.addGenerator(generator);
+        let timeOut = null;
+        const update = () => {
+            if (done)
+                return;
+            WorldSimulation.tick(true);
+            timeOut = setTimeout(update, 0);
+        };
+        update();
+        const inte = setInterval(() => {
+            let allDone = true;
+            for (const [key, task] of dimension.tasks) {
+                if (!task.generationTask)
+                    continue;
+                if (task.waitingFor > 0 || task._task.size > 0) {
+                    allDone = false;
+                    break;
+                }
+            }
+            if (!allDone)
+                return;
+            done = true;
+            clearInterval(inte);
+            clearTimeout(timeOut);
+            WorldSimulation.removeGenerator(generator);
+            (async () => {
+                if (WorldSimulationTools.worldStorage) {
+                    await SaveAllSectors();
+                }
+                resolve(true);
+            })();
+        }, 250);
+    });
+}

package/WorldSimulation/Procedures/InitalLoad.js

@@ -29,6 +29,9 @@ export async function InitalLoad(props) {
         };
         update();
         const inte = setInterval(() => {
+            if (props.logTasks) {
+                console.log(WorldSimulation.logTasks());
+            }
             let allDone = true;
             for (const [key, task] of dimension.tasks) {
                 if (!task.generationTask)

package/WorldSimulation/Tasks/SimulationTaskBase.d.ts

@@ -14,6 +14,8 @@ export type SimulationTaskBaseData = {
 export declare class SimulationTaskBase {
     data: SimulationTaskBaseData;
     constructor(data: SimulationTaskBaseData);
+    getTotal(dimensionId: number): number;
+    getTotalWaitingFor(dimensionId: number): number;
     add(dimensionId: number, x: number, y: number, z: number): void;
     runTask(max?: number): void;
 }

package/WorldSimulation/Tasks/SimulationTaskBase.js

@@ -4,6 +4,16 @@ export class SimulationTaskBase {
     constructor(data) {
         this.data = data;
     }
+    getTotal(dimensionId) {
+        const dimension = WorldSimulationDimensions.getDimension(dimensionId);
+        const task = dimension.getTask(this.data.id);
+        return task.nodes.length;
+    }
+    getTotalWaitingFor(dimensionId) {
+        const dimension = WorldSimulationDimensions.getDimension(dimensionId);
+        const task = dimension.getTask(this.data.id);
+        return task.waitingFor;
+    }
     add(dimensionId, x, y, z) {
         const dimension = WorldSimulationDimensions.getDimension(dimensionId);
         const task = dimension.getTask(this.data.id);
@@ -27,7 +37,6 @@ export class SimulationTaskBase {
                 const updatePosition = dimension.getUpdatePosition();
                 task.sort(updatePosition.x, updatePosition.y, updatePosition.z);
             }
-            let count = 0;
             const addBack = [];
             for (const location of task.run()) {
                 const [d, x, y, z] = location;
@@ -38,9 +47,8 @@ export class SimulationTaskBase {
                 }
                 const taskId = task.addTask(x, y, z);
                 this.data.run(dimension, location, taskId, task, sector);
-                if (count + task.waitingFor > max)
+                if (task.waitingFor > max)
                     break;
-                count++;
             }
             for (let i = 0; i < addBack.length; i += 3) {
                 task.add(addBack[i], addBack[i + 1], addBack[i + 2]);

package/WorldSimulation/Tasks/TaskSegment.d.ts

@@ -3,13 +3,14 @@ import { DimensionSegment } from "../Dimensions/DimensionSegment";
 export declare class TaskSegment {
     dimension: DimensionSegment;
     generationTask: boolean;
+    log: boolean;
     _hash: Set<unknown>;
     nodes: LocationData[];
     waitingFor: number;
     clear(): void;
     _taskCount: number;
     _task: Map<number, LocationData>;
-    constructor(dimension: DimensionSegment, generationTask: boolean);
+    constructor(dimension: DimensionSegment, generationTask: boolean, log?: boolean);
     _getLocationData(dimension: number, x: number, y: number, z: number): LocationData;
     completeTask(id: number): boolean;
     addTask(x: number, y: number, z: number): number;

package/WorldSimulation/Tasks/TaskSegment.js

@@ -3,15 +3,17 @@ const pool = [];
 export class TaskSegment {
     dimension;
     generationTask;
+    log;
     _hash = new Set();
     nodes = [];
     waitingFor = 0;
     clear() { }
     _taskCount = 0;
     _task = new Map();
-    constructor(dimension, generationTask) {
+    constructor(dimension, generationTask, log = false) {
         this.dimension = dimension;
         this.generationTask = generationTask;
+        this.log = log;
     }
     _getLocationData(dimension, x, y, z) {
         const location = pool.length ? pool.shift() : [0, 0, 0, 0];

package/WorldSimulation/Tick/TickQueue.d.ts

@@ -4,6 +4,8 @@ export declare class TickQueue {
     dimension: DimensionSegment;
     constructor(dimension: DimensionSegment);
     ticks: Map<number, VoxelTickUpdate<null>[]>;
+    getTotalTicks(): number;
     addTick(data: VoxelTickUpdate, delay?: number): void;
+    private compareTick;
     run(): boolean;
 }

package/WorldSimulation/Tick/TickQueue.js

@@ -1,3 +1,4 @@
+import { Vector3Like } from "@amodx/math";
 import { VoxelTickUpdateRegister, } from "../Voxels/Ticks/index";
 const tickArrayPool = [];
 export class TickQueue {
@@ -6,14 +7,39 @@ export class TickQueue {
         this.dimension = dimension;
     }
     ticks = new Map();
+    getTotalTicks() {
+        const tick = this.dimension.getTick();
+        const updates = this.ticks.get(tick);
+        if (!updates)
+            return 0;
+        return updates.length;
+    }
     addTick(data, delay = 0) {
         const trueTick = this.dimension.getTick() + 1 + delay;
         if (!this.ticks.get(trueTick)) {
             this.ticks.set(trueTick, tickArrayPool.length ? tickArrayPool.shift() : []);
         }
         const ticks = this.ticks.get(trueTick);
+        for (let i = 0; i < ticks.length; i++) {
+            if (this.compareTick(data, ticks[i])) {
+                return;
+            }
+        }
         ticks.push(data);
     }
+    compareTick(tick, otherTick) {
+        if (!(tick.type == otherTick.type && Vector3Like.Equals(otherTick, tick)))
+            return false;
+        if (!tick.data)
+            return true;
+        if (typeof tick.data == "number") {
+            return tick.data == otherTick.data;
+        }
+        if (typeof tick.data == "string") {
+            return tick.data == otherTick.data;
+        }
+        return JSON.stringify(tick.data) == JSON.stringify(otherTick.data);
+    }
     run() {
         const tick = this.dimension.getTick();
         const updates = this.ticks.get(tick);

package/WorldSimulation/Tools/SimulationBrush.d.ts

@@ -4,6 +4,7 @@ import { LocationData } from "../../Math";
 import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
 import { VoxelUpdateData } from "../../Tasks/Tasks.types";
 import { VoxelPath } from "../../Templates/Path/VoxelPath";
+import { IVoxelSelection } from "../../Templates/Selection/VoxelSelection";
 export declare class SimulationBrush extends BrushTool {
     _dimension: DimensionSegment;
     private taskTool;
@@ -20,6 +21,8 @@ export declare class SimulationBrush extends BrushTool {
     eraseAsync(updateData?: VoxelUpdateData): Promise<void>;
     eraseTemplate(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): this;
     eraseTemplateAsync(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): Promise<this>;
+    eraseSelection(selection: IVoxelSelection, updateData?: VoxelUpdateData): this;
+    eraseSelectionAsync(selection: IVoxelSelection, updateData?: VoxelUpdateData): Promise<this>;
     erasePath(voxelPath: VoxelPath, updateData?: VoxelUpdateData): this;
     erasePathAsync(voxelPath: VoxelPath, updateData?: VoxelUpdateData): Promise<this>;
 }

package/WorldSimulation/Tools/SimulationBrush.js

@@ -9,6 +9,7 @@ import PaintVoxelPath from "../../Tasks/Paint/Paint/PaintVoxelPath";
 import { EraseVoxel } from "../../Tasks/Paint/Erase/EraseVoxel";
 import EraseVoxelTemplate from "../../Tasks/Paint/Erase/EraseVoxelTemplate";
 import EraseVoxelPath from "../../Tasks/Paint/Erase/EraseVoxelPath";
+import EraseVoxelSelection from "../../Tasks/Paint/Erase/EraseVoxelSelection";
 export class SimulationBrush extends BrushTool {
     _dimension;
     taskTool;
@@ -187,6 +188,57 @@ export class SimulationBrush extends BrushTool {
         ]);
         return this;
     }
+    eraseSelection(selection, updateData = {}) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = selection.bounds.size;
+        for (let x = 0; x < sx; x++) {
+            for (let y = 0; y < sy; y++) {
+                for (let z = 0; z < sz; z++) {
+                    const tx = ox + x;
+                    const ty = oy + y;
+                    const tz = oz + z;
+                    if (selection.isSelected(tx, ty, tz))
+                        continue;
+                    const voxel = this.dataCursor.getVoxel(tx, ty, tz);
+                    if (!voxel)
+                        continue;
+                    const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+                    const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+                    behavior.onErase(this._dimension.simulation, tx, ty, tz);
+                }
+            }
+        }
+        EraseVoxelSelection(this.dimension, [this.x, this.y, this.z], selection.toJSON(), updateData);
+        return this;
+    }
+    async eraseSelectionAsync(selection, updateData = {}) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = selection.bounds.size;
+        for (let x = 0; x < sx; x++) {
+            for (let y = 0; y < sy; y++) {
+                for (let z = 0; z < sz; z++) {
+                    const tx = ox + x;
+                    const ty = oy + y;
+                    const tz = oz + z;
+                    if (selection.isSelected(tx, ty, tz))
+                        continue;
+                    const voxel = this.dataCursor.getVoxel(tx, ty, tz);
+                    if (!voxel)
+                        continue;
+                    const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+                    const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+                    behavior.onErase(this._dimension.simulation, tx, ty, tz);
+                }
+            }
+        }
+        await this.taskTool.voxel.eraseTemplate.runAsync([
+            this.dimension,
+            [this.x, this.y, this.z],
+            selection.toJSON(),
+            updateData,
+        ]);
+        return this;
+    }
     erasePath(voxelPath, updateData = {}) {
         EraseVoxelPath(this.dimension, [this.x, this.y, this.z], voxelPath.toJSON(), updateData);
         return this;

package/WorldSimulation/Voxels/Behaviors/Types/DefaultVoxelBehavior.js

@@ -1,6 +1,9 @@
 import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
 VoxelBehaviorsRegister.register({
     type: "dve_default",
+    needUpdate(simulation, voxel, x, y, z) {
+        return false;
+    },
     onInteract(simulation, voxel, x, y, z) { },
     onPaint(simulation, voxel, x, y, z) { },
     onErase(simulation, voxel, x, y, z) { },

package/WorldSimulation/Voxels/Behaviors/Types/LiquidVoxelBehavior.js

@@ -1,7 +1,27 @@
-import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+import { CardinalNeighbors2D, CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
 import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
 VoxelBehaviorsRegister.register({
     type: "dve_liquid",
+    needUpdate(simulation, voxel, x, y, z) {
+        let scheduleUpdate = false;
+        for (let i = 0; i < CardinalNeighbors2D.length; i++) {
+            const nx = CardinalNeighbors2D[i][0] + x;
+            const nz = CardinalNeighbors2D[i][1] + z;
+            const nVoxel = simulation.nDataCursor.getVoxel(nx, y, nz);
+            if (nVoxel && !nVoxel.isSameVoxel(voxel) && nVoxel.isAir()) {
+                scheduleUpdate = true;
+                break;
+            }
+        }
+        const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+        if (downVoxel && !downVoxel.isSameVoxel(voxel) && downVoxel.isAir()) {
+            scheduleUpdate = true;
+        }
+        if (scheduleUpdate) {
+            simulation.scheduleUpdate("dve_liquid", x, y, z, 0);
+        }
+        return scheduleUpdate;
+    },
     onPaint(simulation, voxel, x, y, z) {
         simulation.scheduleUpdate("dve_liquid", x, y, z, 0);
     },

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.d.ts

@@ -3,6 +3,7 @@ import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interfa
 export interface VoxelBehaviorsData {
     type: string;
     inherits?: string;
+    needUpdate?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): boolean;
     onInteract?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
     onPaint?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
     onErase?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
@@ -11,6 +12,7 @@ export interface VoxelBehaviorsData {
 export declare class VoxelBehavior {
     data: VoxelBehaviorsData;
     constructor(data: VoxelBehaviorsData);
+    needUpdate(simulation: DimensionSimulation, x: number, y: number, z: number): boolean | undefined;
     onInteract(simulation: DimensionSimulation, x: number, y: number, z: number): void;
     onPaint(simulation: DimensionSimulation, x: number, y: number, z: number): void;
     onErase(simulation: DimensionSimulation, x: number, y: number, z: number): void;

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.js

@@ -3,6 +3,12 @@ export class VoxelBehavior {
     constructor(data) {
         this.data = data;
     }
+    needUpdate(simulation, x, y, z) {
+        if (!this.data.needUpdate)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        return this.data.needUpdate(simulation, voxel, x, y, z);
+    }
     onInteract(simulation, x, y, z) {
         if (!this.data.onInteract)
             return;