@divinevoxel/vlox 0.0.0

package/Contexts/World/Data/Generators/VoxelDataGenerator.js

@@ -0,0 +1,64 @@
+//types
+import { VoxelTagIDs } from "../../../../Data/Constants/VoxelTagIds.js";
+//objects
+import { VoxelTagBuilder } from "../StructBuilders/VoxelStructBuilder.js";
+import { VoxelPalette } from "../../../../Data/Voxel/VoxelPalette.js";
+import { VoxelStruct } from "../../../../Data/Voxel/VoxelStruct.js";
+import { VoxelManager } from "../Managers/DataManagers.js";
+import { SubstanceDataGenerator } from "./SubstanceDataGenerator.js";
+import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+export class VoxelDataGenerator {
+    static overrides = new Map();
+    static nameToIdMap = {};
+    static idToNameMap = {};
+    static generate() {
+        //build palette
+        for (const [key, voxel] of VoxelManager.data) {
+            if (this.palette.isRegistered(voxel.id))
+                throw new Error(`Duplicate voxel id ${voxel.id}`);
+            this.palette.register(voxel.id);
+            this.nameToIdMap[voxel.name ? voxel.name : voxel.id] = voxel.id;
+            this.idToNameMap[voxel.id] = voxel.name ? voxel.name : voxel.id;
+        }
+        VoxelPalette.setVoxelIdPalette(this.palette._palette, this.palette._map);
+        VoxelPalette.setVoxelNamePalette(this.nameToIdMap, this.idToNameMap);
+        //build index
+        const indexBuffer = new SharedArrayBuffer(this.palette.size * 2);
+        const voxelIndex = new Uint16Array(indexBuffer);
+        for (let i = 0; i < this.palette.size; i++) {
+            voxelIndex[i] = i;
+        }
+        //create data bufferv
+        const tags = VoxelTagBuilder.build(this.palette.size);
+        const buffer = new SharedArrayBuffer(tags.structData.bufferSize);
+        tags.structData.buffer = buffer;
+        tags.setBuffer(buffer);
+        //  VoxelStruct.init(initData);
+        //  VoxelStruct.setBuffer(buffer);
+        //build data
+        for (const [key, voxel] of VoxelManager.data) {
+            const baseID = VoxelPalette.ids.getNumberId(key);
+            if (!baseID)
+                continue;
+            tags.setStructArrayIndex(voxelIndex[baseID]);
+            VoxelTagBuilder.setDefaults(tags);
+            for (const tag of voxel.tags) {
+                const [id, value] = tag;
+                if (!VoxelTagBuilder.hasNode(id))
+                    continue;
+                if (this.overrides.has(id)) {
+                    this.overrides.get(id)(tags, value, id);
+                    continue;
+                }
+                VoxelTagBuilder.setNode(id, value, tags);
+            }
+        }
+        VoxelStruct.sync(voxelIndex);
+        VoxelStruct.init(tags.structData);
+        VoxelStruct.instance.setBuffer(buffer);
+    }
+    static palette = new StringPalette();
+}
+VoxelDataGenerator.overrides.set(VoxelTagIDs.substance, (tags, value, id) => {
+    tags.setProperty(id, SubstanceDataGenerator.palette._map[value]);
+});

package/Contexts/World/Data/Generators/WorldDataGenerator.d.ts

@@ -0,0 +1,12 @@
+import { RegionData, ColumnData, ChunkData } from "../../../../Data/World/Classes/index.js";
+export declare const WorldDataGenerator: {
+    chunk: {
+        create(buffer?: ArrayBuffer | false): ChunkData;
+    };
+    column: {
+        create(buffer?: ArrayBuffer | false): ColumnData;
+    };
+    region: {
+        create(buffer?: ArrayBuffer | false): RegionData;
+    };
+};

package/Contexts/World/Data/Generators/WorldDataGenerator.js

