@divinevoxel/vlox 0.0.74 → 0.0.76

package/WorldSimulation/Internal/runActiveSectorUpdate.js

@@ -0,0 +1,106 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldSimulationDimensions } from "./WorldSimulationDimensions";
+import { Circle, Square, Vector3Like } from "@amodx/math";
+import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
+import { WorldSimulationTasks } from "./WorldSimulationTasks";
+const sectorSquare = new Square();
+const tempPosition = Vector3Like.Create();
+const unrender = new Set();
+const render = new Set();
+const removedSectors = [];
+const queue = [];
+const vistedMap = new Set();
+export function runActiveSectorUpdate() {
+    sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
+    for (const [, dimension] of WorldSimulationDimensions._dimensions) {
+        for (let i = dimension.activeSectors._sectors.length - 1; i > -1; i--) {
+            const sector = dimension.activeSectors._sectors[i];
+            sector.generating = false;
+            sector.renderering = false;
+            sector.ticking = false;
+            const [cx, cy, cz] = sector.position;
+            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
+            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
+            for (let g = 0; g < dimension.generators.length; g++) {
+                const generator = dimension.generators[g];
+                generator._maxCircle.center.x =
+                    generator._sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+                generator._maxCircle.center.y =
+                    generator._sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+                if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._maxCircle)) {
+                    removedSectors.push(sector);
+                    dimension.activeSectors._map.delete(WorldSpaces.hash.hashXYZ(cx, cy, cz));
+                    dimension.activeSectors._sectors.splice(i, 1);
+                }
+            }
+        }
+        for (let g = 0; g < dimension.generators.length; g++) {
+            const generator = dimension.generators[g];
+            const sectorPosition = generator._sectorPosition;
+            queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+            generator._renderCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._renderCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            generator._genCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._genCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            generator._maxCircle.center.x =
+                sectorPosition.x + WorldSpaces.sector.bounds.x / 2;
+            generator._maxCircle.center.y =
+                sectorPosition.z + WorldSpaces.sector.bounds.z / 2;
+            while (queue.length) {
+                const cx = queue.shift();
+                const cy = queue.shift();
+                const cz = queue.shift();
+                const key = WorldSpaces.hash.hashXYZ(cx, cy, cz);
+                if (vistedMap.has(key))
+                    continue;
+                vistedMap.add(key);
+                sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
+                sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
+                sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
+                if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._maxCircle))
+                    continue;
+                if (!dimension.activeSectors._map.has(key)) {
+                    dimension.activeSectors.add(cx, cy, cz);
+                }
+                const sector = dimension.activeSectors._map.get(key);
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._genCircle)) {
+                    sector.generating = true;
+                }
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._renderCircle)) {
+                    render.add(sector);
+                    unrender.delete(sector);
+                    sector.renderering = true;
+                }
+                else {
+                    if (!render.has(sector) && sector._rendered) {
+                        unrender.add(sector);
+                    }
+                }
+                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._tickCircle)) {
+                    sector.ticking = true;
+                }
+                for (let i = 0; i < MooreNeighborhood2D.length; i++) {
+                    const sectorPOS = WorldSpaces.sector.getPosition(cx + MooreNeighborhood2D[i][0] * WorldSpaces.sector.bounds.x, cy, cz + MooreNeighborhood2D[i][1] * WorldSpaces.sector.bounds.z, tempPosition);
+                    queue.push(sectorPOS.x, sectorPOS.y, sectorPOS.z);
+                }
+            }
+            vistedMap.clear();
+        }
+        for (const sector of unrender) {
+            WorldSimulationTasks.unbuildTasks.add(dimension.id, ...sector.position);
+        }
+        for (const removed of removedSectors) {
+            WorldSimulationTasks.unloadTasks.add(dimension.id, ...removed.position);
+        }
+        removedSectors.length = 0;
+        render.clear();
+        unrender.clear();
+        for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+            dimension.activeSectors._sectors[i].updateNeighbors();
+        }
+    }
+}

package/WorldSimulation/Procedures/InitalLoad.d.ts

