@divinevoxel/vlox 0.0.4 → 0.0.5

package/World/Section/Section.d.ts

@@ -0,0 +1,34 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Sector } from "../Sector/Sector.js";
+import { Vec3Array } from "@amodx/math";
+export interface VoxelDataArrays {
+    /**The runtime numeric voxel ids */
+    ids: Uint16Array;
+    /**The light data for voxels stored as 4 nibbles. 0 -> sun light 1 -> red light 2 -> green light 3 -> blue light */
+    light: Uint16Array;
+    /**The levels of the voxel. Used mainly for waterflow now. */
+    level: Uint8Array;
+    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
+    state: Uint16Array;
+    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
+    mod: Uint16Array;
+    /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
+     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
+     */
+    secondary: Uint16Array;
+}
+export interface Section extends VoxelDataArrays {
+}
+export declare class Section {
+    sector: Sector;
+    index: number;
+    static GetBufferSize(): number;
+    static GetArrayStartIndex(index: number): number;
+    static CreateNew(index: number, sectorBuffer: ArrayBufferLike): VoxelDataArrays;
+    static toObject(sector: Sector, index: number, data: VoxelDataArrays): Section;
+    static StateStruct: RemoteBinaryStruct;
+    sectionState: DataView;
+    constructor(sector: Sector, index: number, data: VoxelDataArrays);
+    getPosition(): Readonly<Vec3Array>;
+    serialize(): VoxelDataArrays;
+}

package/World/Section/Section.js

@@ -0,0 +1,89 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { WorldSpaces } from "../WorldSpaces.js";
+import { Sector } from "../Sector/Sector.js";
+function forceMultipleOf2(n) {
+    return n % 2 === 0 ? n : n + 1;
+}
+const position = [0, 0, 0];
+export class Section {
+    sector;
+    index;
+    static GetBufferSize() {
+        const voxelSize = WorldSpaces.section.volumne;
+        return forceMultipleOf2(forceMultipleOf2(Section.StateStruct.structSize) +
+            //ids
+            voxelSize * 2 +
+            //light
+            voxelSize * 2 +
+            //level
+            voxelSize +
+            //state
+            voxelSize * 2 +
+            //mod
+            voxelSize * 2 +
+            //secondary
+            voxelSize * 2);
+    }
+    static GetArrayStartIndex(index) {
+        return (index * Section.GetBufferSize() +
+            Sector.GetHeaderSize() +
+            forceMultipleOf2(Section.StateStruct.structSize));
+    }
+    static CreateNew(index, sectorBuffer) {
+        const voxelSize = WorldSpaces.section.volumne;
+        let bufferStart = this.GetArrayStartIndex(index);
+        const ids = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const light = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const state = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const mod = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const secondary = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize;
+        return {
+            ids,
+            light,
+            level,
+            state,
+            mod,
+            secondary,
+        };
+    }
+    static toObject(sector, index, data) {
+        return new Section(sector, index, data);
+    }
+    static StateStruct = new RemoteBinaryStruct("section-tags");
+    sectionState;
+    constructor(sector, index, data) {
+        this.sector = sector;
+        this.index = index;
+        this.sectionState = new DataView(sector.buffer, index * Section.GetBufferSize() + Sector.GetHeaderSize(), Section.StateStruct.structSize);
+        this.ids = data.ids;
+        this.level = data.level;
+        this.light = data.light;
+        this.secondary = data.secondary;
+        this.state = data.state;
+        this.mod = data.mod;
+    }
+    getPosition() {
+        position[0] = this.sector.position[0];
+        position[1] =
+            this.sector.position[1] + this.index * WorldSpaces.section.bounds.y;
+        position[2] = this.sector.position[2];
+        return position;
+    }
+    serialize() {
+        return {
+            ids: this.ids,
+            light: this.light,
+            level: this.level,
+            secondary: this.secondary,
+            state: this.state,
+            mod: this.mod,
+        };
+    }
+}

package/World/Section/SectionHeightMap.d.ts

