@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/IWG/Internal/Functions/runWorldUpdate.js

@@ -0,0 +1,70 @@
+import { Circle, Square } from "@amodx/math";
+import { getSectorState } from "./getSectorState";
+import { SectorState } from "../Classes/SectorState";
+import { WorldRegister } from "../../../../World/WorldRegister";
+import { Sector } from "../../../../World";
+import { SectorStateStructIds } from "../../../../World/Sector/SectorStructIds";
+import { WorldLock } from "../../../../World/Lock/WorldLock";
+import { IWGTasks } from "../IWGTasks";
+import { IWGDimensions } from "../IWGDimensions";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+const stateCursor = new SectorState();
+const sectorSquare = new Square();
+export function runWorldUpdate(generators) {
+    for (const generator of generators) {
+        const segment = IWGDimensions._dimensions.get(generator._dimension);
+        if (!segment)
+            throw new Error(`No segment for dimensions ${generator._dimension} found.`);
+        const queue = segment.queue;
+        const vistedMap = segment.vistedMap;
+        const sectorPosition = generator._sectorPosition;
+        queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        generator._genCircle.center.x = sectorPosition.x;
+        generator._genCircle.center.y = sectorPosition.z;
+        while (queue.length) {
+            const cx = queue.shift();
+            const cy = queue.shift();
+            const cz = queue.shift();
+            if (WorldLock.isLocked([generator._dimension, cx, cy, cz]) ||
+                segment.inProgress.has(cx, cy, cz) ||
+                vistedMap.has(cx, cy, cz))
+                continue;
+            vistedMap.add(cx, cy, cz);
+            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._genCircle))
+                continue;
+            const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
+            if (!sector) {
+                IWGTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            const state = getSectorState(sector, stateCursor, segment);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (state.allLoaded &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+                IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nWorldGenAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+                IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nDecorAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+                IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+            if (state.nPropagtionAllDone &&
+                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+                IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
+                continue;
+            }
+        }
+    }
+    for (const [key, dimension] of IWGDimensions._dimensions) {
+        dimension.vistedMap.clear();
+    }
+}

package/Tasks/IWG/Internal/IWGDimensions.d.ts

@@ -0,0 +1,6 @@
+import { DimensionSegment } from "./Classes/DimensionSegment";
+export declare class IWGDimensions {
+    static readonly _dimensions: Map<string, DimensionSegment>;
+    static addDimension(dimensionId: string): void;
+    static getDimension(dimensionId: string): DimensionSegment;
+}

package/Tasks/IWG/Internal/IWGDimensions.js

@@ -0,0 +1,17 @@
+import { DimensionSegment } from "./Classes/DimensionSegment";
+import { TaskRegister } from "./TaskRegister";
+export class IWGDimensions {
+    static _dimensions = new Map();
+    static addDimension(dimensionId) {
+        const segment = new DimensionSegment(dimensionId);
+        TaskRegister.addToDimension(segment);
+        this._dimensions.set(dimensionId, segment);
+    }
+    static getDimension(dimensionId) {
+        const dimension = this._dimensions.get(dimensionId);
+        if (!dimension) {
+            throw new Error(`Dimension with id [${dimensionId}] is not registered`);
+        }
+        return dimension;
+    }
+}

package/Tasks/IWG/Internal/IWGTasks.d.ts

@@ -0,0 +1,34 @@
+export declare class IWGTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static readonly worldLoadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# Generate Sectors
+     * ---
+     */
+    static readonly worldGenTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# Decorate Sectors
+     * ---
+     */
+    static readonly worldDecorateTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# World Sun
+     * ---
+     */
+    static readonly worldSunTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# World Propagation
+     * ---
+     */
+    static readonly worldPropagationTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# Save Sector
+     * ---
+     */
+    static readonly saveTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# Save & Unload Sector
+     * ---
+     */
+    static readonly saveAndUnloadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+    /**# Build Task
+     * ---
+     */
+    static readonly buildTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
+}

package/Tasks/IWG/Internal/IWGTasks.js

