@divinevoxel/vlox 0.0.0

package/Contexts/World/Lock/WorldLock.js

@@ -0,0 +1,86 @@
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
+export const WorldLock = {
+    locks: new Map(),
+    dataLoader: {},
+    init(dataLoaderTool) {
+        this.dataLoader = dataLoaderTool;
+    },
+    _loadMap: new Map(),
+    addLock(taskData) {
+        return new Promise(async (resolve) => {
+            this.locks.set(taskData.toString(), taskData);
+            const [dim, [ssx, ssy, ssz], [esx, esy, esz]] = taskData;
+            const { x: sx, y: sy, z: sz, } = WorldSpaces.column.getPositionXYZ(ssx, ssy, ssz);
+            const { x: ex, y: ey, z: ez, } = WorldSpaces.column.getPositionXYZ(esx, esy, esz);
+            const run = async () => {
+                let allFound = true;
+                for (let y = sy; y < ey + WorldSpaces.column._bounds.y; y += WorldSpaces.column._bounds.y) {
+                    for (let x = sx; x <= ex; x += WorldSpaces.column._bounds.x) {
+                        for (let z = sz; z <= ez; z += WorldSpaces.column._bounds.z) {
+                            const columnPos = WorldSpaces.column.getPositionXYZ(x, y, z);
+                            const location = [
+                                taskData[0],
+                                columnPos.x,
+                                columnPos.y,
+                                columnPos.z,
+                            ];
+                            location[0] = dim;
+                            WorldRegister.instance.setDimension(location[0]);
+                            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                                continue;
+                            allFound = false;
+                            const key = location.toString();
+                            if (this._loadMap.has(key))
+                                continue;
+                            this._loadMap.set(key, true);
+                            let success = false;
+                            if (!this.dataLoader.isEnabled()) {
+                                if (WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+                                    success = true;
+                                }
+                            }
+                            else {
+                                success = await this.dataLoader.loadIfExists(location);
+                            }
+                            this._loadMap.delete(key);
+                            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                                return;
+                            if (!success) {
+                                WorldRegister.instance.column.fill(location[1], location[2], location[3]);
+                            }
+                        }
+                    }
+                }
+                return allFound;
+            };
+            const didRun = await run();
+            if (didRun)
+                return resolve(true);
+            const inte = new SafeInterval().setInterval(100).setOnRun(async () => {
+                const didRun = await run();
+                if (didRun) {
+                    inte.stop();
+                    resolve(true);
+                }
+            });
+            inte.start();
+        });
+    },
+    removeLock(data) {
+        this.locks.delete(data.toString());
+    },
+    isLocked([sdim, x, y, z]) {
+        let locked = false;
+        for (const [key, [dim, [sx, sy, sz], [ex, ey, ez]]] of this.locks) {
+            if (dim != sdim)
+                continue;
+            if (x >= sx && y >= sy && z >= sz && x <= ex && y <= ey && z <= ez)
+                continue;
+            locked = true;
+            break;
+        }
+        return locked;
+    },
+};

package/Contexts/World/Tasks/WorldTasks.d.ts

@@ -0,0 +1,11 @@
+import type { LocationData } from "../../../Math/index.js";
+import { ColumnData } from "../../../Data/World/Classes/Column.js";
+import { DivineVoxelEngineWorld } from "../index.js";
+export declare class WorldTasks {
+    DVEW: DivineVoxelEngineWorld;
+    constructor(DVEW: DivineVoxelEngineWorld);
+    loadColumn(location: LocationData, column: ColumnData): void;
+    unLoadColumn(location: LocationData): boolean;
+    loadRegionHeader(location: LocationData, data: SharedArrayBuffer): void;
+}
+export default function (DVEW: DivineVoxelEngineWorld): void;

package/Contexts/World/Tasks/WorldTasks.js

