@divinevoxel/vlox 0.0.3 → 0.0.5

package/Tasks/Mesher/InitTasks.js

@@ -1,46 +0,0 @@
-import { Threads } from "@amodx/threads";
-import { WorldRegister } from "../../Data/World/WorldRegister";
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
-import { TasksIds } from "../TasksIds";
-export default function (mesher) {
-    Threads.registerTasks("build-node-mesh", (data, onDone) => {
-        const nodeData = mesher.nodes.buildNode(data);
-        if (!nodeData)
-            return onDone ? onDone(false) : 0;
-        onDone ? onDone(nodeData[0], nodeData[1]) : 0;
-    }, "deferred");
-    Threads.registerTasks(TasksIds.BuildChunk, async (buildData, onDone) => {
-        WorldRegister.instance.cache.enable();
-        const location = buildData.data[0];
-        await mesher.meshChunk(location, buildData.data[1], 0);
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    });
-    Threads.registerTasks(TasksIds.BuildColumn, async (data, onDone) => {
-        WorldRegister.instance.setDimension(data[0][0]);
-        const column = WorldRegister.instance.column.get(data[0][1], data[0][2], data[0][2]);
-        if (!column) {
-            console.warn("Tried building a column that does not exists.", data);
-            return false;
-        }
-        if (column.chunks.length == 0)
-            return false;
-        const location = data[0];
-        WorldRegister.instance.cache.enable();
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            mesher.meshChunk([
-                location[0],
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ], 1, 100);
-        }
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    }, "deferred");
-}

package/Tasks/Propagation/Flow/Functions/FlowRemove.js

