@divinevoxel/vlox 0.0.73 → 0.0.75

package/{Tasks/IWG → WorldSimulation}/Procedures/SaveAllSectors.js

@@ -1,16 +1,16 @@
-import { WorldRegister } from "../../../World/WorldRegister";
-import { IWGDimensions } from "../Internal/IWGDimensions";
-import { IWGTools } from "../Internal/IWGTools";
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
 /**# Save All Sectors
  * ---
  * Save all sectors that are loaded.
  */
 export default async function SaveAllSectors() {
-    const worldStorage = IWGTools.worldStorage;
+    const worldStorage = WorldSimulationTools.worldStorage;
     if (!worldStorage)
         return;
     const proms = [];
-    for (const [dimensionId] of IWGDimensions._dimensions) {
+    for (const [dimensionId] of WorldSimulationDimensions._dimensions) {
         const dimension = WorldRegister.dimensions.get(dimensionId);
         for (const [key, sector] of dimension.sectors) {
             if (sector.isStored())

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/{Tasks/IWG/Internal → WorldSimulation/Tasks}/TaskRegister.js

@@ -1,14 +1,14 @@
-import { IWGTaskBase } from "./Classes/IWGTaskBase";
+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 {};

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

@@ -0,0 +1,73 @@
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+const levelChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+VoxelBehaviorsRegister.register({
+    type: "dve_farmland",
+    onTick(simulation, voxel, x, y, z) {
+        let currentLevel = voxel.getLevel();
+        let foundHigherLevel = false;
+        let maxLevel = -1;
+        for (let i = 0; i < 4; i++) {
+            const nx = levelChecks[i][0] + x;
+            const ny = levelChecks[i][1] + y;
+            const nz = levelChecks[i][2] + z;
+            const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel)
+                continue;
+            if (!nVoxel.isSameVoxel(voxel) && !nVoxel.substanceTags["dve_is_liquid"])
+                continue;
+            const nLevel = nVoxel.getLevel();
+            if (currentLevel < nLevel) {
+                foundHigherLevel = true;
+            }
+            if (maxLevel < nLevel) {
+                maxLevel = nLevel;
+            }
+        }
+        maxLevel = Math.max(0, maxLevel - 1);
+        if (!foundHigherLevel) {
+            if (currentLevel == 0) {
+                if (Math.random() > 0.1)
+                    return;
+                const upVoxel = simulation.nDataCursor.getVoxel(x, y + 1, z);
+                if (upVoxel && upVoxel.tags["dve_simulation_behavior"] == "dve_crop") {
+                    return;
+                }
+                //turn to dirt
+                voxel.setStringId("dve_dirt");
+                voxel.setState(0);
+                voxel.setMod(0);
+                simulation.bounds.updateDisplay(x, y, z);
+                return;
+            }
+            const newLevel = currentLevel - 1;
+            if (newLevel == 0) {
+                voxel.setState(voxel.schema.state
+                    .startEncoding(voxel.getState())
+                    .setValue("moist", "false")
+                    .getEncoded());
+                simulation.bounds.updateDisplay(x, y, z);
+            }
+            voxel.setLevel(newLevel);
+            return;
+        }
+        if (foundHigherLevel) {
+            if (currentLevel < maxLevel) {
+                const newLevel = currentLevel + 1;
+                if (currentLevel == 0) {
+                    voxel.setState(voxel.schema.state
+                        .startEncoding(voxel.getState())
+                        .setValue("moist", "true")
+                        .getEncoded());
+                    simulation.bounds.updateDisplay(x, y, z);
+                }
+                voxel.setLevel(newLevel);
+                return;
+            }
+        }
+    },
+});

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

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

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

@@ -0,0 +1,21 @@
+import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+import { VoxelBehaviorsRegister } from "../VoxelBehaviorsRegister";
+VoxelBehaviorsRegister.register({
+    type: "dve_liquid",
+    onPaint(simulation, voxel, x, y, z) {
+        simulation.scheduleUpdate("dve_liquid", x, y, z, 0);
+    },
+    onErase(simulation, voxel, x, y, z) {
+        voxel.setLevelState(2);
+        for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
+            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel || !nVoxel.substanceTags["dve_is_liquid"])
+                continue;
+            simulation.scheduleUpdate("dve_liquid", nx, ny, nz, 0);
+        }
+        simulation.scheduleUpdate("dve_liquid", x, y, z, 10);
+    },
+});

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

@@ -0,0 +1,4 @@
+import "./DefaultVoxelBehavior";
+import "./LiquidVoxelBehavior";
+import "./FarmlandVoxelBehavior";
+import "./CropVoxelBehavior";

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

@@ -0,0 +1,4 @@
+import "./DefaultVoxelBehavior";
+import "./LiquidVoxelBehavior";
+import "./FarmlandVoxelBehavior";
+import "./CropVoxelBehavior";