@@ -0,0 +1,10 @@
+import { Section } from "./Section";
+export declare class SectionHeightMap {
+    private static _sectionState;
+    static setSection(section: Section): typeof SectionHeightMap;
+    static setVoxel(y: number, hasVoxel: boolean): void;
+    static getVoxel(y: number): boolean;
+    static setDirty(y: number, dirty: boolean): void;
+    static getDirty(y: number): boolean;
+    static getMinMax(): number[];
+}

package/World/Section/SectionHeightMap.js

@@ -0,0 +1,39 @@
+import { WorldSpaces } from "../WorldSpaces";
+import { Section } from "./Section";
+import { SectionStructProperties } from "./SectionStructProperties";
+export class SectionHeightMap {
+    static _sectionState;
+    static setSection(section) {
+        if (!this._sectionState)
+            this._sectionState = Section.StateStruct.instantiate();
+        this._sectionState.setData(section.sectionState);
+        return this;
+    }
+    static setVoxel(y, hasVoxel) {
+        this._sectionState[SectionStructProperties.heightMap][y] = hasVoxel ? 1 : 0;
+    }
+    static getVoxel(y) {
+        return this._sectionState[SectionStructProperties.heightMap][y] == 1;
+    }
+    static setDirty(y, dirty) {
+        this._sectionState[SectionStructProperties.dirtyMap][y] = dirty ? 1 : 0;
+    }
+    static getDirty(y) {
+        return this._sectionState[SectionStructProperties.dirtyMap][y] == 1;
+    }
+    static getMinMax() {
+        let min = Infinity;
+        let max = -Infinity;
+        let i = WorldSpaces.section.bounds.y;
+        while (i--) {
+            if (this._sectionState[SectionStructProperties.heightMap][i] ||
+                this._sectionState[SectionStructProperties.dirtyMap][i]) {
+                if (i < min)
+                    min = i;
+                if (i > max)
+                    max = i;
+            }
+        }
+        return [min, max];
+    }
+}

package/World/Section/SectionStruct.d.ts

@@ -0,0 +1,8 @@
+import { SectionStructProperties } from "./SectionStructProperties.js";
+export interface SectionStruct {
+    [SectionStructProperties.minHeight]: number;
+    [SectionStructProperties.maxHeight]: number;
+    [SectionStructProperties.heightMap]: number[];
+    [SectionStructProperties.dirtyMap]: number[];
+}
+export declare function InitalizeSectionTags(): void;

package/World/Section/SectionStruct.js

@@ -0,0 +1,29 @@
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { WorldSpaces } from "../WorldSpaces.js";
+import { SectionStructProperties } from "./SectionStructProperties.js";
+import { Section } from "./Section.js";
+const SectionStateStruct = new BinaryStruct("section-tags");
+SectionStateStruct.registerProperty({
+    id: SectionStructProperties.minHeight,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint8,
+}, {
+    id: SectionStructProperties.maxHeight,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint8,
+});
+export function InitalizeSectionTags() {
+    SectionStateStruct.registerProperty({
+        id: SectionStructProperties.heightMap,
+        type: "bit-array",
+        length: WorldSpaces.section.bounds.y,
+    }, {
+        id: SectionStructProperties.dirtyMap,
+        type: "bit-array",
+        length: WorldSpaces.section.bounds.y,
+    });
+    const initData = SectionStateStruct.init({
+        indexBufferMode: "shared",
+    });
+    Section.StateStruct.init(initData);
+}

package/{Data/Structs/Constants/ChunkStructProperties.d.ts → World/Section/SectionStructProperties.d.ts}