@@ -0,0 +1,148 @@
+import { WorldRegister } from "../../../World/WorldRegister";
+import { Sector } from "../../../World/index";
+import { SectorStateStructIds } from "../../../World/Sector/SectorStructIds";
+import { IWGTools } from "./IWGTools";
+import { TaskRegister } from "./TaskRegister";
+export class IWGTasks {
+    /**# Load Sectors
+     * ---
+     */
+    static worldLoadTasks = TaskRegister.addTasks({
+        id: "load",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const [dimension, x, y, z] = location;
+            const sector = WorldRegister.sectors.get(location[0], x, y, z);
+            if (sector)
+                return onDone();
+            if (!IWGTools.worldStorage) {
+                WorldRegister.sectors.new(location[0], x, y, z);
+                return onDone();
+            }
+            const loaded = await IWGTools.worldStorage.loadSector([
+                dimension,
+                x,
+                y,
+                z,
+            ]);
+            if (!loaded) {
+                WorldRegister.sectors.new(location[0], x, y, z);
+            }
+            onDone();
+        },
+    });
+    /**# Generate Sectors
+     * ---
+     */
+    static worldGenTasks = TaskRegister.addTasks({
+        id: "generate",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone))
+                return onDone();
+            IWGTools.taskTool.generate.run([location, []], null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldGenDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# Decorate Sectors
+     * ---
+     */
+    static worldDecorateTasks = TaskRegister.addTasks({
+        id: "decorate",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone))
+                return onDone();
+            IWGTools.taskTool.decorate.run([location, []], null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldDecorDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# World Sun
+     * ---
+     */
+    static worldSunTasks = TaskRegister.addTasks({
+        id: "wolrd_sun",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone))
+                return onDone();
+            IWGTools.taskTool.worldSun.run(location, null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldSunDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# World Propagation
+     * ---
+     */
+    static worldPropagationTasks = TaskRegister.addTasks({
+        id: "propagation",
+        propagationBlocking: true,
+        async run(location, onDone) {
+            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            if (!sector)
+                throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
+            Sector.StateStruct.setBuffer(sector.buffer);
+            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone))
+                return onDone();
+            IWGTools.taskTool.propagation.run(location, null, () => {
+                Sector.StateStruct.setBuffer(sector.buffer);
+                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldPropagationDone, 1);
+                onDone();
+            });
+        },
+    });
+    /**# Save Sector
+     * ---
+     */
+    static saveTasks = TaskRegister.addTasks({
+        id: "save",
+        async run(location, onDone) {
+            if (!IWGTools.worldStorage)
+                return onDone();
+            await IWGTools.worldStorage.saveSector(location);
+            onDone();
+        },
+    });
+    /**# Save & Unload Sector
+     * ---
+     */
+    static saveAndUnloadTasks = TaskRegister.addTasks({
+        id: "save_and_unload",
+        async run(location, onDone) {
+            if (!IWGTools.worldStorage)
+                return onDone();
+            await IWGTools.worldStorage.unloadSector(location);
+            onDone();
+        },
+    });
+    /**# Build Task
+     * ---
+     */
+    static buildTasks = TaskRegister.addTasks({
+        id: "build_tasks",
+        async run(location, onDone, dimenion) {
+            dimenion.rendered.add(location[1], location[2], location[3]);
+            IWGTools.taskTool.build.sector.run(location, null, onDone);
+        },
+    });
+}

package/Tasks/IWG/Internal/IWGTools.d.ts

@@ -0,0 +1,8 @@
+import { Thread } from "@amodx/threads";
+import { TaskTool } from "../../../Tools/Tasks/TasksTool";
+import { WorldStorageInterface } from "../../../World/Storage/WorldStorage.interface";
+export declare class IWGTools {
+    static taskTool: TaskTool;
+    static worldStorage: WorldStorageInterface | null;
+    static parent: Thread;
+}

package/Tasks/IWG/Internal/IWGTools.js

@@ -0,0 +1,5 @@
+export class IWGTools {
+    static taskTool;
+    static worldStorage = null;
+    static parent;
+}

package/Tasks/IWG/Internal/TaskRegister.d.ts

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

package/Tasks/IWG/Internal/TaskRegister.js

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

