@divinevoxel/vlox 0.0.74 → 0.0.75

package/World/Archive/Functions/ImportSector.js

@@ -1,57 +0,0 @@
-import { Sector } from "../../index";
-import { ImportedSector } from "../Classes/ImportedSector";
-export default function ImportSector(archivedSector, archiveData) {
-    const sector = new Sector(Sector.CreateNew(), [
-        archivedSector.location[0],
-        archivedSector.location[1],
-        archivedSector.location[2],
-    ]);
-    sector.loadFlags(archivedSector.flags);
-    sector.loadTimestamps(archivedSector.timestamps);
-    const importedSector = new ImportedSector(archivedSector);
-    for (const importedSection of importedSector.sections) {
-        const archivedSection = importedSection.section;
-        const section = sector.sections[importedSection.sectionIndex];
-        archivedSection.flags && section.loadFlags(archivedSection.flags);
-        if (!ArrayBuffer.isView(archivedSection.buffers.buried)) {
-            for (let i = 0; i < section.buried.length; i++) {
-                section.buried[i] = archivedSection.buffers.buried || 0;
-            }
-        }
-        else {
-            for (let i = 0; i < section.buried.length; i++) {
-                section.buried[i] = archivedSection.buffers.buried[i];
-            }
-        }
-        if (!ArrayBuffer.isView(archivedSection.buffers.voxelMap)) {
-            for (let i = 0; i < section.voxelMap.length; i++) {
-                section.voxelMap[i] = archivedSection.buffers.voxelMap || 0;
-            }
-        }
-        else {
-            for (let i = 0; i < section.voxelMap.length; i++) {
-                section.voxelMap[i] = archivedSection.buffers.voxelMap[i];
-            }
-        }
-        if (!ArrayBuffer.isView(archivedSection.buffers.dirtyMap)) {
-            for (let i = 0; i < section.dirtyMap.length; i++) {
-                section.dirtyMap[i] = archivedSection.buffers.dirtyMap || 0;
-            }
-        }
-        else {
-            for (let i = 0; i < section.dirtyMap.length; i++) {
-                section.dirtyMap[i] = archivedSection.buffers.dirtyMap[i];
-            }
-        }
-        for (let i = 0; i < section.ids.length; i++) {
-            section.ids[i] = importedSection.getId(i);
-            section.level[i] = importedSection.getLevel(i);
-            section.light[i] = importedSection.getLight(i);
-            section.secondary[i] = importedSection.getSecondary(i);
-            section.state[i] = importedSection.getState(i);
-            section.mod[i] = importedSection.getMod(i);
-        }
-    }
-    sector.setBitFlag(Sector.FlagIds.stored, true);
-    return sector;
-}

package/World/Archive/Functions/RemoveDuplicates.d.ts

@@ -1,3 +0,0 @@
-import { ArchivedSectionData, ArchivedSectorData } from "../Archive.types";
-export declare function compareSection(section1: ArchivedSectionData, section2: ArchivedSectionData): boolean;
-export declare function RemoveDuplicates(data: ArchivedSectorData): void;

package/World/Archive/Functions/RemoveDuplicates.js