@@ -1,4 +1,4 @@
-export declare enum ChunkStructProperties {
+export declare enum SectionStructProperties {
     minHeight = "dve_min_height",
     maxHeight = "dve_max_height",
     heightMap = "dve_height_map",

package/World/Section/SectionStructProperties.js

@@ -0,0 +1,11 @@
+export var SectionStructProperties;
+(function (SectionStructProperties) {
+    SectionStructProperties["minHeight"] = "dve_min_height";
+    SectionStructProperties["maxHeight"] = "dve_max_height";
+    SectionStructProperties["heightMap"] = "dve_height_map";
+    SectionStructProperties["dirtyMap"] = "dve_dirty_map";
+    SectionStructProperties["voxelIDSegment"] = "dve_voxel_id";
+    SectionStructProperties["voxelLightSegment"] = "dve_voxel_light";
+    SectionStructProperties["voxelStateSegment"] = "dve_voxel_state";
+    SectionStructProperties["voxelSecondaryIDSegment"] = "dve_voxel_secondary_id";
+})(SectionStructProperties || (SectionStructProperties = {}));

package/World/Section/index.d.ts

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

package/World/Section/index.js

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

package/World/Sector/Sector.d.ts

@@ -0,0 +1,23 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Section, VoxelDataArrays } from "../Section/Section.js";
+import { Vec3Array } from "@amodx/math";
+export interface SectorData {
+    position: Vec3Array;
+    buffer: ArrayBufferLike;
+    sections: VoxelDataArrays[];
+}
+export interface Sector extends SectorData {
+}
+export declare class Sector {
+    static StateStruct: RemoteBinaryStruct;
+    static GetHeaderSize(): number;
+    static GetBufferSize(): number;
+    static CreateNew(): SectorData;
+    sections: Section[];
+    bufferView: Uint8Array;
+    sectorState: DataView;
+    position: Vec3Array;
+    constructor(data: SectorData);
+    getSection(y: number): Section;
+    toJSON(): SectorData;
+}

package/World/Sector/Sector.js

@@ -0,0 +1,60 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Section } from "../Section/Section.js";
+import { WorldSpaces } from "../WorldSpaces";
+function forceMultipleOf2(n) {
+    return n % 2 === 0 ? n : n + 1;
+}
+export class Sector {
+    static StateStruct = new RemoteBinaryStruct("sector-tags");
+    static GetHeaderSize() {
+        return forceMultipleOf2(Sector.StateStruct.structSize);
+    }
+    static GetBufferSize() {
+        const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
+        return this.GetHeaderSize() + Section.GetBufferSize() * totalSections;
+    }
+    static CreateNew() {
+        const buffer = new SharedArrayBuffer(this.GetBufferSize());
+        Sector.StateStruct.setBuffer(buffer);
+        Sector.StateStruct.setProperty("dve_is_stored", 0);
+        const sections = [];
+        const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
+        for (let i = 0; i < totalSections; i++) {
+            sections[i] = Section.CreateNew(i, buffer);
+        }
+        return {
+            position: [0, 0, 0],
+            buffer,
+            sections,
+        };
+    }
+    sections = [];
+    bufferView;
+    sectorState;
+    position;
+    constructor(data) {
+        this.position = data.position;
+        this.sectorState = new DataView(data.buffer);
+        this.buffer = data.buffer;
+        this.bufferView = new Uint8Array(data.buffer);
+        for (let i = 0; i < data.sections.length; i++) {
+            this.sections[i] = new Section(this, i, data.sections[i]);
+        }
+    }
+    getSection(y) {
+        const ry = y - this.position[1];
+        const index = ry / WorldSpaces.section.bounds.y;
+        return this.sections[index];
+    }
+    toJSON() {
+        const sections = [];
+        for (const section of this.sections) {
+            sections.push(section.serialize());
+        }
+        return {
+            position: this.position,
+            buffer: this.buffer,
+            sections,
+        };
+    }
+}

package/World/Sector/SectorHeightMap.d.ts

@@ -0,0 +1,5 @@
+import { LocationData } from "../../Math";
+export declare class SectorHeightMap {
+    static getRelative(location: LocationData): number;
+    static getAbsolute(location: LocationData): number;
+}

package/World/Sector/SectorHeightMap.js