package/Tasks/IWG/Procedures/InitalLoad.d.ts

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

package/Tasks/IWG/Procedures/InitalLoad.js

@@ -0,0 +1,53 @@
+import { IWG } from "../IWG";
+import { IWGDimensions } from "../Internal/IWGDimensions";
+import { IWGTools } from "../Internal/IWGTools";
+import SaveAllSectors from "./SaveAllSectors";
+/**# InitalLoad
+ * ---
+ * Load the world without building.
+ */
+export async function InitalLoad(props) {
+    return new Promise((resolve) => {
+        const generator = IWG.createGenerator({
+            ...props.genData,
+            building: false,
+            culling: false
+        });
+        if (!IWGDimensions._dimensions.has(generator._dimension)) {
+            IWGDimensions.addDimension(generator._dimension);
+        }
+        const dimension = IWGDimensions.getDimension(props.dimension || "main");
+        let done = false;
+        generator._building = false;
+        IWG.addGenerator(generator);
+        let timeOut = null;
+        const update = () => {
+            if (done)
+                return;
+            IWG.update();
+            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) {
+                    allDone = false;
+                    break;
+                }
+            }
+            if (!allDone)
+                return;
+            done = true;
+            clearInterval(inte);
+            clearTimeout(timeOut);
+            IWG.removeGenerator(generator);
+            (async () => {
+                if (IWGTools.worldStorage) {
+                    await SaveAllSectors();
+                }
+                resolve(true);
+            })();
+        }, 100);
+    });
+}

package/Tasks/IWG/Procedures/SaveAllSectors.d.ts

@@ -0,0 +1,5 @@
+/**# Save All Sectors
+ * ---
+ * Save all sectors that are loaded.
+ */
+export default function SaveAllSectors(): Promise<void>;

package/Tasks/IWG/Procedures/SaveAllSectors.js

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

package/Tasks/IWG/index.d.ts

@@ -1 +1,2 @@
-export * from "./World/Types/IWG.types.js";
+export * from "./IWG";
+export * from "./Procedures/InitalLoad";

package/Tasks/IWG/index.js

@@ -1 +1,2 @@
-export * from "./World/Types/IWG.types.js";
+export * from "./IWG";
+export * from "./Procedures/InitalLoad";

package/Tasks/Propagation/Explosion/ExplosionManager.js

@@ -1,16 +1,14 @@
 //data
-import { $3dCardinalNeighbors } from "../../../Math/Constants/CardinalNeighbors.js";
+import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
 //objects
-import { DataTool } from "../../../Tools/Data/DataTool.js";
-import { LightData } from "../../../Voxels/LightData.js";
 //functions
 import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
-import { RGBRemove, RGBUpdate } from "../Illumanation/Functions/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Illumanation/Functions/SunUpdate.js";
+import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate.js";
 import { FlowManager } from "../Flow/FlowManager.js";
 import { VisitedMap } from "../../../Util/VisistedMap";