@@ -0,0 +1,98 @@
+import { Threads } from "@amodx/threads/";
+//data
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { RegionHeaderRegister } from "../../../Data/RegionHeaderRegister.js";
+import { DataLoaderTool } from "../../../DataLoader/World/Tools/DataLoaderTool.js";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+import { WorldLock } from "../Lock/WorldLock.js";
+import { DataSync } from "../Data/DataSync.js";
+export class WorldTasks {
+    DVEW;
+    constructor(DVEW) {
+        this.DVEW = DVEW;
+    }
+    loadColumn(location, column) {
+        WorldRegister.instance.setDimension(location[0]);
+        WorldRegister.instance.column.add(location[1], location[2], location[3], column);
+        DataSync.instance.worldData.column.sync(location);
+    }
+    unLoadColumn(location) {
+        if (WorldLock.isLocked(location))
+            return false;
+        this.DVEW.dataSync.worldData.column.unSync(location);
+        WorldRegister.instance.setDimension(location[0]);
+        WorldRegister.instance.column.remove(location[1], location[2], location[3]);
+        const region = WorldRegister.instance.region.get(location[1], location[2], location[3]);
+        if (region && region.columns.size == 0) {
+            WorldRegister.instance.region.remove(location[1], location[2], location[3]);
+            this.DVEW.dataSync.worldData.region.unSync(location);
+            return true;
+        }
+        return false;
+    }
+    loadRegionHeader(location, data) {
+        RegionHeaderRegister.add(location, data);
+        DataSync.instance.worldData.regionHeader.sync(location);
+    }
+}
+export default function (DVEW) {
+    const dataLoaderTool = new DataLoaderTool();
+    const loadInMap = new Map();
+    Threads.registerTasks("add-chunk", async (location) => {
+        WorldRegister.instance.setDimension(location[0]);
+        const chunk = WorldRegister.instance.chunk.get(location[1], location[2], location[3]);
+        if (chunk) {
+            DVEW.dataSync.worldData.chunk.sync(location);
+            return;
+        }
+        if (dataLoaderTool.isEnabled()) {
+            WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3]);
+            const colunPos = WorldSpaces.column.getPosition();
+            const columnLocation = [
+                location[0],
+                colunPos.x,
+                colunPos.y,
+                colunPos.z,
+            ];
+            if (loadInMap.has(columnLocation.toString()))
+                return;
+            loadInMap.set(columnLocation.toString(), true);
+            const success = await dataLoaderTool.loadIfExists(columnLocation);
+            loadInMap.delete(columnLocation.toString());
+            if (!success) {
+                WorldRegister.instance.setDimension(columnLocation[0]);
+                WorldRegister.instance.column.fill(columnLocation[1], columnLocation[2], columnLocation[3]);
+            }
+            return;
+        }
+        if (!chunk) {
+            WorldRegister.instance.setDimension(location[0]);
+            WorldRegister.instance.column.fill(location[1], location[2], location[3]);
+        }
+    });
+    Threads.registerTasks("world-alloc", async (data, onDone) => {
+        await WorldLock.addLock(data);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks("world-dealloc", async (data, onDone) => {
+        await WorldLock.removeLock(data);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks("unload-column", (data, onDone) => {
+        const resutls = DVEW.tasks.unLoadColumn(data);
+        return onDone ? onDone(resutls) : resutls;
+    }, "deferred");
+    Threads.registerTasks("load-region-header", ([location, data], onDone) => {
+        const resutls = DVEW.tasks.loadRegionHeader(location, data);
+        return onDone ? onDone(resutls) : resutls;
+    });
+    Threads.registerTasks("load-column", ([location, column], onDone) => {
+        const resutls = DVEW.tasks.loadColumn(location, column);
+        return onDone ? onDone(resutls) : resutls;
+    });
+    Threads.registerTasks("clear-all", () => {
+        WorldRegister.instance.clearAll();
+    });
+}

package/Contexts/World/WorldDataHooks.d.ts

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

package/Contexts/World/WorldDataHooks.js

@@ -0,0 +1,96 @@
+import { DivineVoxelEngineWorld } from ".";
+import { DataHooks } from "../../Data/DataHooks";
+import { WorldDataGenerator } from "./Data/Generators/WorldDataGenerator.js";
+//import type { DataLoaderTool } from "Tools/Loader/DataLoaderTool.js";
+export default function () {
+    /*   const DVEW = DivineVoxelEngineWorld.instance;
+    let dataLoaderTool: null | DataLoaderTool = null;
+    if (DVEW.settings.saveWorldData()) {
+      dataLoaderTool = DVEW.getDataLoaderTool();
+    } */
+    /*
+  [chunks]
+  */
+    const DVE = DivineVoxelEngineWorld.instance;
+    DataHooks.chunk.onGetAsync.regiser("world", async (data) => {
+        data.chunk = WorldDataGenerator.chunk.create();
+        return data;
+    });
+    DataHooks.chunk.onGetSync.regiser("world", (data) => {
+        data.chunk = WorldDataGenerator.chunk.create();
+        return data;
+    });
+    DataHooks.chunk.onNew.subscribe("world", (data) => {
+        DVE.dataSync.worldData.chunk.sync(data);
+    });
+    DataHooks.chunk.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+          DVE.dataSync.worldData.chunk.unSync(data);
+          return;
+        }
+        dataLoaderTool.setLocation(data).saveColumn(() => {
+          DVE.dataSync.worldData.chunk.unSync(data);
+        }); */
+    });
+    /*
+  [columns]
+  */
+    DataHooks.column.onGetAsync.regiser("world", async (data) => {
+        data.column = WorldDataGenerator.column.create();
+        return data;
+    });
+    DataHooks.column.onGetSync.regiser("world", (data) => {
+        data.column = WorldDataGenerator.column.create();
+        return data;
+    });
+    DataHooks.column.onNew.subscribe("world", (data) => {
+        DVE.dataSync.worldData.column.sync(data);
+    });
+    DataHooks.column.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+        DVE.dataSync.worldData.column.unSync(data);
+        return;
+      }
+      dataLoaderTool.setLocation(data).saveColumn(() => {
+        DVE.dataSync.worldData.column.unSync(data);
+      }); */
+    });
+    /*
+  [region]
+  */
+    DataHooks.region.onGetAsync.regiser("world", async (data) => {
+        data.region = WorldDataGenerator.region.create();
+        return data;
+    });
+    DataHooks.region.onGetSync.regiser("world", (data) => {
+        data.region = WorldDataGenerator.region.create();
+        return data;
+    });
+    DataHooks.region.onNew.subscribe("world", (data) => {
+        DVE.dataSync.worldData.region.sync(data);
+    });
+    DataHooks.region.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+      DVE.dataSync.worldData.column.unSync(data);
+      return;
+    }
+    dataLoaderTool.setLocation(data).saveColumn(() => {
+      DVE.dataSync.worldData.column.unSync(data);
+    }); */
+    });
+    /*
+  [paint]
+  */
+    DataHooks.paint.onRichVoxelPaint.subscribe("world", (data) => {
+        // DVEW.richworld.setInitalData(data);
+    });
+    /*
+  [dimensions]
+  */
+    DataHooks.dimension.onRegisterDimension.regiser("world", (data) => {
+        DVE.queues.addQueue(data.id);
+        DVE.dataSync.worldData.dimesnion.sync(data.id);
+        return data;
+    });
+}
+;