@@ -1,162 +0,0 @@
-import { FlowUpdate } from "./FlowUpdate.js";
-import { FlowManager as FM } from "../FlowManager.js";
-import { EngineSettings } from "../../../../Settings/EngineSettings.js";
-function RunRemoveCheck(tasks, vox) {
-    const [dimension, x, y, z] = tasks.origin;
-    const queue = tasks.flow.remove.queue;
-    const cl = FM.getLevel(vox, x, y, z);
-    queue.push([x, y, z]);
-    const n1 = FM.getLevel(vox, x + 1, y, z);
-    const n1s = FM.getLevelState(vox, x + 1, y, z);
-    if ((n1 > -1 && n1 < cl) || n1s == 1) {
-        queue.push([x + 1, y, z]);
-    }
-    const n2 = FM.getLevel(vox, x - 1, y, z);
-    const n2s = FM.getLevelState(vox, x - 1, y, z);
-    if ((n2 > -1 && n2 < cl) || n2s == 1) {
-        queue.push([x - 1, y, z]);
-    }
-    const n3 = FM.getLevel(vox, x, y, z + 1);
-    const n3s = FM.getLevelState(vox, x, y, z + 1);
-    if ((n3 > -1 && n3 < cl) || n3s == 1) {
-        queue.push([x, y, z + 1]);
-    }
-    const n4 = FM.getLevel(vox, x, y, z - 1);
-    const n4s = FM.getLevelState(vox, x, y, z - 1);
-    if ((n4 > -1 && n4 < cl) || n4s == 1) {
-        queue.push([x, y, z - 1]);
-    }
-}
-export async function FlowRemove(tasks) {
-    const [dimension, x, y, z] = tasks.origin;
-    FM.setDimension(dimension);
-    const vox = FM.getVoxel(x, y, z);
-    if (!vox)
-        return;
-    const voxId = vox.getStringId();
-    const flowRate = vox.getSubstnaceData().getFlowRate();
-    RunRemoveCheck(tasks, voxId);
-    const noRemoveMap = tasks.flow.remove.noRemoveMap;
-    while (tasks.flow.remove.queue.length != 0) {
-        FM.setDimension(dimension);
-        RunRemovePropagation(tasks, voxId);
-        RunFlowReduce(tasks, voxId);
-        await FlowUpdate(tasks, false);
-        noRemoveMap.clear();
-        //  tasks.runRebuildQueue();
-        await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
-    }
-}
-function RunRemovePropagation(tasks, vox) {
-    const removeQ = tasks.flow.remove.queue;
-    const updateQ = tasks.flow.update.queue;
-    const map = tasks.flow.update.map;
-    const noRemoveMap = tasks.flow.remove.noRemoveMap;
-    for (let i = 0; i < removeQ.length; i++) {
-        const node = removeQ[i];
-        const x = node[0];
-        const y = node[1];
-        const z = node[2];
-        const l = FM.getLevel(vox, x, y, z);
-        const s = FM.getLevelState(vox, x, y, z);
-        map.add(x, y, z);
-        if (noRemoveMap.has(x, y, z))
-            continue;
-        n1t: if (!map.has(x + 1, y, z)) {
-            const n1 = FM.getLevel(vox, x + 1, y, z);
-            const n1s = FM.getLevelState(vox, x + 1, y, z);
-            if (n1 <= 0 || n1s == 1)
-                break n1t;
-            if (n1 < l && l > 0 && n1 > 0) {
-                removeQ.push([x + 1, y, z]);
-            }
-            if (n1 > l) {
-                updateQ.push([x + 1, y, z]);
-            }
-        }
-        n2t: if (!map.has(x - 1, y, z)) {
-            const n2 = FM.getLevel(vox, x - 1, y, z);
-            const n2s = FM.getLevelState(vox, x - 1, y, z);
-            if (n2 <= 0 || n2s == 1)
-                break n2t;
-            if (n2 < l && l > 0 && n2 > 0) {
-                removeQ.push([x - 1, y, z]);
-            }
-            if (n2 > l) {
-                updateQ.push([x - 1, y, z]);
-            }
-        }
-        n3t: if (!map.has(x, y, z + 1)) {
-            const n3 = FM.getLevel(vox, x, y, z + 1);
-            const n3s = FM.getLevelState(vox, x, y, z + 1);
-            if (n3 <= 0 || n3s == 1)
-                break n3t;
-            if (n3 < l && l > 0 && n3 > 0) {
-                removeQ.push([x, y, z + 1]);
-            }
-            if (n3 > l) {
-                updateQ.push([x, y, z + 1]);
-            }
-        }
-        n4t: if (!map.has(x, y, z - 1)) {
-            const n4 = FM.getLevel(vox, x, y, z - 1);
-            const n4s = FM.getLevelState(vox, x, y, z - 1);
-            if (n4 <= 0 || n4s == 1)
-                break n4t;
-            if (n4 < l && l > 0 && n4 > 0) {
-                removeQ.push([x, y, z - 1]);
-            }
-            if (n4 > l) {
-                updateQ.push([x, y, z - 1]);
-            }
-        }
-        if (!map.has(x, y - 1, z)) {
-            const n5 = FM.getLevel(vox, x, y - 1, z);
-            if (n5 < 0)
-                continue;
-            const n5s = FM.getLevelState(vox, x, y - 1, z);
-            let add = false;
-            if (s == 1 && n5s == 1) {
-                if (l <= 1) {
-                    add = true;
-                }
-            }
-            if (s == 0 && l <= 1) {
-                add = true;
-            }
-            if (add) {
-                removeQ.push([x, y - 1, z]);
-            }
-        }
-    }
-    map.clear();
-}
-function RunFlowReduce(tasks, vox) {
-    const queue = tasks.flow.remove.queue;
-    const map = tasks.flow.remove.map;
-    const reque = [];
-    while (queue.length != 0) {
-        const node = queue.shift();
-        if (!node) {
-            break;
-        }
-        const x = node[0];
-        const y = node[1];
-        const z = node[2];
-        if (map.has(x, y, z))
-            continue;
-        map.add(x, y, z);
-        const l = FM.getLevel(vox, x, y, z);
-        if (l <= 1) {
-            FM.removeVoxel(tasks, x, y, z);
-            reque.push([x, y, z]);
-        }
-        else {
-            FM.setLevel(l - 1, x, y, z);
-            reque.push([x, y, z]);
-        }
-        tasks.bounds.update(x, y, z);
-    }
-    tasks.flow.remove.queue = reque;
-    map.clear();
-}