@@ -0,0 +1,49 @@
+import { $2dMooreNeighborhood } from "../../Math/CardinalNeighbors";
+import { SectionHeightMap } from "../Section/SectionHeightMap";
+import { WorldBounds } from "../WorldBounds";
+import { WorldRegister } from "../WorldRegister";
+import { WorldSpaces } from "../WorldSpaces";
+export class SectorHeightMap {
+    static getRelative(location) {
+        location = [...location];
+        const sectionWidth = WorldSpaces.section.bounds.x;
+        const sectionDepth = WorldSpaces.section.bounds.z;
+        let maxHeight = -Infinity;
+        const [dimension, x, y, z] = location;
+        for (const check of $2dMooreNeighborhood) {
+            location[1] = check[0] * sectionWidth + x;
+            location[3] = check[1] * sectionDepth + z;
+            const height = this.getAbsolute(location);
+            if (height > maxHeight) {
+                maxHeight = height;
+            }
+        }
+        return maxHeight;
+    }
+    static getAbsolute(location) {
+        WorldRegister.setDimension(location[0]);
+        const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+        if (!sector)
+            return WorldBounds.bounds.MinY;
+        if (sector.sections.length == 0)
+            return WorldBounds.bounds.MinY;
+        let maxHeight = WorldBounds.bounds.MinY;
+        const positon = [location[1], location[2], location[3]];
+        let y = positon[1];
+        for (let i = 0; i < sector.sections.length; i++) {
+            const section = sector.sections[i];
+            if (!section)
+                continue;
+            SectionHeightMap.setSection(section);
+            const sectionPOS = y + i * WorldSpaces.section.bounds.y;
+            let [sectionMin, sectionMax] = SectionHeightMap.getMinMax();
+            if (Math.abs(sectionMax) == Infinity)
+                continue;
+            sectionMax = sectionPOS + sectionMax;
+            if (maxHeight < sectionMax) {
+                maxHeight = sectionMax;
+            }
+        }
+        return maxHeight + 1;
+    }
+}

package/World/Sector/SectorStruct.d.ts

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

package/World/Sector/SectorStruct.js

@@ -0,0 +1,46 @@
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { Sector } from "./Sector.js";
+import { SectorStateStructIds } from "./SectorStructIds.js";
+const SectorStateStruct = new BinaryStruct("sector-tags");
+SectorStateStruct.registerProperty({
+    id: SectorStateStructIds.lastSaveTimestamp,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint32,
+}, {
+    id: SectorStateStructIds.lastAnalyzerUpdateTimestamp,
+    type: "typed-number",
+    numberType: BinaryNumberTypes.Uint32,
+}, {
+    id: SectorStateStructIds.hasRichData,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.hasEntityData,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isStored,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isWorldGenDone,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isWorldDecorDone,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isWorldSunDone,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isWorldPropagationDone,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.isDirty,
+    type: "boolean",
+}, {
+    id: SectorStateStructIds.persistent,
+    type: "boolean",
+});
+export function InitalizeSectorTags() {
+    const initData = SectorStateStruct.init({
+        indexBufferMode: "shared",
+    });
+    Sector.StateStruct.init(initData);
+}

package/World/Sector/SectorStructIds.d.ts

@@ -0,0 +1,13 @@
+export declare enum SectorStateStructIds {
+    lastSaveTimestamp = "dve_last_save_timestamp",
+    lastAnalyzerUpdateTimestamp = "dve_last_analyzer_update_timestamp",
+    hasRichData = "dve_has_rich_data",
+    hasEntityData = "dve_has_entity_data",
+    isStored = "dve_is_stored",
+    isWorldGenDone = "dve_is_world_gen_done",
+    isWorldDecorDone = "dve_is_world_decor_done",
+    isWorldSunDone = "dve_is_world_sun_done",
+    isWorldPropagationDone = "dve_is_world_propagation_done",
+    isDirty = "dve_is_dirty",
+    persistent = "dve_persistent"
+}

package/World/Sector/SectorStructIds.js