package/Contexts/World/WorldThreadState.d.ts

@@ -0,0 +1,4 @@
+import { ThreadState } from "../../Interfaces/Classes/ThreadState";
+export declare class WorldThreadState extends ThreadState {
+    isReady(): boolean;
+}

package/Contexts/World/WorldThreadState.js

@@ -0,0 +1,6 @@
+import { ThreadState } from "../../Interfaces/Classes/ThreadState";
+export class WorldThreadState extends ThreadState {
+    isReady() {
+        return this.settingsSynced && this.threads.comms.every((_) => _.isReady());
+    }
+}

package/Contexts/World/WorldThreads.d.ts

@@ -0,0 +1,14 @@
+import { ThreadPool } from "@amodx/threads/";
+import { WorldThreadState } from "./WorldThreadState.js";
+import { ThreadManager } from "../../Interfaces/Classes/ThreadManager.js";
+import { DVEWorldProps } from "./index.js";
+export declare class WorldThreadManager extends ThreadManager {
+    props: DVEWorldProps;
+    constructors: ThreadPool;
+    parent: import("@amodx/threads/").Thread;
+    state: WorldThreadState;
+    richWorld: import("@amodx/threads/").Thread;
+    dataLoader: import("@amodx/threads/").Thread;
+    nexus: import("@amodx/threads/").Thread;
+    constructor(props?: DVEWorldProps);
+}

