@divinevoxel/vlox 0.0.80 → 0.0.81

package/World/SnapShot/SectionSnapShot.js

@@ -1,46 +1,71 @@
-import { Flat3DIndex } from "@amodx/math";
 import { WorldSpaces } from "../WorldSpaces";
 import { Section } from "../Section/Section";
 import { WorldRegister } from "../WorldRegister";
 export class SectionSnapShot {
     sections = [];
     location = [0, 0, 0, 0];
-    index = Flat3DIndex.GetXYZOrder();
     _buffers = [];
+    _used = [];
+    _sectionSizeX = 0;
+    _sectionSizeY = 0;
+    _sectionSizeZ = 0;
     constructor() {
-        this.index.setBounds(3, 3, 3);
-        let totalSections = this.index.size;
-        while (totalSections--) {
+        const totalSections = 27;
+        for (let i = 0; i < totalSections; i++) {
             const buffer = new ArrayBuffer(Section.GetBufferSize());
             this.sections.push(new Uint8Array(buffer));
             this._buffers.push(buffer);
+            this._used[i] = false;
         }
+        this._updateSizes();
     }
-    setLocation([dimension, x, y, z]) {
+    _updateSizes() {
+        this._sectionSizeX = WorldSpaces.section.bounds.x;
+        this._sectionSizeY = WorldSpaces.section.bounds.y;
+        this._sectionSizeZ = WorldSpaces.section.bounds.z;
+    }
+    setLocation(dimension, x, y, z) {
         this.location[0] = dimension;
         this.location[1] = x;
         this.location[2] = y;
         this.location[3] = z;
     }
     storeSnapShot() {
-        const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.section.bounds;
-        const [dim, ox, oy, oz] = this.location;
-        for (let x = 0; x < 3; x++) {
+        const sizeX = this._sectionSizeX;
+        const sizeY = this._sectionSizeY;
+        const sizeZ = this._sectionSizeZ;
+        const dim = this.location[0];
+        const ox = this.location[1];
+        const oy = this.location[2];
+        const oz = this.location[3];
+        const sections = this.sections;
+        const used = this._used;
+        const world = WorldSpaces.world;
+        const sectorReg = WorldRegister.sectors;
+        let index = 0;
+        for (let z = 0; z < 3; z++) {
+            const wz = oz + (z - 1) * sizeZ;
             for (let y = 0; y < 3; y++) {
-                for (let z = 0; z < 3; z++) {
+                const wy = oy + (y - 1) * sizeY;
+                for (let x = 0; x < 3; x++) {
                     const wx = ox + (x - 1) * sizeX;
-                    const wy = oy + (y - 1) * sizeY;
-                    const wz = oz + (z - 1) * sizeZ;
-                    const snapShotSection = this.sections[this.index.getIndexXYZ(x, y, z)];
-                    if (!WorldSpaces.world.inBounds(wx, wy, wz)) {
-                        snapShotSection.fill(0);
+                    const i = index++;
+                    const snapShotSection = sections[i];
+                    const beenUsed = used[i];
+                    if (!world.inBounds(wx, wy, wz)) {
+                        if (beenUsed)
+                            snapShotSection.fill(0);
+                        used[i] = false;
                         continue;
                     }
-                    const sector = WorldRegister.sectors.get(dim, wx, wy, wz);
+                    const sector = sectorReg.get(dim, wx, wy, wz);
                     if (!sector) {
-                        snapShotSection.fill(0);
+                        if (beenUsed)
+                            snapShotSection.fill(0);
+                        used[i] = false;
                         continue;
                     }
+                    used[i] = true;
                     snapShotSection.set(sector.getSection(wx, wy, wz).view);
                 }
             }
@@ -54,8 +79,9 @@ export class SectionSnapShot {
         this._isTransfered = true;
         return [
             {
-                location: [...this.location],
-                sections: [...this.sections],
+                location: this.location,
+                sections: this.sections,
+                used: this._used,
             },
             this._buffers,
         ];
@@ -63,10 +89,10 @@ export class SectionSnapShot {
     restore(data) {
         this.sections = data.sections;
         this.location = data.location;
-        this._buffers = [];
+        this._used = data.used;
         this._isTransfered = false;
         for (let i = 0; i < this.sections.length; i++) {
-            this._buffers.push(this.sections[i].buffer);
+            this._buffers[i] = this.sections[i].buffer;
         }
     }
 }

package/World/SnapShot/SectionSnapShotCursor.d.ts

@@ -1,4 +1,4 @@
-import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { SectionSnapShot } from "./SectionSnapShot";
 import { Sector } from "../Sector";
@@ -12,7 +12,9 @@ export declare class SectionSnapshotCursor implements DataCursorInterface {
     volumeBounds: BoundingBox;
     sectors: Sector[];
     cursors: SectorCursor[];
-    index: Flat3DIndex;
+    private invSectorSizeX;
+    private invSectorSizeY;
+    private invSectorSizeZ;
     constructor();
     private updateBounds;
     private _snapShot;

package/World/SnapShot/SectionSnapShotCursor.js

@@ -1,4 +1,4 @@
-import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../WorldSpaces";
 import { Sector } from "../Sector";
 import { SectorCursor } from "../Cursor/SectorCursor";
@@ -12,16 +12,22 @@ export class SectionSnapshotCursor {
     volumeBounds = new BoundingBox();
     sectors = [];
     cursors = [];
-    index = Flat3DIndex.GetXYZOrder();
+    invSectorSizeX = 0;
+    invSectorSizeY = 0;
+    invSectorSizeZ = 0;
     constructor() {
-        this.index.setBounds(3, 3, 3);
+        // Initialize inverse sizes FIRST
+        this.invSectorSizeX = 1 / WorldSpaces.sector.bounds.x;
+        this.invSectorSizeY = 1 / WorldSpaces.sector.bounds.y;
+        this.invSectorSizeZ = 1 / WorldSpaces.sector.bounds.z;
         const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.sector.bounds;
         for (let x = 0; x < 3; x++) {
             for (let y = 0; y < 3; y++) {
                 for (let z = 0; z < 3; z++) {
                     if (!WorldSpaces.world.inBounds((x - 1) * sizeX, (y - 1) * sizeY, (z - 1) * sizeZ))
                         continue;
-                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    // Use direct index calculation here — we're iterating grid positions, not world coords
+                    const sectorIndex = x + y * 3 + z * 9;
                     const sector = new Sector();
                     sector.setBuffer(Sector.CreateNewBuffer());
                     const cursor = new SectorCursor();
@@ -35,6 +41,9 @@ export class SectionSnapshotCursor {
     }
     updateBounds() {
         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));
+        this.invSectorSizeX = 1 / WorldSpaces.sector.bounds.x;
+        this.invSectorSizeY = 1 / WorldSpaces.sector.bounds.y;
+        this.invSectorSizeZ = 1 / WorldSpaces.sector.bounds.z;
     }
     _snapShot;
     _centeralCursor = new SectionCursor();
@@ -62,7 +71,8 @@ export class SectionSnapshotCursor {
         for (let x = 0; x < 3; x++) {
             for (let y = 0; y < 3; y++) {
                 for (let z = 0; z < 3; z++) {
-                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    // Direct index — these are grid positions, not world coords
+                    const sectorIndex = x + y * 3 + z * 9;
                     const sector = this.sectors[sectorIndex];
                     if (!sector)
                         continue;
@@ -89,23 +99,25 @@ export class SectionSnapshotCursor {
                         continue;
                     const section = sector.getSection(sectionX, sectionY, sectionZ);
                     section.updatePosition();
-                    section.view.set(snapShot.sections[snapShot.index.getIndexXYZ(x, y, z)]);
+                    section.view.set(snapShot.sections[x + y * 3 + z * 9]);
                 }
             }
         }
     }
     getSectorIndex(x, y, z) {
-        const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
-        return this.index.getIndexXYZ((sectorPos.x - this.sectorOrigin.x) / WorldSpaces.sector.bounds.x + 1, (sectorPos.y - this.sectorOrigin.y) / WorldSpaces.sector.bounds.y + 1, (sectorPos.z - this.sectorOrigin.z) / WorldSpaces.sector.bounds.z + 1);
+        const ix = ((x - this.sectorOrigin.x) * this.invSectorSizeX + 1) | 0;
+        const iy = ((y - this.sectorOrigin.y) * this.invSectorSizeY + 1) | 0;
+        const iz = ((z - this.sectorOrigin.z) * this.invSectorSizeZ + 1) | 0;
+        return ix + iy * 3 + iz * 9;
     }
     inBounds(x, y, z) {
         return WorldSpaces.world.inBounds(x, y, z);
     }
     getVoxel(x, y, z) {
-        const sector = this.cursors[this.getSectorIndex(x, y, z)];
-        if (!sector)
+        const cursor = this.cursors[this.getSectorIndex(x, y, z)];
+        if (!cursor)
             return null;
-        return sector.getVoxel(x, y, z);
+        return cursor.getVoxel(x, y, z);
     }
     clone() {
         return new SectionSnapshotCursor();

package/World/SnapShot/SnapShots.d.ts

@@ -1,4 +1,3 @@
-import { LocationData } from "../../Math";
 import { SectionSnapShot } from "./SectionSnapShot";
 import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 export declare class SnapShots {
@@ -6,6 +5,6 @@ export declare class SnapShots {
     static _pendingCache: SectionSnapShot[];
     private static bounds;
     static getSnapShotBounds(x: number, y: number, z: number): Readonly<BoundingBox>;
-    static createSnapShot(location: LocationData): SectionSnapShot;
+    static createSnapShot(dimension: number, x: number, y: number, z: number): SectionSnapShot;
     static transferSnapShot(snapShot: SectionSnapShot): void;
 }

package/World/SnapShot/SnapShots.js

@@ -10,11 +10,11 @@ export class SnapShots {
         this.bounds.setMinMax(WorldSpaces.section.transformPosition(Vector3Like.Subtract({ x, y, z }, WorldSpaces.section.bounds)), WorldSpaces.section.transformPosition(Vector3Like.Add({ x, y, z }, WorldSpaces.section.bounds)));
         return this.bounds;
     }
-    static createSnapShot(location) {
+    static createSnapShot(dimension, x, y, z) {
         let snapShot = this._readyCache.length
-            ? this._readyCache.shift()
+            ? this._readyCache.pop()
             : new SectionSnapShot();
-        snapShot.setLocation(location);
+        snapShot.setLocation(dimension, x, y, z);
         snapShot.storeSnapShot();
         return snapShot;
     }

package/World/WorldSpaces.d.ts

@@ -40,6 +40,10 @@ declare class SectorSpace {
     static bounds: Vector3Like;
     static volumne: number;
     static sectionBounds: Vector3Like;
+    static sectionPower2Axes: Vector3Like;
+    static sectionXZPower: number;
+    static sectionZMask: number;
+    static sectionXMask: number;
     static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static transformPosition(position: Vector3Like): Vector3Like;
@@ -49,6 +53,9 @@ declare class SectionSpace {
     static power2Axes: Vector3Like;
     static bounds: Vector3Like;
     static volumne: number;
+    static xzPower: number;
+    static zMask: number;
+    static xMask: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;

package/World/WorldSpaces.js

@@ -1,7 +1,6 @@
-//types
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { Vector3Like } from "@amodx/math";
-import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, GetYXZOrderArrayPositionVec3Array, } from "../Math/Indexing.js";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, GetYXZOrderArrayPositionVec3Array, } from "../Math/WorldIndexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
 class WorldBounds {
@@ -16,7 +15,7 @@ class WorldBounds {
     static setWorldBounds(minX, minY, minZ, maxX, maxY, maxZ) {
         this.bounds.MinX = minX;
         this.bounds.MaxX = maxX;
-        this.bounds.MinX = minZ;
+        this.bounds.MinZ = minZ;
         this.bounds.MaxZ = maxZ;
         this.bounds.MinY = minY;
         this.bounds.MaxY = maxY;
@@ -58,6 +57,10 @@ class SectorSpace {
     static bounds = Vector3Like.Create();
     static volumne = 0;
     static sectionBounds = Vector3Like.Create();
+    static sectionPower2Axes = Vector3Like.Create();
+    static sectionXZPower = 0;
+    static sectionZMask = 0;
+    static sectionXMask = 0;
     static sectionVolumne = 0;
     static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
         CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
@@ -76,6 +79,9 @@ class SectionSpace {
     static power2Axes = Vector3Like.Create();
     static bounds = Vector3Like.Create();
     static volumne = 0;
+    static xzPower = 0;
+    static zMask = 0;
+    static xMask = 0;
     static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
         CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
         return refPosition;
@@ -85,19 +91,19 @@ class SectionSpace {
         return position;
     }
     static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
-        CubeHashVec3Array(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
+        CubeHashVec3Array(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
         return refPosition;
     }
     static getIndex(x, y, z) {
         SectionSpace.getPosition(x, y, z, tempPosition);
         SectorSpace.getPosition(x, y, z, tempPosition2);
-        return GetYXZOrderArrayIndex((tempPosition.x - tempPosition2.x) / SectionSpace.bounds.x, (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y, (tempPosition.z - tempPosition2.z) / SectionSpace.bounds.z, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z);
+        return GetYXZOrderArrayIndex((tempPosition.x - tempPosition2.x) >> SectionSpace.power2Axes.x, (tempPosition.y - tempPosition2.y) >> SectionSpace.power2Axes.y, (tempPosition.z - tempPosition2.z) >> SectionSpace.power2Axes.z, SectorSpace.sectionPower2Axes.z, SectorSpace.sectionXZPower);
     }
     static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
-        return GetYXZOrderArrayPositionVec3(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
+        return GetYXZOrderArrayPositionVec3(index, SectorSpace.sectionPower2Axes.z, SectorSpace.sectionXZPower, SectorSpace.sectionZMask, SectorSpace.sectionXMask, refPosition);
     }
     static getPositionFromIndexVec3Array(index, refPosition = [0, 0, 0]) {
-        return GetYXZOrderArrayPositionVec3Array(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
+        return GetYXZOrderArrayPositionVec3Array(index, SectorSpace.sectionPower2Axes.z, SectorSpace.sectionXZPower, SectorSpace.sectionZMask, SectorSpace.sectionXMask, refPosition);
     }
 }
 class VoxelSpace {
@@ -125,14 +131,14 @@ class VoxelSpace {
         return position;
     }
     static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
-        return GetYXZOrderArrayPositionVec3(index, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
+        return GetYXZOrderArrayPositionVec3(index, SectionSpace.power2Axes.z, SectionSpace.xzPower, SectionSpace.zMask, SectionSpace.xMask, refPosition);
     }
     static getIndex(x, y, z) {
         const position = this.getPosition(x, y, z, tempPosition);
-        return GetYXZOrderArrayIndex(position.x, position.y, position.z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+        return GetYXZOrderArrayIndex(position.x, position.y, position.z, SectionSpace.power2Axes.z, SectionSpace.xzPower);
     }
     static getIndexFromPosition(x, y, z) {
-        return GetYXZOrderArrayIndex(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+        return GetYXZOrderArrayIndex(x, y, z, SectionSpace.power2Axes.z, SectionSpace.xzPower);
     }
 }
 class Hash {
@@ -189,11 +195,27 @@ EngineSettings.addEventListener("synced", (event) => {
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;
     SectionSpace.volumne =
         SectionSpace.bounds.x * SectionSpace.bounds.y * SectionSpace.bounds.z;
-    SectorSpace.sectionBounds.x = SectorSpace.bounds.x / SectionSpace.bounds.x;
-    SectorSpace.sectionBounds.y = SectorSpace.bounds.y / SectionSpace.bounds.y;
-    SectorSpace.sectionBounds.z = SectorSpace.bounds.z / SectionSpace.bounds.z;
+    SectionSpace.xzPower = SectionSpace.power2Axes.x + SectionSpace.power2Axes.z;
+    SectionSpace.zMask = SectionSpace.bounds.z - 1;
+    SectionSpace.xMask = SectionSpace.bounds.x - 1;
+    SectorSpace.sectionBounds.x =
+        SectorSpace.bounds.x >> SectionSpace.power2Axes.x;
+    SectorSpace.sectionBounds.y =
+        SectorSpace.bounds.y >> SectionSpace.power2Axes.y;
+    SectorSpace.sectionBounds.z =
+        SectorSpace.bounds.z >> SectionSpace.power2Axes.z;
     SectorSpace.sectionVolumne =
         SectorSpace.sectionBounds.x *
             SectorSpace.sectionBounds.y *
             SectorSpace.sectionBounds.z;
+    SectorSpace.sectionPower2Axes.x =
+        SectorSpace.power2Axes.x - SectionSpace.power2Axes.x;
+    SectorSpace.sectionPower2Axes.y =
+        SectorSpace.power2Axes.y - SectionSpace.power2Axes.y;
+    SectorSpace.sectionPower2Axes.z =
+        SectorSpace.power2Axes.z - SectionSpace.power2Axes.z;
+    SectorSpace.sectionXZPower =
+        SectorSpace.sectionPower2Axes.x + SectorSpace.sectionPower2Axes.z;
+    SectorSpace.sectionZMask = SectorSpace.sectionBounds.z - 1;
+    SectorSpace.sectionXMask = SectorSpace.sectionBounds.x - 1;
 });

package/WorldSimulation/Dimensions/DimensionSegment.d.ts

@@ -11,6 +11,7 @@ declare class ActiveSectors {
     _map: Map<string, SimulationSector>;
     constructor(dimension: DimensionSegment);
     add(x: number, y: number, z: number): false | undefined;
+    clearAll(): void;
     get(x: number, y: number, z: number): SimulationSector | null | undefined;
     remove(x: number, y: number, z: number): false | undefined;
 }
@@ -33,6 +34,7 @@ export declare class DimensionSegment {
     addTask(id: string, generationTask: boolean): void;
     getTask(id: string): TaskSegment;
     clearAllTasks(): void;
+    clearAll(): void;
     logTasks(): string;
 }
 export {};

package/WorldSimulation/Dimensions/DimensionSegment.js

@@ -24,6 +24,10 @@ class ActiveSectors {
         this._sectors.push(newSector);
         this._map.set(key, newSector);
     }
+    clearAll() {
+        this._sectors = [];
+        this._map.clear();
+    }
     get(x, y, z) {
         const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
         if (!this._map.has(key))
@@ -107,9 +111,13 @@ export class DimensionSegment {
     }
     clearAllTasks() {
         for (const [key, task] of this.tasks) {
-            task.clear();
+            task.clearAll();
         }
     }
+    clearAll() {
+        this.activeSectors.clearAll();
+        this.clearAllTasks();
+    }
     logTasks() {
         const tasks = [];
         for (const [key, task] of this.tasks) {

package/WorldSimulation/Dimensions/DimensionSimulation.js

@@ -1,5 +1,4 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
-import { VoxelFaces } from "../../Math";
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { WorldRegister } from "../../World/WorldRegister";
 import { Vector3Like } from "@amodx/math";
@@ -72,12 +71,12 @@ export class DimensionSimulation {
     nDataCursor = new WorldCursor();
     sDataCursor = new WorldCursor();
     tickCursor = {
-        [VoxelFaces.Up]: new WorldCursor(),
-        [VoxelFaces.Down]: new WorldCursor(),
-        [VoxelFaces.North]: new WorldCursor(),
-        [VoxelFaces.South]: new WorldCursor(),
-        [VoxelFaces.East]: new WorldCursor(),
-        [VoxelFaces.West]: new WorldCursor(),
+        [0 /* VoxelFaces.Up */]: new WorldCursor(),
+        [1 /* VoxelFaces.Down */]: new WorldCursor(),
+        [2 /* VoxelFaces.North */]: new WorldCursor(),
+        [3 /* VoxelFaces.South */]: new WorldCursor(),
+        [4 /* VoxelFaces.East */]: new WorldCursor(),
+        [5 /* VoxelFaces.West */]: new WorldCursor(),
     };
     bounds = new UpdatedBounds();
     brush;

package/WorldSimulation/Dimensions/Generator.d.ts

@@ -17,6 +17,7 @@ export declare class Generator {
     _generating: boolean;
     _isNew: boolean;
     _dirty: boolean;
+    _valuesUpdated: boolean;
     _waitingForCull: boolean;
     _cullTime: number;
     _culling: boolean;
@@ -27,5 +28,8 @@ export declare class Generator {
     _renderCircle: Circle;
     _maxCircle: Circle;
     constructor(data: GeneratorData);
+    setRenderRadius(value: number): void;
+    setGenRadius(value: number): void;
+    setMaxRadius(value: number): void;
     update(): void;
 }

package/WorldSimulation/Dimensions/Generator.js

@@ -8,6 +8,7 @@ export class Generator {
     _generating = true;
     _isNew = true;
     _dirty = true;
+    _valuesUpdated = false;
     _waitingForCull = false;
     _cullTime = 0;
     _culling = true;
@@ -28,8 +29,21 @@ export class Generator {
         this._tickCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
     }
+    setRenderRadius(value) {
+        this._renderCircle.radius = value;
+        this._valuesUpdated = true;
+    }
+    setGenRadius(value) {
+        this._genCircle.radius = value;
+        this._valuesUpdated = true;
+    }
+    setMaxRadius(value) {
+        this._maxCircle.radius = value;
+        this._valuesUpdated = true;
+    }
     update() {
-        this._dirty = false;
+        this._dirty = this._valuesUpdated;
+        this._valuesUpdated = false;
         WorldSpaces.section.getPosition(this.position.x, 0, this.position.z, this._sectorPosition);
         if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
             this._dirty = true;

package/WorldSimulation/Dimensions/SimulationSector.d.ts

@@ -29,5 +29,6 @@ export declare class SimulationSector {
     checkOut(thread: Thread): void;
     checkIn(thread: Thread): void;
     tickUpdate(doTickUpdate?: boolean): boolean;
+    updateGenAllDone(): 0 | 1 | 2 | 3;
     generateUpdate(): boolean | undefined;
 }

package/WorldSimulation/Dimensions/SimulationSector.js

@@ -188,6 +188,24 @@ export class SimulationSector {
         }
         return true;
     }
+    updateGenAllDone() {
+        if (this._genAllDone)
+            return 0;
+        if (!this.sector) {
+            const sector = WorldRegister.sectors.get(this.dimension.id, ...this.position);
+            if (!sector) {
+                return 1;
+            }
+            this.sector = sector;
+        }
+        const state = this.state.update();
+        if (state.nSunAllDone &&
+            this.sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+            this._genAllDone = true;
+            return 2;
+        }
+        return 3;
+    }
     generateUpdate() {
         if (!this.fullNeighbors)
             return false;

package/WorldSimulation/Internal/WorldSimulationTasks.js

@@ -8,6 +8,13 @@ import { EngineSettings } from "../../Settings/EngineSettings";
 import { SnapShots } from "../../World/SnapShot/SnapShots";
 import LockSectors from "../../World/Lock/Function/LockSectors";
 import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
+function createAndTransferSnapShot(task, taskId, dim, x, y, z) {
+    task.completeTask(taskId);
+    const snapShot = SnapShots.createSnapShot(dim, x, y, z);
+    WorldSimulationTools.taskTool.build.sectionSnapShot.run(...snapShot.transfer());
+    SnapShots.transferSnapShot(snapShot);
+    UnLockSectors(dim, SnapShots.getSnapShotBounds(x, y, z));
+}
 export class WorldSimulationTasks {
     /**# Load Sectors
      * ---
@@ -45,6 +52,7 @@ export class WorldSimulationTasks {
         generationTask: true,
         checkInRequired: true,
         log: true,
+        sort: true,
         checkDone(location) {
             const sector = WorldRegister.sectors.get(...location);
             if (!sector || sector.isCheckedOut())
@@ -163,7 +171,7 @@ export class WorldSimulationTasks {
      * ---
      */
     static buildTasks = TaskRegister.addTasks({
-        id: "build_tasks",
+        id: "build",
         sort: true,
         checkInRequired: false,
         run(dimension, location, taskId, task, simSector) {
@@ -180,16 +188,12 @@ export class WorldSimulationTasks {
             }
             const [dim, x, y, z] = location;
             LockSectors(dim, SnapShots.getSnapShotBounds(x, y, z)).then(() => {
-                task.completeTask(taskId);
-                const snapShot = SnapShots.createSnapShot(location);
-                WorldSimulationTools.taskTool.build.sectionSnapShot.run(...snapShot.transfer());
-                SnapShots.transferSnapShot(snapShot);
-                UnLockSectors(dim, SnapShots.getSnapShotBounds(x, y, z));
+                createAndTransferSnapShot(task, taskId, dim, x, y, z);
             });
         },
     });
     static unbuildTasks = TaskRegister.addTasks({
-        id: "unbuild_tasks",
+        id: "unbuild",
         sort: true,
         checkInRequired: false,
         run(dimension, location, taskId, task) {

package/WorldSimulation/Procedures/InitalLoad.d.ts

@@ -7,4 +7,5 @@ export declare function InitalLoad(props: {
     dimension?: number;
     logTasks?: true;
     genData: Partial<GeneratorData>;
+    buildOnly?: boolean;
 }): Promise<unknown>;

package/WorldSimulation/Procedures/InitalLoad.js

@@ -18,13 +18,13 @@ export async function InitalLoad(props) {
         }
         const dimension = WorldSimulationDimensions.getDimension(props.dimension || 0);
         let done = false;
-        generator._building = false;
+        generator._building = props.buildOnly || false;
         WorldSimulation.addGenerator(generator);
         let timeOut = null;
         const update = () => {
             if (done)
                 return;
-            WorldSimulation.tick(true);
+            WorldSimulation.tick(props.buildOnly ? false : true, props.buildOnly || false);
             timeOut = setTimeout(update, 0);
         };
         update();
@@ -33,12 +33,20 @@ export async function InitalLoad(props) {
                 console.log(WorldSimulation.logTasks());
             }
             let allDone = true;
-            for (const [key, task] of dimension.tasks) {
-                if (!task.generationTask)
-                    continue;
+            if (props.buildOnly) {
+                const task = dimension.tasks.get("build");
                 if (task.waitingFor > 0 || task._task.size > 0) {
                     allDone = false;
-                    break;
+                }
+            }
+            else {
+                for (const [key, task] of dimension.tasks) {
+                    if (!task.generationTask)
+                        continue;
+                    if (task.waitingFor > 0 || task._task.size > 0) {
+                        allDone = false;
+                        break;
+                    }
                 }
             }
             if (!allDone)
@@ -48,8 +56,10 @@ export async function InitalLoad(props) {
             clearTimeout(timeOut);
             WorldSimulation.removeGenerator(generator);
             (async () => {
-                if (WorldSimulationTools.worldStorage) {
-                    await SaveAllSectors();
+                if (!props.buildOnly) {
+                    if (WorldSimulationTools.worldStorage) {
+                        await SaveAllSectors();
+                    }
                 }
                 resolve(true);
             })();

package/WorldSimulation/Tasks/SimulationTaskBase.d.ts

@@ -13,9 +13,12 @@ export type SimulationTaskBaseData = {
 };
 export declare class SimulationTaskBase {
     data: SimulationTaskBaseData;
-    constructor(data: SimulationTaskBaseData);
+    parent?: SimulationTaskBase | undefined;
+    _subTask: Map<string, SimulationTaskBase>;
+    constructor(data: SimulationTaskBaseData, parent?: SimulationTaskBase | undefined);
     getTotal(dimensionId: number): number;
     getTotalWaitingFor(dimensionId: number): number;
     add(dimensionId: number, x: number, y: number, z: number): void;
+    addSubTask(data: SimulationTaskBaseData): void;
     runTask(max?: number): void;
 }