@@ -0,0 +1,24 @@
+import { Region, Column, Chunk, } from "../../../../Data/World/Classes/index.js";
+export const WorldDataGenerator = {
+    chunk: {
+        create(buffer = false) {
+            if (buffer) {
+            }
+            return Chunk.CreateNew();
+        },
+    },
+    column: {
+        create(buffer = false) {
+            if (buffer) {
+            }
+            return Column.CreateNew({});
+        },
+    },
+    region: {
+        create(buffer = false) {
+            if (buffer) {
+            }
+            return Region.CreateNew();
+        },
+    },
+};

package/Contexts/World/Data/Managers/DataManagers.d.ts

@@ -0,0 +1,5 @@
+import { VoxelData } from "../../../../Types/index.js";
+import { RegisterDataManager } from "../Classes/RegisterDataManager.js";
+import { SubstanceData } from "../../../../Types/Substances.types.js";
+export declare const VoxelManager: RegisterDataManager<VoxelData>;
+export declare const SubstanceManager: RegisterDataManager<SubstanceData>;

package/Contexts/World/Data/Managers/DataManagers.js

@@ -0,0 +1,126 @@
+import { RegisterDataManager } from "../Classes/RegisterDataManager.js";
+import { SubstanceTagIds } from "../../../../Data/Constants/SubstanceTagIds.js";
+export const VoxelManager = new RegisterDataManager();
+export const SubstanceManager = new RegisterDataManager();
+VoxelManager.registerData([
+    {
+        id: "dve_air",
+        tags: [
+            ["#dve_substance", "#dve_air"],
+            ["#dve_shape_id", "#dve_cube"],
+        ],
+    },
+    {
+        id: "dve_barrier",
+        tags: [
+            ["#dve_substance", "#dve_air"],
+            ["#dve_shape_id", "#dve_cube"],
+        ],
+    },
+]);
+SubstanceManager.registerData([
+    {
+        id: "#dve_air",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_air"],
+            [SubstanceTagIds.rendered, "#dve_air"],
+            [SubstanceTagIds.isSolid, false],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, true],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, []],
+        ],
+    },
+    {
+        id: "#dve_solid",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_solid"],
+            [SubstanceTagIds.rendered, "#dve_solid"],
+            [SubstanceTagIds.isSolid, true],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, false],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, ["#dve_solid"]],
+        ],
+    },
+    {
+        id: "#dve_glow",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_solid"],
+            [SubstanceTagIds.rendered, "#dve_glow"],
+            [SubstanceTagIds.isSolid, true],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, false],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, ["#dve_solid"]],
+        ],
+    },
+    {
+        id: "#dve_translucent",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_flora"],
+            [SubstanceTagIds.rendered, "#dve_solid"],
+            [SubstanceTagIds.isSolid, true],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, true],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, []],
+        ],
+    },
+    {
+        id: "#dve_transparent",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_transparent"],
+            [SubstanceTagIds.rendered, "#dve_transparent"],
+            [SubstanceTagIds.isSolid, true],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, true],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, ["#dve_transparent"]],
+        ],
+    },
+    {
+        id: "#dve_flora",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_flora"],
+            [SubstanceTagIds.rendered, "#dve_flora"],
+            [SubstanceTagIds.isSolid, true],
+            [SubstanceTagIds.isLiquid, false],
+            [SubstanceTagIds.isTransparent, true],
+            [SubstanceTagIds.flowRate, 0],
+            [SubstanceTagIds.culledSubstnaces, []],
+            [SubstanceTagIds.cullDense, true],
+            [SubstanceTagIds.isWindAffected, true],
+            [SubstanceTagIds.isBackFaceCulled, false],
+        ],
+    },
+    {
+        id: "#dve_liquid",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_liquid"],
+            [SubstanceTagIds.rendered, "#dve_liquid"],
+            [SubstanceTagIds.isSolid, false],
+            [SubstanceTagIds.isLiquid, true],
+            [SubstanceTagIds.isTransparent, true],
+            [SubstanceTagIds.flowRate, 1],
+            [
+                SubstanceTagIds.culledSubstnaces,
+                ["#dve_liquid", "#dve_solid", "#dve_glow"],
+            ],
+            [SubstanceTagIds.isBackFaceCulled, false],
+        ],
+    },
+    {
+        id: "#dve_magma",
+        tags: [
+            [SubstanceTagIds.parent, "#dve_liquid"],
+            [SubstanceTagIds.rendered, "#dve_liquid"],
+            [SubstanceTagIds.isSolid, false],
+            [SubstanceTagIds.isLiquid, true],
+            [SubstanceTagIds.isTransparent, false],
+            [SubstanceTagIds.flowRate, 3],
+            [SubstanceTagIds.culledSubstnaces, ["#dve_liquid", "#dve_solid"]],
+            [SubstanceTagIds.isBackFaceCulled, false],
+        ],
+    },
+]);

