@divinevoxel/vlox 0.0.73 → 0.0.75

package/Tasks/IWG/Internal/Classes/BuildQueue.js

@@ -1,49 +0,0 @@
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-export class BuildQueue {
-    tasks;
-    hash = new Set();
-    sections = [];
-    constructor(tasks) {
-        this.tasks = tasks;
-    }
-    add(data) {
-        const key = WorldSpaces.hash.hashXYZ(data[1], data[2], data[3]);
-        if (this.hash.has(key))
-            return false;
-        this.hash.add(key);
-        this.sections.push(data);
-    }
-    sort(x, y, z) {
-        const sections = this.sections;
-        const sx = x, sy = y, sz = z;
-        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
-        while (i > 1) {
-            for (j = 1; j < i; j++) {
-                (ax = sections[j - 1][1]),
-                    (ay = sections[j - 1][2]),
-                    (az = sections[j - 1][3]);
-                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
-                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
-                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
-                if (distA > distB) {
-                    temp = sections[j - 1];
-                    sections[j - 1] = sections[j];
-                    sections[j] = temp;
-                }
-            }
-            i--;
-        }
-    }
-    run(limit = 25) {
-        let count = 0;
-        while (this.sections.length) {
-            const vec = this.sections.shift();
-            const [dimension, x, y, z] = vec;
-            this.tasks.build.section.run([dimension, x, y, z]);
-            this.hash.delete(WorldSpaces.hash.hashXYZ(x, y, z));
-            count++;
-            if (count > limit)
-                break;
-        }
-    }
-}

package/Tasks/IWG/Internal/Classes/DimensionSegment.d.ts

@@ -1,37 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { SectorVisistedMap } from "./SectorVisistedMap";
-import { Sector } from "World";
-declare class TaskSegment {
-    queue: number[];
-    vistedMap: SectorVisistedMap;
-    waitingFor: number;
-    clear(): void;
-}
-declare class SecotrQueueNode {
-    position: Vec3Array;
-    time: number;
-    constructor(position: Vec3Array);
-}
-declare class SectorQueue {
-    nodes: SecotrQueueNode[];
-    private addedMap;
-    removeIndex(index: number): void;
-    inMap(sector: Sector): boolean;
-    addSector(sector: Sector): void;
-}
-export declare class DimensionSegment {
-    id: string;
-    tasks: Map<string, TaskSegment>;
-    queue: number[];
-    vistedMap: SectorVisistedMap;
-    rendered: SectorVisistedMap;
-    inProgress: SectorVisistedMap;
-    unRenderQueue: SectorQueue;
-    unLoadQueue: SectorQueue;
-    constructor(id: string);
-    addTask(id: string): void;
-    getTask(id: string): TaskSegment;
-    clearAllTasks(): void;
-    logTasks(): string;
-}
-export {};

package/Tasks/IWG/Internal/Classes/DimensionSegment.js

@@ -1,67 +0,0 @@
-import { SectorVisistedMap } from "./SectorVisistedMap";
-class TaskSegment {
-    queue = [];
-    vistedMap = new SectorVisistedMap();
-    waitingFor = 0;
-    clear() {
-        this.waitingFor = 0;
-        this.queue.length = 0;
-        this.vistedMap.clear();
-    }
-}
-class SecotrQueueNode {
-    position;
-    time = 0;
-    constructor(position) {
-        this.position = position;
-    }
-}
-class SectorQueue {
-    nodes = [];
-    addedMap = new SectorVisistedMap();
-    removeIndex(index) {
-        const sector = this.nodes.splice(index, 1)[0];
-        this.addedMap.remove(...sector.position);
-    }
-    inMap(sector) {
-        return this.addedMap.has(...sector.position);
-    }
-    addSector(sector) {
-        this.addedMap.add(...sector.position);
-        this.nodes.push(new SecotrQueueNode([...sector.position]));
-    }
-}
-export class DimensionSegment {
-    id;
-    tasks = new Map();
-    queue = [];
-    vistedMap = new SectorVisistedMap();
-    rendered = new SectorVisistedMap();
-    inProgress = new SectorVisistedMap();
-    unRenderQueue = new SectorQueue();
-    unLoadQueue = new SectorQueue();
-    constructor(id) {
-        this.id = id;
-    }
-    addTask(id) {
-        this.tasks.set(id, new TaskSegment());
-    }
-    getTask(id) {
-        const task = this.tasks.get(id);
-        if (!task)
-            throw new Error(`Task with id [${id}] not registered in dimension segment ${this.id}`);
-        return task;
-    }
-    clearAllTasks() {
-        for (const [key, task] of this.tasks) {
-            task.clear();
-        }
-    }
-    logTasks() {
-        const tasks = [];
-        for (const [key, task] of this.tasks) {
-            tasks.push(`${key} | ${task.waitingFor}`);
-        }
-        return tasks.join("\n");
-    }
-}