package/Contexts/World/WorldThreads.js

@@ -0,0 +1,34 @@
+import { Threads } from "@amodx/threads/";
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { ThreadManager } from "../../Interfaces/Classes/ThreadManager.js";
+export class WorldThreadManager extends ThreadManager {
+    props;
+    constructors = Threads.createThreadPool({
+        name: "constructor",
+        onPortSet(port, commName) { },
+    });
+    parent = Threads.parent;
+    state;
+    richWorld = Threads.createThread("rich-world");
+    dataLoader = Threads.createThread("data-loader");
+    nexus = Threads.createThread("nexus");
+    constructor(props = {}) {
+        super();
+        this.props = props;
+        this.addThread(this.constructors);
+        this.addThread(this.parent);
+        Threads.registerTasks("sync-settings", (settings) => {
+            EngineSettings.syncSettings(settings);
+            this.state.settingsSynced = true;
+        });
+        if (props.nexusEnabled) {
+            this.addThread(this.nexus);
+        }
+        if (props.dataLoaderEnabled) {
+            this.addThread(this.dataLoader);
+        }
+        if (props.richWorldEnabled) {
+            this.addThread(this.richWorld);
+        }
+    }
+}

package/Contexts/World/index.d.ts

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineWorld.js";

package/Contexts/World/index.js

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineWorld.js";

package/Data/Constants/DVEFDataSyncIds.d.ts

@@ -0,0 +1,12 @@
+export declare enum DVEFDataSyncIds {
+    Chunk = "Chunk",
+    Column = "Column",
+    Region = "Region",
+    RegionHeader = "RegionHeader",
+    Dimesnion = "Dimesnion",
+    ChunkTags = "ChunkTags",
+    ColumnTags = "ColumnTags",
+    RegionTags = "RegionTags",
+    RegisterStringMap = "RegisterStringMap",
+    RegisterObjectMap = "RegisterObjectMap"
+}

package/Data/Constants/DVEFDataSyncIds.js

@@ -0,0 +1,13 @@
+export var DVEFDataSyncIds;
+(function (DVEFDataSyncIds) {
+    DVEFDataSyncIds["Chunk"] = "Chunk";
+    DVEFDataSyncIds["Column"] = "Column";
+    DVEFDataSyncIds["Region"] = "Region";
+    DVEFDataSyncIds["RegionHeader"] = "RegionHeader";
+    DVEFDataSyncIds["Dimesnion"] = "Dimesnion";
+    DVEFDataSyncIds["ChunkTags"] = "ChunkTags";
+    DVEFDataSyncIds["ColumnTags"] = "ColumnTags";
+    DVEFDataSyncIds["RegionTags"] = "RegionTags";
+    DVEFDataSyncIds["RegisterStringMap"] = "RegisterStringMap";
+    DVEFDataSyncIds["RegisterObjectMap"] = "RegisterObjectMap";
+})(DVEFDataSyncIds || (DVEFDataSyncIds = {}));

package/Data/Constants/DataHeaders.d.ts

@@ -0,0 +1,6 @@
+export declare const DVEMessageHeader = 65535;
+export declare const WorldDataHeaders: {
+    region: number;
+    column: number;
+    chunk: number;
+};

package/Data/Constants/DataHeaders.js

@@ -0,0 +1,6 @@
+export const DVEMessageHeader = 0xffff;
+export const WorldDataHeaders = {
+    region: 0,
+    column: 1,
+    chunk: 2,
+};

