@divinevoxel/vlox 0.0.72 → 0.0.74

package/Tasks/Update/Common.js

@@ -0,0 +1,41 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+export const updateLightTask = (tasks) => {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of $3dCardinalNeighbors) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        if (doRGB) {
+            if (nVoxel.hasRGBLight()) {
+                tasks.rgb.update.push(nx, ny, nz);
+            }
+        }
+        if (doSun) {
+            if (nVoxel.hasSunLight()) {
+                tasks.sun.update.push(nx, ny, nz);
+            }
+        }
+    }
+};
+export const updatePowerTask = (tasks) => {
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of $3dCardinalNeighbors) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        if (nVoxel.getPower() > 0) {
+            tasks.power.update.push(nx, ny, nz);
+        }
+    }
+};

package/Tasks/Update/EreaseUpdate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { LocationData } from "../../Math/index.js";
+export declare function EreaseAndUpdate(location: LocationData): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/EreaseUpdate.js

@@ -0,0 +1,66 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
+import { updateLightTask } from "./Common.js";
+import { PowerRemove, PowerUpdate } from "../Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export async function EreaseAndUpdate(location) {
+    const [dimension, x, y, z] = location;
+    tasks.setOrigin(location);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    const substanceData = voxel.getSubstanceData();
+    const foundPower = voxel.getPower();
+    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
+        if (substanceData["dve_is_liquid"]) {
+            FlowRemove(tasks);
+            return tasks;
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const light = voxel.getLight();
+    const isLightSource = voxel.isLightSource();
+    voxel.setSecondary(true).setId(0).setSecondary(false);
+    voxel
+        .setLight(light > 0 ? light : 0)
+        .setId(0)
+        .setLevel(0)
+        .setLevelState(0)
+        .setState(0)
+        .setMod(0)
+        .updateVoxel(1);
+    if (ES.doLight) {
+        if (ES.doRGBPropagation && isLightSource) {
+            tasks.rgb.remove.push(x, y, z);
+            RGBRemove(tasks);
+        }
+        updateLightTask(tasks);
+        if (ES.doRGBPropagation) {
+            RGBUpdate(tasks);
+        }
+        if (ES.doSunPropagation) {
+            SunUpdate(tasks);
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doPower) {
+        if (foundPower > -1) {
+            voxel.setLevel(foundPower);
+            tasks.power.remove.push(x, y, z);
+            PowerRemove(tasks);
+            PowerUpdate(tasks);
+        }
+    }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
+    return tasks;
+}

package/Tasks/Update/InitTasks.d.ts

@@ -1,5 +1,5 @@
 import { Thread } from "@amodx/threads";
-import { UpdateTask } from "./UpdateTask";
+import { VoxelUpdateTask } from "../VoxelUpdateTask";
 export default function (props: {
-    onDone(taks: UpdateTask, origin: Thread): void;
+    onDone(taks: VoxelUpdateTask, origin: Thread): void;
 }): void;

package/Tasks/Update/InitTasks.js

@@ -1,6 +1,8 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
-import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
+import { VoxelUpdate } from "./VoxelUpdate";
+import { EreaseAndUpdate } from "./EreaseUpdate";
+import { PaintAndUpdate } from "./PaintUpdate";
 export default function (props) {
     Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
         const tasks = await VoxelUpdate(data);

package/Tasks/Update/PaintUpdate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateTasks } from "../Tasks.types.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/PaintUpdate.js

@@ -0,0 +1,89 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
+import { updateLightTask, updatePowerTask } from "./Common.js";
+import { PowerUpdate } from "../../Tasks/Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export async function PaintAndUpdate(data) {
+    const [dimension, x, y, z] = data[0];
+    tasks.setOrigin(data[0]);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    const raw = data[1];
+    const isOpaque = voxel.isOpaque();
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    lighttest: if (ES.doLight) {
+        const light = voxel.getLight();
+        if (light <= 0)
+            break lighttest;
+        if (doSun) {
+            if (voxel.hasSunLight()) {
+                tasks.sun.remove.push(x, y, z);
+                SunRemove(tasks);
+            }
+        }
+        if (doRGB) {
+            if (voxel.hasRGBLight() && isOpaque) {
+                tasks.rgb.remove.push(x, y, z);
+                RGBRemove(tasks);
+            }
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const id = raw[0];
+    if (id < 0)
+        return false;
+    voxel.setId(id);
+    voxel.setLevel(raw[2]);
+    voxel.setState(raw[3]);
+    voxel.setMod(raw[4]);
+    voxel.process();
+    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
+        voxel.setSecondary(true);
+        voxel.setId(raw[5]);
+        voxel.setSecondary(false);
+    }
+    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+        voxel.setLight(voxel.getLightSourceValue());
+    }
+    voxel.updateVoxel(0);
+    if (ES.doLight) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.rgb.update.push(x, y, z);
+            RGBUpdate(tasks);
+        }
+        if (doSun) {
+            SunUpdate(tasks);
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doFlow) {
+        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
+            FlowUpdate(tasks);
+        }
+    }
+    if (ES.doPower) {
+        if (voxel._tags["dve_can_be_powered"] ||
+            voxel._tags["dve_is_power_source"] ||
+            voxel._tags["dve_can_carry_power"] ||
+            voxel._tags["dve_can_hold_power"]) {
+            updatePowerTask(tasks);
+            tasks.power.update.push(x, y, z);
+            PowerUpdate(tasks);
+        }
+    }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
+    return tasks;
+}

