@divinevoxel/vlox 0.0.76 → 0.0.77

package/WorldSimulation/Procedures/BuildOnly.js

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

package/WorldSimulation/Procedures/InitalLoad.js

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

package/WorldSimulation/Tasks/SimulationTaskBase.d.ts

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

package/WorldSimulation/Tasks/SimulationTaskBase.js

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

package/WorldSimulation/Tasks/TaskSegment.d.ts

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

package/WorldSimulation/Tasks/TaskSegment.js

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

package/WorldSimulation/Tick/TickQueue.d.ts

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

package/WorldSimulation/Tick/TickQueue.js

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

package/WorldSimulation/Tools/SimulationBrush.d.ts

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

package/WorldSimulation/Tools/SimulationBrush.js

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

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

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

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

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

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

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

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.js

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

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.js

@@ -1,5 +1,6 @@
 import { VoxelTickUpdateRegister } from "../VoxelTickUpdateRegister";
 import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+import { VoxelFaces } from "../../../../Math";
 const floodOutChecks = [
     [1, 0, 0],
     [-1, 0, 0],
@@ -56,7 +57,7 @@ VoxelTickUpdateRegister.registerType({
         const currentLevel = voxel.getLevel();
         const levelState = voxel.getLevelState();
         if (levelState == 1 && currentLevel < 7) {
-            voxel.setLevel(currentLevel + 1);
+            voxel.setLevel(7);
             voxel.updateVoxel(0);
             simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
             simulation.bounds.updateDisplay(x, y, z);
@@ -83,9 +84,7 @@ VoxelTickUpdateRegister.registerType({
                 downVoxel.getLevelState() == 1) {
                 simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
             }
-            voxel.setAir();
-            voxel.setLevel(0);
-            voxel.updateVoxel(1);
+            simulation.brush.setXYZ(x, y, z).erase();
             simulation.bounds.updateDisplay(x, y, z);
             for (let i = 0; i < CardinalNeighbors3D.length; i++) {
                 const nx = x + CardinalNeighbors3D[i][0];
@@ -128,12 +127,34 @@ VoxelTickUpdateRegister.registerType({
             simulation.bounds.updateDisplay(x, y, z);
         }
         const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
-        if (!downVoxel || downVoxel.isAir() || downVoxel.isSameVoxel(voxel)) {
-            if (downVoxel) {
-                downVoxel.setId(voxel.getId());
-                downVoxel.setLevel(0);
-                downVoxel.setLevelState(1);
-                downVoxel.updateVoxel(0);
+        const below = simulation.tickCursor[VoxelFaces.Down].getVoxel(x, y - 2, z);
+        const isSame = downVoxel && downVoxel.isSameVoxel(voxel);
+        if (downVoxel && (downVoxel.isAir() || isSame)) {
+            let addToTick = false;
+            if (downVoxel.isAir()) {
+                simulation.brush
+                    .setXYZ(x, y - 1, z)
+                    .setId(voxel.getStringId())
+                    .setLevel((!below?.isAir() && !below?.isSameVoxel(voxel)) ? 7 : 0)
+                    .setLevelState((below?.isAir() || below?.isSameVoxel(voxel)) ? 1 : 0)
+                    .paint()
+                    .clear();
+                addToTick = true;
+            }
+            else {
+                /*   if (
+                    downVoxel.getLevelState() !== 1 &&
+                    below &&
+                    below.isSameVoxel(voxel)
+                  ) {
+                    downVoxel.setLevel(7);
+                    downVoxel.setLevelState(1);
+                    downVoxel.updateVoxel(0);
+                    addToTick = true;
+                  } */
+            }
+            if (addToTick) {
+                simulation.bounds.updateDisplay(x, y - 1, z);
                 simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
             }
             return;
@@ -142,7 +163,7 @@ VoxelTickUpdateRegister.registerType({
             const nx = floodOutChecks[i][0] + x;
             const ny = floodOutChecks[i][1] + y;
             const nz = floodOutChecks[i][2] + z;
-            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
             if (!nVoxel || !(nVoxel.isSameVoxel(voxel) || nVoxel.isAir()))
                 continue;
             const vLevel = nVoxel.getLevel();
@@ -150,14 +171,18 @@ VoxelTickUpdateRegister.registerType({
             if (nState == 2)
                 continue;
             if (vLevel + 1 < currentLevel) {
-                nVoxel.setId(voxel.getId());
-                nVoxel.setLevel(vLevel + 1);
-                nVoxel.updateVoxel(0);
+                simulation.brush
+                    .setId(voxel.getStringId())
+                    .setXYZ(nx, ny, nz)
+                    .setLevel(vLevel + 1)
+                    .setLevelState(1)
+                    .paint();
                 simulation.bounds.updateDisplay(nx, ny, nz);
                 if (currentLevel - 1 > 0) {
                     simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
                 }
             }
         }
+        simulation.brush.clear();
     },
 });

package/WorldSimulation/WorldSimulation.d.ts

@@ -2,6 +2,7 @@ import { Thread, ThreadPool } from "@amodx/threads";
 import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Dimensions/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
+import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 interface WorldSimulationInitData {
     parent: Thread;
@@ -19,6 +20,15 @@ export declare class WorldSimulation {
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
+        BuildOnly: typeof BuildOnly;
+    };
+    static logTasks(): {
+        loading: number[];
+        generating: number[];
+        propagating: number[];
+        sun: number[];
+        building: number[];
+        unbuilding: number[];
     };
     static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;

package/WorldSimulation/WorldSimulation.js

@@ -5,6 +5,7 @@ import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
 import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
 import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
+import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 import { runActiveSectorUpdate } from "./Internal/runActiveSectorUpdate";
 let initalized = false;
@@ -20,7 +21,36 @@ export class WorldSimulation {
     static Procedures = {
         InitalLoad,
         SaveAllSectors,
+        BuildOnly,
     };
+    static logTasks() {
+        return {
+            loading: [
+                WorldSimulationTasks.worldLoadTasks.getTotal(0),
+                WorldSimulationTasks.worldLoadTasks.getTotalWaitingFor(0),
+            ],
+            generating: [
+                WorldSimulationTasks.worldGenTasks.getTotal(0),
+                WorldSimulationTasks.worldGenTasks.getTotalWaitingFor(0),
+            ],
+            propagating: [
+                WorldSimulationTasks.worldPropagationTasks.getTotal(0),
+                WorldSimulationTasks.worldPropagationTasks.getTotalWaitingFor(0),
+            ],
+            sun: [
+                WorldSimulationTasks.worldSunTasks.getTotal(0),
+                WorldSimulationTasks.worldSunTasks.getTotalWaitingFor(0),
+            ],
+            building: [
+                WorldSimulationTasks.buildTasks.getTotal(0),
+                WorldSimulationTasks.buildTasks.getTotalWaitingFor(0),
+            ],
+            unbuilding: [
+                WorldSimulationTasks.unbuildTasks.getTotal(0),
+                WorldSimulationTasks.unbuildTasks.getTotalWaitingFor(0),
+            ],
+        };
+    }
     static init(data) {
         initalized = true;
         WorldSimulationTools.parent = data.parent;
@@ -59,9 +89,11 @@ export class WorldSimulation {
         return false;
     }
     static tick(generationOnly = false) {
+        let total = 0;
         for (const [, dimension] of WorldSimulationDimensions._dimensions) {
             dimension.incrementTick();
             for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+                total += dimension.activeSectors._sectors[i].tickQueue.getTotalTicks();
                 dimension.activeSectors._sectors[i].tickUpdate();
                 dimension.activeSectors._sectors[i].generateUpdate();
             }
@@ -83,9 +115,17 @@ export class WorldSimulation {
         WorldSimulationTasks.worldDecorateTasks.runTask();
         WorldSimulationTasks.worldSunTasks.runTask();
         WorldSimulationTasks.worldPropagationTasks.runTask();
+        /*    console.log(
+          "total ticks",
+          total,
+          "building",
+              "building",
+          WorldSimulationTasks.buildTasks.getTotalWaitingFor(0),
+          WorldSimulationTasks.buildTasks.getTotal(0)
+        ); */
         if (generationOnly)
             return;
-        WorldSimulationTasks.buildTasks.runTask(125);
+        WorldSimulationTasks.buildTasks.runTask(32);
         WorldSimulationTasks.saveTasks.runTask(50);
         WorldSimulationTasks.unloadTasks.runTask(50);
         WorldSimulationTasks.unbuildTasks.runTask();

package/package.json

@@ -1,30 +1 @@
-{
-  "name": "@divinevoxel/vlox",
-  "version": "0.0.76",
-  "description": "Vlox a block style voxel engine.",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "type": "module",
-  "devDependencies": {},
-  "scripts": {
-    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
-    "compile": "cd src && npx tsc --watch"
-  },
-  "keywords": [],
-  "author": "Divine Star Software",
-  "license": "MIT",
-  "repository": {
-    "url": "git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
-  },
-  "dependencies": {
-    "@amodx/math": "latest",
-    "@amodx/binary": "latest",
-    "@amodx/threads": "latest"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{"name":"@divinevoxel/vlox","version":"0.0.77","description":"Vlox a block style voxel engine.","main":"index.js","types":"index.d.ts","type":"module","devDependencies":{},"scripts":{"clean:dist-ts":"test -d dist && find dist -type f \\( -name \"*.js\" -o -name \"*.d.ts\" \\) -delete || true","build":"mkdir -p dist && npm run clean:dist-ts && cp package.json dist/package.json && cd ./src && npx tsc","publish":"mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc","compile":"cd src && npx tsc --watch","compile:fresh":"npm run clean:dist-ts && cd src && npx tsc --watch"},"keywords":[],"author":"Divine Star Software","license":"MIT","repository":{"url":"git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"},"bugs":{"url":"https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"},"dependencies":{"@amodx/math":"latest","@amodx/binary":"latest","@amodx/threads":"latest"},"publishConfig":{"access":"public"}}

package/Builder/Tools/Box/BoxSelection.d.ts

@@ -1,12 +0,0 @@
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
-import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
-import { Vector3Like } from "@amodx/math";
-export declare class BoxSelection {
-    space: VoxelBuildSpace;
-    selection: VoxelBoxSelection;
-    planeOrigin: Vector3Like;
-    planeNormal: Vector3Like;
-    offset: number;
-    constructor(space: VoxelBuildSpace, selection: VoxelBoxSelection);
-    update(): void;
-}

package/Builder/Tools/Box/BoxTool.d.ts

@@ -1,31 +0,0 @@
-import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
-import { PaintVoxelData } from "../../../Voxels";
-import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
-import { BoxSelection } from "./BoxSelection";
-import { BoxToolTemplate } from "./BoxToolTemplate";
-import { BuilderToolBase } from "../BuilderToolBase";
-export declare enum BoxToolModes {
-    Fill = "Fill",
-    Extrude = "Extrude",
-    Template = "Template",
-    Remove = "Remove"
-}
-interface BoxToolEvents {
-    "template-created": BoxToolTemplate;
-}
-export declare class BoxTool extends BuilderToolBase<BoxToolEvents> {
-    space: VoxelBuildSpace;
-    static ToolId: string;
-    static ModeArray: BoxToolModes[];
-    mode: BoxToolModes;
-    selection: VoxelBoxSelection;
-    boxSelection: BoxSelection;
-    constructor(space: VoxelBuildSpace);
-    private _started;
-    isSelectionStarted(): boolean;
-    updateOffset(offset: number): void;
-    updatePlacer(picked: VoxelPickResult | null, placerMode?: "start" | "end" | null): void;
-    use(voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<void>;
-}
-export {};