package/Data/Constants/Structs/ChunkStructProperties.d.ts

@@ -0,0 +1,10 @@
+export declare const ChunkStructProperties: {
+    minHeight: string;
+    maxHeight: string;
+    heightMap: string;
+    dirtyMap: string;
+    voxelIDSegment: string;
+    voxelLightSegment: string;
+    voxelStateSegment: string;
+    voxelSecondaryIDSegment: string;
+};

package/Data/Constants/Structs/ChunkStructProperties.js

@@ -0,0 +1,10 @@
+export const ChunkStructProperties = {
+    minHeight: "#dve_min_height",
+    maxHeight: "#dve_max_height",
+    heightMap: "#dve_height_map",
+    dirtyMap: "#dve_dirty_map",
+    voxelIDSegment: "#dve_voxel_id",
+    voxelLightSegment: "#dve_voxel_light",
+    voxelStateSegment: "#dve_voxel_state",
+    voxelSecondaryIDSegment: "#dve_voxel_secondary_id",
+};

package/Data/Constants/Structs/SubstanceStructProperties.d.ts

@@ -0,0 +1,8 @@
+export declare const SubstanceStructProperties: {
+    parent: string;
+    rendered: string;
+    isSolid: string;
+    isLiquid: string;
+    flowRate: string;
+    culledSubstnaces: string;
+};

package/Data/Constants/Structs/SubstanceStructProperties.js

@@ -0,0 +1,8 @@
+export const SubstanceStructProperties = {
+    parent: "#dve_parent_substance",
+    rendered: "#dve_rendered_substance",
+    isSolid: "#dve_is_solid",
+    isLiquid: "#dve_is_liquid",
+    flowRate: "#dve_flow_rate",
+    culledSubstnaces: "#dve_culled_substances",
+};

package/Data/Constants/Structs/VoxelStructProperties.d.ts

@@ -0,0 +1,11 @@
+export declare const VoxelStructProperties: {
+    substance: string;
+    shapeID: string;
+    material: string;
+    hardness: string;
+    colliderID: string;
+    checkCollisions: string;
+    isLightSource: string;
+    lightValue: string;
+    isRich: string;
+};

package/Data/Constants/Structs/VoxelStructProperties.js

@@ -0,0 +1,11 @@
+export const VoxelStructProperties = {
+    substance: "#dve_substance",
+    shapeID: "#dve_shape_id",
+    material: "#dve_material",
+    hardness: "#dve_hardness",
+    colliderID: "#dve_collider_id",
+    checkCollisions: "#dve_check_collisions",
+    isLightSource: "#dve_is_light_source",
+    lightValue: "#dve_light_value",
+    isRich: "#dve_is_rich",
+};

package/Data/Constants/Structs/WorldDataStructProperties.d.ts

@@ -0,0 +1,8 @@
+export declare const WorldDataStructProperties: {
+    header: string;
+    dataType: string;
+    dimensionId: string;
+    positionX: string;
+    positionY: string;
+    positionZ: string;
+};

package/Data/Constants/Structs/WorldDataStructProperties.js

@@ -0,0 +1,8 @@
+export const WorldDataStructProperties = {
+    header: "#dve_header",
+    dataType: "#dve_data_type",
+    dimensionId: "#dve_dimension_id",
+    positionX: "#dve_p_x",
+    positionY: "#dve_p_y",
+    positionZ: "#dve_p_z",
+};

package/Data/Constants/SubstanceTagIds.d.ts

@@ -0,0 +1,12 @@
+export declare enum SubstanceTagIds {
+    parent = "#dve_parent_substance",
+    rendered = "#dve_rendered_substance",
+    isSolid = "#dve_is_solid",
+    isTransparent = "#dve_is_transparent",
+    isLiquid = "#dve_is_liquid",
+    flowRate = "#dve_flow_rate",
+    culledSubstnaces = "#dve_culled_substances",
+    cullDense = "#dve_cull_dense",
+    isWindAffected = "#dve_is_wind_affected",
+    isBackFaceCulled = "#dve_is_back_face_culled"
+}