@@ -0,0 +1,14 @@
+export var SectorStateStructIds;
+(function (SectorStateStructIds) {
+    SectorStateStructIds["lastSaveTimestamp"] = "dve_last_save_timestamp";
+    SectorStateStructIds["lastAnalyzerUpdateTimestamp"] = "dve_last_analyzer_update_timestamp";
+    SectorStateStructIds["hasRichData"] = "dve_has_rich_data";
+    SectorStateStructIds["hasEntityData"] = "dve_has_entity_data";
+    SectorStateStructIds["isStored"] = "dve_is_stored";
+    SectorStateStructIds["isWorldGenDone"] = "dve_is_world_gen_done";
+    SectorStateStructIds["isWorldDecorDone"] = "dve_is_world_decor_done";
+    SectorStateStructIds["isWorldSunDone"] = "dve_is_world_sun_done";
+    SectorStateStructIds["isWorldPropagationDone"] = "dve_is_world_propagation_done";
+    SectorStateStructIds["isDirty"] = "dve_is_dirty";
+    SectorStateStructIds["persistent"] = "dve_persistent";
+})(SectorStateStructIds || (SectorStateStructIds = {}));

package/World/Sector/index.d.ts

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

package/World/Sector/index.js

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

package/World/Storage/WorldStorage.interface.d.ts

@@ -0,0 +1,6 @@
+import { LocationData } from "Math";
+export interface WorldStorageInterface {
+    saveSector(location: LocationData): Promise<void>;
+    loadSector(location: LocationData): Promise<boolean>;
+    unloadSector(location: LocationData): Promise<void>;
+}

package/{Data/Types/RichWorldData.types.d.ts → World/Types/WorldData.types.d.ts}

@@ -1,9 +1,18 @@
+export type DimensionOptions = {
+    liquidFlowSpeed: number;
+    magmaFlowSpeed: number;
+    sunLight: boolean;
+};
+export type DimensionData = {
+    id: string;
+    options: DimensionOptions;
+};
 export type RichDataSchema = Record<string, Record<string, any>>;