package/Contexts/World/Data/StructBuilders/SubstanceStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../Classes/StructBuilder.js";
+export declare const SubstanceTagBuilder: StructBuilder;

package/Contexts/World/Data/StructBuilders/SubstanceStructBuilder.js

@@ -0,0 +1,57 @@
+import { BinaryNumberTypes } from "@amodx/binary";
+import { SubstanceTagIds } from "../../../../Data/Constants/SubstanceTagIds.js";
+import { StructBuilder } from "../Classes/StructBuilder.js";
+export const SubstanceTagBuilder = new StructBuilder("substance-tag-manager", "substance");
+SubstanceTagBuilder.addNode([
+    {
+        id: SubstanceTagIds.parent,
+        type: "string-map",
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
+    },
+    {
+        id: SubstanceTagIds.rendered,
+        type: "string-map",
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
+    },
+    {
+        id: SubstanceTagIds.culledSubstnaces,
+        type: "object-map",
+        allowedComms: ["constructor"],
+    },
+    {
+        id: SubstanceTagIds.isTransparent,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceTagIds.isSolid,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceTagIds.isLiquid,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceTagIds.flowRate,
+        type: "number",
+        numberType: BinaryNumberTypes.Float32,
+        default: 1,
+    },
+    {
+        id: SubstanceTagIds.cullDense,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceTagIds.isWindAffected,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceTagIds.isBackFaceCulled,
+        type: "boolean",
+        default: true,
+    },
+]);

package/Contexts/World/Data/StructBuilders/VoxelStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../Classes/StructBuilder.js";
+export declare const VoxelTagBuilder: StructBuilder;

package/Contexts/World/Data/StructBuilders/VoxelStructBuilder.js

@@ -0,0 +1,68 @@
+import { BinaryNumberTypes } from "@amodx/binary";
+import { VoxelTagIDs } from "../../../../Data/Constants/VoxelTagIds.js";
+import { StructBuilder } from "../Classes/StructBuilder.js";
+export const VoxelTagBuilder = new StructBuilder("voxel-tag-manager", "voxel");
+VoxelTagBuilder.addNode([
+    {
+        id: VoxelTagIDs.substance,
+        type: "string-map",
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
+    },
+    {
+        id: VoxelTagIDs.shapeID,
+        type: "string-map",
+        allowedComms: ["constructor"],
+    },
+    {
+        id: VoxelTagIDs.colliderID,
+        type: "string-map",
+        allowedComms: ["nexus"],
+    },
+    {
+        id: VoxelTagIDs.checkCollisions,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.material,
+        type: "string-map",
+        allowedComms: ["nexus"],
+    },
+    {
+        id: VoxelTagIDs.isLightSource,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.noAO,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.lightValue,
+        type: "number",
+        numberType: BinaryNumberTypes.Uint16,
+        default: 0,
+    },
+    {
+        id: VoxelTagIDs.isRich,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.isTransparent,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.canHaveSecondary,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: VoxelTagIDs.hardness,
+        type: "number",
+        numberType: BinaryNumberTypes.Uint32,
+        default: 0,
+    },
+]);