package/Data/Constants/SubstanceTagIds.js

@@ -0,0 +1,13 @@
+export var SubstanceTagIds;
+(function (SubstanceTagIds) {
+    SubstanceTagIds["parent"] = "#dve_parent_substance";
+    SubstanceTagIds["rendered"] = "#dve_rendered_substance";
+    SubstanceTagIds["isSolid"] = "#dve_is_solid";
+    SubstanceTagIds["isTransparent"] = "#dve_is_transparent";
+    SubstanceTagIds["isLiquid"] = "#dve_is_liquid";
+    SubstanceTagIds["flowRate"] = "#dve_flow_rate";
+    SubstanceTagIds["culledSubstnaces"] = "#dve_culled_substances";
+    SubstanceTagIds["cullDense"] = "#dve_cull_dense";
+    SubstanceTagIds["isWindAffected"] = "#dve_is_wind_affected";
+    SubstanceTagIds["isBackFaceCulled"] = "#dve_is_back_face_culled";
+})(SubstanceTagIds || (SubstanceTagIds = {}));

package/Data/Constants/VoxelTagIds.d.ts

@@ -0,0 +1,14 @@
+export declare enum VoxelTagIDs {
+    substance = "#dve_substance",
+    shapeID = "#dve_shape_id",
+    material = "#dve_material",
+    hardness = "#dve_hardness",
+    colliderID = "#dve_collider_id",
+    checkCollisions = "#dve_check_collisions",
+    isLightSource = "#dve_is_light_source",
+    noAO = "#dve_no_ao",
+    isTransparent = "#dve_is_transparent",
+    lightValue = "#dve_light_value",
+    isRich = "#dve_is_rich",
+    canHaveSecondary = "#dve_can_have_secondary"
+}

package/Data/Constants/VoxelTagIds.js

@@ -0,0 +1,15 @@
+export var VoxelTagIDs;
+(function (VoxelTagIDs) {
+    VoxelTagIDs["substance"] = "#dve_substance";
+    VoxelTagIDs["shapeID"] = "#dve_shape_id";
+    VoxelTagIDs["material"] = "#dve_material";
+    VoxelTagIDs["hardness"] = "#dve_hardness";
+    VoxelTagIDs["colliderID"] = "#dve_collider_id";
+    VoxelTagIDs["checkCollisions"] = "#dve_check_collisions";
+    VoxelTagIDs["isLightSource"] = "#dve_is_light_source";
+    VoxelTagIDs["noAO"] = "#dve_no_ao";
+    VoxelTagIDs["isTransparent"] = "#dve_is_transparent";
+    VoxelTagIDs["lightValue"] = "#dve_light_value";
+    VoxelTagIDs["isRich"] = "#dve_is_rich";
+    VoxelTagIDs["canHaveSecondary"] = "#dve_can_have_secondary";
+})(VoxelTagIDs || (VoxelTagIDs = {}));

package/Data/DVEFDataCore.d.ts

@@ -0,0 +1,7 @@
+import { DVEDataCore } from "../Interfaces/Data/DVEDataCore";
+import { DVEFDataManager } from "./DVEFDataManager";
+import { DVEFDataSyncNode } from "../Data/DVEFDataSyncNode";
+export declare class DVEFDataCore extends DVEDataCore {
+    dataManager: DVEFDataManager;
+    dataSync: DVEFDataSyncNode;
+}

package/Data/DVEFDataCore.js

@@ -0,0 +1,7 @@
+import { DVEDataCore } from "../Interfaces/Data/DVEDataCore";
+import { DVEFDataManager } from "./DVEFDataManager";
+import { DVEFDataSyncNode } from "../Data/DVEFDataSyncNode";
+export class DVEFDataCore extends DVEDataCore {
+    dataManager = new DVEFDataManager();
+    dataSync = new DVEFDataSyncNode();
+}

package/Data/DVEFDataManager.d.ts