@@ -1,92 +0,0 @@
-import { uint16To4CharString } from "./Shared";
-function traverseSection(source, target) {
-    if (typeof source == "object" && typeof target == "object") {
-        if (Object.keys(source).length != Object.keys(target).length)
-            return false;
-    }
-    for (const key in source) {
-        if (!(key in target))
-            return false;
-        const sourceValue = source[key];
-        const targetValue = target[key];
-        if (!ArrayBuffer.isView(sourceValue) &&
-            typeof sourceValue === "object" &&
-            sourceValue !== null &&
-            !ArrayBuffer.isView(targetValue) &&
-            typeof targetValue == "object" &&
-            targetValue !== null) {
-            if (!traverseSection(sourceValue, targetValue))
-                return false;
-            continue;
-        }
-        if (typeof sourceValue === "number" ||
-            typeof sourceValue === "string" ||
-            typeof targetValue === "number" ||
-            typeof targetValue === "string") {
-            if (sourceValue !== targetValue)
-                return false;
-            continue;
-        }
-        if (sourceValue instanceof Uint8Array ||
-            sourceValue instanceof Uint16Array) {
-            if (!(targetValue instanceof sourceValue.constructor))
-                return false;
-            if (sourceValue.length !== targetValue.length)
-                return false;
-            let target = targetValue;
-            for (let i = 0; i < target.length; i++) {
-                if (sourceValue[i] != target[i])
-                    return false;
-            }
-        }
-    }
-    return true;
-}
-export function compareSection(section1, section2) {
-    return traverseSection(section1, section2);
-}
-export function RemoveDuplicates(data) {
-    const duplicateSectionMap = new Map();
-    let duplicateSections = [];
-    for (let i = 0; i < data.sections.length; i++) {
-        for (let j = i + 1; j < data.sections.length; j++) {
-            const section1 = data.sections[i];
-            const section2 = data.sections[j];
-            if (typeof section1 == "string" || typeof section2 == "string")
-                continue;
-            let index = -1;
-            if (compareSection(section1, section2)) {
-                if (duplicateSectionMap.has(section2)) {
-                    index = duplicateSectionMap.get(section2)[1];
-                }
-                else {
-                    let found = false;
-                    for (let k = 0; k < duplicateSections.length; k++) {
-                        if (compareSection(section1, duplicateSections[k])) {
-                            index = k;
-                            found = true;
-                        }
-                    }
-                    if (!found) {
-                        duplicateSections.push(section1);
-                        index = duplicateSections.length - 1;
-                    }
-                }
-                duplicateSectionMap.set(section1, [i, index]);
-            }
-        }
-    }
-    const sections = {};
-    for (let i = 0; i < data.sections.length; i++) {
-        const section = data.sections[i];
-        if (duplicateSectionMap.has(section)) {
-            const [, dupIndex] = duplicateSectionMap.get(section);
-            const id = uint16To4CharString(dupIndex);
-            data.sections[i] = id;
-            sections[id] = section;
-        }
-    }
-    data.duplicates = {
-        sections,
-    };
-}

package/WorldSimulation/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: number;
-    tasks: Map<string, TaskSegment>;
-    queue: number[];
-    vistedMap: SectorVisistedMap;
-    rendered: SectorVisistedMap;
-    inProgress: SectorVisistedMap;
-    unRenderQueue: SectorQueue;
-    unLoadQueue: SectorQueue;
-    constructor(id: number);
-    addTask(id: string): void;
-    getTask(id: string): TaskSegment;
-    clearAllTasks(): void;
-    logTasks(): string;
-}
-export {};

package/WorldSimulation/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/WorldSimulation/Internal/Classes/Queues/BuildQueue.d.ts

@@ -1,5 +0,0 @@
-import { LocationData } from "Math";
-import { TickQueue } from "../TickQueue";
-export declare class BuildQueue extends TickQueue {
-    runTask(section: LocationData): void;
-}

package/WorldSimulation/Internal/Classes/Queues/BuildQueue.js

@@ -1,6 +0,0 @@
-import { TickQueue } from "../TickQueue";
-export class BuildQueue extends TickQueue {
-    runTask(section) {
-        this.tasks.build.section.run(section);
-    }
-}

package/WorldSimulation/Internal/Classes/Queues/LogiccQueue.d.ts

@@ -1,5 +0,0 @@
-import { LocationData } from "Math";
-import { TickQueue } from "../TickQueue";
-export declare class LogicQueue extends TickQueue {
-    runTask(section: LocationData): void;
-}

package/WorldSimulation/Internal/Classes/Queues/LogiccQueue.js

@@ -1,6 +0,0 @@
-import { TickQueue } from "../TickQueue";
-export class LogicQueue extends TickQueue {
-    runTask(section) {
-        this.tasks.voxel.logic.run(section);
-    }
-}