package/Contexts/World/Data/Structs/ChunkStruct.d.ts

@@ -0,0 +1,3 @@
+import { BinaryStruct } from "@amodx/binary/";
+export declare const ChunkStatStruct: BinaryStruct;
+export declare function InitalizeChunkTags(): void;

package/Contexts/World/Data/Structs/ChunkStruct.js

@@ -0,0 +1,29 @@
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
+import { ChunkStructProperties } from "../../../../Data/Constants/Structs/ChunkStructProperties.js";
+import { Chunk } from "../../../../Data/World/Classes/Chunk.js";
+export const ChunkStatStruct = new BinaryStruct("chunk-tags");
+ChunkStatStruct.registerProperty({
+    id: ChunkStructProperties.minHeight,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint8,
+}, {
+    id: ChunkStructProperties.maxHeight,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint8,
+});
+export function InitalizeChunkTags() {
+    ChunkStatStruct.registerProperty({
+        id: ChunkStructProperties.heightMap,
+        type: "bit-array",
+        length: WorldSpaces.chunk.getHeight(),
+    }, {
+        id: ChunkStructProperties.dirtyMap,
+        type: "bit-array",
+        length: WorldSpaces.chunk.getHeight(),
+    });
+    const initData = ChunkStatStruct.init({
+        indexBufferMode: "shared",
+    });
+    Chunk.StateStruct.init(initData);
+}

package/Contexts/World/Data/Structs/ColumnStruct.d.ts

@@ -0,0 +1,3 @@
+import { BinaryStruct } from "@amodx/binary/";
+export declare const ColumnStateStruct: BinaryStruct;
+export declare function InitalizeColumnTags(): void;

package/Contexts/World/Data/Structs/ColumnStruct.js

@@ -0,0 +1,45 @@
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { Column } from "../../../../Data/World/Classes/Column.js";
+export const ColumnStateStruct = new BinaryStruct("column-tags");
+ColumnStateStruct.registerProperty({
+    id: "#dve_last_save_timestamp",
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint32,
+}, {
+    id: "#dve_last_analyzer_update_timestamp",
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint32,
+}, {
+    id: "#dve_has_rich_data",
+    type: "boolean",
+}, {
+    id: "#dve_has_entity_data",
+    type: "boolean",
+}, {
+    id: "#dve_is_stored",
+    type: "boolean",
+}, {
+    id: "#dve_is_world_gen_done",
+    type: "boolean",
+}, {
+    id: "#dve_is_world_decor_done",
+    type: "boolean",
+}, {
+    id: "#dve_is_world_sun_done",
+    type: "boolean",
+}, {
+    id: "#dve_is_world_propagation_done",
+    type: "boolean",
+}, {
+    id: "#dve_is_dirty",
+    type: "boolean",
+}, {
+    id: "#dve_persistent",
+    type: "boolean",
+});
+export function InitalizeColumnTags() {
+    const initData = ColumnStateStruct.init({
+        indexBufferMode: "shared",
+    });
+    Column.StateStruct.init(initData);
+}

package/Contexts/World/Data/Structs/RegionStruct.d.ts

@@ -0,0 +1,4 @@
+import { BinaryStruct } from "@amodx/binary/";
+export declare const RegionStateStruct: BinaryStruct;
+export declare const RegionHeaderTagManager: BinaryStruct;
+export declare function InitalizeRegionTags(): void;

package/Contexts/World/Data/Structs/RegionStruct.js

