@divinevoxel/vlox 0.0.74 → 0.0.75

package/Tasks/Propagation/Power/PowerUpdate.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
 //@todo change array to not use push and shift
 export function PowerUpdate(tasks) {
     const queue = tasks.power.update;
@@ -13,9 +13,9 @@ export function PowerUpdate(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -23,13 +23,13 @@ export function PowerUpdate(tasks) {
                 continue;
             const nl = voxel.getPower();
             if (nl > -1 && nl < sl) {
-                if (voxel._tags["dve_can_carry_power"]) {
+                if (voxel.tags["dve_can_carry_power"]) {
                     queue.push(nx, ny, nz);
                 }
                 voxel.setPower(sl - 1);
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function PowerRemove(tasks) {
@@ -51,9 +51,9 @@ export function PowerRemove(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -73,7 +73,7 @@ export function PowerRemove(tasks) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setPower(0);
     }
     removeMap.clear();

package/Tasks/Tasks.types.d.ts

@@ -1,15 +1,31 @@
-import type { LocationData } from "../Math/index.js";
 import type { Vec3Array } from "@amodx/math";
-import type { RawVoxelData } from "../Voxels/Types/Voxel.types.js";
-import { SectorData } from "World/index.js";
+import type { VoxelPathData } from "../Templates/Path/VoxelPath.types.js";
+import type { EraseVoxel } from "./Paint/Erase/EraseVoxel.js";
+import type EraseVoxelTemplate from "./Paint/Erase/EraseVoxelTemplate.js";
+import type EraseVoxelPath from "./Paint/Erase/EraseVoxelPath.js";
+import { PaintVoxel } from "./Paint/Paint/PaintVoxel.js";
+import PaintVoxelTemplate from "./Paint/Paint/PaintVoxelTemplate.js";
+export type VoxelUpdateData = {
+    /**An array of allowed areas to update in. If not set will be ignored.*/
+    includedAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**An array of excluded areas to update in. If not set will be ignored.*/
+    excludeAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**Define what happens when painting a voxel and must replace it. Default is destory which will replace the voxel. Keep will keep the current voxel and not update. */
+    paintMode?: "keep" | "destory";
+};
+export type PaintVoxelTask = Parameters<typeof PaintVoxel>;
+export type PaintVoxelTemplateTask = Parameters<typeof PaintVoxelTemplate>;
+export type PaintVoxelPathTask = [
+    dimension: number,
+    start: Vec3Array,
+    pathData: VoxelPathData,
+    data: VoxelUpdateData
+];
+export type EraseVoxelTask = Parameters<typeof EraseVoxel>;
+export type EraseVoxelTemplateTask = Parameters<typeof EraseVoxelTemplate>;
+export type EraseVoxelPathTask = Parameters<typeof EraseVoxelPath>;
 export type WorldLockTasks = [
     dimension: number,
     start: Vec3Array,
     end: Vec3Array
 ];
-export type VoxelUpdateTasks = [location: LocationData, raw: RawVoxelData];
-export type RunRebuildTasks = [buildQueue: string];
-export type RunBuildQueue = [dimension: number, sections: Vec3Array[]];
-export type GenerateTasks = [location: LocationData, data: any];
-export type ExplosionTasks = [location: LocationData, radius: number];
-export type LoadSectorDataTasks = [location: LocationData, sector: SectorData];

package/Tasks/TasksIds.d.ts

@@ -1,22 +1,15 @@
 export declare enum TasksIds {
-    BuildSection = 0,
-    BuildSector = 1,
-    Generate = 2,
-    Decorate = 3,
-    RGBlightUpdate = 4,
-    RGBlightRemove = 5,
-    WorldSun = 6,
-    SunLightUpdate = 7,
-    SunLightRemove = 8,
-    Propagation = 9,
-    AnalyzerUpdate = 10,
-    FlowUpdate = 11,
-    FlowRemove = 12,
-    ConstructEntity = 13,
-    ConstructItem = 14,
-    Explosion = 15,
-    VoxelErease = 16,
-    VoxelPaint = 17,
-    VoxelUpdate = 18,
-    LogicUpdate = 19
+    BuildSection = "BuildSection",
+    BuildSectionSnapShot = "BuildSectionSnapShot",
+    BuildSector = "BuildSector",
+    Generate = "Generate",
+    Decorate = "Decorate",
+    WorldSun = "WorldSun",
+    WorldPropagation = "Propagation",
+    PaintVoxel = "PaintVoxel",
+    PaintVoxelTemplate = "PaintVoxelTemplate",
+    PaintVoxelPath = "PaintVoxelPath",
+    EraseVoxel = "EraseVoxel",
+    EraseVoxelTemplate = "EraseVoxelTemplate",
+    EraseVoxelPath = "EraseVoxelPath"
 }

package/Tasks/TasksIds.js

@@ -1,23 +1,16 @@
 export var TasksIds;
 (function (TasksIds) {
-    TasksIds[TasksIds["BuildSection"] = 0] = "BuildSection";
-    TasksIds[TasksIds["BuildSector"] = 1] = "BuildSector";
-    TasksIds[TasksIds["Generate"] = 2] = "Generate";
-    TasksIds[TasksIds["Decorate"] = 3] = "Decorate";
-    TasksIds[TasksIds["RGBlightUpdate"] = 4] = "RGBlightUpdate";
-    TasksIds[TasksIds["RGBlightRemove"] = 5] = "RGBlightRemove";
-    TasksIds[TasksIds["WorldSun"] = 6] = "WorldSun";
-    TasksIds[TasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
-    TasksIds[TasksIds["SunLightRemove"] = 8] = "SunLightRemove";
-    TasksIds[TasksIds["Propagation"] = 9] = "Propagation";
-    TasksIds[TasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
-    TasksIds[TasksIds["FlowUpdate"] = 11] = "FlowUpdate";
-    TasksIds[TasksIds["FlowRemove"] = 12] = "FlowRemove";
-    TasksIds[TasksIds["ConstructEntity"] = 13] = "ConstructEntity";
-    TasksIds[TasksIds["ConstructItem"] = 14] = "ConstructItem";
-    TasksIds[TasksIds["Explosion"] = 15] = "Explosion";
-    TasksIds[TasksIds["VoxelErease"] = 16] = "VoxelErease";
-    TasksIds[TasksIds["VoxelPaint"] = 17] = "VoxelPaint";
-    TasksIds[TasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
-    TasksIds[TasksIds["LogicUpdate"] = 19] = "LogicUpdate";
+    TasksIds["BuildSection"] = "BuildSection";
+    TasksIds["BuildSectionSnapShot"] = "BuildSectionSnapShot";
+    TasksIds["BuildSector"] = "BuildSector";
+    TasksIds["Generate"] = "Generate";
+    TasksIds["Decorate"] = "Decorate";
+    TasksIds["WorldSun"] = "WorldSun";
+    TasksIds["WorldPropagation"] = "Propagation";
+    TasksIds["PaintVoxel"] = "PaintVoxel";
+    TasksIds["PaintVoxelTemplate"] = "PaintVoxelTemplate";
+    TasksIds["PaintVoxelPath"] = "PaintVoxelPath";
+    TasksIds["EraseVoxel"] = "EraseVoxel";
+    TasksIds["EraseVoxelTemplate"] = "EraseVoxelTemplate";
+    TasksIds["EraseVoxelPath"] = "EraseVoxelPath";
 })(TasksIds || (TasksIds = {}));

package/Tasks/VoxelUpdateTask.d.ts

@@ -13,14 +13,14 @@ export declare class TaskMap {
 }
 declare class UpdatedBounds {
     _task: VoxelUpdateTask;
-    min: Vector3Like;
-    max: Vector3Like;
+    displayMin: Vector3Like;
+    displayMax: Vector3Like;
     dimension: number;
     constructor(_task: VoxelUpdateTask);
     start(dimension?: number): void;
-    update(x: number, y: number, z: number): void;
+    updateDisplay(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
-    markSectionsAsDirty(): void;
+    markDisplayDirty(): false | undefined;
 }
 export declare class VoxelUpdateTask {
     flow: FlowQueues;
@@ -31,7 +31,8 @@ export declare class VoxelUpdateTask {
     sDataCursor: WorldCursor;
     nDataCursor: WorldCursor;
     origin: LocationData;
-    setOrigin(origin: LocationData): void;
+    setOrigin(dimension: number, x: number, y: number, z: number): void;
+    setOriginAt(origin: LocationData): void;
     clear(): void;
 }
 declare class FlowQueues {

package/Tasks/VoxelUpdateTask.js

@@ -33,37 +33,37 @@ const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
 const tempPosition = Vector3Like.Create();
 class UpdatedBounds {
     _task;
-    min = Vector3Like.Clone(InfinityVec3);
-    max = Vector3Like.Clone(NegativeInfinityVec3);
+    displayMin = Vector3Like.Clone(InfinityVec3);
+    displayMax = Vector3Like.Clone(NegativeInfinityVec3);
     dimension = 0;
     constructor(_task) {
         this._task = _task;
     }
     start(dimension) {
         this.dimension = dimension || 0;
-        Vector3Like.Copy(this.min, InfinityVec3);
-        Vector3Like.Copy(this.max, NegativeInfinityVec3);
-    }
-    update(x, y, z) {
-        if (x < this.min.x)
-            this.min.x = x;
-        if (y < this.min.y)
-            this.min.y = y;
-        if (z < this.min.z)
-            this.min.z = z;
-        if (x > this.max.x)
-            this.max.x = x;
-        if (y > this.max.y)
-            this.max.y = y;
-        if (z > this.max.z)
-            this.max.z = z;
+        Vector3Like.Copy(this.displayMin, InfinityVec3);
+        Vector3Like.Copy(this.displayMax, NegativeInfinityVec3);
+    }
+    updateDisplay(x, y, z) {
+        if (x < this.displayMin.x)
+            this.displayMin.x = x;
+        if (y < this.displayMin.y)
+            this.displayMin.y = y;
+        if (z < this.displayMin.z)
+            this.displayMin.z = z;
+        if (x > this.displayMax.x)
+            this.displayMax.x = x;
+        if (y > this.displayMax.y)
+            this.displayMax.y = y;
+        if (z > this.displayMax.z)
+            this.displayMax.z = z;
     }
     getSections() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x, this.displayMin.y, this.displayMin.z, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x, this.displayMax.y, this.displayMax.z, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -79,12 +79,20 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
-    markSectionsAsDirty() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+    markDisplayDirty() {
+        if (this.displayMax.x == -Infinity ||
+            this.displayMax.y == -Infinity ||
+            this.displayMax.z == -Infinity)
+            return false;
+        if (this.displayMin.x == Infinity ||
+            this.displayMin.y == Infinity ||
+            this.displayMin.z == Infinity)
+            return false;
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x - 1, this.displayMin.y - 1, this.displayMin.z - 1, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x + 1, this.displayMax.y + 1, this.displayMax.z + 1, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -97,7 +105,9 @@ class UpdatedBounds {
                     if (!sector)
                         continue;
                     const section = sector.getSection(x, y, z);
-                    section.setDisplayDirty(true);
+                    if (!section.canRender())
+                        continue;
+                    section.incrementTick(section._Ticks.displayDirty);
                 }
             }
         }
@@ -111,21 +121,27 @@ export class VoxelUpdateTask {
     bounds = new UpdatedBounds(this);
     sDataCursor = new WorldCursor();
     nDataCursor = new WorldCursor();
-    origin;
-    setOrigin(origin) {
-        this.sDataCursor.setFocalPoint(...origin);
-        this.nDataCursor.setFocalPoint(...origin);
-        this.origin = origin;
-        this.rgb.removeMap.start(origin[1], origin[2], origin[3]);
-        this.sun.removeMap.start(origin[1], origin[2], origin[3]);
-        this.rgb.updateMap.start(origin[1], origin[2], origin[3]);
-        this.sun.updateMap.start(origin[1], origin[2], origin[3]);
-        this.flow.update.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
-        this.bounds.start(origin[0]);
+    origin = [0, 0, 0, 0];
+    setOrigin(dimension, x, y, z) {
+        this.sDataCursor.setFocalPoint(dimension, x, y, z);
+        this.nDataCursor.setFocalPoint(dimension, x, y, z);
+        this.origin[0] = dimension;
+        this.origin[1] = x;
+        this.origin[2] = y;
+        this.origin[3] = z;
+        this.rgb.removeMap.start(x, y, z);
+        this.sun.removeMap.start(x, y, z);
+        this.rgb.updateMap.start(x, y, z);
+        this.sun.updateMap.start(x, y, z);
+        this.flow.update.map.start(x, y, z);
+        this.flow.remove.map.start(x, y, z);
+        this.flow.remove.noRemoveMap.start(x, y, z);
+        this.bounds.start(dimension);
         this.clear();
     }
+    setOriginAt(origin) {
+        this.setOrigin(...origin);
+    }
     clear() {
         this.rgb.clear();
         this.sun.clear();

package/Tasks/WorldGeneration/InitTasks.d.ts

@@ -1 +1,4 @@
-export default function (): void;
+import { Thread } from "@amodx/threads";
+export default function (props: {
+    worldThread: Thread;
+}): void;

package/Tasks/WorldGeneration/InitTasks.js

@@ -1,7 +1,10 @@
 import { Threads } from "@amodx/threads";
 import { WorldGeneration } from "./WorldGeneration";
 import { TasksIds } from "../../Tasks/TasksIds";
-export default function () {
-    Threads.registerTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "generate", resolve)));
-    Threads.registerTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "decorate", resolve)));
+import { getLocationData } from "../../Util/LocationData";
+import { WorldGenRegister } from "./WorldGenRegister";
+export default function (props) {
+    WorldGenRegister._worldThread = props.worldThread;
+    Threads.registerBinaryTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "generate", resolve)));
+    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "decorate", resolve)));
 }

package/Tasks/WorldGeneration/WorldGen.types.d.ts

@@ -1,5 +1,4 @@
-import { GenerateTasks } from "../Tasks.types";
 export type WorldGenInterface = {
-    generate(data: GenerateTasks): Promise<any | void>;
-    decorate(data: GenerateTasks): Promise<any | void>;
+    generate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
+    decorate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
 };

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -2,7 +2,6 @@ import { WorldGenRegister } from "./WorldGenRegister.js";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
 import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
 import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
@@ -16,7 +15,7 @@ export class WorldGenBrush extends BrushTool {
     tasks = new VoxelUpdateTask();
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
-        this.tasks.setOrigin([dimension, x, y, z]);
+        this.tasks.setOriginAt([dimension, x, y, z]);
         this.dimension = dimension;
         this.x = x;
         this.y = y;
@@ -51,7 +50,7 @@ export class WorldGenBrush extends BrushTool {
             }
         }
         this._paint();
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     getUpdatedSections() {
@@ -73,7 +72,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.update.push(this.x, this.y, this.z);
             //  Propagation.instance.sunUpdate(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
     }
     erase() {
         let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
@@ -91,7 +90,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.remove.push(this.x, this.y, this.z);
             SunRemove(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     runUpdates() {
@@ -101,9 +100,9 @@ export class WorldGenBrush extends BrushTool {
         this.tasks.sun.removeMap.clear();
     }
     worldAlloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-alloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-alloc", [this.dimension, start, end]);
     }
     worldDealloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-dealloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-dealloc", [this.dimension, start, end]);
     }
 }

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -1,6 +1,8 @@
 import type { LocationData } from "../../Math";
 import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { Thread } from "@amodx/threads";
 export declare class WorldGenRegister {
+    static _worldThread: Thread;
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
@@ -8,7 +10,7 @@ export declare class WorldGenRegister {
         sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;
-    static registerRequest(location: LocationData): string;
+    static registerRequest(location: Readonly<LocationData>): string;
     static addToRequest(registerId: string, location: LocationData, rawData: RawVoxelData): false | undefined;
     static attemptRequestFullFill(registerId: string): boolean;
 }

package/Tasks/WorldGeneration/WorldGenRegister.js

@@ -1,10 +1,10 @@
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 import { BrushTool } from "../../Tools/Brush/Brush";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
 import { WorldRegister } from "../../World/WorldRegister";
 const brush = new BrushTool();
 const dataTool = brush.voxelCursor;
 export class WorldGenRegister {
+    static _worldThread;
     static MAX_ATTEMPTS = 100;
     static _requests = new Map();
     static registerRequest(location) {
@@ -29,7 +29,12 @@ export class WorldGenRegister {
             const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
             const sectorKey = WorldSpaces.hash.hashVec3(sectorPos);
             if (!requests.sections.has(sectorKey)) {
-                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, sectorPos.x, sectorPos.y, sectorPos.z]);
+                this._worldThread.runTask("add-sector", [
+                    requests.dimension,
+                    sectorPos.x,
+                    sectorPos.y,
+                    sectorPos.z,
+                ]);
                 requests.sections.set(sectorKey, [
                     sectorPos.x,
                     sectorPos.y,
@@ -51,7 +56,12 @@ export class WorldGenRegister {
             const sector = WorldRegister.sectors.get(requests.dimension, pos[0], pos[1], pos[2]);
             if (!sector) {
                 done = false;
-                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, pos[0], pos[1], pos[2]]);
+                this._worldThread.runTask("add-sector", [
+                    requests.dimension,
+                    pos[0],
+                    pos[1],
+                    pos[2],
+                ]);
             }
         }
         if (!done) {

package/Tasks/WorldGeneration/WorldGeneration.d.ts

@@ -1,12 +1,12 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { WorldGenInterface } from "./WorldGen.types.js";
-import { GenerateTasks } from "../Tasks.types.js";
+import { LocationData } from "../../Math/index.js";
 export declare class WorldGeneration {
     static worldGen: WorldGenInterface | null;
     static register: typeof WorldGenRegister;
     static _brushes: any[];
     static setWorldGen(worldGen: WorldGenInterface): void;
-    static generate(data: GenerateTasks, mode: "generate" | "decorate", onDone: Function): Promise<void>;
+    static generate(data: Readonly<LocationData>, mode: "generate" | "decorate", onDone: Function): Promise<void>;
     static getBrush(): WorldGenBrush;
 }

package/Tasks/WorldGeneration/WorldGeneration.js

@@ -3,6 +3,8 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
+import { WorldRegister } from "../../World/WorldRegister.js";
+import { Sector } from "../../World/index.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
@@ -14,19 +16,30 @@ export class WorldGeneration {
         if (!this.worldGen) {
             throw new Error(`A World Generator must be set.`);
         }
-        const requestsId = WorldGenRegister.registerRequest(data[0]);
+        const requestsId = WorldGenRegister.registerRequest(data);
         for (const brush of this._brushes) {
             brush.requestsId = requestsId;
         }
+        const sector = WorldRegister.sectors.get(...data);
+        if (!sector) {
+            console.error(`Error when attempting wolrd gen at [${data.join(",")}] Sector does not exist`);
+            return;
+        }
         if (mode == "generate") {
-            await this.worldGen.generate(data);
+            await this.worldGen.generate(...data);
         }
         if (mode == "decorate") {
-            await this.worldGen.decorate(data);
+            await this.worldGen.decorate(...data);
         }
         if (!WorldGenRegister.attemptRequestFullFill(requestsId)) {
             const readyCheck = () => {
                 if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
+                    if (mode == "generate") {
+                        sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
+                    }
+                    if (mode == "decorate") {
+                        sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
+                    }
                     onDone();
                     return;
                 }
@@ -35,6 +48,12 @@ export class WorldGeneration {
             readyCheck();
         }
         else {
+            if (mode == "generate") {
+                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
+            }
+            if (mode == "decorate") {
+                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
+            }
             onDone();
         }
     }

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -0,0 +1,37 @@
+import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { ArchivedVoxelTemplateData } from "./ArchivedVoxelTemplate.types";
+import type { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { NumberPalette } from "../../Util/NumberPalette";
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { BinaryBuffer } from "../../Util/BinaryBuffer/index";
+import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+type TemplateCursor = {
+    position: Vec3Array;
+    raw: RawVoxelData;
+};
+export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
+    private _data;
+    index: Flat3DIndex;
+    position: Vector3Like;
+    bounds: BoundingBox;
+    ids: BinaryBuffer;
+    level: BinaryBuffer;
+    secondary: BinaryBuffer;
+    voxelPalette: VoxelPaletteArchiveReader;
+    levelPalette: NumberPalette;
+    secondaryPalette: NumberPalette;
+    constructor(_data: ArchivedVoxelTemplateData);
+    setPosition(x: number, y: number, z: number): void;
+    isAir(index: number): boolean;
+    isIncluded(index: number): boolean;
+    getIndex(x: number, y: number, z: number): number;
+    getId(index: number): number;
+    getLevel(index: number): number;
+    getLight(index: number): number;
+    getSecondary(index: number): number;
+    traverse(curosr?: TemplateCursor): Generator<TemplateCursor>;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    toJSON(): ArchivedVoxelTemplateData;
+}
+export {};