@divinevoxel/vlox 0.0.2 → 0.0.3

package/Renderer/MeshRegister.js

@@ -0,0 +1,218 @@
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../Data/World/WorldSpaces.js";
+import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
+import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
+import { ChunkMesh } from "./Classes/ChunkMesh.js";
+class Chunk {
+    static addMesh(location, mesh, substance) {
+        let column = MeshRegister.column.get(location);
+        if (!column) {
+            column = MeshRegister.column.add(location);
+        }
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        let chunk = column.chunks.get(index);
+        if (!chunk) {
+            chunk = new ChunkMesh([location[1], location[2], location[3]]);
+            column.chunks.set(index, chunk);
+        }
+        chunk?.meshes.set(substance, mesh);
+        return chunk;
+    }
+    static add(location) {
+        let column = MeshRegister.column.get(location);
+        if (!column) {
+            column = MeshRegister.column.add(location);
+        }
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        let chunk = column.chunks.get(index);
+        if (!chunk) {
+            chunk = new ChunkMesh([location[1], location[2], location[3]]);
+            column.chunks.set(index, chunk);
+        }
+        return chunk;
+    }
+    static removeMesh(location, substance) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        const chunk = column.chunks.get(index);
+        if (!chunk)
+            return false;
+        const chunkMesh = chunk.meshes.get(substance);
+        if (!chunkMesh)
+            return false;
+        chunk.meshes.delete(substance);
+        if (chunk.meshes.size == 0) {
+            column.chunks.delete(index);
+        }
+        return chunkMesh;
+    }
+    static getMesh(location, substance) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
+        if (!chunk)
+            return false;
+        const chunkMesh = chunk.meshes.get(substance);
+        if (!chunkMesh)
+            return false;
+        return chunkMesh;
+    }
+    static remove(location) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        const chunk = column.chunks.get(index);
+        if (!chunk)
+            return false;
+        column.chunks.delete(index);
+        return chunk;
+    }
+    static get(location) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
+        if (!chunk)
+            return false;
+        return chunk;
+    }
+}
+class Column {
+    static add(location) {
+        let region = MeshRegister.region.get(location);
+        if (!region) {
+            region = MeshRegister.region.add(location);
+        }
+        const column = new MeshRegisterColumn([
+            location[0],
+            ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
+        ]);
+        region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
+        return column;
+    }
+    static remove(location) {
+        const region = MeshRegister.region.get(location);
+        if (!region)
+            return false;
+        const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
+        const column = region.columns.get(index);
+        if (!column)
+            return false;
+        region.columns.delete(index);
+        if (region.columns.size == 0) {
+            MeshRegister.region.remove(location);
+        }
+        return column;
+    }
+    static get(location) {
+        const region = MeshRegister.region.get(location);
+        if (!region)
+            return false;
+        return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
+    }
+}
+class Region {
+    static add(location) {
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension) {
+            dimension = MeshRegister.dimensions.add(location[0]);
+        }
+        const region = new MushRegisterRegion();
+        dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
+        return region;
+    }
+    static remove(location) {
+        const region = this.get(location);
+        if (!region)
+            return false;
+        const dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            return false;
+        dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+        region.columns.forEach((column) => {
+            column.chunks.forEach((chunk) => {
+                chunk.meshes.forEach((chunkMeshes) => {
+                    chunkMeshes.dispose();
+                });
+            });
+        });
+        return true;
+    }
+    static get(location) {
+        const dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            return false;
+        const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+        if (!region)
+            return false;
+        return region;
+    }
+}
+class Dimensions {
+    static add(id) {
+        const dimension = new Map();
+        MeshRegister._dimensions.set(id, dimension);
+        return dimension;
+    }
+    static get(id) {
+        return MeshRegister._dimensions.get(id);
+    }
+    static *getAllMeshes(id) {
+        const dimension = MeshRegister._dimensions.get(id);
+        if (!dimension)
+            return;
+        for (const [key, region] of dimension) {
+            for (const [columnKey, column] of region.columns) {
+                for (const [chunkKey, chunk] of column.chunks) {
+                    for (const [substance, mesh] of chunk.meshes) {
+                        yield [
+                            [
+                                column.location[0],
+                                column.location[1],
+                                column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
+                                column.location[3],
+                            ],
+                            substance,
+                            mesh,
+                        ];
+                    }
+                }
+            }
+        }
+    }
+    static remove(id) {
+        const dimension = MeshRegister._dimensions.get(id);
+        if (!dimension)
+            return false;
+        dimension.forEach((region) => {
+            region.columns.forEach((column) => {
+                column.chunks.forEach((chunk) => {
+                    chunk.meshes.forEach((chunkMeshes) => {
+                        chunkMeshes.dispose();
+                    });
+                });
+            });
+        });
+        MeshRegister._dimensions.delete(id);
+        return true;
+    }
+}
+export class MeshRegister {
+    // Main dimensions data store
+    static _dimensions = new Map([["main", new Map()]]);
+    static dimensions = Dimensions;
+    static region = Region;
+    static column = Column;
+    static chunk = Chunk;
+    static clearAll() {
+        for (const [dkey, dim] of this._dimensions) {
+            this.dimensions.remove(dkey);
+        }
+        this._dimensions.clear();
+        this._dimensions.set("main", new Map());
+    }
+}