package/WorldSimulation/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/WorldSimulation/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/WorldSimulation/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/WorldSimulation/Internal/Classes/TickQueue.d.ts

@@ -1,12 +0,0 @@
-import { LocationData } from "../../../Math";
-import { TaskTool } from "../../../Tools/Tasks/TasksTool";
-export declare abstract class TickQueue {
-    tasks: TaskTool;
-    hash: Set<unknown>;
-    sections: LocationData[];
-    constructor(tasks: TaskTool);
-    add(dimension: number, x: number, y: number, z: number): false | undefined;
-    sort(x: number, y: number, z: number): LocationData[];
-    abstract runTask(section: LocationData): void;
-    run(limit?: number): void;
-}

package/WorldSimulation/Internal/Classes/TickQueue.js

@@ -1,58 +0,0 @@
-import { WorldSpaces } from "../../../World/WorldSpaces";
-const pool = [];
-export class TickQueue {
-    tasks;
-    hash = new Set();
-    sections = [];
-    constructor(tasks) {
-        this.tasks = tasks;
-    }
-    add(dimension, x, y, z) {
-        const key = WorldSpaces.hash.hashXYZ(x, y, z);
-        if (this.hash.has(key))
-            return false;
-        this.hash.add(key);
-        const location = pool.length ? pool.shift() : [0, 0, 0, 0];
-        location[0] = dimension;
-        location[1] = x;
-        location[2] = y;
-        location[3] = z;
-        this.sections.push(location);
-    }
-    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--;
-        }
-        return sections;
-    }
-    run(limit = 25) {
-        let count = 0;
-        while (this.sections.length) {
-            const vec = this.sections.shift();
-            const [, x, y, z] = vec;
-            this.runTask(vec);
-            this.tasks.build.section.run(vec);
-            this.hash.delete(WorldSpaces.hash.hashXYZ(x, y, z));
-            count++;
-            pool.push(vec);
-            if (count > limit)
-                break;
-        }
-    }
-}

package/WorldSimulation/Internal/Classes/WorldSimulationTaskBase.d.ts

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

package/WorldSimulation/Internal/Classes/WorldSimulationTaskBase.js

@@ -1,62 +0,0 @@
-import { WorldSimulationDimensions } from "../WorldSimulationDimensions.js";
-export class IWGTaskBase {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    add(dimensionId, x, y, z) {
-        const dimension = WorldSimulationDimensions.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 = WorldSimulationDimensions.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 = WorldSimulationDimensions.getDimension(dimensionId);
-            const task = dimension.getTask(this.data.id);
-            task.clear();
-        }
-        else {
-            for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
-                dimension.clearAllTasks();
-            }
-        }
-    }
-    runTask(max = 1000) {
-        for (const [key, dimension] of WorldSimulationDimensions._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/WorldSimulation/Internal/Functions/cullSectors.d.ts

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

package/WorldSimulation/Internal/Functions/cullSectors.js

@@ -1,111 +0,0 @@
-import { Circle, Square } from "@amodx/math";
-import { WorldSimulationDimensions } from "../WorldSimulationDimensions";
-import { WorldRegister } from "../../../World/WorldRegister";
-import { WorldSpaces } from "../../../World/WorldSpaces";
-import { WorldSimulationTools } from "../WorldSimulationTools";
-import { WorldLock } from "../../../World/Lock/WorldLock";
-const sectorSquare = new Square();
-export function cullSectors(generatos, cullGenerators) {
-    const time = performance.now();
-    for (const [, dimension] of WorldSimulationDimensions._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);
-                WorldSimulationTools.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 (WorldSimulationTools.worldStorage) {
-                    dimension.inProgress.add(cx, cy, cz);
-                    WorldSimulationTools.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/WorldSimulation/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/WorldSimulation/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/WorldSimulation/Internal/Functions/runTickUpdate.d.ts

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