@divinevoxel/vlox 0.0.74 → 0.0.76

package/WorldSimulation/{Internal/Classes → Dimensions}/SectorState.d.ts

@@ -1,4 +1,6 @@
+import { SimulationSector } from "./SimulationSector";
 export declare class SectorState {
+    simSector: SimulationSector;
     isLoaded: boolean;
     isGenerated: boolean;
     genAlldone: boolean;
@@ -7,5 +9,7 @@ export declare class SectorState {
     nDecorAllDone: boolean;
     nSunAllDone: boolean;
     nPropagtionAllDone: boolean;
+    constructor(simSector: SimulationSector);
     resset(): void;
+    update(): this;
 }

package/WorldSimulation/Dimensions/SectorState.js

@@ -0,0 +1,56 @@
+import { Sector } from "../../World/Sector";
+export class SectorState {
+    simSector;
+    isLoaded = true;
+    isGenerated = true;
+    genAlldone = true;
+    allLoaded = true;
+    nWorldGenAllDone = true;
+    nDecorAllDone = true;
+    nSunAllDone = true;
+    nPropagtionAllDone = true;
+    constructor(simSector) {
+        this.simSector = simSector;
+    }
+    resset() {
+        this.isLoaded = true;
+        this.isGenerated = true;
+        this.genAlldone = true;
+        this.allLoaded = true;
+        this.nWorldGenAllDone = true;
+        this.nDecorAllDone = true;
+        this.nSunAllDone = true;
+        this.nPropagtionAllDone = true;
+    }
+    update() {
+        if (!this.simSector.sector)
+            throw new Error(`Sector must be set`);
+        const state = this;
+        state.resset();
+        for (const simSector of this.simSector.neighbors) {
+            const sector = simSector.sector;
+            if (!sector || sector.isCheckedOut()) {
+                state.genAlldone = false;
+                state.nWorldGenAllDone = false;
+                state.nPropagtionAllDone = false;
+                state.nSunAllDone = false;
+                state.nDecorAllDone = false;
+                state.allLoaded = false;
+                break;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+                state.nWorldGenAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
+                state.nDecorAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+                state.nSunAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
+                state.nPropagtionAllDone = false;
+            }
+        }
+        return this;
+    }
+}

package/WorldSimulation/Dimensions/SimulationSector.d.ts

@@ -0,0 +1,30 @@
+import { Vec3Array } from "@amodx/math";
+import { SectorState } from "./SectorState";
+import { Sector } from "../../World/Sector";
+import { TickQueue } from "../Tick/TickQueue";
+import { DimensionSegment } from "./DimensionSegment";
+import { Thread } from "@amodx/threads";
+export declare class SimulationSector {
+    dimension: DimensionSegment;
+    position: Vec3Array;
+    renderering: boolean;
+    generating: boolean;
+    ticking: boolean;
+    state: SectorState;
+    sector: Sector | null;
+    _rendered: boolean;
+    _genAllDone: boolean;
+    /**An array of the last tick each section was built at */
+    _displayTicks: Uint32Array<ArrayBuffer>;
+    tickQueue: TickQueue;
+    neighbors: SimulationSector[];
+    fullNeighbors: boolean;
+    readonly maxNeighbors: number;
+    constructor(dimension: DimensionSegment);
+    updateNeighbors(): void;
+    canCheckOut(): boolean;
+    checkOut(thread: Thread): void;
+    checkIn(thread: Thread): void;
+    tickUpdate(): boolean;
+    generateUpdate(): boolean | undefined;
+}

package/WorldSimulation/Dimensions/SimulationSector.js

@@ -0,0 +1,214 @@
+import { Vector3Like } from "@amodx/math";
+import { SectorState } from "./SectorState";
+import { Sector } from "../../World/Sector";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSimulationTasks } from "../Internal/WorldSimulationTasks";
+import { TickQueue } from "../Tick/TickQueue";
+import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
+import { WorldDataSyncIds } from "../../World/Types/WorldDataSyncIds";
+import { EngineSettings } from "../../Settings/EngineSettings";
+const tempPosition = Vector3Like.Create();
+export class SimulationSector {
+    dimension;
+    position = [0, 0, 0];
+    renderering = false;
+    generating = false;
+    ticking = false;
+    state = new SectorState(this);
+    sector = null;
+    _rendered = false;
+    _genAllDone = false;
+    /**An array of the last tick each section was built at */
+    _displayTicks = new Uint32Array(WorldSpaces.sector.sectionVolumne);
+    tickQueue;
+    neighbors = [];
+    fullNeighbors = false;
+    maxNeighbors = MooreNeighborhood2D.length - 1;
+    constructor(dimension) {
+        this.dimension = dimension;
+        this.tickQueue = new TickQueue(dimension);
+    }
+    updateNeighbors() {
+        this.neighbors.length = 0;
+        const [cx, cy, cz] = this.position;
+        this.fullNeighbors = true;
+        for (let i = 0; i < MooreNeighborhood2D.length; i++) {
+            const [nx, nz] = MooreNeighborhood2D[i];
+            if (nx === 0 && nz === 0)
+                continue;
+            const sectorPOS = WorldSpaces.sector.getPosition(cx + nx * WorldSpaces.sector.bounds.x, cy, cz + nz * WorldSpaces.sector.bounds.z, tempPosition);
+            const sector = this.dimension.activeSectors.get(sectorPOS.x, cy, sectorPOS.z);
+            if (!sector) {
+                this.fullNeighbors = false;
+                continue;
+            }
+            this.neighbors.push(sector);
+        }
+    }
+    canCheckOut() {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return true;
+        if (!this.fullNeighbors)
+            return false;
+        if (!this.sector || this.sector.isCheckedOut() || this.sector.isLocked())
+            return false;
+        for (const simSector of this.neighbors) {
+            if (!simSector.sector)
+                return false;
+            if (simSector.sector.isCheckedOut() || simSector.sector.isLocked())
+                return false;
+        }
+        return true;
+    }
+    checkOut(thread) {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return;
+        if (!this.sector)
+            return;
+        for (const simSector of this.neighbors) {
+            const sector = simSector?.sector;
+            sector.setCheckedOut(true);
+            thread.runTask(WorldDataSyncIds.CheckInSector, [[this.dimension.id, ...simSector.position], sector.buffer], [sector.buffer]);
+        }
+        this.sector.setCheckedOut(true);
+        thread.runTask(WorldDataSyncIds.CheckInSector, [[this.dimension.id, ...this.position], this.sector.buffer], [this.sector.buffer]);
+    }
+    checkIn(thread) {
+        if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+            return;
+        if (!this.sector)
+            return;
+        for (const simSector of this.neighbors) {
+            thread.runTask(WorldDataSyncIds.CheckOutSector, [
+                this.dimension.id,
+                ...simSector.position,
+            ]);
+        }
+        thread.runTask(WorldDataSyncIds.CheckOutSector, [
+            this.dimension.id,
+            ...this.position,
+        ]);
+    }
+    tickUpdate() {
+        if (!this.fullNeighbors)
+            return false;
+        if (this.sector?.isCheckedOut()) {
+            return false;
+        }
+        if ((!this.renderering && !this.ticking) || !this.sector)
+            return false;
+        if (!this._genAllDone)
+            return false;
+        let renderedSection = false;
+        const sector = this.sector;
+        if (this.renderering) {
+            for (const section of sector.sections) {
+                if (!this._rendered ||
+                    this._displayTicks[section.index] !==
+                        section.getTick(section._Ticks.displayDirty)) {
+                    this._displayTicks[section.index] = section.getTick(section._Ticks.displayDirty);
+                    WorldSimulationTasks.buildTasks.add(this.dimension.id, ...section.position);
+                    renderedSection = true;
+                }
+            }
+            this._rendered = true;
+        }
+        /*   if (this.ticking) {
+          this.dimension.simulation.setOrigin(...this.position);
+          this.dimension.simulation.bounds.start();
+          this.tickQueue.run();
+    
+          const [min, max] = sector.getMinMax();
+          if (min == Math.abs(Infinity) || max == Math.abs(Infinity)) return true;
+    
+          const height = max - min + 1;
+          let attempts = 100;
+          let ticks = 20;
+          while (attempts) {
+            const randomX =
+              Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
+              this.sector.position[0];
+            const randomY =
+              Math.floor(height * Math.random()) + min + this.sector.position[1];
+            const randomZ =
+              Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
+              this.sector.position[2];
+            const voxel = this.dimension.simulation.nDataCursor.getVoxel(
+              randomX,
+              randomY,
+              randomZ
+            );
+            if (!voxel || voxel.isAir()) {
+              attempts--;
+              continue;
+            }
+    
+            const behavior = VoxelBehaviorsRegister.get(
+              voxel.tags["dve_simulation_behavior"]
+            );
+            behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
+    
+            ticks--;
+    
+            if (!ticks) break;
+          }
+    
+          this.dimension.simulation.bounds.markDisplayDirty();
+        } */
+        return true;
+    }
+    generateUpdate() {
+        if (!this.fullNeighbors)
+            return false;
+        if (this.sector?.isCheckedOut())
+            return;
+        if (this._genAllDone)
+            return true;
+        if (!this.generating)
+            return false;
+        if (!this.sector) {
+            const sector = WorldRegister.sectors.get(this.dimension.id, ...this.position);
+            if (!sector) {
+                WorldSimulationTasks.worldLoadTasks.add(this.dimension.id, ...this.position);
+                return;
+            }
+            this.sector = sector;
+        }
+        const sector = this.sector;
+        const state = this.state.update();
+        /*     if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+          console.log(
+            "world gen set true",
+            state.nWorldGenAllDone,
+            state.allLoaded
+          );
+        } */
+        if (state.allLoaded && !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+            // console.log("add to world gen", ...this.position);
+            WorldSimulationTasks.worldGenTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nWorldGenAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
+            //  console.log("add to world decor");
+            WorldSimulationTasks.worldDecorateTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nDecorAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
+            WorldSimulationTasks.worldPropagationTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nPropagtionAllDone &&
+            !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+            WorldSimulationTasks.worldSunTasks.add(this.dimension.id, ...this.position);
+            return true;
+        }
+        if (state.nSunAllDone && sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+            this._genAllDone = true;
+            return true;
+        }
+        return true;
+    }
+}