package/Tasks/Update/VoxelUpdate.d.ts

@@ -1,6 +1,3 @@
 import { VoxelUpdateTasks } from "../Tasks.types.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { LocationData } from "../../Math/index.js";
-export declare function EreaseAndUpdate(location: LocationData): Promise<false | UpdateTask>;
-export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
-export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -1,148 +1,10 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
-import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
-const tasks = new UpdateTask();
-const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    const [dimension, x, y, z] = tasks.origin;
-    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
-    for (const n of $3dCardinalNeighbors) {
-        const nx = n[0] + x;
-        const ny = n[1] + y;
-        const nz = n[2] + z;
-        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-        if (!nVoxel)
-            continue;
-        if (doRGB) {
-            if (nVoxel.hasRGBLight()) {
-                tasks.rgb.update.push(nx, ny, nz);
-            }
-        }
-        if (doSun) {
-            if (nVoxel.hasSunLight()) {
-                tasks.sun.update.push(nx, ny, nz);
-            }
-        }
-    }
-};
-export async function EreaseAndUpdate(location) {
-    const [dimension, x, y, z] = location;
-    tasks.setOrigin(location);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const substanceData = voxel.getSubstanceData();
-    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData["dve_is_liquid"]) {
-            FlowRemove(tasks);
-            return tasks;
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const light = voxel.getLight();
-    const isLightSource = voxel.isLightSource();
-    voxel.setSecondary(true).setId(0).setSecondary(false);
-    voxel
-        .setLight(light > 0 ? light : 0)
-        .setId(0)
-        .setLevel(0)
-        .setLevelState(0)
-        .setState(0)
-        .setMod(0)
-        .updateVoxel(1);
-    if (ES.doLight) {
-        if (ES.doRGBPropagation && isLightSource) {
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-        }
-        updateLightTask(tasks);
-        if (ES.doRGBPropagation) {
-            RGBUpdate(tasks);
-        }
-        if (ES.doSunPropagation) {
-            SunUpdate(tasks);
-        }
-    }
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
-export async function PaintAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const raw = data[1];
-    const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    lighttest: if (ES.doLight) {
-        const light = voxel.getLight();
-        if (light <= 0)
-            break lighttest;
-        if (doSun) {
-            if (voxel.hasSunLight()) {
-                tasks.sun.remove.push(x, y, z);
-                SunRemove(tasks);
-            }
-        }
-        if (doRGB) {
-            if (voxel.hasRGBLight() && isOpaque) {
-                tasks.rgb.remove.push(x, y, z);
-                RGBRemove(tasks);
-            }
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const id = raw[0];
-    if (id < 0)
-        return false;
-    voxel.setId(id);
-    voxel.setLevel(raw[2]);
-    voxel.setState(raw[3]);
-    voxel.setMod(raw[4]);
-    voxel.process();
-    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
-        voxel.setSecondary(true);
-        voxel.setId(raw[5]);
-        voxel.setSecondary(false);
-    }
-    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
-        voxel.setLight(voxel.getLightSourceValue());
-    }
-    voxel.updateVoxel(0);
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            SunUpdate(tasks);
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow) {
-        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
+import { updateLightTask } from "./Common.js";
+const tasks = new VoxelUpdateTask();
 export async function VoxelUpdate(data) {
     const [dimension, x, y, z] = data[0];
     tasks.setOrigin(data[0]);
@@ -167,5 +29,7 @@ export async function VoxelUpdate(data) {
             FlowUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
     return tasks;
 }

package/Tasks/{Update/UpdateTask.d.ts → VoxelUpdateTask.d.ts}

@@ -1,6 +1,6 @@
-import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldCursor } from "../World/Cursor/WorldCursor";
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { LocationData } from "../../Math";
+import { LocationData } from "../Math";
 export declare class TaskMap {
     _map: boolean[];
     get size(): number;
@@ -12,18 +12,21 @@ export declare class TaskMap {
     clear(): void;
 }
 declare class UpdatedBounds {
-    _task: UpdateTask;
+    _task: VoxelUpdateTask;
     min: Vector3Like;
     max: Vector3Like;
-    constructor(_task: UpdateTask);
-    reset(): void;
+    dimension: number;
+    constructor(_task: VoxelUpdateTask);
+    start(dimension?: number): void;
     update(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
+    markSectionsAsDirty(): void;
 }
-export declare class UpdateTask {
+export declare class VoxelUpdateTask {
     flow: FlowQueues;
     rgb: LightQueue;
     sun: LightQueue;
+    power: PowerQueue;
     bounds: UpdatedBounds;
     sDataCursor: WorldCursor;
     nDataCursor: WorldCursor;
@@ -50,4 +53,11 @@ declare class LightQueue {
     updateMap: TaskMap;
     clear(): void;
 }
+declare class PowerQueue {
+    update: number[];
+    remove: number[];
+    removeMap: TaskMap;
+    updateMap: TaskMap;
+    clear(): void;
+}
 export {};

package/Tasks/{Update/UpdateTask.js → VoxelUpdateTask.js}

@@ -1,6 +1,7 @@
-import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldCursor } from "../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldSpaces } from "../World/WorldSpaces";
+import { WorldRegister } from "../World/WorldRegister";
 export class TaskMap {
     _map = [];
     get size() {
@@ -34,10 +35,12 @@ class UpdatedBounds {
     _task;
     min = Vector3Like.Clone(InfinityVec3);
     max = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = 0;
     constructor(_task) {
         this._task = _task;
     }
-    reset() {
+    start(dimension) {
+        this.dimension = dimension || 0;
         Vector3Like.Copy(this.min, InfinityVec3);
         Vector3Like.Copy(this.max, NegativeInfinityVec3);
     }
@@ -76,11 +79,35 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
+    markSectionsAsDirty() {
+        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.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 maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
+                for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(this.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(x, y, z);
+                    section.setDisplayDirty(true);
+                }
+            }
+        }
+    }
 }
-export class UpdateTask {
+export class VoxelUpdateTask {
     flow = new FlowQueues();
     rgb = new LightQueue();
     sun = new LightQueue();
+    power = new PowerQueue();
     bounds = new UpdatedBounds(this);
     sDataCursor = new WorldCursor();
     nDataCursor = new WorldCursor();
@@ -96,13 +123,13 @@ export class UpdateTask {
         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]);
         this.clear();
     }
     clear() {
         this.rgb.clear();
         this.sun.clear();
         this.flow.clear();
-        this.bounds.reset();
     }
 }
 class FlowQueues {
@@ -135,3 +162,15 @@ class LightQueue {
         this.updateMap.clear();
     }
 }
+class PowerQueue {
+    update = [];
+    remove = [];
+    removeMap = new TaskMap();
+    updateMap = new TaskMap();
+    clear() {
+        this.update.length = 0;
+        this.remove.length = 0;
+        this.removeMap.clear();
+        this.updateMap.clear();
+    }
+}

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -1,11 +1,11 @@
 import type { Vec3Array } from "@amodx/math";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
-import { UpdateTask } from "../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 export declare class WorldGenBrush extends BrushTool {
     constructor();
     requestsId: "";
-    tasks: UpdateTask;
-    start(dimension: string, x: number, y: number, z: number): this;
+    tasks: VoxelUpdateTask;
+    start(dimension: number, x: number, y: number, z: number): this;
     paint(): this;
     getUpdatedSections(): Vec3Array[];
     update(): false | undefined;

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -3,7 +3,7 @@ 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 { UpdateTask } from "../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 const lightData = new VoxelLightData();
@@ -13,7 +13,7 @@ export class WorldGenBrush extends BrushTool {
         WorldGeneration._brushes.push(this);
     }
     requestsId;
-    tasks = new UpdateTask();
+    tasks = new VoxelUpdateTask();
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
         this.tasks.setOrigin([dimension, x, y, z]);
@@ -56,7 +56,7 @@ export class WorldGenBrush extends BrushTool {
     }
     getUpdatedSections() {
         const queue = this.tasks.bounds.getSections();
-        this.tasks.bounds.reset();
+        this.tasks.bounds.start();
         return queue;
     }
     update() {

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -4,7 +4,7 @@ export declare class WorldGenRegister {
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
-        dimension: string;
+        dimension: number;
         sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;

package/Templates/Cursor/TemplateCursor.d.ts

@@ -1,7 +1,7 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
-export declare class TemplateCursor extends DataCursorInterface {
+export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
     _template: FullVoxelTemplate | null;
     private voxel;

package/Templates/Cursor/TemplateCursor.js

@@ -1,6 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
-export class TemplateCursor extends DataCursorInterface {
+export class TemplateCursor {
     _voxelIndex = 0;
     _template = null;
     voxel = new TemplateVoxelCursor(this);

package/Templates/Functions/CreateTemplate.d.ts

@@ -1,3 +1,3 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelTemplate } from "../VoxelTemplate";
-export default function CreateTemplate(dimension: string, start: Vec3Array, end: Vec3Array): VoxelTemplate;
+export default function CreateTemplate(dimension: number, start: Vec3Array, end: Vec3Array): VoxelTemplate;

package/Templates/VoxelTemplates.types.d.ts

@@ -1,5 +1,5 @@
 import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "../World";
+import { VoxelDataArrays } from "../Voxels";
 export interface VoxelTemplateBuffers {
     ids: Uint16Array | Uint8Array | number;
     state: Uint16Array | Uint8Array | number;

package/Textures/Classes/CompiledTexture.d.ts

@@ -0,0 +1,18 @@
+import { Vec2Array } from "@amodx/math";
+import { TextureId } from "../../Textures/Texture.types";
+import { CompiledTextureAnimation } from "./CompiledTextureAnimation";
+import { TextureAnimationTexture } from "./TextureAnimationTexture";
+export declare class CompiledTexture {
+    id: string;
+    static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
+    static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
+    images: HTMLImageElement[];
+    atlasSizeMap: Record<string, [width: number, height: number]>;
+    textureMap: Record<string, number>;
+    animations: CompiledTextureAnimation[];
+    shaderTexture: any;
+    animatedTexture: TextureAnimationTexture;
+    constructor(id: string);
+    getTextureIndex(id: TextureId): number;
+    getTexturePath(id: TextureId): string;
+}