package/{Data/Settings → Settings}/EngineSettings.d.ts

@@ -1,4 +1,4 @@
-import { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+import { EngineSettingsData } from "./EngineSettings.types.js";
 import { Observable } from "@amodx/core/Observers/Observable.js";
 /**# Engine Settings
  * ---

package/{Data/Settings → Settings}/EngineSettings.js

@@ -1,6 +1,6 @@
-import { EngineSettingsData } from "../../Types/EngineSettings.types.js";
-import { WorldBounds } from "../World/WorldBounds.js";
-import { InitWorldSpaces } from "../World/WorldSpaces.js";
+import { EngineSettingsData } from "./EngineSettings.types.js";
+import { WorldBounds } from "../Data/World/WorldBounds.js";
+import { InitWorldSpaces } from "../Data/World/WorldSpaces.js";
 import { Environment } from "@amodx/core/Environment/Environment.js";
 import { Observable } from "@amodx/core/Observers/Observable.js";
 /**# Engine Settings
@@ -52,7 +52,7 @@ export class EngineSettings {
         return this.settings.richWorld.enabled;
     }
     static syncChunkInDataThread() {
-        return this.settings.data.enabled && this.settings.data.autoSyncChunks;
+        return this.settings.dataLoader.enabled && this.settings.dataLoader.autoSyncChunks;
     }
     static syncChunksInNexusThread() {
         return this.settings.nexus.enabled && this.settings.nexus.autoSyncChunks;
@@ -70,7 +70,7 @@ export class EngineSettings {
         return this.settings.flow.enable;
     }
     static saveWorldData() {
-        return this.settings.data.enabled;
+        return this.settings.dataLoader.enabled;
     }
     static isServer() {
         return this.settings.server.enabled && this.enviorment == "node";

package/{Types → Settings}/EngineSettings.types.d.ts

@@ -1,4 +1,7 @@
 export declare class EngineSettingsData {
+    rendererSettings: {
+        mode: "webgl" | "webgpu";
+    };
     floatingOrigi: {
         enable: boolean;
     };
@@ -7,7 +10,7 @@ export declare class EngineSettingsData {
         autoSyncChunks: boolean;
         autoSyncVoxelPalette: boolean;
     };
-    data: {
+    dataLoader: {
         enabled: boolean;
         autoSyncChunks: boolean;
         mode: string;
@@ -63,10 +66,7 @@ export declare class EngineSettingsData {
     };
     meshes: {
         clearChachedGeometry: boolean;
-        checkMagmaCollisions: boolean;
-        checkLiquidCollisions: boolean;
-        checkFloraCollisions: boolean;
-        checkSolidCollisions: boolean;
+        checkCollisions: boolean;
         serialize: boolean;
         pickable: boolean;
     };

package/{Types → Settings}/EngineSettings.types.js

@@ -1,4 +1,5 @@
 export class EngineSettingsData {
+    rendererSettings = { mode: "webgl" };
     floatingOrigi = {
         enable: false,
     };
@@ -7,7 +8,7 @@ export class EngineSettingsData {
         autoSyncChunks: true,
         autoSyncVoxelPalette: true,
     };
-    data = {
+    dataLoader = {
         enabled: false,
         autoSyncChunks: true,
         mode: "indexdb",
@@ -63,10 +64,7 @@ export class EngineSettingsData {
     };
     meshes = {
         clearChachedGeometry: true,
-        checkMagmaCollisions: false,
-        checkLiquidCollisions: false,
-        checkFloraCollisions: false,
-        checkSolidCollisions: false,
+        checkCollisions: false,
         serialize: false,
         pickable: false,
     };

package/Tasks/Analyzer/Analyzer.d.ts

@@ -0,0 +1,19 @@
+import type { AnaylzerTask } from "../Tasks.types.js";
+import type { LocationData } from "../../Math";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+export declare class Analyzer {
+    updater: {
+        _voxels: Map<string, (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void>;
+        registerVoxel(id: string, run: (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void): void;
+        getVoxel(id: string): false | ((locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void);
+    };
+    worldCurosr: WorldCursor;
+    chunkCursor: ChunkCursor;
+    substanceData: SubstanceDataTool;
+    _flowChecks: number[][];
+    runPropagation(data: AnaylzerTask): Promise<void>;
+    runUpdate(data: AnaylzerTask): Promise<void>;
+}

package/Tasks/Analyzer/Analyzer.js

@@ -0,0 +1,156 @@
+//objects
+import { EngineSettings } from "../../Settings/EngineSettings.js";
+import { AnalyzerUpdater } from "./AnalyzerUpdater.js";
+import { Propagation } from "../Propagation/Propagation.js";
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+//tools
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { UpdateTask } from "../Update/UpdateTask.js";
+const columnTool = new ColumnDataTool();
+const heightMapTool = new HeightMapTool();
+//const mainDT = new DataTool();
+//const secondaryDT = new DataTool();
+export class Analyzer {
+    updater = AnalyzerUpdater;
+    worldCurosr = new WorldCursor();
+    chunkCursor = new ChunkCursor();
+    substanceData = new SubstanceDataTool();
+    _flowChecks = [
+        [0, -1, 0],
+        [1, 0, 0],
+        [-1, 0, 0],
+        [0, 0, 1],
+        [0, 0, -1],
+    ];
+    async runPropagation(data) {
+        let t = {};
+        this.worldCurosr.setFocalPoint(...data[0]);
+        const options = {
+            light: EngineSettings.doLight(),
+            flow: EngineSettings.doFlow(),
+        };
+        //  mainDT.setDimension(data[0][0]);
+        const location = data[0];
+        // secondaryDT.setDimension(data[0][0]);
+        const tasks = new UpdateTask();
+        tasks.setOrigin(location);
+        if (!columnTool.loadInAtLocation(location))
+            return;
+        WorldRegister.instance.cache.enable();
+        const column = columnTool.getColumn();
+        let maxX = WorldSpaces.chunk._bounds.x + location[1];
+        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
+        for (let i = 0; i < column.chunks.length; i++) {
+            const chunk = column.chunks[i];
+            if (!chunk)
+                continue;
+            heightMapTool.chunk.setChunk(chunk);
+            this.chunkCursor.setChunk(chunk);
+            const [cx, cy, cz] = [
+                location[1],
+                location[2] + i * WorldSpaces.chunk.getHeight(),
+                location[3],
+            ];
+            let [minY, maxY] = heightMapTool.chunk.getMinMax();
+            if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+                continue;
+            for (let y = cy + minY; y <= cy + maxY; y++) {
+                for (let z = cz; z < maxZ; z++) {
+                    for (let x = cx; x < maxX; x++) {
+                        const voxel = this.chunkCursor.getVoxel(x, y, z);
+                        if (!voxel || voxel.isAir())
+                            continue;
+                        if (options.light) {
+                            if (voxel.isLightSource()) {
+                                tasks.rgb.update.push(x, y, z);
+                            }
+                        }
+                        if (options.flow) {
+                            t = {
+                                id: voxel.getStringId(),
+                                sustance: voxel.getSubstance(),
+                                substanceStringId: voxel.getSubstanceStringId(),
+                            };
+                            if (this.substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+                                let add = false;
+                                for (const check of this._flowChecks) {
+                                    const nVoxel = this.worldCurosr.getVoxel(x + check[0], y + check[1], z + check[2]);
+                                    if (nVoxel) {
+                                        if (nVoxel.isAir()) {
+                                            add = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (add) {
+                                    //  tasks.flow.update.queue.push([x, y, z]);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        WorldRegister.instance.cache.disable();
+        Propagation.instance.rgbUpdate(tasks);
+        const dimension = data[0][0];
+        for (const flowUpdate of tasks.flow.update.queue) {
+            const [x, y, z] = flowUpdate;
+            if (!this.worldCurosr.getVoxel(x, y, z))
+                continue;
+            const tasks = new UpdateTask();
+            tasks.setOrigin([dimension, x, y, z]);
+            await Propagation.instance.flowUpdate(tasks, false);
+        }
+    }
+    async runUpdate(data) {
+        /*     if (!columnTool.setLocation(data[0]).loadIn()) return;
+        const deltaTime = Date.now() - columnTool.getLastAnalyzerUpdateTimestamp();
+    
+        const location = [...data[0]] as LocationData;
+    
+        WorldRegister.instance.cache.enable();
+        const column = columnTool.getColumn();
+        let maxX = WorldSpaces.chunk._bounds.x + location[1];
+        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
+        for (let i = 0; i < column.chunks.length; i++) {
+          const chunk = column.chunks[i];
+          if (!chunk) continue;
+          heightMapTool.chunk.setChunk(chunk);
+          const [cx, cy, cz] = [
+            location[1],
+            location[2] + i * WorldSpaces.chunk.getHeight(),
+            location[3],
+          ];
+          let [minY, maxY] = heightMapTool.chunk.getMinMax();
+          minY += cy;
+          maxY += cy + 1;
+          for (let y = minY; y < maxY; y += 1) {
+            for (let z = cz; z < maxZ; z += 1) {
+              for (let x = cx; x < maxX; x += 1) {
+                if (!mainDT.loadInAt(x, y, z)) continue;
+                location[1] = x;
+                location[2] = y;
+                location[3] = z;
+                const run = this.updater.getVoxel(mainDT.getStringId());
+                if (!run) continue;
+                run(
+                  location,
+                  deltaTime,
+                  this,
+                  DivineVoxelEngineConstructor.instance
+                );
+              }
+            }
+          }
+        }
+    
+        WorldRegister.instance.cache.disable();
+        columnTool.setLastAnalyzerUpdateTimestamp(); */
+    }
+}