@@ -1,4 +1,4 @@
-import { GeneratorData } from "../Internal/Classes/Generator";
+import { GeneratorData } from "../Dimensions/Generator";
 /**# InitalLoad
  * ---
  * Load the world without building.

package/WorldSimulation/Procedures/InitalLoad.js

@@ -11,7 +11,7 @@ export async function InitalLoad(props) {
         const generator = WorldSimulation.createGenerator({
             ...props.genData,
             building: false,
-            culling: false
+            culling: false,
         });
         if (!WorldSimulationDimensions._dimensions.has(generator._dimension)) {
             WorldSimulationDimensions.addDimension(generator._dimension);
@@ -24,14 +24,16 @@ export async function InitalLoad(props) {
         const update = () => {
             if (done)
                 return;
-            WorldSimulation.update();
+            WorldSimulation.tick(true);
             timeOut = setTimeout(update, 0);
         };
         update();
         const inte = setInterval(() => {
             let allDone = true;
             for (const [key, task] of dimension.tasks) {
-                if (task.waitingFor > 0 || task.queue.length > 0) {
+                if (!task.generationTask)
+                    continue;
+                if (task.waitingFor > 0 || task._task.size > 0) {
                     allDone = false;
                     break;
                 }
@@ -48,6 +50,6 @@ export async function InitalLoad(props) {
                 }
                 resolve(true);
             })();
-        }, 100);
+        }, 250);
     });
 }

package/WorldSimulation/Tasks/SimulationTaskBase.d.ts

@@ -0,0 +1,19 @@
+import { LocationData } from "../../Math/index.js";
+import { DimensionSegment } from "../Dimensions/DimensionSegment.js";
+import { TaskSegment } from "./TaskSegment.js";
+import { SimulationSector } from "WorldSimulation/Dimensions/SimulationSector.js";
+export type SimulationTaskBaseData = {
+    id: string;
+    sort?: boolean;
+    generationTask?: boolean;
+    checkInRequired?: boolean;
+    log?: boolean;
+    checkDone?(location: LocationData): boolean;
+    run(dimension: DimensionSegment, location: LocationData, taskId: number, task: TaskSegment, sector: SimulationSector): void;
+};
+export declare class SimulationTaskBase {
+    data: SimulationTaskBaseData;
+    constructor(data: SimulationTaskBaseData);
+    add(dimensionId: number, x: number, y: number, z: number): void;
+    runTask(max?: number): void;
+}

package/WorldSimulation/Tasks/SimulationTaskBase.js

@@ -0,0 +1,50 @@
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions.js";
+export class SimulationTaskBase {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    add(dimensionId, x, y, z) {
+        const dimension = WorldSimulationDimensions.getDimension(dimensionId);
+        const task = dimension.getTask(this.data.id);
+        if (task.has(x, y, z))
+            return;
+        task.add(x, y, z);
+    }
+    runTask(max = 10) {
+        for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
+            const task = dimension.getTask(this.data.id);
+            if (this.data.checkDone) {
+                for (const [id, taskData] of task._task) {
+                    if (this.data.checkDone(taskData)) {
+                        task.completeTask(id);
+                    }
+                }
+            }
+            if (task.waitingFor >= max)
+                continue;
+            if (this.data.sort) {
+                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;
+                const sector = dimension.activeSectors.get(x, y, z);
+                if (!sector || (this.data.checkInRequired && !sector.canCheckOut())) {
+                    addBack.push(x, y, z);
+                    continue;
+                }
+                const taskId = task.addTask(x, y, z);
+                this.data.run(dimension, location, taskId, task, sector);
+                if (count + 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/TaskRegister.d.ts

@@ -0,0 +1,7 @@
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+import { SimulationTaskBase, SimulationTaskBaseData } from "./SimulationTaskBase";
+export declare class TaskRegister {
+    static readonly tasks: SimulationTaskBase[];
+    static addTasks(data: SimulationTaskBaseData): SimulationTaskBase;
+    static addToDimension(dimension: DimensionSegment): void;
+}

package/WorldSimulation/{Internal → Tasks}/TaskRegister.js

@@ -1,14 +1,14 @@
-import { IWGTaskBase } from "./Classes/WorldSimulationTaskBase";
+import { SimulationTaskBase, } from "./SimulationTaskBase";
 export class TaskRegister {
     static tasks = [];
     static addTasks(data) {
-        const newTask = new IWGTaskBase(data);
+        const newTask = new SimulationTaskBase(data);
         this.tasks.push(newTask);
         return newTask;
     }
     static addToDimension(dimension) {
         for (const task of this.tasks) {
-            dimension.addTask(task.data.id);
+            dimension.addTask(task.data.id, task.data.generationTask || false);
         }
     }
 }

package/WorldSimulation/Tasks/TaskSegment.d.ts

@@ -0,0 +1,20 @@
+import { LocationData } from "../../Math";
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+export declare class TaskSegment {
+    dimension: DimensionSegment;
+    generationTask: boolean;
+    _hash: Set<unknown>;
+    nodes: LocationData[];
+    waitingFor: number;
+    clear(): void;
+    _taskCount: number;
+    _task: Map<number, LocationData>;
+    constructor(dimension: DimensionSegment, generationTask: boolean);
+    _getLocationData(dimension: number, x: number, y: number, z: number): LocationData;
+    completeTask(id: number): boolean;
+    addTask(x: number, y: number, z: number): number;
+    has(x: number, y: number, z: number): boolean;
+    add(x: number, y: number, z: number): false | undefined;
+    sort(x: number, y: number, z: number): LocationData[];
+    run(): Generator<LocationData>;
+}

package/WorldSimulation/Tasks/TaskSegment.js

@@ -0,0 +1,83 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+const pool = [];
+export class TaskSegment {
+    dimension;
+    generationTask;
+    _hash = new Set();
+    nodes = [];
+    waitingFor = 0;
+    clear() { }
+    _taskCount = 0;
+    _task = new Map();
+    constructor(dimension, generationTask) {
+        this.dimension = dimension;
+        this.generationTask = generationTask;
+    }
+    _getLocationData(dimension, x, y, z) {
+        const location = pool.length ? pool.shift() : [0, 0, 0, 0];
+        location[0] = dimension;
+        location[1] = x;
+        location[2] = y;
+        location[3] = z;
+        return location;
+    }
+    completeTask(id) {
+        const locationData = this._task.get(id);
+        if (!locationData)
+            return false;
+        this._hash.delete(WorldSpaces.hash.hashXYZ(locationData[1], locationData[2], locationData[3]));
+        this._task.delete(id);
+        pool.push(locationData);
+        this.waitingFor--;
+        return true;
+    }
+    addTask(x, y, z) {
+        const id = this._taskCount;
+        this._task.set(id, this._getLocationData(this.dimension.id, x, y, z));
+        this._taskCount++;
+        this.waitingFor++;
+        return id;
+    }
+    has(x, y, z) {
+        return this._hash.has(WorldSpaces.hash.hashXYZ(x, y, z));
+    }
+    add(x, y, z) {
+        const key = WorldSpaces.hash.hashXYZ(x, y, z);
+        if (this._hash.has(key))
+            return false;
+        this._hash.add(key);
+        const location = this._getLocationData(this.dimension.id, x, y, z);
+        this.nodes.push(location);
+    }
+    sort(x, y, z) {
+        const sections = this.nodes;
+        const sx = x, sy = y, sz = z;
+        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
+        while (i > 1) {
+            for (j = 1; j < i; j++) {
+                (ax = sections[j - 1][1]),
+                    (ay = sections[j - 1][2]),
+                    (az = sections[j - 1][3]);
+                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
+                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
+                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
+                if (distA > distB) {
+                    temp = sections[j - 1];
+                    sections[j - 1] = sections[j];
+                    sections[j] = temp;
+                }
+            }
+            i--;
+        }
+        return sections;
+    }
+    *run() {
+        while (this.nodes.length) {
+            const vec = this.nodes.shift();
+            const key = WorldSpaces.hash.hashXYZ(vec[1], vec[2], vec[3]);
+            this._hash.delete(key);
+            yield vec;
+            pool.push(vec);
+        }
+    }
+}

package/WorldSimulation/Tick/TickQueue.d.ts

@@ -0,0 +1,9 @@
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+import { VoxelTickUpdate } from "../Voxels/Ticks/index";
+export declare class TickQueue {
+    dimension: DimensionSegment;
+    constructor(dimension: DimensionSegment);
+    ticks: Map<number, VoxelTickUpdate<null>[]>;
+    addTick(data: VoxelTickUpdate, delay?: number): void;
+    run(): boolean;
+}

package/WorldSimulation/Tick/TickQueue.js

@@ -0,0 +1,31 @@
+import { VoxelTickUpdateRegister, } from "../Voxels/Ticks/index";
+const tickArrayPool = [];
+export class TickQueue {
+    dimension;
+    constructor(dimension) {
+        this.dimension = dimension;
+    }
+    ticks = new Map();
+    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);
+        ticks.push(data);
+    }
+    run() {
+        const tick = this.dimension.getTick();
+        const updates = this.ticks.get(tick);
+        if (!updates)
+            return false;
+        while (updates.length) {
+            const update = updates.shift();
+            const type = VoxelTickUpdateRegister.getUpdateType(update.type);
+            type.run(this.dimension.simulation, update);
+        }
+        this.ticks.delete(tick);
+        tickArrayPool.push(updates);
+        return true;
+    }
+}

package/WorldSimulation/Tools/SimulationBrush.d.ts

@@ -0,0 +1,25 @@
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+import { BrushTool } from "../../Tools/Brush/Brush";
+import { LocationData } from "../../Math";
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { VoxelUpdateData } from "../../Tasks/Tasks.types";
+import { VoxelPath } from "../../Templates/Path/VoxelPath";
+export declare class SimulationBrush extends BrushTool {
+    _dimension: DimensionSegment;
+    private taskTool;
+    _location: LocationData;
+    _mapLocation(): void;
+    constructor(_dimension: DimensionSegment);
+    paint(updateData?: VoxelUpdateData): this;
+    paintAsync(updateData?: VoxelUpdateData): Promise<void>;
+    paintTemplate(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): this;
+    paintTemplateAsync(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): Promise<this>;
+    paintPath(voxelPath: VoxelPath, updateData?: VoxelUpdateData): this;
+    paintPathAsync(voxelPath: VoxelPath, updateData?: VoxelUpdateData): Promise<this>;
+    erase(updateData?: VoxelUpdateData): this;
+    eraseAsync(updateData?: VoxelUpdateData): Promise<void>;
+    eraseTemplate(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): this;
+    eraseTemplateAsync(voxelTemplate: IVoxelTemplate, updateData?: VoxelUpdateData): Promise<this>;
+    erasePath(voxelPath: VoxelPath, updateData?: VoxelUpdateData): this;
+    erasePathAsync(voxelPath: VoxelPath, updateData?: VoxelUpdateData): Promise<this>;
+}

package/WorldSimulation/Tools/SimulationBrush.js

@@ -0,0 +1,203 @@
+import { BrushTool } from "../../Tools/Brush/Brush";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
+import { VoxelBehaviorsRegister } from "../Voxels/Behaviors";
+import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { PaintVoxel } from "../../Tasks/Paint/Paint/PaintVoxel";
+import PaintVoxelTemplate from "../../Tasks/Paint/Paint/PaintVoxelTemplate";
+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";
+export class SimulationBrush extends BrushTool {
+    _dimension;
+    taskTool;
+    _location = [0, 0, 0, 0];
+    _mapLocation() {
+        this._location[0] = this._dimension.id;
+        this._location[1] = this.x;
+        this._location[2] = this.y;
+        this._location[3] = this.z;
+    }
+    constructor(_dimension) {
+        super();
+        this._dimension = _dimension;
+        this.taskTool = WorldSimulationTools.taskTool;
+    }
+    paint(updateData = {}) {
+        this._mapLocation();
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+        const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+        PaintVoxel(this._location, this.getRaw(), updateData);
+        behavior.onPaint(this._dimension.simulation, x, y, z);
+        return this;
+    }
+    async paintAsync(updateData = {}) {
+        this._mapLocation();
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+        const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+        await this.taskTool.voxel.paint.runAsync([
+            this._location,
+            this.getRaw(),
+            {},
+        ]);
+        behavior.onPaint(this._dimension.simulation, x, y, z);
+    }
+    paintTemplate(voxelTemplate, updateData = {}) {
+        PaintVoxelTemplate(this.dimension, [this.x, this.y, this.z], voxelTemplate.toJSON(), updateData);
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.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;
+                    const voxel = this.dataCursor.getVoxel(tx, ty, tz);
+                    if (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        continue;
+                    if (!voxel)
+                        continue;
+                    const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+                    const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+                    behavior.onPaint(this._dimension.simulation, tx, ty, tz);
+                }
+            }
+        }
+        return this;
+    }
+    async paintTemplateAsync(voxelTemplate, updateData = {}) {
+        await this.taskTool.voxel.paintTemplate.runAsync([
+            this.dimension,
+            [this.x, this.y, this.z],
+            voxelTemplate.toJSON(),
+            updateData,
+        ]);
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.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;
+                    const voxel = this.dataCursor.getVoxel(tx, ty, tz);
+                    if (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        continue;
+                    if (!voxel)
+                        continue;
+                    const tags = VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(this.data.id)];
+                    const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+                    behavior.onPaint(this._dimension.simulation, tx, ty, tz);
+                }
+            }
+        }
+        return this;
+    }
+    paintPath(voxelPath, updateData = {}) {
+        PaintVoxelPath(this.dimension, [this.x, this.y, this.z], voxelPath.toJSON(), updateData);
+        return this;
+    }
+    async paintPathAsync(voxelPath, updateData = {}) {
+        await this.taskTool.voxel.paintPath.runAsync([
+            this.dimension,
+            [this.x, this.y, this.z],
+            voxelPath.toJSON(),
+            updateData,
+        ]);
+        return this;
+    }
+    erase(updateData = {}) {
+        this._mapLocation();
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const voxel = this._dimension.simulation.getVoxelForUpdate(x, y, z);
+        const tags = VoxelTagsRegister.VoxelTags[voxel.getVoxelId()];
+        const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+        EraseVoxel(this._location, updateData);
+        behavior.onErase(this._dimension.simulation, x, y, z);
+        return this;
+    }
+    async eraseAsync(updateData = {}) {
+        this._mapLocation();
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const voxel = this._dimension.simulation.getVoxelForUpdate(x, y, z);
+        const tags = VoxelTagsRegister.VoxelTags[voxel.getVoxelId()];
+        const behavior = VoxelBehaviorsRegister.get(tags["dve_simulation_behavior"] || "default");
+        await this.taskTool.voxel.erase.runAsync([this._location, updateData]);
+        behavior.onErase(this._dimension.simulation, x, y, z);
+    }
+    eraseTemplate(voxelTemplate, updateData = {}) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.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 (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        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);
+                }
+            }
+        }
+        EraseVoxelTemplate(this.dimension, [this.x, this.y, this.z], voxelTemplate.toJSON(), updateData);
+        return this;
+    }
+    async eraseTemplateAsync(voxelTemplate, updateData = {}) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.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 (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        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],
+            voxelTemplate.toJSON(),
+            updateData,
+        ]);
+        return this;
+    }
+    erasePath(voxelPath, updateData = {}) {
+        EraseVoxelPath(this.dimension, [this.x, this.y, this.z], voxelPath.toJSON(), updateData);
+        return this;
+    }
+    async erasePathAsync(voxelPath, updateData = {}) {
+        await this.taskTool.voxel.erasePath.runAsync([
+            this.dimension,
+            [this.x, this.y, this.z],
+            voxelPath.toJSON(),
+            updateData,
+        ]);
+        return this;
+    }
+}

package/WorldSimulation/Voxels/Behaviors/Types/CropVoxelBehavior.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,23 @@
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+VoxelBehaviorsRegister.register({
+    type: "dve_crop",
+    onTick(simulation, voxel, x, y, z) {
+        const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+        if (downVoxel &&
+            downVoxel.tags["dve_simulation_behavior"] == "dve_farmland") {
+            const waterLevel = downVoxel.getLevel();
+            if (waterLevel <= 0)
+                return;
+            const plantLevel = voxel.schema.state
+                .startEncoding(voxel.getState())
+                .getNumber("level");
+            if (plantLevel >= 7)
+                return;
+            voxel.setState(voxel.schema.state
+                .startEncoding()
+                .setNumber("level", plantLevel + 1)
+                .getEncoded());
+            simulation.bounds.updateDisplay(x, y, z);
+        }
+    },
+});

package/WorldSimulation/Voxels/Behaviors/Types/DefaultVoxelBehavior.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+VoxelBehaviorsRegister.register({
+    type: "dve_default",
+    onInteract(simulation, voxel, x, y, z) { },
+    onPaint(simulation, voxel, x, y, z) { },
+    onErase(simulation, voxel, x, y, z) { },
+    onTick(simulation, voxel, x, y, z) {
+        //  console.log("tick the default", voxel.getStringId(),x,y,z);
+    },
+});

package/WorldSimulation/Voxels/Behaviors/Types/FarmlandVoxelBehavior.d.ts

@@ -0,0 +1 @@
+export {};