@divinevoxel/vlox 0.0.79 → 0.0.81

package/Voxels/State/Schema/BinarySchema.d.ts

@@ -19,5 +19,6 @@ export declare class BinarySchema {
     setValue(id: string, value: string): this;
     getEncoded(): number;
     getSchema(): VoxelBinaryStateSchemaNode[];
+    totalStates(): number;
 }
 export {};

package/Voxels/State/Schema/BinarySchema.js

@@ -149,4 +149,18 @@ export class BinarySchema {
     getSchema() {
         return this.nodes.map((_) => _.data);
     }
+    totalStates() {
+        if (this.nodes.length === 0)
+            return 1;
+        let total = 1;
+        for (const node of this.nodes) {
+            if (node.data.values) {
+                total *= node.data.values.length;
+            }
+            else {
+                total *= node.bitMask + 1;
+            }
+        }
+        return total;
+    }
 }

package/Voxels/State/VoxelSchemas.d.ts

@@ -4,19 +4,26 @@ import { VoxelBinaryStateSchemaNode, VoxelModelRelationsSchemaNodes } from "./St
 export type VoxelSchemasExport = {
     state: [key: string, VoxelBinaryStateSchemaNode[]][];
     mod: [key: string, VoxelBinaryStateSchemaNode[]][];
-    reltioanlState: [key: string, VoxelBinaryStateSchemaNode[]][];
+    relationalState: [key: string, VoxelBinaryStateSchemaNode[]][];
     reltionalStateBuilder: [key: string, VoxelModelRelationsSchemaNodes[]][];
-    reltioanlMod: [key: string, VoxelBinaryStateSchemaNode[]][];
+    relationalMod: [key: string, VoxelBinaryStateSchemaNode[]][];
     reltionalModBuilder: [key: string, VoxelModelRelationsSchemaNodes[]][];
 };
 export declare class VoxelSchemas {
     static state: Map<string, BinarySchema>;
+    static stateMap: BinarySchema[];
     static mod: Map<string, BinarySchema>;
-    static reltioanlState: Map<string, BinarySchema>;
+    static modMap: BinarySchema[];
+    static relationalState: Map<string, BinarySchema>;
+    static relationalStateMap: BinarySchema[];
     static reltionalStateBuilder: Map<string, ReltionalStateBuilder>;
-    static reltioanlMod: Map<string, BinarySchema>;
+    static reltionalStateBuilderMap: ReltionalStateBuilder[];
+    static relationalMod: Map<string, BinarySchema>;
+    static relationalModMap: BinarySchema[];
     static reltionalModBuilder: Map<string, ReltionalStateBuilder>;
+    static reltionalModBuilderMap: ReltionalStateBuilder[];
     static getStateSchema(voxelId: string): BinarySchema | undefined;
+    static buildMaps(): void;
     static export(): VoxelSchemasExport;
     static import(exported: VoxelSchemasExport): void;
 }

package/Voxels/State/VoxelSchemas.js

@@ -4,30 +4,62 @@ import { BinarySchema } from "./Schema/BinarySchema";
 export class VoxelSchemas {
     //maps voxel model ids to the their state scehma
     static state = new Map();
+    //maps voxel model number ids to their state schemas
+    static stateMap = [];
     //maps voxel ids to their mod schemao
     static mod = new Map();
+    //maps voxel  number ids to their state schemas
+    static modMap = [];
     //maps voxel model ids to their reltional state schema
-    static reltioanlState = new Map();
+    static relationalState = new Map();
+    //maps voxel model number ids to their reltional state schema
+    static relationalStateMap = [];
     //maps voxel model ids = their reltional state builder
     static reltionalStateBuilder = new Map();
+    //maps voxel model number ids = their reltional state builder
+    static reltionalStateBuilderMap = [];
     //maps voxel ids to their reltional mod schema
-    static reltioanlMod = new Map();
-    //maps voxel ids = their reltional mod builder
+    static relationalMod = new Map();
+    //maps voxel number ids to their reltional mod schema
+    static relationalModMap = [];
+    //maps voxel ids to their reltional mod builder
     static reltionalModBuilder = new Map();
+    //maps voxel number ids to their reltional mod builder
+    static reltionalModBuilderMap = [];
     static getStateSchema(voxelId) {
         const modelId = VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[VoxelLUT.voxelIds.getNumberId(voxelId)]);
         return this.state.get(modelId);
     }