package/Tasks/IWG/Internal/Classes/IWGTaskBase.d.ts

@@ -1,15 +0,0 @@
-import { LocationData } from "../../../../Math/index.js";
-import { DimensionSegment } from "./DimensionSegment.js";
-export type IWGTasksData = {
-    id: string;
-    propagationBlocking?: boolean;
-    run(location: LocationData, onDone: () => void, dimension: DimensionSegment): void;
-};
-export declare class IWGTaskBase {
-    data: IWGTasksData;
-    constructor(data: IWGTasksData);
-    add(dimensionId: string, x: number, y: number, z: number): void;
-    remove(dimensionId: string, x: number, y: number, z: number): void;
-    cancelAll(dimensionId?: string | null): void;
-    runTask(max?: number): void;
-}

package/Tasks/IWG/Internal/Classes/IWGTaskBase.js

@@ -1,62 +0,0 @@
-import { IWGDimensions } from "../../Internal/IWGDimensions.js";
-export class IWGTaskBase {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    add(dimensionId, x, y, z) {
-        const dimension = IWGDimensions.getDimension(dimensionId);
-        const task = dimension.getTask(this.data.id);
-        if (task.vistedMap.has(x, y, z))
-            return;
-        if (this.data.propagationBlocking && dimension.inProgress.has(x, y, z))
-            return;
-        task.queue.push(x, y, z);
-        task.vistedMap.add(x, y, z);
-    }
-    remove(dimensionId, x, y, z) {
-        const dimension = IWGDimensions.getDimension(dimensionId);
-        const task = dimension.getTask(this.data.id);
-        task.vistedMap.remove(x, y, z);
-        if (this.data.propagationBlocking) {
-            dimension.inProgress.remove(x, y, z);
-        }
-    }
-    cancelAll(dimensionId = null) {
-        if (dimensionId) {
-            const dimension = IWGDimensions.getDimension(dimensionId);
-            const task = dimension.getTask(this.data.id);
-            task.clear();
-        }
-        else {
-            for (const [key, dimension] of IWGDimensions._dimensions) {
-                dimension.clearAllTasks();
-            }
-        }
-    }
-    runTask(max = 1000) {
-        for (const [key, dimension] of IWGDimensions._dimensions) {
-            const task = dimension.getTask(this.data.id);
-            if (task.waitingFor < 0)
-                task.waitingFor = 0;
-            if (task.waitingFor >= max)
-                continue;
-            while (task.waitingFor < max && task.queue.length) {
-                const x = task.queue.shift();
-                const y = task.queue.shift();
-                const z = task.queue.shift();
-                task.waitingFor++;
-                if (this.data.propagationBlocking) {
-                    dimension.inProgress.add(x, y, z);
-                }
-                this.data.run([dimension.id, x, y, z], () => {
-                    task.vistedMap.remove(x, y, z);
-                    if (this.data.propagationBlocking) {
-                        dimension.inProgress.remove(x, y, z);
-                    }
-                    task.waitingFor--;
-                }, dimension);
-            }
-        }
-    }
-}

package/Tasks/IWG/Internal/Classes/SectorState.js

@@ -1,20 +0,0 @@
-export class SectorState {
-    isLoaded = true;
-    isGenerated = true;
-    genAlldone = true;
-    allLoaded = true;
-    nWorldGenAllDone = true;
-    nDecorAllDone = true;
-    nSunAllDone = true;
-    nPropagtionAllDone = true;
-    resset() {
-        this.isLoaded = true;
-        this.isGenerated = true;
-        this.genAlldone = true;
-        this.allLoaded = true;
-        this.nWorldGenAllDone = true;
-        this.nDecorAllDone = true;
-        this.nSunAllDone = true;
-        this.nPropagtionAllDone = true;
-    }
-}

package/Tasks/IWG/Internal/Classes/SectorVisistedMap.d.ts

@@ -1,9 +0,0 @@
-export declare class SectorVisistedMap {
-    _map: Set<string>;
-    get size(): number;
-    _getKey(x: number, y: number, z: number): string;
-    has(x: number, y: number, z: number): boolean;
-    add(x: number, y: number, z: number): void;
-    remove(x: number, y: number, z: number): void;
-    clear(): void;
-}

package/Tasks/IWG/Internal/Classes/SectorVisistedMap.js