@@ -0,0 +1,50 @@
+import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { WorldDataStructProperties } from "../../../../Data/Constants/Structs/WorldDataStructProperties.js";
+import { Region } from "../../../../Data/World/Classes/Region.js";
+import { RegionHeaderTags } from "../../../../Data/RegionHeaderRegister.js";
+export const RegionStateStruct = new BinaryStruct("region-tags");
+RegionStateStruct.registerProperty({
+    id: "#dve_total_players",
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint16,
+}, {
+    id: WorldDataStructProperties.positionX,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Int32,
+}, {
+    id: WorldDataStructProperties.positionY,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Int32,
+}, {
+    id: WorldDataStructProperties.positionZ,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Int32,
+});
+export const RegionHeaderTagManager = new BinaryStruct("region-header-tags");
+export function InitalizeRegionTags() {
+    const initData = RegionStateStruct.init({
+        indexBufferMode: "shared",
+    });
+    Region.StateStruct.init(initData);
+    RegionHeaderTagManager.registerProperty({
+        id: "#dved-column-sector-index",
+        type: "typed-number-array",
+        numberType: BinaryNumberTypes.Uint16,
+        length: WorldSpaces.region.getColumnVolume(),
+    }, {
+        id: "#dved-column-legnth-index",
+        type: "typed-number-array",
+        numberType: BinaryNumberTypes.Uint16,
+        length: WorldSpaces.region.getColumnVolume(),
+    }, {
+        id: "#dved-column-save-timestamp",
+        type: "typed-number-array",
+        numberType: BinaryNumberTypes.Uint32,
+        length: WorldSpaces.region.getColumnVolume(),
+    });
+    const headerInitData = RegionHeaderTagManager.init({
+        indexBufferMode: "shared",
+    });
+    RegionHeaderTags.init(headerInitData);
+}

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -0,0 +1,34 @@
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { Threads } from "@amodx/threads/";
+import { WorldThreadManager } from "./WorldThreads.js";
+import { DVEConstructorTasksQueues } from "../Constructor/DVEConstructorTasksQueues";
+import { WorldTasks } from "./Tasks/WorldTasks";
+import { LocationData } from "../../Math";
+import { DataSync } from "./Data/DataSync.js";
+import { DataRegister } from "./Data/DataRegister.js";
+import { DataStructBuilders } from "./Data/DataStructBuilders.js";
+/**# Divine Voxel Engine World
+ * ---
+ * This handles everything in the world worker context.
+ */
+export type DVEWorldProps = {
+    nexusEnabled?: boolean;
+    richWorldEnabled?: boolean;
+    dataLoaderEnabled?: boolean;
+};
+export declare class DivineVoxelEngineWorld {
+    props: DVEWorldProps;
+    static environment: "node" | "browser";
+    static instance: DivineVoxelEngineWorld;
+    TC: typeof Threads;
+    settings: typeof EngineSettings;
+    threads: WorldThreadManager;
+    dataSync: DataSync;
+    queues: DVEConstructorTasksQueues;
+    dataRegiser: DataRegister;
+    dataTagBulders: DataStructBuilders;
+    tasks: WorldTasks;
+    constructor(props?: DVEWorldProps);
+    init(): Promise<void>;
+    removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
+}

package/Contexts/World/DivineVoxelEngineWorld.js