package/Tasks/Propagation/Flow/Functions/FlowUpdate.js

@@ -1,96 +0,0 @@
-import { FlowManager as FM } from "../FlowManager.js";
-import { EngineSettings } from "../../../../Settings/EngineSettings.js";
-export async function FlowUpdate(tasks, rebuild = true) {
-    const [dimension, x, y, z] = tasks.origin;
-    FM.setDimension(dimension);
-    const vox = FM.getVoxel(x, y, z);
-    if (!vox)
-        return;
-    const flowRate = vox.getSubstnaceData().getFlowRate();
-    const level = FM.getLevel(vox.getStringId(), x, y, z);
-    if (level < 0)
-        return;
-    const levelState = FM.getLevelState(vox.getStringId(), x, y, z);
-    tasks.flow.update.queue.push([x, y, z, level, levelState]);
-    while (tasks.flow.update.queue.length != 0) {
-        FM.setDimension(dimension);
-        RunFlowPropagation(tasks, vox.getStringId());
-        RunFlowIncrease(tasks, vox.getStringId());
-        if (rebuild) {
-            //  tasks.runRebuildQueue();
-            await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
-        }
-    }
-}
-function RunFlowPropagation(tasks, vox) {
-    const que = tasks.flow.update.queue;
-    const noRemoveMap = tasks.flow.remove.noRemoveMap;
-    for (let i = 0; i < que.length; i++) {
-        const node = que[i];
-        const x = node[0];
-        const y = node[1];
-        const z = node[2];
-        const l = FM.getLevel(vox, x, y, z);
-        const s = FM.getLevelState(vox, x, y, z);
-        noRemoveMap.add(x, y, z);
-        if (FM.canFlowOutwardTest(vox, x, y, z)) {
-            const n1 = FM.getLevel(vox, x + 1, y, z);
-            if (n1 + 1 < l && n1 >= 0) {
-                let n1l = l - 1;
-                que.push([x + 1, y, z, n1l, 0]);
-            }
-            const n2 = FM.getLevel(vox, x - 1, y, z);
-            if (n2 + 1 < l && n2 >= 0) {
-                let n2l = l - 1;
-                que.push([x - 1, y, z, n2l, 0]);
-            }
-            const n3 = FM.getLevel(vox, x, y, z + 1);
-            if (n3 + 1 < l && n3 >= 0) {
-                let n3l = l - 1;
-                que.push([x, y, z + 1, n3l, 0]);
-            }
-            const n4 = FM.getLevel(vox, x, y, z - 1);
-            if (n4 + 1 < l && n4 >= 0) {
-                let n4l = l - 1;
-                que.push([x, y, z - 1, n4l, 0]);
-            }
-        }
-        const n5 = FM.getLevel(vox, x, y - 1, z);
-        if (n5 <= l && n5 >= 0) {
-            let state = 1;
-            let level = 7;
-            if (l <= 0 && s != 1) {
-                state = 0;
-                level = l - 2;
-            }
-            que.push([x, y - 1, z, level, state]);
-        }
-    }
-}
-function RunFlowIncrease(tasks, vox) {
-    const que = tasks.flow.update.queue;
-    const map = tasks.flow.update.map;
-    const reque = [];
-    while (que.length != 0) {
-        const node = que.shift();
-        if (!node) {
-            break;
-        }
-        const x = node[0];
-        const y = node[1];
-        const z = node[2];
-        const level = node[3];
-        const levelState = node[4];
-        if (map.has(x, y, z))
-            continue;
-        map.add(x, y, z);
-        if (level > -1) {
-            FM.setVoxel(tasks, vox, level, levelState, x, y, z);
-            reque.push([x, y, z, -1]);
-        }
-        tasks.bounds.update(x, y, z);
-    }
-    //@ts-ignore
-    tasks.queues.flow.update.queue = reque;
-    map.clear();
-}