+    static buildMaps() {
+        for (const [key, schema] of this.state) {
+            this.stateMap[VoxelLUT.models.getNumberId(key)] = schema;
+        }
+        for (const [key, schema] of this.relationalState) {
+            this.relationalStateMap[VoxelLUT.models.getNumberId(key)] = schema;
+        }
+        for (const [key, schema] of this.reltionalStateBuilder) {
+            this.reltionalStateBuilderMap[VoxelLUT.models.getNumberId(key)] = schema;
+        }
+        for (const [key, schema] of this.mod) {
+            this.modMap[VoxelLUT.voxelIds.getNumberId(key)] = schema;
+        }
+        for (const [key, schema] of this.relationalMod) {
+            this.relationalModMap[VoxelLUT.voxelIds.getNumberId(key)] = schema;
+        }
+        for (const [key, schema] of this.reltionalModBuilder) {
+            this.reltionalModBuilderMap[VoxelLUT.voxelIds.getNumberId(key)] = schema;
+        }
+    }
     static export() {
         return {
             state: [...this.state].map(([key, value]) => [key, value.getSchema()]),
             mod: [...this.mod].map(([key, value]) => [key, value.getSchema()]),
-            reltioanlState: [...this.reltioanlState].map(([key, value]) => [
+            relationalState: [...this.relationalState].map(([key, value]) => [
                 key,
                 value.getSchema(),
             ]),
             reltionalStateBuilder: [...this.reltionalStateBuilder].map(([key, value]) => [key, value.getSchema()]),
-            reltioanlMod: [...this.reltioanlMod].map(([key, value]) => [
+            relationalMod: [...this.relationalMod].map(([key, value]) => [
                 key,
                 value.getSchema(),
             ]),
@@ -40,21 +72,22 @@ export class VoxelSchemas {
     static import(exported) {
         this.state = new Map(exported.state.map(([key, nodes]) => [key, new BinarySchema(nodes)]));
         this.mod = new Map(exported.mod.map(([key, nodes]) => [key, new BinarySchema(nodes)]));
-        this.reltioanlState = new Map(exported.reltioanlState.map(([key, nodes]) => [
+        this.relationalState = new Map(exported.relationalState.map(([key, nodes]) => [
             key,
             new BinarySchema(nodes),
         ]));
         this.reltionalStateBuilder = new Map(exported.reltionalStateBuilder.map(([key, nodes]) => [
             key,
-            new ReltionalStateBuilder(this.reltioanlState.get(key), nodes),
+            new ReltionalStateBuilder(this.relationalState.get(key), nodes),
         ]));
-        this.reltioanlMod = new Map(exported.reltioanlMod.map(([key, nodes]) => [
+        this.relationalMod = new Map(exported.relationalMod.map(([key, nodes]) => [
             key,
             new BinarySchema(nodes),
         ]));
         this.reltionalModBuilder = new Map(exported.reltionalModBuilder.map(([key, nodes]) => [
             key,
-            new ReltionalStateBuilder(this.reltioanlMod.get(key), nodes),
+            new ReltionalStateBuilder(this.relationalMod.get(key), nodes),
         ]));
+        this.buildMaps();
     }
 }

package/Voxels/Types/PaintVoxelData.js

@@ -21,13 +21,17 @@ export class PaintVoxelData {
     }
     /**Transforms numeric voxel data into a PaintVoxelData object */
     static FromRaw(data, paintData = PaintVoxelData.Create()) {
-        const [trueVoxelId, state, mod] = VoxelLUT.voxels[data[0]];
+        const trueVoxelId = VoxelLUT.voxelIdToTrueId[data[0]];
+        const state = VoxelLUT.voxelIdToState[data[0]];
+        const mod = VoxelLUT.voxelIdToMod[data[0]];
         paintData.id = VoxelLUT.voxelIds.getStringId(trueVoxelId);
         paintData.state = state;
         paintData.mod = mod;
         paintData.name = VoxelLUT.voxelIdToNameMap.get(paintData.id) || "";
         if (data[3] !== 0) {
-            const [trueVoxelId, state, mod] = VoxelLUT.voxels[data[3]];
+            const trueVoxelId = VoxelLUT.voxelIdToTrueId[data[3]];
+            const state = VoxelLUT.voxelIdToState[data[3]];
+            const mod = VoxelLUT.voxelIdToMod[data[3]];
             paintData.secondaryVoxelId = VoxelLUT.voxelIds.getStringId(trueVoxelId);
             paintData.secondaryState = state;
             paintData.secondaryMod = mod;

package/World/Archive/Classes/ImportedSection.js

@@ -153,7 +153,7 @@ export class ImportedSection {
         return value;
     }
     getSecondary(index) {
-        const trueVoxelId = VoxelLUT.voxels[this.getId(index)][0];
+        const trueVoxelId = VoxelLUT.voxelIdToTrueId[this.getId(index)];
         const value = this.buffers.secondary.getValue(index);
         if (VoxelTagsRegister.VoxelTags[trueVoxelId]["dve_can_have_secondary"]) {
             if (this.buffers.ids.isValue) {

package/World/Archive/Classes/ImportedSector.js

@@ -29,7 +29,6 @@ class ImportedSectorPalettes {
         };
     }
 }
-const temp = ["", 0, 0];
 export class ImportedSector {
     sector;
     sections = [];

package/World/Archive/Functions/Sector/ArchiveSector.js

@@ -34,7 +34,7 @@ export default function ArchiveSector(archiveData) {
             if (!processedSection.palettes.voxels.isRegistered(voxelId))
                 processedSection.palettes.voxels.register(voxelId);
             let voxelSecondary = 0;
-            if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxels[section.ids[i]][0]]["dve_can_have_secondary"]) {
+            if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxelIdToTrueId[section.ids[i]]]["dve_can_have_secondary"]) {
                 voxelSecondary = sectorPalettes.voxels.register(section.secondary[i]);
                 if (!processedSection.palettes.secondaryVoxels.isRegistered(voxelSecondary))
                     processedSection.palettes.secondaryVoxels.register(voxelSecondary);
@@ -140,7 +140,7 @@ export default function ArchiveSector(archiveData) {
         const length = archivedSection.original.ids.length;
         for (let i = 0; i < length; i++) {
             let secondary = false;
-            if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxels[archivedSection.original.ids[i]][0]]["dve_can_have_secondary"] &&
+            if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxelIdToTrueId[archivedSection.original.ids[i]]]["dve_can_have_secondary"] &&
                 archivedSection.original.secondary[i] !== 0) {
                 secondary = true;
             }

package/World/Archive/Functions/Sector/ImportSector.d.ts

@@ -2,6 +2,7 @@ import { SectorData } from "../../../index";
 import { ArchivedSectorData } from "../../Types/index";
 type RunData = {
     version?: number;
+    healLight?: boolean;
 };
 export default function ImportSector(archivedSector: ArchivedSectorData, archiveData: RunData): SectorData;
 export {};

package/World/Archive/Functions/Sector/ImportSector.js

@@ -2,30 +2,206 @@ import { WorldSpaces } from "../../../WorldSpaces";
 import { Sector } from "../../../index";
 import { ImportedSector } from "../../Classes/ImportedSector";
 import { Vector3Like } from "@amodx/math";
+import { VoxelLUT } from "../../../../Voxels/Data/VoxelLUT";
+import { VoxelTagsRegister } from "../../../../Voxels/Data/VoxelTagsRegister";
+import { BinaryBufferFormat } from "../../../../Util/BinaryBuffer/index";
+import { lightSemgnetSet } from "../../Functions/Shared/LightSegments";
 export default function ImportSector(archivedSector, archiveData) {
     const sector = new Sector();
     sector.setBuffer(Sector.CreateNewBuffer());
     sector.position[0] = archivedSector.position.x;
     sector.position[1] = archivedSector.position.y;
     sector.position[2] = archivedSector.position.z;
+    if (archiveData.healLight) {
+        archivedSector.flags["dve_is_world_progation_done"] = false;
+        archivedSector.flags["dve_is_world_sun_done"] = false;
+    }
     sector.loadFlags(archivedSector.flags);
     sector.loadTimestamps(archivedSector.timestamps);
     const importedSector = new ImportedSector(archivedSector);
     const position = Vector3Like.Create();
+    const sectionVolume = WorldSpaces.section.volumne;
     for (const importedSection of importedSector.sections) {
         const archivedSection = importedSection.section;
         const section = sector.sections[importedSection.sectionIndex];
         archivedSection.flags && section.loadFlags(archivedSection.flags);
-        section.dirtyMap.fill(0xff);
-        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.dirtyMap.fill(0);
+        const idsBuffer = importedSection.buffers.ids;
+        const levelBuffer = importedSection.buffers.level;
+        const secondaryBuffer = importedSection.buffers.secondary;
+        const lightBuffers = importedSection.buffers.light;
+        const sectionPalettes = importedSection.palettes;
+        const sectorPalettes = importedSection.sector.palettes;
+        const voxelReader = importedSection.sector.voxels;
+        let voxelIdLUT = null;
+        if (!idsBuffer.isValue && sectionPalettes.voxels) {
+            const paletteSize = sectionPalettes.voxels.size;
+            voxelIdLUT = new Uint16Array(paletteSize);
+            for (let p = 0; p < paletteSize; p++) {
+                const paletteValue = sectionPalettes.voxels.getValue(p);
+                voxelIdLUT[p] = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(paletteValue));
+            }
+        }
+        let secondaryIdLUT = null;
+        if (!secondaryBuffer.isValue && sectionPalettes.secondaryVoxels) {
+            const paletteSize = sectionPalettes.secondaryVoxels.size;
+            secondaryIdLUT = new Uint16Array(paletteSize);
+            for (let p = 0; p < paletteSize; p++) {
+                const paletteValue = sectionPalettes.secondaryVoxels.getValue(p);
+                secondaryIdLUT[p] = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(paletteValue));
+            }
+        }
+        if (idsBuffer.isValue) {
+            const voxelId = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(idsBuffer.getValue(0)));
+            section.ids.fill(voxelId);
+        }
+        if (levelBuffer.isValue) {
+            let levelValue = levelBuffer.getValue(0);
+            if (sectionPalettes.level) {
+                levelValue = sectionPalettes.level.getValue(levelValue);
+            }
+            else if (sectorPalettes.level) {
+                levelValue = sectorPalettes.level.getValue(levelValue);
+            }
+            section.level.fill(levelValue);
+        }
+        const sunIsValue = lightBuffers.sun.isValue;
+        const redIsValue = lightBuffers.red.isValue;
+        const greenIsValue = lightBuffers.green.isValue;
+        const blueIsValue = lightBuffers.blue.isValue;
+        if (sunIsValue && redIsValue && greenIsValue && blueIsValue) {
+            let finalLight = 0;
+            finalLight = lightSemgnetSet.sun(lightBuffers.sun.getValue(0), finalLight);
+            finalLight = lightSemgnetSet.red(lightBuffers.red.getValue(0), finalLight);
+            finalLight = lightSemgnetSet.green(lightBuffers.green.getValue(0), finalLight);
+            finalLight = lightSemgnetSet.blue(lightBuffers.blue.getValue(0), finalLight);
+            section.light.fill(finalLight);
+        }
+        const needsPerVoxelIds = !idsBuffer.isValue;
+        const needsPerVoxelLevel = !levelBuffer.isValue;
+        const needsPerVoxelSecondary = !secondaryBuffer.isValue;
+        const needsPerVoxelLight = !(sunIsValue &&
+            redIsValue &&
+            greenIsValue &&
+            blueIsValue);
+        if (!needsPerVoxelIds &&
+            !needsPerVoxelLevel &&
+            !needsPerVoxelSecondary &&
+            !needsPerVoxelLight) {
+            const staticId = section.ids[0];
+            const trueVoxelId = VoxelLUT.voxelIdToTrueId[staticId];
+            if (VoxelTagsRegister.VoxelTags[trueVoxelId]?.["dve_can_have_secondary"]) {
+                const secondaryValue = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(secondaryBuffer.getValue(0)));
+                section.secondary.fill(secondaryValue);
+            }
+            const staticSecondary = section.secondary[0];
+            if (staticId !== 0 || staticSecondary !== 0) {
+                for (let i = 0; i < sectionVolume; i++) {
+                    section.setHasVoxel(WorldSpaces.voxel.getPositionFromIndex(i, position).y, true);
+                }
+            }
+            if (archiveData.healLight) {
+                section.light.fill(0);
+            }
+            continue;
+        }
+        const sunPalette = sectionPalettes.light.sun || sectorPalettes.light.sun;
+        const redPalette = sectionPalettes.light.red || sectorPalettes.light.red;
+        const greenPalette = sectionPalettes.light.green || sectorPalettes.light.green;
+        const bluePalette = sectionPalettes.light.blue || sectorPalettes.light.blue;
+        const sunIsNibble = lightBuffers.sun.format === BinaryBufferFormat.NibbleArray;
+        const redIsNibble = lightBuffers.red.format === BinaryBufferFormat.NibbleArray;
+        const greenIsNibble = lightBuffers.green.format === BinaryBufferFormat.NibbleArray;
+        const blueIsNibble = lightBuffers.blue.format === BinaryBufferFormat.NibbleArray;
+        for (let i = 0; i < sectionVolume; i++) {
+            let voxelId;
+            if (needsPerVoxelIds) {
+                const rawValue = idsBuffer.getValue(i);
+                if (voxelIdLUT) {
+                    voxelId = voxelIdLUT[rawValue];
+                }
+                else {
+                    voxelId = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(rawValue));
+                }
+                section.ids[i] = voxelId;
+            }
+            else {
+                voxelId = section.ids[i];
+            }
+            if (needsPerVoxelLevel) {
+                let levelValue = levelBuffer.getValue(i);
+                if (sectionPalettes.level) {
+                    levelValue = sectionPalettes.level.getValue(levelValue);
+                }
+                else if (sectorPalettes.level) {
+                    levelValue = sectorPalettes.level.getValue(levelValue);
+                }
+                section.level[i] = levelValue;
+            }
+            if (needsPerVoxelLight) {
+                let finalLight = 0;
+                if (!sunIsValue) {
+                    let sunValue = lightBuffers.sun.getValue(i);
+                    if (!sunIsNibble && sunPalette) {
+                        sunValue = sunPalette.getValue(sunValue);
+                    }
+                    finalLight = lightSemgnetSet.sun(sunValue, finalLight);
+                }
+                else {
+                    finalLight = lightSemgnetSet.sun(lightBuffers.sun.getValue(0), finalLight);
+                }
+                if (!redIsValue) {
+                    let redValue = lightBuffers.red.getValue(i);
+                    if (!redIsNibble && redPalette) {
+                        redValue = redPalette.getValue(redValue);
+                    }
+                    finalLight = lightSemgnetSet.red(redValue, finalLight);
+                }
+                else {
+                    finalLight = lightSemgnetSet.red(lightBuffers.red.getValue(0), finalLight);
+                }
+                if (!greenIsValue) {
+                    let greenValue = lightBuffers.green.getValue(i);
+                    if (!greenIsNibble && greenPalette) {
+                        greenValue = greenPalette.getValue(greenValue);
+                    }
+                    finalLight = lightSemgnetSet.green(greenValue, finalLight);
+                }
+                else {
+                    finalLight = lightSemgnetSet.green(lightBuffers.green.getValue(0), finalLight);
+                }
+                if (!blueIsValue) {
+                    let blueValue = lightBuffers.blue.getValue(i);
+                    if (!blueIsNibble && bluePalette) {
+                        blueValue = bluePalette.getValue(blueValue);
+                    }
+                    finalLight = lightSemgnetSet.blue(blueValue, finalLight);
+                }
+                else {
+                    finalLight = lightSemgnetSet.blue(lightBuffers.blue.getValue(0), finalLight);
+                }
+                section.light[i] = finalLight;
+            }
+            const trueVoxelId = VoxelLUT.voxelIdToTrueId[voxelId];
+            const rawSecondary = secondaryBuffer.getValue(i);
+            if (VoxelTagsRegister.VoxelTags[trueVoxelId]?.["dve_can_have_secondary"]) {
+                if (secondaryIdLUT) {
+                    section.secondary[i] = secondaryIdLUT[rawSecondary];
+                }
+                else {
+                    section.secondary[i] = VoxelLUT.getVoxelIdFromString(...voxelReader.getVoxelData(rawSecondary));
+                }
+            }
+            else {
+                section.secondary[i] = 0;
+            }
             if (section.ids[i] !== 0 || section.secondary[i] !== 0) {
-                section.setHasVoxel(WorldSpaces.voxel.getPositionFromIndex(i, position).y - 1, true);
+                section.setHasVoxel(WorldSpaces.voxel.getPositionFromIndex(i, position).y, true);
             }
         }
+        if (archiveData.healLight) {
+            section.light.fill(0);
+        }
     }
     sector.setBitFlag(Sector.FlagIds.stored, true);
     return sector;

package/World/Cursor/SectorCursor.js

@@ -46,10 +46,7 @@ export class SectorCursor {
             return null;
         const section = this._current.sections[WorldSpaces.section.getIndex(x, y, z)];
         if (!section) {
-            if (!section)
-                throw new Error(`Could not load section at ${x}-${y}-${z} | ${WorldSpaces.section.getIndex(x, y, z)}`);
-            this._section = null;
-            return null;
+            throw new Error(`Could not load section at ${x}-${y}-${z} | ${WorldSpaces.section.getIndex(x, y, z)}`);
         }
         return section;
     }

package/World/Cursor/WorldCursor.d.ts

@@ -3,11 +3,20 @@ import { SectorCursor } from "./SectorCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 export declare class WorldCursor implements DataCursorInterface {
-    volumeBounds: BoundingBox;
-    sectorCursors: Record<number, Record<number, SectorCursor | null>>;
+    sectorCursors: Map<number, Map<number, SectorCursor>>;
+    activeCursors: SectorCursor[];
     origin: Vector3Like;
     dimension: number;
-    _lastPosition: Vector3Like;
+    _sectorPowerX: number;
+    _sectorPowerY: number;
+    _sectorPowerZ: number;
+    _minX: number;
+    _minY: number;
+    _minZ: number;
+    _maxX: number;
+    _maxY: number;
+    _maxZ: number;
+    volumeBounds: BoundingBox;
     constructor();
     private updateBounds;
     setFocalPoint(dimension: number, x: number, y: number, z: number): void;

package/World/Cursor/WorldCursor.js

@@ -5,55 +5,85 @@ import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor {
-    volumeBounds = new BoundingBox();
-    sectorCursors = {};
+    sectorCursors = new Map();
+    activeCursors = [];
     origin = Vector3Like.Create();
     dimension = 0;
-    _lastPosition = Vector3Like.Create();
+    _sectorPowerX = 0;
+    _sectorPowerY = 0;
+    _sectorPowerZ = 0;
+    _minX = 0;
+    _minY = 0;
+    _minZ = 0;
+    _maxX = 0;
+    _maxY = 0;
+    _maxZ = 0;
+    volumeBounds = new BoundingBox();
     constructor() {
         this.updateBounds();
     }
     updateBounds() {
+        const world = WorldSpaces.world.bounds;
+        this._minX = world.MinX;
+        this._minY = world.MinY;
+        this._minZ = world.MinZ;
+        this._maxX = world.MaxX;
+        this._maxY = world.MaxY;
+        this._maxZ = world.MaxZ;
+        this._sectorPowerX = WorldSpaces.sector.power2Axes.x;
+        this._sectorPowerY = WorldSpaces.sector.power2Axes.y;
+        this._sectorPowerZ = WorldSpaces.sector.power2Axes.z;
         this.volumeBounds.setMinMax(Vector3Like.Create(WorldSpaces.world.bounds.MinX, WorldSpaces.world.bounds.MinY, WorldSpaces.world.bounds.MinZ), Vector3Like.Create(WorldSpaces.world.bounds.MaxX, WorldSpaces.world.bounds.MaxY, WorldSpaces.world.bounds.MaxZ));
     }
     setFocalPoint(dimension, x, y, z) {
-        const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
-        for (const row in this.sectorCursors) {
-            for (const col in this.sectorCursors[row]) {
-                const cursor = this.sectorCursors[row][col];
-                if (!cursor)
-                    continue;
+        const sectorPosX = (x >> this._sectorPowerX) << this._sectorPowerX;
+        const sectorPosY = (y >> this._sectorPowerY) << this._sectorPowerY;
+        const sectorPosZ = (z >> this._sectorPowerZ) << this._sectorPowerZ;
+        this.sectorCursors.forEach((row) => {
+            row.forEach((cursor) => {
                 cursorCache.push(cursor);
-                this.sectorCursors[row][col] = null;
-            }
-        }
+            });
+            row.clear();
+        });
+        this.sectorCursors.clear();
         this.dimension = dimension;
-        this.origin.x = sectorPos.x / WorldSpaces.sector.bounds.x;
-        this.origin.y = sectorPos.y / WorldSpaces.sector.bounds.y;
-        this.origin.z = sectorPos.z / WorldSpaces.sector.bounds.z;
+        this.origin.x = sectorPosX >> this._sectorPowerX;
+        this.origin.y = sectorPosY >> this._sectorPowerY;
+        this.origin.z = sectorPosZ >> this._sectorPowerZ;
         this.getSector(x, y, z);
     }
     inBounds(x, y, z) {
-        return WorldSpaces.world.inBounds(x, y, z);
+        return (x >= this._minX &&
+            x <= this._maxX &&
+            y >= this._minY &&
+            y <= this._maxY &&
+            z >= this._minZ &&
+            z <= this._maxZ);
     }
     getSector(x, y, z) {
         if (!this.inBounds(x, y, z))
             return null;
-        const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
-        const cx = sectorPos.x / WorldSpaces.sector.bounds.x - this.origin.x;
-        const cz = sectorPos.z / WorldSpaces.sector.bounds.z - this.origin.z;
-        let cursor = this.sectorCursors[cx]?.[cz];
-        if (!cursor) {
-            cursor = cursorCache.length ? cursorCache.shift() : new SectorCursor();
-            if (!cursor.loadSector(this.dimension, sectorPos.x, sectorPos.y, sectorPos.z)) {
-                cursorCache.push(cursor);
-                return null;
-            }
-            if (!this.sectorCursors[cx]) {
-                this.sectorCursors[cx] = {};
-            }
-            this.sectorCursors[cx][cz] = cursor;
+        const sectorPosX = (x >> this._sectorPowerX) << this._sectorPowerX;
+        const sectorPosY = (y >> this._sectorPowerY) << this._sectorPowerY;
+        const sectorPosZ = (z >> this._sectorPowerZ) << this._sectorPowerZ;
+        const cx = (sectorPosX >> this._sectorPowerX) - this.origin.x;
+        const cz = (sectorPosZ >> this._sectorPowerZ) - this.origin.z;
+        let row = this.sectorCursors.get(cx);
+        if (row) {
+            const cursor = row.get(cz);
+            if (cursor)
+                return cursor;
+        }
+        else {
+            row = new Map();
+            this.sectorCursors.set(cx, row);
+        }
+        const cursor = cursorCache.length ? cursorCache.pop() : new SectorCursor();
+        if (!cursor.loadSector(this.dimension, sectorPosX, sectorPosY, sectorPosZ)) {
+            cursorCache.push(cursor);
+            return null;
         }
+        row.set(cz, cursor);
         return cursor;
     }
     getVoxel(x, y, z) {

package/World/InitTasks.js

@@ -10,7 +10,7 @@ export default function ({ threads, worldStorage, }) {
     WorldRegister.sectors.setSecotrBufferPool(true);
     const loadInMap = new Map();
     Threads.registerTask("cache-snap-shot", (data) => {
-        const snapShot = SnapShots._pendingCache.shift();
+        const snapShot = SnapShots._pendingCache.pop();
         snapShot.restore(data);
         SnapShots._readyCache.push(snapShot);
     });

package/World/Lock/Function/LockSectors.js

@@ -21,7 +21,11 @@ export default async function LockSectors(dimension, bounds) {
             }
         }
     }
-    await Promise.all(waitingToLockSectors.map((_) => _.waitTillCheckedIn()));
+    const proms = [];
+    for (const _ of waitingToLockSectors) {
+        proms.push(_.waitTillCheckedIn());
+    }
+    await Promise.all(proms);
     for (const sector of waitingToLockSectors) {
         sector.setLocked(true);
     }

package/World/Lock/Function/UnLockSectors.js

@@ -21,7 +21,11 @@ export default async function UnLockSectors(dimension, bounds) {
             }
         }
     }
-    await Promise.all(waitingToLockSectors.map((_) => _.waitTillCheckedIn()));
+    const proms = [];
+    for (const _ of waitingToLockSectors) {
+        proms.push(_.waitTillCheckedIn());
+    }
+    await Promise.all(proms);
     for (const sector of waitingToLockSectors) {
         sector.setLocked(false);
     }

package/World/SnapShot/SectionSnapShot.d.ts

@@ -1,16 +1,20 @@
-import { Flat3DIndex } from "@amodx/math";
 import { LocationData } from "../../Math";
 export interface SectionSnapShotTransferData {
     location: LocationData;
     sections: Uint8Array[];
+    used: boolean[];
 }
 export declare class SectionSnapShot {
     sections: Uint8Array[];
     location: LocationData;
-    index: Flat3DIndex;
     private _buffers;
+    private _used;
+    private _sectionSizeX;
+    private _sectionSizeY;
+    private _sectionSizeZ;
     constructor();
-    setLocation([dimension, x, y, z]: LocationData): void;
+    private _updateSizes;
+    setLocation(dimension: number, x: number, y: number, z: number): void;
     storeSnapShot(): void;
     private _isTransfered;
     isTransfered(): boolean;