@divinevoxel/vlox 0.0.4 → 0.0.5

package/Cache/Cache.types.d.ts

@@ -1,7 +1,7 @@
 import { CompactMeshData } from "../Mesher/Types/Mesher.types";
 import { TextureData } from "../Textures/Texture.types";
-import { ConstructorVoxelModelSyncData } from "../Voxels/VoxelSyncData";
-export interface CachedVoxelModelData extends ConstructorVoxelModelSyncData {
+import { FinalCompiledVoxelModelData } from "../Voxels/Types/VoxelModelCompiledData.types";
+export interface CachedVoxelModelData extends FinalCompiledVoxelModelData {
 }
 export interface CachedDisplayIndex {
     textures: Record<string, Record<string, string>>;
@@ -11,7 +11,7 @@ export interface CachedDisplayIndex {
     }>>;
 }
 export interface CacheData {
-    models: CachedVoxelModelData;
+    models: FinalCompiledVoxelModelData;
     textures: TextureData[];
     displayIndex: CachedDisplayIndex;
 }

package/Contexts/Base/Main/DataGenerator.types.d.ts

@@ -0,0 +1,5 @@
+import { DataSyncData } from "../Remote/DataSync.types";
+import { InitVoxelDataProps } from "Voxels/InitVoxelData";
+export type DataGeneratorData = {
+    threads: DataSyncData["threads"];
+} & InitVoxelDataProps;

package/Contexts/Base/Main/{Generator/InitDataGenerator.d.ts → InitDataGenerator.d.ts}

@@ -1,3 +1,3 @@
-import { DataSyncData } from "../../Remote/Sync/DataSync.types";
+import { DataSyncData } from "../Remote/DataSync.types";
 import { DataGeneratorData } from "./DataGenerator.types";
 export default function InitDataGenerator(data: DataGeneratorData): DataSyncData;

package/Contexts/Base/Main/InitDataGenerator.js

@@ -0,0 +1,19 @@
+import { InitalizeSectionTags } from "../../../World/Section/SectionStruct.js";
+import { InitalizeSectorTags } from "../../../World/Sector/SectorStruct.js";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+import { Section, Sector } from "../../../World";
+import { InitVoxelData } from "../../../Voxels/InitVoxelData";
+export default function InitDataGenerator(data) {
+    InitalizeSectionTags();
+    InitalizeSectorTags();
+    const voxels = InitVoxelData(data);
+    return {
+        settings: EngineSettings.settings,
+        threads: data.threads,
+        voxels,
+        worldData: {
+            sectionStruct: Section.StateStruct.structData,
+            sectorStruct: Sector.StateStruct.structData,
+        },
+    };
+}

package/Contexts/Base/Remote/DataSync.types.d.ts

@@ -0,0 +1,18 @@
+import { LocationData } from "Math/index.js";
+import { BinaryStructData } from "@amodx/binary";
+import { EngineSettingsData } from "../../../Settings/EngineSettings.types";
+import { CachedVoxelModelData } from "../../../Cache/Cache.types";
+import { CompiledVoxelData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
+export type DataSyncData = {
+    settings: EngineSettingsData;
+    voxels: CompiledVoxelData;
+    modelData?: CachedVoxelModelData;
+    threads: {
+        nexus: boolean;
+    };
+    worldData: {
+        sectionStruct: BinaryStructData;
+        sectorStruct: BinaryStructData;
+    };
+};
+export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];

package/Contexts/Base/Remote/InitDataSync.js

@@ -0,0 +1,42 @@
+import { Threads } from "@amodx/threads/";
+import { VoxelPalette } from "../../../Voxels/Palettes/VoxelPalette";
+import { SubstancePalette } from "../../../Voxels/Palettes/SubstancePalette";
+import { MappedDataRegister } from "../../../Data/Register/MappedDataRegister";
+import { VoxelStruct } from "../../../Voxels/Structs/VoxelStruct";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+//objects
+import { MaterialPalette } from "../../../Voxels/Palettes/MaterialPalette";
+import { Section, Sector } from "../../../World";
+import { SubstanceStruct } from "../../../Voxels/Structs/SubstanceStruct";
+export default function InitDataSync(props) {
+    Threads.registerTask("sync-data", (data) => {
+        EngineSettings.syncSettings(data.settings);
+        MaterialPalette.setPalette(data.voxels.materials.palette);
+        //voxels
+        VoxelPalette.loadIn(data.voxels.data.palette, data.voxels.data.nameToIdMap, data.voxels.data.idToNameMap);
+        const voxelStringMaps = MappedDataRegister.stringMaps.getSegment("voxel");
+        for (const key in data.voxels.data.stringMaps) {
+            voxelStringMaps.add(key, data.voxels.data.stringMaps[key]);
+        }
+        const voxelObjectMaps = MappedDataRegister.objectMaps.getSegment("voxel");
+        for (const key in data.voxels.data.objectMaps) {
+            voxelObjectMaps.add(key, data.voxels.data.objectMaps[key]);
+        }
+        VoxelStruct.init(data.voxels.data.struct);
+        VoxelStruct.sync(data.voxels.data.index);
+        //substances
+        SubstancePalette.setPalette(data.voxels.substances.palette);
+        const substanceStringMaps = MappedDataRegister.stringMaps.getSegment("substance");
+        for (const key in data.voxels.substances.stringMaps) {
+            substanceStringMaps.add(key, data.voxels.substances.stringMaps[key]);
+        }
+        const substanceObjectMaps = MappedDataRegister.objectMaps.getSegment("substance");
+        for (const key in data.voxels.substances.objectMaps) {
+            substanceObjectMaps.add(key, data.voxels.substances.objectMaps[key]);
+        }
+        SubstanceStruct.init(data.voxels.substances.struct);
+        Section.StateStruct.init(data.worldData.sectionStruct);
+        Sector.StateStruct.init(data.worldData.sectorStruct);
+        props.onSync(data);
+    });
+}

package/Contexts/Base/Remote/InitWorldDataSync.js

@@ -0,0 +1,19 @@
+import { Threads } from "@amodx/threads/";
+import { WorldDataSyncIds } from "../../../World/Types/WorldDataSyncIds.js";
+import { WorldRegister } from "../../../World/WorldRegister.js";
+export default function () {
+    Threads.registerTask(WorldDataSyncIds.SyncDimension, (data) => {
+        WorldRegister.dimensions.add(data.id);
+    });
+    Threads.registerTask(WorldDataSyncIds.UnSyncDimension, (data) => {
+        //  register.dimensions.re(data.id);
+    });
+    Threads.registerTask(WorldDataSyncIds.SyncSector, (data) => {
+        WorldRegister.setDimension(data[0][0]);
+        WorldRegister.sectors.add(data[0][1], data[0][2], data[0][3], data[1]);
+    });
+    Threads.registerTask(WorldDataSyncIds.UnSyncSector, (data) => {
+        WorldRegister.setDimension(data[0]);
+        WorldRegister.sectors.remove(data[1], data[2], data[3]);
+    });
+}

package/Contexts/Base/ThreadManager.d.ts

@@ -1,14 +1,9 @@
-import { Thread, ThreadPool, CommPortTypes } from "@amodx/threads";
-import { Pipeline } from "@amodx/core/Pipelines";
+import { Thread, ThreadPool, ThreadPortTypes } from "@amodx/threads";
 export declare abstract class ThreadManager {
-    pipelines: {
-        setPorts: Pipeline<ThreadManager>;
-        init: Pipeline<ThreadManager>;
-    };
-    commMap: Map<string, Thread | ThreadPool>;
-    comms: (Thread | ThreadPool)[];
-    init(): Promise<void>;
-    setThreadPort(id: string, ports: CommPortTypes | CommPortTypes[]): void;
-    addThread(comm: Thread | ThreadPool): void;
+    threadMap: Map<string, Thread | ThreadPool>;
+    _threads: (Thread | ThreadPool)[];
+    constructor();
+    setThreadPort(id: string, ports: ThreadPortTypes | ThreadPortTypes[]): void;
+    addThread(thread: Thread | ThreadPool): void;
     getThread(id: string): Thread | ThreadPool;
 }

package/Contexts/Base/ThreadManager.js

@@ -1,42 +1,43 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { Pipeline } from "@amodx/core/Pipelines";
 export class ThreadManager {
-    pipelines = {
-        setPorts: new Pipeline(),
-        init: new Pipeline(),
-    };
-    commMap = new Map();
-    comms = [];
-    async init() {
-        await this.pipelines.init.pipe(this);
+    threadMap = new Map();
+    _threads = [];
+    constructor() {
+        self.addEventListener("beforeunload", () => {
+            for (const thread of this._threads) {
+                if (thread instanceof ThreadPool) {
+                    thread.destroyAll();
+                }
+                if (thread instanceof Thread) {
+                    thread.destroy();
+                }
+            }
+        });
     }
     setThreadPort(id, ports) {
-        const comm = this.getThread(id);
-        let error;
-        if (Array.isArray(ports) && comm instanceof ThreadPool) {
-            comm.addPorts(ports);
+        const thread = this.getThread(id);
+        if (thread instanceof ThreadPool) {
+            if (!Array.isArray(ports))
+                throw new Error("Thread is a pool and needs an array of ports");
+            for (const port of ports) {
+                thread.addPort(port);
+            }
             return;
         }
-        else
-            error =
-                "Comm is an instance of comm manager and the passed in ports was not an array.";
-        if (!Array.isArray(ports) && comm instanceof Thread) {
-            comm.setPort(ports);
-            return;
+        if (thread instanceof Thread) {
+            if (Array.isArray(ports))
+                throw new Error("Thread is a single thread and needs one port.");
+            thread.setPort(ports);
         }
-        else
-            error =
-                "Comm is an instance of comm base and the passed in ports was an array.";
-        throw new Error(error);
     }
-    addThread(comm) {
-        this.commMap.set(comm.name, comm);
-        this.comms.push(comm);
+    addThread(thread) {
+        this.threadMap.set(thread.name, thread);
+        this._threads.push(thread);
     }
     getThread(id) {
-        const comm = this.commMap.get(id);
-        if (!comm)
-            throw new Error(`Comm with id ${id} does not exists`);
-        return comm;
+        const thread = this.threadMap.get(id);
+        if (!thread)
+            throw new Error(`Thread with id ${id} does not exists`);
+        return thread;
     }
 }

package/Contexts/Constructor/DivineVoxelEngineConstructor.d.ts

@@ -1,12 +1,10 @@
 import { Threads } from "@amodx/threads/";
 import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
-import { DVEMesher } from "../../Mesher/Mesher.js";
 export type DivineVoxelEngineConstructorInitData = {};
 export declare class DivineVoxelEngineConstructor {
     static environment: "node" | "browser";
     static instance: DivineVoxelEngineConstructor;
     TC: typeof Threads;
     threads: ConstructorThreadManager;
-    mesher: DVEMesher;
     constructor();
 }

package/Contexts/Constructor/DivineVoxelEngineConstructor.js

@@ -1,13 +1,11 @@
 //threadcomm
 import { Threads } from "@amodx/threads/";
 import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
-import { DVEMesher } from "../../Mesher/Mesher.js";
 export class DivineVoxelEngineConstructor {
     static environment = "browser";
     static instance;
     TC = Threads;
     threads = new ConstructorThreadManager();
-    mesher = new DVEMesher();
     constructor() {
         if (DivineVoxelEngineConstructor.instance)
             return DivineVoxelEngineConstructor.instance;

package/Contexts/Nexus/DivineVoxelEngineNexus.d.ts

@@ -1,5 +1,4 @@
 import { Threads } from "@amodx/threads/";
-import { DataTool } from "../../Tools/Data/DataTool.js";
 import { NexusThreads } from "./NexusTheads.js";
 export declare class DivineVoxelEngineNexus {
     static environment: "node" | "browser";
@@ -7,5 +6,4 @@ export declare class DivineVoxelEngineNexus {
     TC: typeof Threads;
     threads: NexusThreads;
     constructor(data: {});
-    getDataTool(): DataTool;
 }

package/Contexts/Nexus/DivineVoxelEngineNexus.js

@@ -1,7 +1,4 @@
-//intercomms
-//functions
 import { Threads } from "@amodx/threads/";
-import { DataTool } from "../../Tools/Data/DataTool.js";
 import { NexusThreads } from "./NexusTheads.js";
 export class DivineVoxelEngineNexus {
     static environment = "browser";
@@ -13,7 +10,4 @@ export class DivineVoxelEngineNexus {
             return DivineVoxelEngineNexus.instance;
         DivineVoxelEngineNexus.instance = this;
     }
-    getDataTool() {
-        return new DataTool();
-    }
 }

package/Contexts/Nexus/NexusTheads.js

@@ -8,8 +8,5 @@ export class NexusThreads extends ThreadManager {
     world = Threads.createThread("world");
     NexusComm = Threads.createThread("nexus");
     DataComm = Threads.createThread("data-loader");
-    ConstructorComm = Threads.createThreadPool({
-        name: "constructor",
-        onPortSet() { },
-    });
+    ConstructorComm = Threads.createThreadPool("constructor");
 }

package/Contexts/Render/DVERenderThreads.d.ts

@@ -1,9 +1,6 @@
 import { ThreadManager } from "../Base/ThreadManager";
 export declare class DVERenderThreads extends ThreadManager {
     nexus: import("@amodx/threads").Thread;
-    richWorld: import("@amodx/threads").Thread;
-    dataLoader: import("@amodx/threads").Thread;
-    state: any;
     construcotrs: import("@amodx/threads").ThreadPool;
     parent: import("@amodx/threads").Thread;
     world: import("@amodx/threads").Thread;

package/Contexts/Render/DVERenderThreads.js

@@ -2,13 +2,7 @@ import { Threads } from "@amodx/threads";
 import { ThreadManager } from "../Base/ThreadManager";
 export class DVERenderThreads extends ThreadManager {
     nexus = Threads.createThread("nexus");
-    richWorld = Threads.createThread("rich-world");
-    dataLoader = Threads.createThread("data-loader");
-    state = {};
-    construcotrs = Threads.createThreadPool({
-        name: "constructor",
-        onPortSet(port, commName) { },
-    });
+    construcotrs = Threads.createThreadPool("constructor");
     parent = Threads.parent;
     world = Threads.createThread("world");
     constructor() {

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -1,4 +1,3 @@
-import { EngineSettings } from "../../Settings/EngineSettings.js";
 import { Threads } from "@amodx/threads/";
 import type { EngineSettingsData } from "../../Settings/EngineSettings.types.js";
 import type { RecursivePartial } from "../../Util/Util.types.js";
@@ -17,17 +16,37 @@ export declare class DivineVoxelEngineRender {
     static instance: DivineVoxelEngineRender;
     static initialized: boolean;
     TC: typeof Threads;
-    settings: typeof EngineSettings;
+    settings: {
+        enviorment: "node" | "browser";
+        settings: EngineSettingsData;
+        getSettings(): EngineSettingsData;
+        syncSettings(data: EngineSettingsData): void;
+        getSettingsCopy(): any;
+        doSunPropagation(): boolean;
+        doRGBPropagation(): boolean;
+        doLight(): boolean;
+        doFlow(): boolean;
+        isClient(): boolean;
+        addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null, options?: AddEventListenerOptions): void;
+        removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null): void;
+        dispatch<K extends "synced">(type: K, detail: {
+            synced: {
+                settings: any;
+            };
+        }[K]): boolean;
+        dispatchEvent(event: Event): boolean;
+    };
     meshManager: typeof MeshManager;
     meshRegister: typeof MeshRegister;
     renderer: DVERenderer;
-    tasks: {
-        setChunk: void;
-        removeChunk: void;
-        removeColumn: void;
-        clearAll: void;
-        removeColumnsOutsideRadius: void;
-    };
     threads: DVERenderThreads;
     constructor();
     /**# clearAll

package/Contexts/Render/DivineVoxelEngineRender.js

@@ -1,6 +1,5 @@
 //objects
 import { EngineSettings } from "../../Settings/EngineSettings.js";
-import { RenderTasks } from "./Tasks/RenderTasks.js";
 import { Threads } from "@amodx/threads/";
 import { MeshManager } from "../../Renderer/MeshManager.js";
 import { MeshRegister } from "../../Renderer/MeshRegister.js";
@@ -13,7 +12,6 @@ export class DivineVoxelEngineRender {
     meshManager = MeshManager;
     meshRegister = MeshRegister;
     renderer;
-    tasks = RenderTasks;
     threads = new DVERenderThreads();
     constructor() {
         if (DivineVoxelEngineRender.instance)
@@ -26,9 +24,9 @@ export class DivineVoxelEngineRender {
      */
     async clearAll() {
         this.meshRegister.clearAll();
-        await this.threads.world.runAsyncTasks("clear-all", "", []);
+        await this.threads.world.runTaskAsync("clear-all", "");
         await Promise.all(this.threads.construcotrs
             .getThreads()
-            .map((_) => _.runAsyncTasks("clear-all", "")));
+            .map((_) => _.runTaskAsync("clear-all", "")));
     }
 }

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -1,10 +1,5 @@
-import { EngineSettings } from "../../Settings/EngineSettings.js";
 import { Threads } from "@amodx/threads/";
 import { WorldThreadManager } from "./WorldThreads.js";
-import { DVEConstructorTasksQueues } from "../Constructor/Tasks/DVEConstructorTasksQueues.js";
-import { WorldTasks } from "./Tasks/WorldTasks";
-import { LocationData } from "../../Math";
-import { DataSync } from "./Data/DataSync.js";
 /**# Divine Voxel Engine World
  * ---
  * This handles everything in the world worker context.
@@ -13,11 +8,34 @@ export declare class DivineVoxelEngineWorld {
     static environment: "node" | "browser";
     static instance: DivineVoxelEngineWorld;
     TC: typeof Threads;
-    settings: typeof EngineSettings;
+    settings: {
+        enviorment: "node" | "browser";
+        settings: import("../../Settings/EngineSettings.types.js").EngineSettingsData;
+        getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
+        syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
+        getSettingsCopy(): any;
+        doSunPropagation(): boolean;
+        doRGBPropagation(): boolean;
+        doLight(): boolean;
+        doFlow(): boolean;
+        isClient(): boolean;
+        addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null, options?: AddEventListenerOptions): void;
+        removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null): void;
+        dispatch<K extends "synced">(type: K, detail: {
+            synced: {
+                settings: any;
+            };
+        }[K]): boolean;
+        dispatchEvent(event: Event): boolean;
+    };
     threads: WorldThreadManager;
-    dataSync: DataSync;
-    queues: DVEConstructorTasksQueues;
-    tasks: WorldTasks;
     constructor();
-    removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
 }

package/Contexts/World/DivineVoxelEngineWorld.js

@@ -3,11 +3,6 @@ import { EngineSettings } from "../../Settings/EngineSettings.js";
 //functions
 import { Threads } from "@amodx/threads/";
 import { WorldThreadManager } from "./WorldThreads.js";
-import { DVEConstructorTasksQueues } from "../Constructor/Tasks/DVEConstructorTasksQueues.js";
-import { WorldTasks } from "./Tasks/WorldTasks";
-import { Distance3D } from "@amodx/math";
-import { WorldRegister } from "../../Data/World/WorldRegister";
-import { DataSync } from "./Data/DataSync.js";
 /**# Divine Voxel Engine World
  * ---
  * This handles everything in the world worker context.
@@ -18,30 +13,9 @@ export class DivineVoxelEngineWorld {
     TC = Threads;
     settings = EngineSettings;
     threads = new WorldThreadManager();
-    dataSync = new DataSync();
-    queues = new DVEConstructorTasksQueues(this.threads.constructors);
-    tasks = new WorldTasks(this);
     constructor() {
         if (DivineVoxelEngineWorld.instance)
             return DivineVoxelEngineWorld.instance;
         DivineVoxelEngineWorld.instance = 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]);
-                }
-            });
-        });
-    }
 }

package/Contexts/World/WorldThreads.d.ts

@@ -1,7 +1,6 @@
-import { ThreadPool } from "@amodx/threads/";
 import { ThreadManager } from "../Base/ThreadManager.js";
 export declare class WorldThreadManager extends ThreadManager {
-    constructors: ThreadPool;
+    constructors: import("@amodx/threads/").ThreadPool;
     parent: import("@amodx/threads/").Thread;
     nexus: import("@amodx/threads/").Thread;
     constructor();

package/Contexts/World/WorldThreads.js

@@ -1,10 +1,7 @@
 import { Threads } from "@amodx/threads/";
 import { ThreadManager } from "../Base/ThreadManager.js";
 export class WorldThreadManager extends ThreadManager {
-    constructors = Threads.createThreadPool({
-        name: "constructor",
-        onPortSet(port, commName) { },
-    });
+    constructors = Threads.createThreadPool("constructor");
     parent = Threads.parent;
     nexus = Threads.createThread("nexus");
     constructor() {

package/Data/Cursor/{Interfaces/DataCursor.interface.d.ts → DataCursor.interface.d.ts}

@@ -1,4 +1,4 @@
-import { VoxelCursorInterface } from "./VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export declare abstract class DataCursorInterface {
     abstract getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
     abstract inBounds(x: number, y: number, z: number): boolean;

package/Data/Structs/{Builder/StructBuilder.d.ts → StructBuilder.d.ts}

@@ -1,7 +1,6 @@
-import type { TagBuilderNodes } from "Data/Types/StructBuilder.types.js";
+import type { TagBuilderNodes } from "Data/Structs/StructBuilder.types.js";
 import { BinaryStructData, BinraryStructBase } from "@amodx/binary/";
 import { BinaryStruct } from "@amodx/binary/";
-import { DataSyncMapsData } from "../../../Contexts/Base/Remote/Sync/DataSync.types";
 export declare class StructBuilder {
     id: string;
     dataSegment: string;
@@ -28,5 +27,8 @@ export declare class StructBuilder {
     hasNode(id: string): boolean;
     setNode(id: string, value: any, tagManager: BinraryStructBase): false | undefined;
     build(totalTagIndexes?: number): BinaryStruct;
-    getMaps(): DataSyncMapsData;
+    getMaps(): {
+        objectMaps: Record<string, any[]>;
+        stringMaps: Record<string, string[]>;
+    };
 }

package/Init/StartConstructor.js

@@ -1,50 +1,54 @@
-import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
 import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
 import { Threads } from "@amodx/threads";
-import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck";
 import { VoxelGeometryLookUp } from "../Mesher/Models/VoxelGeometryLookUp";
-import { Environment } from "@amodx/core/Environment/Environment";
-import { WorldRegister } from "../Data/World/WorldRegister";
-import InitAnalyzerTasks from "../Tasks/Analyzer/InitTasks";
+import { Environment } from "../Util/Environment";
+import { WorldRegister } from "../World/WorldRegister";
 import InitUpdateTasks from "../Tasks/Update/InitTasks";
 import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
-import InitMesherTasks from "../Tasks/Mesher/InitTasks";
+import InitMesherTasks from "../Mesher/InitTask";
 import InitWorldGenerationTasks from "../Tasks/WorldGeneration/InitTasks";
-import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
+import InitMesher from "../Mesher/InitMesher";
+import InitArchiveTasks from "../World/Archive/InitTasks";
 export async function StartContrusctor(data = {}) {
     const DVEC = new DivineVoxelEngineConstructor();
-    DivineVoxelEngineConstructor.environment = Environment.nodeJS.isNode
+    DivineVoxelEngineConstructor.environment = Environment.isNode()
         ? "node"
         : "browser";
     let parent = "render";
     if (DivineVoxelEngineConstructor.environment == "node") {
         parent = "server";
     }
-    await Threads.init("constructor", parent);
+    await Threads.init("constructor", self, parent);
     let ready = false;
     VoxelGeometryLookUp.init();
     InitDataSync({
         onSync(data) {
-            DVEC.mesher.init(data);
+            InitMesher(data.voxels.materials.palette, data.voxels.models);
             ready = true;
         },
     });
-    Threads.registerTasks("clear-all", () => {
-        WorldRegister.instance.clearAll();
+    Threads.registerTask("clear-all", () => {
+        WorldRegister.clearAll();
     });
-    await CreatePromiseCheck({
-        check: () => ready,
-        checkInterval: 1,
+    await new Promise((resolve) => {
+        const readyCheck = () => {
+            if (ready)
+                return resolve(true);
+            setTimeout(readyCheck, 10);
+        };
+        readyCheck();
     });
+    InitArchiveTasks({ worldThread: DVEC.threads.world });
     InitWorldDataSync();
-    InitAnalyzerTasks();
     InitPropagationTasks();
-    InitMesherTasks(DVEC.mesher);
+    InitMesherTasks(DVEC.threads.parent);
     InitUpdateTasks({
         onDone(tasks) {
-            DVEC.threads.world.runTasks("build-queue", [
+            DVEC.threads.world.runTask("build-queue", [
                 tasks.origin[0],
-                tasks.bounds.getChunks(),
+                tasks.bounds.getSections(),
             ]);
         },
     });