package/Tasks/Propagation/Illumanation/Functions/WorldSun.d.ts

@@ -1,2 +0,0 @@
-import { UpdateTask } from "../../../Update/UpdateTask.js";
-export declare function RunWorldSun(tasks: UpdateTask): false | undefined;

package/Tasks/Propagation/Illumanation/Functions/WorldSun.js

@@ -1,115 +0,0 @@
-//types
-//data
-import { WorldBounds } from "../../../../Data/World/WorldBounds.js";
-import { WorldRegister } from "../../../../Data/World/WorldRegister.js";
-import { $3dCardinalNeighbors } from "../../../../Math/Constants/CardinalNeighbors.js";
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
-import { IlluminationManager as IM } from "../IlluminationManager.js";
-import { HeightMapTool } from "../../../../Tools/Data/WorldData/HeightMapTool.js";
-import { LightData } from "../../../../Voxels/LightData";
-import { WorldCursor } from "../../../../Data/Cursor/World/WorldCursor";
-const worldCursor = new WorldCursor();
-const heightMapTool = new HeightMapTool();
-const FloodOutPositions = [
-    [1, 0, 0],
-    [-1, 0, 0],
-    [0, 0, 1],
-    [0, 0, -1],
-    [0, 1, 0],
-];
-const queue = [];
-export function RunWorldSun(tasks) {
-    IM.setDimension(tasks.origin[0]);
-    WorldRegister.instance.setDimension(tasks.origin[0]);
-    if (!WorldRegister.instance.column.get(tasks.origin[1], tasks.origin[2], tasks.origin[2]))
-        return false;
-    const [dimension, cx, cy, cz] = tasks.origin;
-    IM._sDataTool.setDimension(dimension);
-    const RmaxY = heightMapTool.column.getRelative(tasks.origin);
-    const AmaxY = heightMapTool.column.getAbsolute(tasks.origin);
-    const maxX = cx + WorldSpaces.chunk._bounds.x;
-    const maxY = WorldBounds.bounds.MaxY;
-    const maxZ = cz + WorldSpaces.chunk._bounds.z;
-    worldCursor.setFocalPoint(...tasks.origin);
-    const columnCursor = worldCursor.getColumn(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
-    if (!columnCursor)
-        return;
-    const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
-    //fill
-    for (let iy = minY; iy < maxY; iy++) {
-        for (let iz = cz; iz < maxZ; iz++) {
-            for (let ix = cx; ix < maxX; ix++) {
-                const voxel = columnCursor.getVoxel(ix, iy, iz);
-                if (!voxel)
-                    continue;
-                const l = voxel.getLight();
-                if (l < 0)
-                    continue;
-                voxel.setLight(LightData.setS(0xf, l));
-            }
-        }
-    }
-    const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
-    //accumulate
-    for (let iy = minY; iy <= maxAcculamteY; iy++) {
-        for (let iz = cz; iz < maxZ; iz++) {
-            for (let ix = cx; ix < maxX; ix++) {
-                const l = columnCursor.getVoxel(ix, iy, iz)?.getLight();
-                if (l && l < 0 && LightData.getS(l) != 0xf)
-                    continue;
-                for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-                    const n = $3dCardinalNeighbors[i];
-                    const nx = ix + n[0];
-                    const ny = iy + n[1];
-                    const nz = iz + n[2];
-                    const nVoxel = worldCursor.getVoxel(nx, ny, nz);
-                    if (!nVoxel)
-                        continue;
-                    const nl = nVoxel.getLight();
-                    if (nl > -1 && LightData.getS(nl) < 0xf) {
-                        queue.push(ix, iy, iz);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    //flood
-    while (queue.length) {
-        const x = queue.shift();
-        const y = queue.shift();
-        const z = queue.shift();
-        const sl = worldCursor.getVoxel(x, y, z)?.getLight();
-        if (!sl || sl < 0)
-            continue;
-        for (let i = 0; i < 5; i++) {
-            const nx = x + FloodOutPositions[i][0];
-            const ny = y + FloodOutPositions[i][1];
-            const nz = z + FloodOutPositions[i][2];
-            const nVoxel = worldCursor.getVoxel(nx, ny, nz);
-            if (nVoxel) {
-                const nl = nVoxel.getLight();
-                if (nl > -1 && LightData.isLessThanForSunAdd(nl, sl)) {
-                    queue.push(nx, ny, nz);
-                    nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
-                }
-            }
-        }
-        const nVoxel = worldCursor.getVoxel(x, y - 1, z);
-        if (nVoxel) {
-            const nl = nVoxel.getLight();
-            if (nl > -1 && LightData.isLessThanForSunAddDown(nl, sl)) {
-                if (nVoxel.isAir()) {
-                    queue.push(x, y - 1, z);
-                    nVoxel.setLight(LightData.getSunLightForUnderVoxel(sl, nl));
-                }
-                else {
-                    if (!nVoxel.isOpaque()) {
-                        queue.push(x, y - 1, z);
-                        nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
-                    }
-                }
-            }
-        }
-    }
-}

package/Tasks/Propagation/Illumanation/IlluminationManager.d.ts

@@ -1,48 +0,0 @@
-import { DataTool } from "../../../Tools/Data/DataTool.js";
-export declare const IlluminationManager: {
-    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;
-    };
-    _sDataTool: DataTool;
-    _nDataTool: DataTool;
-    setDimension(dimension: string): void;
-};

package/Tasks/Propagation/Illumanation/IlluminationManager.js

@@ -1,13 +0,0 @@
-//functions
-import { DataTool } from "../../../Tools/Data/DataTool.js";
-import { LightData } from "../../../Voxels/LightData.js";
-export const IlluminationManager = {
-    lightData: LightData,
-    //tools
-    _sDataTool: new DataTool(),
-    _nDataTool: new DataTool(),
-    setDimension(dimension) {
-        this._sDataTool.setDimension(dimension);
-        this._nDataTool.setDimension(dimension);
-    },
-};

package/Tasks/Propagation/Propagation.d.ts

@@ -1,13 +0,0 @@
-import { UpdateTask } from "../Update/UpdateTask.js";
-export declare class Propagation {
-    static instance: Propagation;
-    constructor();
-    explosion(tasks: UpdateTask, radius: number): void;
-    flowUpdate(tasks: UpdateTask, rebuild?: boolean): Promise<void>;
-    flowRemove(tasks: UpdateTask, rebuild?: boolean): Promise<void>;
-    worldSun(tasks: UpdateTask): void;
-    rgbUpdate(tasks: UpdateTask): void;
-    rgbRemove(tasks: UpdateTask): void;
-    sunUpdate(tasks: UpdateTask): void;
-    sunRemove(tasks: UpdateTask, clearUpdateMap?: boolean): void;
-}

package/Tasks/Propagation/Propagation.js

@@ -1,38 +0,0 @@
-//objects
-import { RGBRemove, RGBUpdate } from "./Illumanation/Functions/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "./Illumanation/Functions/SunUpdate.js";
-import { RunWorldSun } from "./Illumanation/Functions/WorldSun.js";
-import { FlowUpdate } from "./Flow/Functions/FlowUpdate.js";
-import { FlowRemove } from "./Flow/Functions/FlowRemove.js";
-import { ExplosionManager } from "./Explosion/ExplosionManager.js";
-export class Propagation {
-    static instance;
-    constructor() {
-        if (!Propagation.instance)
-            Propagation.instance = this;
-    }
-    explosion(tasks, radius) {
-        ExplosionManager.runExplosion(tasks, radius);
-    }
-    async flowUpdate(tasks, rebuild = true) {
-        await FlowUpdate(tasks, rebuild);
-    }
-    async flowRemove(tasks, rebuild = true) {
-        await FlowRemove(tasks);
-    }
-    worldSun(tasks) {
-        RunWorldSun(tasks);
-    }
-    rgbUpdate(tasks) {
-        RGBUpdate(tasks);
-    }
-    rgbRemove(tasks) {
-        RGBRemove(tasks);
-    }
-    sunUpdate(tasks) {
-        SunUpdate(tasks);
-    }
-    sunRemove(tasks, clearUpdateMap = false) {
-        SunRemove(tasks, clearUpdateMap);
-    }
-}

package/Textures/Constructor.types.d.ts

@@ -1,5 +0,0 @@
-export type ConstructorTextureData = [
-    type: string,
-    id: string,
-    varation?: string
-];

package/Textures/Constructor.types.js

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

package/Tools/Anaylzer/AnaylzerTool.d.ts

@@ -1,6 +0,0 @@
-import { ColumnDataTool } from "../Data/WorldData/ColumnDataTool.js";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-export declare class AnaylzerTool extends LocationBoundTool {
-    static columnDataTool: ColumnDataTool;
-    runUpdate(radius: number, onDone: Function): void;
-}

package/Tools/Anaylzer/AnaylzerTool.js

@@ -1,31 +0,0 @@
-import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
-import { ColumnDataTool } from "../Data/WorldData/ColumnDataTool.js";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-import { WorldRegister } from "../../Data/World/WorldRegister.js";
-import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
-export class AnaylzerTool extends LocationBoundTool {
-    static columnDataTool = new ColumnDataTool();
-    runUpdate(radius, onDone) {
-        const [dimension, sx, sy, sz] = this.location;
-        const dim = WorldRegister.instance.dimensions.get(dimension);
-        if (!dim)
-            return;
-        let totalColumns = 0;
-        for (const [key, region] of dim.regions) {
-            for (const [index, column] of region.columns) {
-                const [cx, cy, cz] = region.getColumnPosition(index);
-                if (Distance3D(sx, sy, sz, cx, cy, cz) > radius) {
-                    totalColumns++;
-                }
-            }
-        }
-        const inte = new SafeInterval().setInterval(1).setOnRun(() => {
-            if (totalColumns == 0) {
-                inte.stop();
-                if (onDone)
-                    onDone();
-            }
-        });
-        inte.start();
-    }
-}

package/Tools/Classes/DataToolBase.d.ts

@@ -1,43 +0,0 @@
-import type { RemoteBinaryStruct } from "@amodx/binary/";
-import type { LocationData } from "../../Math";
-import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
-import { LocationBoundTool } from "./LocationBoundTool.js";
-import { Vector3Like, Vec3Array } from "@amodx/math";
-export declare abstract class DataToolBase extends LocationBoundTool {
-    struct: RemoteBinaryStruct;
-    _c: ArrayBuffer | SharedArrayBuffer | DataView;
-    _dimensionRegister: DimensionsRegister;
-    constructor();
-    getStructValue(id: string): number;
-    setTagValue(id: string, value: number): boolean;
-    getArrayTagValue(id: string, index: number): number;
-    setArrayTagValue(id: string, index: number, value: number): number | void;
-    setBuffer(buffer: ArrayBuffer | DataView | SharedArrayBuffer): void;
-    getBuffer(): ArrayBuffer;
-    getAsArrayBuffer(): ArrayBuffer;
-    getBufferSize(): number;
-    abstract loadIn(): boolean;
-    loadInAt(x: number, y: number, z: number): boolean;
-    loadInVec3Array(vec3: Vec3Array): boolean;
-    loadInVec3(vec3: Vector3Like): boolean;
-    loadInAtLocation(location: LocationData): boolean;
-}
-export declare abstract class EncodedPositionDataTool extends DataToolBase {
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    constructor();
-    getPositionData(): {
-        x: number;
-        y: number;
-        z: number;
-    };
-    setPositionData(x: number, y: number, z: number): {
-        x: number;
-        y: number;
-        z: number;
-    };
-    getLocationData(): LocationData;
-}