@@ -1,24 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-const tempPosition = Vector3Like.Create();
-export class SectorVisistedMap {
-    _map = new Set();
-    get size() {
-        return this._map.size;
-    }
-    _getKey(x, y, z) {
-        return WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
-    }
-    has(x, y, z) {
-        return this._map.has(this._getKey(x, y, z));
-    }
-    add(x, y, z) {
-        this._map.add(this._getKey(x, y, z));
-    }
-    remove(x, y, z) {
-        this._map.delete(this._getKey(x, y, z));
-    }
-    clear() {
-        this._map.clear();
-    }
-}

package/Tasks/IWG/Internal/Functions/cullSectors.d.ts

@@ -1,2 +0,0 @@
-import { Generator } from "../Classes/Generator";
-export declare function cullSectors(generatos: Generator[], cullGenerators: Generator[]): void;

package/Tasks/IWG/Internal/Functions/cullSectors.js

@@ -1,111 +0,0 @@
-import { Circle, Square } from "@amodx/math";
-import { IWGDimensions } from "../IWGDimensions";
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { IWGTools } from "../IWGTools";
-import { WorldLock } from "../../../../World/Lock/WorldLock";
-const sectorSquare = new Square();
-export function cullSectors(generatos, cullGenerators) {
-    const time = performance.now();
-    for (const [, dimension] of IWGDimensions._dimensions) {
-        for (let i = dimension.unRenderQueue.nodes.length - 1; i > -1; i--) {
-            const node = dimension.unRenderQueue.nodes[i];
-            const [cx, cy, cz] = node.position;
-            sectorSquare.center.x =
-                node.position[0] + WorldSpaces.sector.bounds.x / 2;
-            sectorSquare.center.y =
-                node.position[2] + WorldSpaces.sector.bounds.z / 2;
-            let inRenderCircle = false;
-            for (const gen of generatos) {
-                if (gen._dimension != dimension.id)
-                    continue;
-                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._renderCircle)) {
-                    inRenderCircle = true;
-                }
-            }
-            if (inRenderCircle) {
-                dimension.unRenderQueue.removeIndex(i);
-                continue;
-            }
-            const delta = time - node.time;
-            if (delta > 5_000) {
-                dimension.rendered.remove(cx, cy, cz);
-                dimension.inProgress.add(cx, cy, cz);
-                IWGTools.parent
-                    .runTaskAsync("remove-sector", [dimension.id, cx, cy, cz])
-                    .then(() => {
-                    dimension.inProgress.remove(cx, cy, cz);
-                });
-                dimension.unRenderQueue.removeIndex(i);
-            }
-        }
-        for (let i = dimension.unLoadQueue.nodes.length - 1; i > -1; i--) {
-            const node = dimension.unLoadQueue.nodes[i];
-            const [cx, cy, cz] = node.position;
-            sectorSquare.center.x =
-                node.position[0] + WorldSpaces.sector.bounds.x / 2;
-            sectorSquare.center.y =
-                node.position[2] + WorldSpaces.sector.bounds.z / 2;
-            let inMaxCircle = false;
-            for (const gen of generatos) {
-                if (gen._dimension != dimension.id)
-                    continue;
-                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._maxCircle)) {
-                    inMaxCircle = true;
-                }
-            }
-            if (inMaxCircle) {
-                dimension.unLoadQueue.removeIndex(i);
-                continue;
-            }
-            const delta = time - node.time;
-            if (delta > 5_000) {
-                dimension.unLoadQueue.removeIndex(i);
-                if (IWGTools.worldStorage) {
-                    dimension.inProgress.add(cx, cy, cz);
-                    IWGTools.worldStorage
-                        .unloadSector([dimension.id, cx, cy, cz])
-                        .finally(() => {
-                        dimension.inProgress.remove(cx, cy, cz);
-                    });
-                }
-                else {
-                    WorldRegister.sectors.remove(dimension.id, cx, cy, cz);
-                }
-            }
-        }
-        if (!cullGenerators.length)
-            continue;
-        const worldDimension = WorldRegister.dimensions.get(dimension.id);
-        for (const [, sector] of worldDimension.sectors) {
-            const [cx, cy, cz] = sector.position;
-            sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
-            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
-            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
-            let inRenderCircle = false;
-            let inMaxCircle = false;
-            if (WorldLock.isLocked([dimension.id, cx, cy, cz]))
-                continue;
-            if (dimension.inProgress.has(cx, cy, cz))
-                continue;
-            for (const gen of cullGenerators) {
-                if (gen._dimension != dimension.id)
-                    continue;
-                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._renderCircle)) {
-                    inRenderCircle = true;
-                }
-                if (Circle.IsSquareInsideOrTouchingCircle(sectorSquare, gen._maxCircle)) {
-                    inMaxCircle = true;
-                }
-            }
-            if (inRenderCircle && inMaxCircle)
-                continue;
-            if (!inRenderCircle && !dimension.unRenderQueue.inMap(sector)) {
-                dimension.unRenderQueue.addSector(sector);
-            }
-            if (!inMaxCircle && !dimension.unLoadQueue.inMap(sector)) {
-                dimension.unLoadQueue.addSector(sector);
-            }
-        }
-    }
-}