@@ -0,0 +1,31 @@
+import { DimensionsRegister } from "./World/DimensionsRegister.js";
+import { WorldPainter } from "./World/WorldPainter.js";
+import { WorldRegister } from "./World/WorldRegister.js";
+import { DVEFDataSyncNode } from "./DVEFDataSyncNode.js";
+import { DataManager } from "../Interfaces/Data/DataManager.js";
+export declare class DVEFDataManager extends DataManager {
+    world: WorldPainter;
+    dataSync: DVEFDataSyncNode;
+    registers: {
+        dimensions: typeof DimensionsRegister;
+        world: WorldRegister;
+        regionHeader: {
+            _headers: Map<string, Map<string, {
+                data: DataView;
+                buffer: SharedArrayBuffer;
+            }>>;
+            remove(location: import("../Math/index.js").LocationData): boolean;
+            add(location: import("../Math/index.js").LocationData, buffer: SharedArrayBuffer): void;
+            get(location: import("../Math/index.js").LocationData): false | {
+                data: DataView;
+                buffer: SharedArrayBuffer;
+            } | undefined;
+            isStored(location: import("../Math/index.js").LocationData): 0 | 1 | -1;
+        };
+    };
+    worldDataTags: {
+        chunks: import("@amodx/binary").RemoteBinaryStruct;
+        column: import("@amodx/binary").RemoteBinaryStruct;
+        region: import("@amodx/binary").RemoteBinaryStruct;
+    };
+}

package/Data/DVEFDataManager.js

@@ -0,0 +1,23 @@
+import { DimensionsRegister } from "./World/DimensionsRegister.js";
+import { WorldPainter } from "./World/WorldPainter.js";
+import { WorldRegister } from "./World/WorldRegister.js";
+import { RegionHeaderRegister } from "./RegionHeaderRegister.js";
+import { Chunk } from "./World/Classes/Chunk.js";
+import { Column } from "./World/Classes/Column.js";
+import { Region } from "./World/Classes/Region.js";
+import { DVEFDataSyncNode } from "./DVEFDataSyncNode.js";
+import { DataManager } from "../Interfaces/Data/DataManager.js";
+export class DVEFDataManager extends DataManager {
+    world = new WorldPainter();
+    dataSync = new DVEFDataSyncNode();
+    registers = {
+        dimensions: DimensionsRegister,
+        world: new WorldRegister(),
+        regionHeader: RegionHeaderRegister,
+    };
+    worldDataTags = {
+        chunks: Chunk.StateStruct,
+        column: Column.StateStruct,
+        region: Region.StateStruct,
+    };
+}

package/Data/DVEFDataSyncNode.d.ts

@@ -0,0 +1,20 @@
+import type { LocationData } from "../Math";
+import { BinaryStructData } from "@amodx/binary/";
+import { RegionData, ColumnData, ChunkData } from "./World/Classes/index.js";
+import { WorldDataSync } from "./Types/DataSync.types.js";
+import { DimensionData } from "./Types/DimensionData.types.js";
+import { RemoteDataSyncNode } from "../Interfaces/Data/RemoteDataSyncNode.js";
+export declare class DVEFDataSyncNode extends RemoteDataSyncNode {
+    worldData: {
+        dimension: import("@amodx/threads/").DataSync<DimensionData, void>;
+        chunk: import("@amodx/threads/").DataSync<[LocationData, ChunkData], LocationData>;
+        column: import("@amodx/threads/").DataSync<[LocationData, ColumnData], LocationData>;
+        region: import("@amodx/threads/").DataSync<[LocationData, RegionData], LocationData>;
+        regionHeader: import("@amodx/threads/").DataSync<WorldDataSync, LocationData>;
+    };
+    worldDataTags: {
+        chunk: import("@amodx/threads/").DataSync<BinaryStructData, void>;
+        column: import("@amodx/threads/").DataSync<BinaryStructData, void>;
+        region: import("@amodx/threads/").DataSync<BinaryStructData[], void>;
+    };
+}