package/WorldSimulation/Internal/WorldSimulationDimensions.d.ts

@@ -1,4 +1,4 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
 export declare class WorldSimulationDimensions {
     static readonly _dimensions: Map<number, DimensionSegment>;
     static addDimension(dimensionId: number): void;

package/WorldSimulation/Internal/WorldSimulationDimensions.js

@@ -1,9 +1,10 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
-import { TaskRegister } from "./TaskRegister";
+import { DimensionSegment } from "../Dimensions/DimensionSegment";
+import { TaskRegister } from "../Tasks/TaskRegister";
+import { WorldSimulationTools } from "./WorldSimulationTools";
 export class WorldSimulationDimensions {
     static _dimensions = new Map();
     static addDimension(dimensionId) {
-        const segment = new DimensionSegment(dimensionId);
+        const segment = new DimensionSegment(dimensionId, WorldSimulationTools.taskTool);
         TaskRegister.addToDimension(segment);
         this._dimensions.set(dimensionId, segment);
     }

package/WorldSimulation/Internal/WorldSimulationTasks.d.ts

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

package/WorldSimulation/Internal/WorldSimulationTasks.js

@@ -1,22 +1,29 @@
 import { WorldRegister } from "../../World/WorldRegister";
 import { Sector } from "../../World/index";
 import { WorldSimulationTools } from "./WorldSimulationTools";
-import { TaskRegister } from "./TaskRegister";
+import { TaskRegister } from "../Tasks/TaskRegister";
+import { Threads } from "@amodx/threads";
+import { setLocationData } from "../../Util/LocationData";
+import { EngineSettings } from "../../Settings/EngineSettings";
+import { SnapShots } from "../../World/SnapShot/SnapShots";
+import LockSectors from "../../World/Lock/Function/LockSectors";
+import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
 export class WorldSimulationTasks {
     /**# Load Sectors
      * ---
      */
     static worldLoadTasks = TaskRegister.addTasks({
         id: "load",
-        propagationBlocking: true,
-        async run(location, onDone) {
+        generationTask: true,
+        checkInRequired: false,
+        async run(dimesnion, location, taskId, task) {
             const [dimension, x, y, z] = location;
             const sector = WorldRegister.sectors.get(location[0], x, y, z);
             if (sector)
-                return onDone();
+                return task.completeTask(taskId);
             if (!WorldSimulationTools.worldStorage) {
                 WorldRegister.sectors.new(location[0], x, y, z);
-                return onDone();
+                return task.completeTask(taskId);
             }
             const loaded = await WorldSimulationTools.worldStorage.loadSector([
                 dimension,
@@ -27,7 +34,7 @@ export class WorldSimulationTasks {
             if (!loaded) {
                 WorldRegister.sectors.new(location[0], x, y, z);
             }
-            onDone();
+            task.completeTask(taskId);
         },
     });
     /**# Generate Sectors
@@ -35,17 +42,24 @@ export class WorldSimulationTasks {
      */
     static worldGenTasks = TaskRegister.addTasks({
         id: "generate",
-        propagationBlocking: true,
-        async run(location, onDone) {
+        generationTask: true,
+        checkInRequired: true,
+        log: true,
+        checkDone(location) {
             const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
-                return onDone();
-            WorldSimulationTools.taskTool.generate.run([location, []], null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
-                onDone();
-            });
+            if (!sector || sector.isCheckedOut())
+                return false;
+            const worldGenDone = sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
+            return worldGenDone;
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.generate.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
         },
     });
     /**# Decorate Sectors
@@ -53,53 +67,68 @@ export class WorldSimulationTasks {
      */
     static worldDecorateTasks = TaskRegister.addTasks({
         id: "decorate",
-        propagationBlocking: true,
-        async run(location, onDone) {
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
             const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
-                return onDone();
-            WorldSimulationTools.taskTool.decorate.run([location, []], null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
-                onDone();
-            });
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldDecorDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.decorate.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
         },
     });
-    /**# World Sun
+    /**# World Propagation
      * ---
      */
-    static worldSunTasks = TaskRegister.addTasks({
-        id: "wolrd_sun",
-        propagationBlocking: true,
-        async run(location, onDone) {
+    static worldPropagationTasks = TaskRegister.addTasks({
+        id: "world_propagation",
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
             const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
-                return onDone();
-            WorldSimulationTools.taskTool.worldSun.run(location, null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldSunDone, true);
-                onDone();
-            });
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.propagation.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
         },
     });
-    /**# World Propagation
+    /**# World Sun
      * ---
      */
-    static worldPropagationTasks = TaskRegister.addTasks({
-        id: "propagation",
-        propagationBlocking: true,
-        async run(location, onDone) {
+    static worldSunTasks = TaskRegister.addTasks({
+        id: "wolrd_sun",
+        generationTask: true,
+        checkInRequired: true,
+        checkDone(location) {
             const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
-                return onDone();
-            WorldSimulationTools.taskTool.propagation.run(location, null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
-                onDone();
-            });
+            if (!sector || sector.isCheckedOut())
+                return false;
+            return sector.getBitFlag(Sector.FlagIds.isWorldSunDone);
+        },
+        run(dimension, location, taskId, task, simSector) {
+            if (simSector.sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
+                return task.completeTask(taskId);
+            const generator = WorldSimulationTools.taskTool.getGenerator();
+            simSector.checkOut(generator);
+            WorldSimulationTools.taskTool.generation.worldSun.run(location, null, () => {
+                simSector.checkIn(generator);
+            }, generator);
         },
     });
     /**# Save Sector
@@ -107,23 +136,65 @@ export class WorldSimulationTasks {
      */
     static saveTasks = TaskRegister.addTasks({
         id: "save",
-        async run(location, onDone) {
+        checkInRequired: false,
+        async run(dimension, location, taskId, task) {
             if (!WorldSimulationTools.worldStorage)
-                return onDone();
+                return task.completeTask(taskId);
             await WorldSimulationTools.worldStorage.saveSector(location);
-            onDone();
+            task.completeTask(taskId);
         },
     });
     /**# Save & Unload Sector
      * ---
      */
-    static saveAndUnloadTasks = TaskRegister.addTasks({
-        id: "save_and_unload",
-        async run(location, onDone) {
-            if (!WorldSimulationTools.worldStorage)
-                return onDone();
+    static unloadTasks = TaskRegister.addTasks({
+        id: "unload",
+        checkInRequired: false,
+        async run(dimension, location, taskId, task) {
+            if (!WorldSimulationTools.worldStorage) {
+                WorldRegister.sectors.removeAt(location);
+                return task.completeTask(taskId);
+            }
             await WorldSimulationTools.worldStorage.unloadSector(location);
-            onDone();
+            task.completeTask(taskId);
+        },
+    });
+    /**# Build Task
+     * ---
+     */
+    static buildTasks = TaskRegister.addTasks({
+        id: "build_tasks",
+        sort: true,
+        checkInRequired: false,
+        run(dimension, location, taskId, task, simSector) {
+            simSector
+                .sector?.getSection(location[1], location[2], location[3])
+                ?.setInProgress(true);
+            if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
+                task.completeTask(taskId);
+                WorldSimulationTools.taskTool.build.section.run(location);
+                return;
+            }
+            const [dim, x, y, z] = location;
+            LockSectors(dim, SnapShots.getSnapShotBounds(x, y, z)).then(() => {
+                task.completeTask(taskId);
+                const snapShot = SnapShots.createSnapShot(location);
+                WorldSimulationTools.taskTool.build.sectionSnapShot.run(...snapShot.transfer());
+                SnapShots.transferSnapShot(snapShot);
+                UnLockSectors(dim, SnapShots.getSnapShotBounds(x, y, z));
+            });
+        },
+    });
+    static unbuildTasks = TaskRegister.addTasks({
+        id: "unbuild_tasks",
+        sort: true,
+        checkInRequired: false,
+        run(dimension, location, taskId, task) {
+            const view = Threads.createBinaryTask(16);
+            setLocationData(view, location);
+            WorldSimulationTools.parent.runBinaryTask("remove-sector", view);
+            dimension.activeSectors.get(location[1], location[2], location[3])._rendered = false;
+            task.completeTask(taskId);
         },
     });
 }

package/WorldSimulation/Internal/runActiveSectorUpdate.d.ts

@@ -0,0 +1 @@
+export declare function runActiveSectorUpdate(): void;