package/Tasks/IWG/Internal/Functions/getSectorState.d.ts

@@ -1,4 +0,0 @@
-import { SectorState } from "../Classes/SectorState";
-import { Sector } from "../../../../World/index";
-import { DimensionSegment } from "../Classes/DimensionSegment";
-export declare function getSectorState(sector: Sector, state: SectorState, segment: DimensionSegment): SectorState;

package/Tasks/IWG/Internal/Functions/getSectorState.js

@@ -1,39 +0,0 @@
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { $2dMooreNeighborhood } from "../../../../Math/CardinalNeighbors";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { Sector } from "../../../../World/index";
-import { Vector3Like } from "@amodx/math";
-const tempPosition = Vector3Like.Create();
-export function getSectorState(sector, state, segment) {
-    state.resset();
-    const [cx, cy, cz] = sector.position;
-    for (let i = 0; i < $2dMooreNeighborhood.length; i++) {
-        const sectorPOS = WorldSpaces.sector.getPosition(cx + $2dMooreNeighborhood[i][0] * WorldSpaces.sector.bounds.x, cy, cz + $2dMooreNeighborhood[i][1] * WorldSpaces.sector.bounds.z, tempPosition);
-        if (!segment.vistedMap.has(sectorPOS.x, cy, sectorPOS.z)) {
-            segment.queue.push(sectorPOS.x, cy, sectorPOS.z);
-        }
-        const sector = WorldRegister.sectors.get(segment.id, sectorPOS.x, cy, sectorPOS.z);
-        if (!sector) {
-            state.genAlldone = false;
-            state.nWorldGenAllDone = false;
-            state.nPropagtionAllDone = false;
-            state.nSunAllDone = false;
-            state.nDecorAllDone = false;
-            state.allLoaded = false;
-            break;
-        }
-        if (!sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
-            state.nWorldGenAllDone = false;
-        }
-        if (!sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
-            state.nDecorAllDone = false;
-        }
-        if (!sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
-            state.nSunAllDone = false;
-        }
-        if (!sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
-            state.nPropagtionAllDone = false;
-        }
-    }
-    return state;
-}

package/Tasks/IWG/Internal/Functions/runBuildUpdate.d.ts

@@ -1,2 +0,0 @@
-import { Generator } from "../Classes/Generator";
-export declare function runBuildUpdate(generators: Generator[]): void;

package/Tasks/IWG/Internal/Functions/runBuildUpdate.js

@@ -1,70 +0,0 @@
-import { Circle, Square } from "@amodx/math";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { SectorState } from "../Classes/SectorState";
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { getSectorState } from "./getSectorState";
-import { IWGDimensions } from "../IWGDimensions";
-const stateCursor = new SectorState();
-const sectorSquare = new Square();
-function run(dimenion, sector, location, generator) {
-    let rendered = true;
-    if (!dimenion.rendered.has(location[1], location[2], location[3])) {
-        rendered = false;
-        dimenion.rendered.add(location[1], location[2], location[3]);
-    }
-    for (const section of sector.getRenerableSections()) {
-        if (rendered && (section.isInProgress() || !section.isDirty()))
-            continue;
-        section.setInProgress(true);
-        generator.buildQueue.add([
-            location[0],
-            ...section.getPosition(),
-        ]);
-    }
-}
-export function runBuildUpdate(generators) {
-    for (const generator of generators) {
-        if (!generator._building)
-            continue;
-        const segment = IWGDimensions._dimensions.get(generator._dimension);
-        if (!segment)
-            throw new Error(`No segment for dimensions ${generator._dimension} found.`);
-        const queue = segment.queue;
-        const visitedMap = segment.vistedMap;
-        const sectorPosition = generator._sectorPosition;
-        queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
-        generator._renderCircle.center.x = sectorPosition.x;
-        generator._renderCircle.center.y = sectorPosition.z;
-        while (queue.length) {
-            const cx = queue.shift();
-            const cy = queue.shift();
-            const cz = queue.shift();
-            if (visitedMap.has(cx, cy, cz))
-                continue;
-            visitedMap.add(cx, cy, cz);
-            sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
-            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
-            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
-            if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._renderCircle))
-                continue;
-            const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
-            if (!sector)
-                continue;
-            const state = getSectorState(sector, stateCursor, segment);
-            if (state.nWorldGenAllDone &&
-                state.nSunAllDone &&
-                state.nPropagtionAllDone) {
-                if (sector.anySectionDirty()) {
-                    run(segment, sector, [generator._dimension, cx, cy, cz], generator);
-                    continue;
-                }
-                if (segment.rendered.has(cx, cy, cz))
-                    continue;
-                run(segment, sector, [generator._dimension, cx, cy, cz], generator);
-            }
-        }
-    }
-    for (const [, dimension] of IWGDimensions._dimensions) {
-        dimension.vistedMap.clear();
-    }
-}