@@ -0,0 +1,64 @@
+//objects
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { Environment } from "@amodx/core/Environment/Environment.js";
+//functions
+import InitWorldWorker from "./InitWorker.js";
+import { Threads } from "@amodx/threads/";
+import { WorldThreadManager } from "./WorldThreads.js";
+import { DVEConstructorTasksQueues } from "../Constructor/DVEConstructorTasksQueues";
+import InitWorldTasks, { WorldTasks } from "./Tasks/WorldTasks";
+import { Distance3D } from "@amodx/math";
+import { WorldRegister } from "../../Data/World/WorldRegister";
+import { DataSync } from "./Data/DataSync.js";
+import { DataRegister } from "./Data/DataRegister.js";
+import { DataStructBuilders } from "./Data/DataStructBuilders.js";
+export class DivineVoxelEngineWorld {
+    props;
+    static environment = "browser";
+    static instance;
+    TC = Threads;
+    settings = EngineSettings;
+    threads;
+    dataSync;
+    queues;
+    dataRegiser;
+    dataTagBulders;
+    tasks = new WorldTasks(this);
+    constructor(props = {}) {
+        this.props = props;
+        if (DivineVoxelEngineWorld.instance)
+            return DivineVoxelEngineWorld.instance;
+        DivineVoxelEngineWorld.instance = this;
+        this.threads = new WorldThreadManager(props);
+        this.dataSync = new DataSync();
+        this.queues = new DVEConstructorTasksQueues(this.threads.constructors);
+        this.dataRegiser = new DataRegister();
+        this.dataTagBulders = new DataStructBuilders();
+        InitWorldTasks(this);
+    }
+    async init() {
+        await InitWorldWorker(this);
+    }
+    removeColumnsOutsideRadius(origion, radius) {
+        const [dimesnionId, x, y, z] = origion;
+        const dimension = WorldRegister.instance.dimensions.get(dimesnionId);
+        if (!dimension)
+            return;
+        dimension.regions.forEach((region) => {
+            region.columns.forEach((column, index) => {
+                WorldRegister.instance.columnTool.setColumn(column);
+                const location = region.getColumnPosition(index);
+                const distnace = Distance3D(location[0], 0, location[2], x, 0, z);
+                if (distnace > radius) {
+                    this.dataSync.worldData.column.unSync([origion[0], ...location]);
+                    WorldRegister.instance.setDimension(origion[0]);
+                    WorldRegister.instance.column.remove(location[0], location[1], location[2]);
+                }
+            });
+        });
+    }
+}
+DivineVoxelEngineWorld.environment = Environment.nodeJS.isNode
+    ? "node"
+    : "browser";
+Threads.threadName = "world";

package/Contexts/World/InitWorker.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineWorld } from "./index.js";
+export default function (DVEW: DivineVoxelEngineWorld): Promise<any>;

package/Contexts/World/InitWorker.js

@@ -0,0 +1,35 @@
+import { DivineVoxelEngineWorld } from "./index.js";
+import { Threads } from "@amodx/threads/";
+import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
+import { WorldLock } from "./Lock/WorldLock";
+import { DataLoaderTool } from "../../DataLoader/World/Tools/DataLoaderTool";
+import RegisterDataHooks from "./WorldDataHooks";
+export default function (DVEW) {
+    return new Promise(async (resolve) => {
+        let parent = "render";
+        if (DivineVoxelEngineWorld.environment == "node") {
+            parent = "server";
+        }
+        await Threads.init("world", parent);
+        RegisterDataHooks();
+        WorldLock.init(new DataLoaderTool());
+        await CreatePromiseCheck({
+            check: () => {
+                return DVEW.threads.state.isReady();
+            },
+            checkInterval: 1,
+        });
+        Threads.registerTasks("sync-all-data", async () => {
+            await DVEW.dataSync.init(DVEW);
+            await DVEW.threads.constructors
+                .getThreads()
+                .map((comm) => comm.waitTillTasksExist("ready"));
+            await Promise.all(DVEW.threads.constructors.getThreads().map((comm) => new Promise((resolve) => {
+                comm.runPromiseTasks("ready", [], [], () => {
+                    resolve(true);
+                });
+            })));
+            resolve(true);
+        });
+    });
+}

package/Contexts/World/Lock/WorldLock.d.ts

@@ -0,0 +1,12 @@
+import type { WorldLockTasks } from "../../../Types/Tasks.types";
+import type { LocationData } from "../../../Math";
+import { DataLoaderTool } from "../../../DataLoader/World/Tools/DataLoaderTool.js";
+export declare const WorldLock: {
+    locks: Map<string, WorldLockTasks>;
+    dataLoader: DataLoaderTool;
+    init(dataLoaderTool: DataLoaderTool): void;
+    _loadMap: Map<string, boolean>;
+    addLock(taskData: WorldLockTasks): Promise<unknown>;
+    removeLock(data: WorldLockTasks): void;
+    isLocked([sdim, x, y, z]: LocationData): boolean;
+};