-export type RichColumn = {
+export type RichSector = {
     data: RichDataSchema;
 };
 export type RichRegion = {
-    columns: Map<string, RichColumn>;
+    sectors: Map<string, RichSector>;
 };
 export type RichWorldDimensions = Map<string, Map<string, RichRegion>>;
 export type SetRichVoxel = [

package/World/Types/WorldDataSyncIds.d.ts

@@ -0,0 +1,6 @@
+export declare enum WorldDataSyncIds {
+    SyncSector = "sync-sector",
+    UnSyncSector = "unsync-sector",
+    SyncDimension = "sync-dimension",
+    UnSyncDimension = "unsync-dimension"
+}

package/World/Types/WorldDataSyncIds.js

@@ -0,0 +1,7 @@
+export var WorldDataSyncIds;
+(function (WorldDataSyncIds) {
+    WorldDataSyncIds["SyncSector"] = "sync-sector";
+    WorldDataSyncIds["UnSyncSector"] = "unsync-sector";
+    WorldDataSyncIds["SyncDimension"] = "sync-dimension";
+    WorldDataSyncIds["UnSyncDimension"] = "unsync-dimension";
+})(WorldDataSyncIds || (WorldDataSyncIds = {}));

package/{Data/World → World}/WorldBounds.js

@@ -1,3 +1,4 @@
+import { EngineSettings } from "../Settings/EngineSettings";
 export class WorldBounds {
     static bounds = {
         MinZ: -Number.MAX_SAFE_INTEGER,
@@ -47,3 +48,6 @@ export class WorldBounds {
         };
     }
 }
+EngineSettings.addEventListener("synced", ({ detail: { settings: { settings }, }, }) => {
+    WorldBounds.setWorldBounds(settings.world.minX, settings.world.maxX, settings.world.minZ, settings.world.maxZ, settings.world.minY, settings.world.maxY);
+});

package/World/WorldRegister.d.ts

@@ -0,0 +1,35 @@
+import { Dimension } from "./Dimension/Dimension";
+import { Sector, SectorData } from "./Sector/Sector.js";
+import type { LocationData } from "../Math/index.js";
+import { DimensionData } from "./Types/WorldData.types.js";
+declare class WorldDataHooks {
+    static dimension: {
+        onNew: (dimension: DimensionData) => void;
+        onRemove: (location: LocationData) => void;
+    };
+    static sectors: {
+        onNew: (location: LocationData, sector: SectorData) => void;
+        onRemove: (location: LocationData, sector: SectorData) => void;
+    };
+}
+declare class WorldRegisterDimensions {
+    static add(id: string): Dimension;
+    static get(id: string): Dimension | undefined;
+}
+declare class WorldRegisterSectors {
+    static setSecotrPool(enabled: boolean): void;
+    static add(x: number, y: number, z: number, sector: SectorData): Sector;
+    static new(x: number, y: number, z: number): boolean;
+    static get(x: number, y: number, z: number): false | Sector;
+    static remove(x: number, y: number, z: number): boolean;
+}
+export declare class WorldRegister {
+    static _dimensions: Map<string, Dimension>;
+    static _hooks: typeof WorldDataHooks;
+    static dimensions: typeof WorldRegisterDimensions;
+    static sectors: typeof WorldRegisterSectors;
+    static _currentDimension: Dimension;
+    static setDimension(dimensionId: string): void;
+    static clearAll(): void;
+}
+export {};

package/World/WorldRegister.js

@@ -0,0 +1,91 @@
+import { WorldSpaces } from "./WorldSpaces.js";
+import { Dimension } from "./Dimension/Dimension";
+import { Sector } from "./Sector/Sector.js";
+import { Vector3Like } from "@amodx/math";
+class WorldDataHooks {
+    static dimension = {
+        onNew: (dimension) => { },
+        onRemove: (location) => { },
+    };
+    static sectors = {
+        onNew: (location, sector) => { },
+        onRemove: (location, sector) => { },
+    };
+}
+class WorldRegisterDimensions {
+    static add(id) {
+        const dimesnion = Dimension.CreateNew(id);
+        WorldRegister._dimensions.set(id, dimesnion);
+        return dimesnion;
+    }
+    static get(id) {
+        return WorldRegister._dimensions.get(id);
+    }
+}
+const tempPosition = Vector3Like.Create();
+class SectorPool {
+    static _secotrs = [];
+    static _enabled = false;
+    static getSector() {
+        if (!this._enabled)
+            return Sector.CreateNew();
+        if (this._secotrs.length)
+            return this._secotrs.shift();
+        return Sector.CreateNew();
+    }
+    static returnSector(secotr) {
+        secotr.bufferView.fill(0);
+    }
+}
+class WorldRegisterSectors {
+    static setSecotrPool(enabled) {
+        SectorPool._enabled = enabled;
+        SectorPool._secotrs.length = 0;
+    }
+    static add(x, y, z, sector) {
+        WorldSpaces.sector.getPositionVec3Array(x, y, z, sector.position);
+        const newSector = new Sector(sector);
+        WorldRegister._currentDimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
+        return newSector;
+    }
+    static new(x, y, z) {
+        if (this.get(x, y, z))
+            return false;
+        const sector = this.add(x, y, z, Sector.CreateNew());
+        WorldDataHooks.sectors.onNew([WorldRegister._currentDimension.id, x, y, z], sector);
+        return true;
+    }
+    static get(x, y, z) {
+        const sector = WorldRegister._currentDimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
+        return sector || false;
+    }
+    static remove(x, y, z) {
+        const position = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
+        const sectorKey = WorldSpaces.hash.hashVec3(position);
+        const sector = WorldRegister._currentDimension.sectors.get(sectorKey);
+        if (!sector)
+            return false;
+        if (SectorPool._enabled)
+            SectorPool.returnSector(sector);
+        WorldRegister._currentDimension.sectors.delete(sectorKey);
+        WorldDataHooks.sectors.onRemove([WorldRegister._currentDimension.id, position.x, position.y, position.z], sector);
+        return true;
+    }
+}
+export class WorldRegister {
+    static _dimensions = new Map();
+    static _hooks = WorldDataHooks;
+    static dimensions = WorldRegisterDimensions;
+    static sectors = WorldRegisterSectors;
+    static _currentDimension;
+    static setDimension(dimensionId) {
+        let dimension = this.dimensions.get(dimensionId);
+        if (!dimension) {
+            dimension = this.dimensions.add(dimensionId);
+        }
+        this._currentDimension = dimension;
+    }
+    static clearAll() {
+        this._dimensions.clear();
+    }
+}