-const dataTool = new DataTool();
-const nDataTool = new DataTool();
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
+const lightData = new VoxelLightData();
 export const ExplosionManager = {
     runExplosion(tasks, radius) {
         const [dimension, sx, sy, sz] = tasks.origin;
@@ -18,8 +16,6 @@ export const ExplosionManager = {
         const queue = [];
         const map = new VisitedMap();
         queue.push([sx, sy, sz]);
-        dataTool.setDimension(dimension);
-        nDataTool.setDimension(dimension);
         while (queue.length) {
             const node = queue.shift();
             if (!node)
@@ -28,7 +24,7 @@ export const ExplosionManager = {
             const y = node[1];
             const z = node[2];
             if (!map.inMap(x + 1, y, z)) {
-                if (dataTool.loadInAt(x + 1, y, z)) {
+                if (tasks.sDataCursor.getVoxel(x + 1, y, z)) {
                     const d = Distance3D(sx, sy, sz, x + 1, y, z);
                     if (d <= radius) {
                         queue.push([x + 1, y, z]);
@@ -37,7 +33,7 @@ export const ExplosionManager = {
                 }
             }
             if (!map.inMap(x - 1, y, z)) {
-                if (dataTool.loadInAt(x - 1, y, z)) {
+                if (tasks.sDataCursor.getVoxel(x - 1, y, z)) {
                     const d = Distance3D(sx, sy, sz, x - 1, y, z);
                     if (d <= radius) {
                         queue.push([x - 1, y, z]);
@@ -46,7 +42,7 @@ export const ExplosionManager = {
                 map.add(x - 1, y, z);
             }
             if (!map.inMap(x, y, z + 1)) {
-                if (dataTool.loadInAt(x, y, z + 1)) {
+                if (tasks.sDataCursor.getVoxel(x, y, z + 1)) {
                     const d = Distance3D(sx, sy, sz, x, y, z + 1);
                     if (d <= radius) {
                         queue.push([x, y, z + 1]);
@@ -55,7 +51,7 @@ export const ExplosionManager = {
                 map.add(x, y, z + 1);
             }
             if (!map.inMap(x, y, z - 1)) {
-                if (dataTool.loadInAt(x, y, z - 1)) {
+                if (tasks.sDataCursor.getVoxel(x, y, z - 1)) {
                     const d = Distance3D(sx, sy, sz, x, y, z - 1);
                     if (d <= radius) {
                         queue.push([x, y, z - 1]);
@@ -64,7 +60,7 @@ export const ExplosionManager = {
                 map.add(x, y, z - 1);
             }
             if (!map.inMap(x, y + 1, z)) {
-                if (dataTool.loadInAt(x, y + 1, z)) {
+                if (tasks.sDataCursor.getVoxel(x, y + 1, z)) {
                     const d = Distance3D(sx, sy, sz, x, y + 1, z);
                     if (d <= radius) {
                         queue.push([x, y + 1, z]);
@@ -73,7 +69,7 @@ export const ExplosionManager = {
                 map.add(x, y + 1, z);
             }
             if (!map.inMap(x, y - 1, z)) {
-                if (dataTool.loadInAt(x, y - 1, z)) {
+                if (tasks.sDataCursor.getVoxel(x, y - 1, z)) {
                     const d = Distance3D(sx, sy, sz, x, y - 1, z);
                     if (d <= radius) {
                         queue.push([x, y - 1, z]);
@@ -81,30 +77,34 @@ export const ExplosionManager = {
                 }
                 map.add(x, y - 1, z);
             }
-            if (dataTool.loadInAt(x, y, z)) {
-                if (dataTool.isRenderable()) {
+            const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+            if (voxel) {
+                if (voxel.isRenderable()) {
                     for (const n of $3dCardinalNeighbors) {
                         const nx = x + n[0];
                         const ny = y + n[1];
                         const nz = z + n[2];
-                        if (nDataTool.loadInAt(nx, ny, nz)) {
-                            const l = nDataTool.getLight();
+                        const nvoxel = tasks.nDataCursor.getVoxel(x, y, z);
+                        if (nvoxel) {
+                            const l = nvoxel.getLight();
                             if (l > 0) {
-                                if (LightData.getS(l) > 0) {
+                                if (lightData.getS(l) > 0) {
                                     tasks.sun.remove.push(nx, ny, nz);
                                 }
-                                if (LightData.hasRGBLight(l)) {
+                                if (lightData.hasRGBLight(l)) {
                                     tasks.rgb.remove.push(nx, ny, nz);
                                 }
                             }
                         }
                     }
                     tasks.bounds.update(x, y, z);
-                    if (dataTool.getHardness() > 10_000 ||
-                        dataTool.getSubstnaceData().isLiquid()) {
-                        continue;
-                    }
-                    dataTool.setAir().commit(2);
+                    /*           if (
+                                voxel.getHardness() > 10_000 ||
+                                voxel.getSubstnaceData().isLiquid()
+                              ) {
+                                continue;
+                              } */
+                    voxel.setAir().updateHeightMap(1);
                 }
             }
         }

package/Tasks/Propagation/Flow/FlowManager.d.ts

@@ -1,66 +1,24 @@
-import { DataTool } from "../../../Tools/Data/DataTool.js";
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
 import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 import { UpdateTask } from "../../Update/UpdateTask.js";
+import { WorldCursor } from "../../../World/index.js";
 export declare class FlowManager {
-    static lightData: {
-        SRS: number;
-        _lightValues: [s: number, r: number, g: number, b: number];
-        sumRGB(value: number): number;
-        getS(value: number): number;
-        getR(value: number): number;
-        getG(value: number): number;
-        getB(value: number): number;
-        setS(value: number, sl: number): number;
-        setR(value: number, sl: number): number;
-        setG(value: number, sl: number): number;
-        setB(value: number, sl: number): number;
-        removeS(sl: number): number;
-        hasRGBLight(sl: number): boolean;
-        hasSunLight(sl: number): boolean;
-        mixLight(l1: number, l2: number): number;
-        getRGB(sl: number): number;
-        setRGB(value: number, sl: number): number;
-        decodeLightFromVoxelData(voxelData: number): number;
-        encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
-        setLightValues(values: ArrayLike<number>): number;
-        getLightValues(value: number): [s: number, r: number, g: number, b: number];
-        getLightValuesToRef(value: number, values: [s: number, r: number, g: number, b: number]): [s: number, r: number, g: number, b: number];
-        isLessThanForRGBRemove(n1: number, n2: number): boolean;
-        isLessThanForRGBAdd(n1: number, n2: number): boolean;
-        isGreaterOrEqualThanForRGBRemove(n1: number, n2: number): boolean;
-        getMinusOneForRGB(sl: number, nl: number): number;
-        removeRGBLight(sl: number): number;
-        getFullSunLight(sl: number): number;
-        isLessThanForSunAdd(n1: number, n2: number): boolean;
-        isLessThanForSunAddDown(n1: number, n2: number): boolean;
-        isLessThanForSunAddUp(n1: number, n2: number): boolean;
-        getSunLightForUnderVoxel(sl: number, nl: number): number;
-        getMinusOneForSun(sl: number, nl: number): number;
-        isLessThanForSunRemove(n1: number, sl: number): boolean;
-        isGreaterOrEqualThanForSunRemove(n1: number, sl: number): boolean;
-        sunLightCompareForDownSunRemove(n1: number, sl: number): boolean;
-        removeSunLight(sl: number): number;
-        minusOneForAll(sl: number): number;
-        addLightValues(sl: number, sl2: number): number;
-        divideLightValue(sl: number, divisor: number): number;
-    };
     static _brush: BrushTool;
-    static _sDataTool: DataTool;
-    static _nDataTool: DataTool;
+    static _sDataTool: WorldCursor;
+    static _nDataTool: WorldCursor;
     static _substanceTool: SubstanceDataTool;
     static setVoxel(tasks: UpdateTask, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
     static setDimension(dimension: string): void;
     static removeVoxel(tasks: UpdateTask, x: number, y: number, z: number): void;
     static getFlowRate(substance: string): number;
-    static getVoxel(x: number, y: number, z: number): false | DataTool;
+    static getVoxel(x: number, y: number, z: number): WorldCursor;
     static setLevel(level: number, x: number, y: number, z: number): void;
-    static getLevel(vox: string, x: number, y: number, z: number): number;
-    static getLevelState(vox: string, x: number, y: number, z: number): number;
-    static canFlowOutwardTest(vox: string, x: number, y: number, z: number): boolean;
-    static flowDownTest(vox: string, x: number, y: number, z: number): boolean;
+    static getLevel(vox: string, x: number, y: number, z: number): void;
+    static getLevelState(vox: string, x: number, y: number, z: number): void;
+    static canFlowOutwardTest(vox: string, x: number, y: number, z: number): void;
+    static flowDownTest(vox: string, x: number, y: number, z: number): void;
     static wait(ms: number): Promise<unknown>;
     static _lightValues: [s: number, r: number, g: number, b: number];
-    static getAbsorbLight(x: number, y: number, z: number): number;
+    static getAbsorbLight(x: number, y: number, z: number): void;
     static sunCheck(tasks: UpdateTask, x: number, y: number, z: number): void;
 }