package/Tasks/IWG/Internal/Functions/runWorldUpdate.d.ts

@@ -1,2 +0,0 @@
-import { Generator } from "../Classes/Generator";
-export declare function runWorldUpdate(generators: Generator[]): void;

package/Tasks/IWG/Internal/Functions/runWorldUpdate.js

@@ -1,69 +0,0 @@
-import { Circle, Square } from "@amodx/math";
-import { getSectorState } from "./getSectorState";
-import { SectorState } from "../Classes/SectorState";
-import { WorldRegister } from "../../../../World/WorldRegister";
-import { Sector } from "../../../../World";
-import { WorldLock } from "../../../../World/Lock/WorldLock";
-import { IWGTasks } from "../IWGTasks";
-import { IWGDimensions } from "../IWGDimensions";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-const stateCursor = new SectorState();
-const sectorSquare = new Square();
-export function runWorldUpdate(generators) {
-    for (const generator of generators) {
-        const segment = IWGDimensions._dimensions.get(generator._dimension);
-        if (!segment)
-            throw new Error(`No segment for dimensions ${generator._dimension} found.`);
-        const queue = segment.queue;
-        const vistedMap = segment.vistedMap;
-        const sectorPosition = generator._sectorPosition;
-        queue.push(sectorPosition.x, sectorPosition.y, sectorPosition.z);
-        generator._genCircle.center.x = sectorPosition.x;
-        generator._genCircle.center.y = sectorPosition.z;
-        while (queue.length) {
-            const cx = queue.shift();
-            const cy = queue.shift();
-            const cz = queue.shift();
-            if (WorldLock.isLocked([generator._dimension, cx, cy, cz]) ||
-                segment.inProgress.has(cx, cy, cz) ||
-                vistedMap.has(cx, cy, cz))
-                continue;
-            vistedMap.add(cx, cy, cz);
-            sectorSquare.sideLength = WorldSpaces.sector.bounds.x;
-            sectorSquare.center.x = cx + WorldSpaces.sector.bounds.x / 2;
-            sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
-            if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._genCircle))
-                continue;
-            const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
-            if (!sector) {
-                IWGTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
-                continue;
-            }
-            const state = getSectorState(sector, stateCursor, segment);
-            sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
-            if (state.allLoaded &&
-                !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
-                IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
-                continue;
-            }
-            if (state.nWorldGenAllDone &&
-                !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
-                IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
-                continue;
-            }
-            if (state.nDecorAllDone &&
-                !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
-                IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
-                continue;
-            }
-            if (state.nPropagtionAllDone &&
-                !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
-                IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
-                continue;
-            }
-        }
-    }
-    for (const [key, dimension] of IWGDimensions._dimensions) {
-        dimension.vistedMap.clear();
-    }
-}

package/Tasks/IWG/Internal/IWGDimensions.d.ts

@@ -1,6 +0,0 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
-export declare class IWGDimensions {
-    static readonly _dimensions: Map<string, DimensionSegment>;
-    static addDimension(dimensionId: string): void;
-    static getDimension(dimensionId: string): DimensionSegment;
-}

package/Tasks/IWG/Internal/IWGTasks.d.ts

@@ -1,30 +0,0 @@
-export declare class IWGTasks {
-    /**# Load Sectors
-     * ---
-     */
-    static readonly worldLoadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Generate Sectors
-     * ---
-     */
-    static readonly worldGenTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Decorate Sectors
-     * ---
-     */
-    static readonly worldDecorateTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# World Sun
-     * ---
-     */
-    static readonly worldSunTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# World Propagation
-     * ---
-     */
-    static readonly worldPropagationTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Save Sector
-     * ---
-     */
-    static readonly saveTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Save & Unload Sector
-     * ---
-     */
-    static readonly saveAndUnloadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-}