package/{Analyzer → Tasks/Analyzer}/AnalyzerUpdater.d.ts

@@ -1,5 +1,5 @@
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import type { LocationData } from "../Math";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+import type { LocationData } from "../../Math";
 import type { Analyzer } from "./Analyzer";
 type RunFunction = (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void;
 export declare const AnalyzerUpdater: {

package/Tasks/Analyzer/InitTasks.js

@@ -0,0 +1,16 @@
+import { Threads } from "@amodx/threads";
+import { Analyzer } from "./Analyzer";
+import { TasksIds } from "../TasksIds";
+export default function () {
+    const analyzer = new Analyzer();
+    Threads.registerTasks(TasksIds.AnalyzerPropagation, async (data, onDone) => {
+        await analyzer.runPropagation(data);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks(TasksIds.AnalyzerUpdate, async (data, onDone) => {
+        await analyzer.runUpdate(data);
+        if (onDone)
+            onDone();
+    }, "deferred");
+}

package/{DataLoader → Tasks/DataLoader}/Broswer/DataHandler.d.ts

@@ -1,6 +1,6 @@
 import { WorldDataTool } from "./WorldDataTool";
-import { LocationData } from "../../Math";
-import { DVEDataHandler } from "../../Interfaces/DataLoader/DVEDataHandler";
+import { LocationData } from "../../../Math";
+import { DVEDataHandler } from "../Types/DVEDataHandler";
 import { WorldDataBase } from "./WorldDataBase";
 export declare class DefaultDataHandler extends DVEDataHandler {
     static instance: DefaultDataHandler;

package/{DataLoader → Tasks/DataLoader}/Broswer/DataHandler.js

@@ -1,4 +1,4 @@
-import { DVEDataHandler } from "../../Interfaces/DataLoader/DVEDataHandler";
+import { DVEDataHandler } from "../Types/DVEDataHandler";
 import { WorldDataBaseManager } from "./WorldDataBaseManager";
 export class DefaultDataHandler extends DVEDataHandler {
     static instance;

package/{DataLoader → Tasks/DataLoader}/Broswer/WorldDataTool.d.ts

@@ -1,6 +1,6 @@
 import { WorldDataBase } from "./WorldDataBase";
-import { LocationData } from "../../Math";
-import { DataLoaderSegments } from "Interfaces/DataLoader/DVEDataHandler";
+import { LocationData } from "../../../Math";
+import { DataLoaderSegments } from "Tasks/DataLoader/Types/DVEDataHandler";
 export declare class WorldDataTool {
     worldDataBase: WorldDataBase;
     setPath(id: string): Promise<boolean>;

package/{DataLoader → Tasks/DataLoader}/Broswer/WorldDataTool.js

@@ -1,4 +1,4 @@
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces";
 import { Compressor } from "@amodx/core/Compression/Compression";
 export class WorldDataTool {
     worldDataBase;

package/{DataLoader → Tasks/DataLoader}/Constructor/WorldDataSerializer.d.ts

@@ -1,8 +1,8 @@
-import type { ColumnData } from "../../Data/World/Classes/Column.js";
-import type { LocationData } from "../../Math";
-import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
-import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
-import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool.js";
+import type { ColumnData } from "../../../Data/World/Classes/Column.js";
+import type { LocationData } from "../../../Math";
+import { RegionDataTool } from "../../../Tools/Data/WorldData/RegionDataTool.js";
+import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
+import { ChunkDataTool } from "../../../Tools/Data/WorldData/ChunkDataTool.js";
 export declare class WorldDataSerializer {
     regions: RegionDataTool;
     columns: ColumnDataTool;

package/{DataLoader → Tasks/DataLoader}/Constructor/WorldDataSerializer.js

@@ -1,7 +1,7 @@
 //objects
-import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
-import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
-import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool.js";
+import { RegionDataTool } from "../../../Tools/Data/WorldData/RegionDataTool.js";
+import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
+import { ChunkDataTool } from "../../../Tools/Data/WorldData/ChunkDataTool.js";
 import { BinaryObject } from "@amodx/binary";
 export class WorldDataSerializer {
     regions = new RegionDataTool();

package/{DataLoader → Tasks/DataLoader}/Node/DivineVoxelEngineData.d.ts

@@ -1,6 +1,6 @@
 import type * as FileSystem from "fs";
 import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
-import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+import { VoxelSpaces } from "../../../Math/Spaces/VoxelSpaces.js";
 import { BinaryStruct } from "@amodx/binary/";
 type Vector3 = {
     x: number;

package/{DataLoader → Tasks/DataLoader}/Node/DivineVoxelEngineData.js

@@ -1,6 +1,6 @@
 import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
 import { RegionData, RegionTagIds, SecotrData } from "./Util/DVED.util.js";
-import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+import { VoxelSpaces } from "../../../Math/Spaces/VoxelSpaces.js";
 import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
 import { System } from "./System/System.js";
 import { SystemPath } from "./System/SystemPath.js";

package/{DataLoader → Tasks/DataLoader}/Node/System/RegionSystem.d.ts

@@ -1,5 +1,5 @@
 import type { DVEDSyncFile } from "../../Types/DVED.types";
-import type { LocationData } from "../../../Math/";
+import type { LocationData } from "../../../../Math/";
 export declare const RegionSystem: {
     _processInput(buffer: ArrayBuffer | string): ArrayBufferLike;
     _getTagIndex(id: string, index: number): number;

package/{DataLoader → Tasks/DataLoader}/Node/Tools/NodeRegionTool.d.ts

@@ -1,5 +1,5 @@
 import type { DVEDDataTypes } from "../../Types/DVED.types";
-import type { LocationData } from "../../../Math/";
+import type { LocationData } from "../../../../Math/";
 export declare class NodeRegionTool {
     location: LocationData;
     dimension: string;

package/{DataLoader → Tasks/DataLoader}/Node/Util/DVED.util.js

@@ -19,7 +19,7 @@ export const RegionData = {
     numColumns: 0
 };
 export const RegionTagIds = {
-    sectorIndex: "#dved-column-sector-index",
-    columnLength: "#dved-column-legnth-index",
-    timeStamp: "#dved-column-save-timestamp",
+    sectorIndex: "dved-column-sector-index",
+    columnLength: "dved-column-legnth-index",
+    timeStamp: "dved-column-save-timestamp",
 };

package/{Interfaces/DataLoader → Tasks/DataLoader/Types}/DVEDataHandler.d.ts

@@ -1,4 +1,4 @@
-import { LocationData } from "../../Math";
+import { LocationData } from "../../../Math";
 export type DataLoaderModes = "server" | "indexdb" | "both";
 export type DataLoaderSegments = "world-data" | "rich-data" | "dbo" | "entities";
 export declare abstract class DVEDataHandler {

package/{Interfaces/DataLoader → Tasks/DataLoader/Types}/DVEDataHandler.js

@@ -1,4 +1,4 @@
-import { DataHanlderWrapper } from "../../DataLoader/World/DataHandlerWrapper";
+import { DataHanlderWrapper } from "../World/DataHandlerWrapper";
 export class DVEDataHandler {
     mode = "indexdb";
     constructor() {

package/{DataLoader → Tasks/DataLoader}/World/DataHandlerWrapper.d.ts

@@ -1,14 +1,12 @@
-import type { LocationData } from "../../Math";
-import { DVEDataHandler, DataLoaderModes } from "../../Interfaces/DataLoader/DVEDataHandler.js";
-import { RichDataTool } from "../../Tools/Data/RichDataTool.js";
-import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import type { LocationData } from "../../../Math";
+import { DVEDataHandler, DataLoaderModes } from "../Types/DVEDataHandler.js";
+import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
 import { DataSerializerTool } from "./Tools/DataSerializerTool.js";
 export declare class DataHanlderWrapper {
     static instance: DataHanlderWrapper;
     columnDatatool: ColumnDataTool;
     static mode: DataLoaderModes;
     handler: DVEDataHandler;
-    richData: RichDataTool;
     seralizer: DataSerializerTool;
     constructor();
     init(handler: DVEDataHandler): void;