@divinevoxel/vlox 0.0.76 → 0.0.78

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileQuadGeometryNode.js

@@ -1,7 +1,7 @@
 import { Quad } from "../../../../../../Mesher/Geomtry/Primitives/Quad";
 import { getQuadWeights, mapQuadUvs } from "./CalcFunctions";
 import { TransformQuad } from "../../../../../../Mesher/Geomtry/Transform/TransformQuad";
-import { QuadVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { QuadVoxelGometryInputs, } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
 import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
 import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
 export function CompileQuadGeometryNode(buildRules, input, points, node, transform = {}) {

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.d.ts

@@ -1,6 +1,6 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
-import { CompiledTriangleVoxelGeomtryNode } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { CompiledTriangleVoxelGeomtryNode } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
 import { GeomtryInput } from "../../../Classes/GeomtryInput";
 import { BaseVoxelTriangleData } from "../../../../VoxelModel.types";
 export declare function CompileTriangleGeometryNode(buildRules: boolean, input: GeomtryInput, points: [Vec3Array, Vec3Array, Vec3Array], node: BaseVoxelTriangleData, transform?: VoxelGeometryTransform): CompiledTriangleVoxelGeomtryNode;

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.js

@@ -1,7 +1,7 @@
 import { Triangle } from "../../../../../../Mesher/Geomtry/Primitives/Triangle";
 import { getVertexWeights } from "./CalcFunctions";
 import { TransformTriangle } from "../../../../../../Mesher/Geomtry/Transform/TransformTriangle";
-import { TriangleVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { TriangleVoxelGometryInputs, } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
 import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
 import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
 export function CompileTriangleGeometryNode(buildRules, input, points, node, transform) {

package/Voxels/Models/VoxelModel.types.d.ts

@@ -51,6 +51,11 @@ export interface VoxelTriangleGeometryNode extends BaseVoxelTriangleData {
 export interface VoxelGeometryTextureArgument {
     type: "texture";
 }
+/**Creates a way to set multiple arguments to the same thing. What ever value is passed in will be passed to the arguments. */
+export interface VoxelGeometryArgumentAliasList {
+    type: "arg-list";
+    arguments: string[];
+}
 export interface VoxelGeometryBooleanArgument {
     type: "boolean";
     default: boolean;
@@ -103,7 +108,7 @@ export interface VoxelGeometryData {
      * Define the culling procedure for faces
      */
     cullingProcedure?: CullingProcedureData;
-    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument | VoxelGeometryArgumentAliasList>;
 }
 export interface VoxelGeometryLinkData {
     geometryId: string;

package/Voxels/Types/PaintVoxelData.d.ts

@@ -23,5 +23,7 @@ export declare class PaintVoxelData {
     static Clear(data: PaintVoxelData): PaintVoxelData;
     /**Clears the target data and then copies properties from source to target. */
     static Set(target: PaintVoxelData, source: Partial<PaintVoxelData>): PaintVoxelData;
+    /**Takes PaintVoxelData and convert mod and state strings to numbers and then */
+    static Populate(data: Partial<PaintVoxelData>): Partial<PaintVoxelData>;
     private constructor();
 }

package/Voxels/Types/PaintVoxelData.js

@@ -140,6 +140,57 @@ export class PaintVoxelData {
             target.secondaryStateString = source.secondaryStateString;
         return target;
     }
+    /**Takes PaintVoxelData and convert mod and state strings to numbers and then */
+    static Populate(data) {
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.secondaryName
+            ? data.secondaryVoxelId
+            : data.secondaryName
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
+                : "dve_air";
+        if (data.name && !data.id) {
+            data.id = VoxelPalettesRegister.voxelNametoIdMap.get(data.name);
+        }
+        if (!data.name && !data.id) {
+            data.id = "dve_air";
+        }
+        delete data.name;
+        let state = data.state || 0;
+        let mod = data.mod || 0;
+        if (SchemaRegister.hasVoxelSchema(stringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(stringId);
+            if (data.stateString && data.stateString !== "") {
+                state = schema.state.readString(data.stateString);
+            }
+            if (data.modString && data.modString !== "") {
+                mod = schema.mod.readString(data.modString);
+            }
+        }
+        data.state = state;
+        data.mod = mod;
+        delete data.stateString;
+        delete data.modString;
+        let secondaryState = data.secondaryState || 0;
+        let secondaryMod = data.secondaryMod || 0;
+        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
+            if (data.secondaryStateString && data.secondaryStateString !== "") {
+                secondaryState = schema.state.readString(data.secondaryStateString);
+            }
+            if (data.secondaryModString && data.secondaryModString !== "") {
+                secondaryMod = schema.mod.readString(data.secondaryModString);
+            }
+        }
+        data.secondaryState = secondaryState;
+        data.secondaryMod = secondaryMod;
+        delete data.secondaryModString;
+        delete data.secondaryStateString;
+        return data;
+    }
     constructor(id = "dve_air", name = "", state = 0, stateString = "", mod = 0, modString = "", level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryName = "", secondaryMod = 0, secondaryModString = "", secondaryState = 0, secondaryStateString = "") {
         this.id = id;
         this.name = name;

package/World/Cursor/SectionCursor.d.ts

@@ -3,12 +3,16 @@ import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 import type { Section } from "../Section/index";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectionCursor implements WorldSectionCursorInterface, DataCursorInterface {
     _section: Section | null;
     private voxel;
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
     _sectionPosition: Vector3Like;
+    volumeBounds: BoundingBox;
+    get volumePosition(): Vector3Like;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setSection(section: Section): void;
     loadSection(dimension: number, x: number, y: number, z: number): boolean;

package/World/Cursor/SectionCursor.js

@@ -2,29 +2,26 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class SectionCursor {
     _section;
     voxel = new WorldVoxelCursor(this);
     _voxelIndex = 0;
     _voxelPosition = Vector3Like.Create();
     _sectionPosition = Vector3Like.Create();
+    volumeBounds = new BoundingBox();
+    get volumePosition() {
+        return this._sectionPosition;
+    }
+    constructor() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(0, 0, 0), Vector3Like.Create(WorldSpaces.section.bounds.x, WorldSpaces.section.bounds.y, WorldSpaces.section.bounds.z));
+    }
     inBounds(x, y, z) {
-        const maxX = this._sectionPosition.x + WorldSpaces.section.bounds.x;
-        const maxY = this._sectionPosition.y + WorldSpaces.section.bounds.y;
-        const maxZ = this._sectionPosition.z + WorldSpaces.section.bounds.z;
-        if (x < this._sectionPosition.x)
-            return false;
-        if (y < this._sectionPosition.y)
-            return false;
-        if (z < this._sectionPosition.z)
-            return false;
-        if (x > maxX)
-            return false;
-        if (y > maxY)
-            return false;
-        if (z > maxZ)
-            return false;
-        return true;
+        point.x = x - this._sectionPosition.x + 0.5;
+        point.y = y - this._sectionPosition.y + 0.5;
+        point.z = z - this._sectionPosition.z + 0.5;
+        return this.volumeBounds.intersectsPoint(point);
     }
     setSection(section) {
         this._section = section;

package/World/Cursor/SectorCursor.d.ts

@@ -4,6 +4,7 @@ import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectorCursor implements DataCursorInterface, WorldSectionCursorInterface {
     _current: Sector | null;
     _section: Section | null;
@@ -11,6 +12,9 @@ export declare class SectorCursor implements DataCursorInterface, WorldSectionCu
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
     _sectorPosition: Vector3Like;
+    volumeBounds: BoundingBox;
+    get volumePosition(): Vector3Like;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setSector(sector: Sector): boolean;
     loadSector(dimension: number, x: number, y: number, z: number): boolean;

package/World/Cursor/SectorCursor.js

@@ -2,6 +2,8 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class SectorCursor {
     _current = null;
     _section;
@@ -9,23 +11,18 @@ export class SectorCursor {
     _voxelIndex = 0;
     _voxelPosition = Vector3Like.Create();
     _sectorPosition = Vector3Like.Create();
+    volumeBounds = new BoundingBox();
+    get volumePosition() {
+        return this._sectorPosition;
+    }
+    constructor() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(0, 0, 0), Vector3Like.Create(WorldSpaces.sector.bounds.x, WorldSpaces.sector.bounds.y, WorldSpaces.sector.bounds.z));
+    }
     inBounds(x, y, z) {
-        const maxX = this._sectorPosition.x + WorldSpaces.sector.bounds.x;
-        const maxY = this._sectorPosition.y + WorldSpaces.sector.bounds.y;
-        const maxZ = this._sectorPosition.z + WorldSpaces.sector.bounds.z;
-        if (x < this._sectorPosition.x)
-            return false;
-        if (y < this._sectorPosition.y)
-            return false;
-        if (z < this._sectorPosition.z)
-            return false;
-        if (x > maxX)
-            return false;
-        if (y > maxY)
-            return false;
-        if (z > maxZ)
-            return false;
-        return true;
+        point.x = x - this._sectorPosition.x + 0.5;
+        point.y = y - this._sectorPosition.y + 0.5;
+        point.z = z - this._sectorPosition.z + 0.5;
+        return this.volumeBounds.intersectsPoint(point);
     }
     setSector(sector) {
         this._current = sector;

package/World/Cursor/WorldCursor.d.ts

@@ -1,11 +1,15 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class WorldCursor implements DataCursorInterface {
+    volumeBounds: BoundingBox;
     sectorCursors: Record<number, Record<number, SectorCursor | null>>;
     origin: Vector3Like;
     dimension: number;
     _lastPosition: Vector3Like;
+    constructor();
+    private updateBounds;
     setFocalPoint(dimension: number, x: number, y: number, z: number): void;
     inBounds(x: number, y: number, z: number): boolean;
     getSector(x: number, y: number, z: number): SectorCursor | null;

package/World/Cursor/WorldCursor.js

@@ -1,13 +1,21 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor {
+    volumeBounds = new BoundingBox();
     sectorCursors = {};
     origin = Vector3Like.Create();
     dimension = 0;
     _lastPosition = Vector3Like.Create();
+    constructor() {
+        this.updateBounds();
+    }
+    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));
+    }
     setFocalPoint(dimension, x, y, z) {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         for (const row in this.sectorCursors) {

package/World/Sector/SectorHeightMap.d.ts

@@ -1,5 +1,11 @@
 import { LocationData } from "../../Math";
 export declare class SectorHeightMap {
+    /**
+     * Gets the relative height of the sector. Meaning will get the tallest sector in a square around it.
+     */
     static getRelative(location: LocationData): number;
+    /**
+     * Gets the exact heigh of the single sector.
+     */
     static getAbsolute(dimension: number, x: number, sy: number, z: number): number;
 }

package/World/Sector/SectorHeightMap.js

@@ -2,6 +2,9 @@ import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
+    /**
+     * Gets the relative height of the sector. Meaning will get the tallest sector in a square around it.
+     */
     static getRelative(location) {
         location = [...location];
         const sectionWidth = WorldSpaces.section.bounds.x;
@@ -18,6 +21,9 @@ export class SectorHeightMap {
         }
         return maxHeight;
     }
+    /**
+     * Gets the exact heigh of the single sector.
+     */
     static getAbsolute(dimension, x, sy, z) {
         const sector = WorldRegister.sectors.get(dimension, x, sy, z);
         if (!sector)

package/World/SnapShot/SectionSnapShotCursor.d.ts

@@ -4,14 +4,17 @@ import { SectionSnapShot } from "./SectionSnapShot";
 import { Sector } from "../Sector";
 import { SectorCursor } from "../Cursor/SectorCursor";
 import { SectionCursor } from "../Cursor/SectionCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectionSnapshotCursor implements DataCursorInterface {
     origin: Vector3Like;
     sectorOrigin: Vector3Like;
     dimension: number;
+    volumeBounds: BoundingBox;
     sectors: Sector[];
     cursors: SectorCursor[];
     index: Flat3DIndex;
     constructor();
+    private updateBounds;
     private _snapShot;
     private _centeralCursor;
     getCenteralCursor(): SectionCursor | null;

package/World/SnapShot/SectionSnapShotCursor.js

@@ -3,11 +3,13 @@ import { WorldSpaces } from "../WorldSpaces";
 import { Sector } from "../Sector";
 import { SectorCursor } from "../Cursor/SectorCursor";
 import { SectionCursor } from "../Cursor/SectionCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 const tempPosition = Vector3Like.Create();
 export class SectionSnapshotCursor {
     origin = Vector3Like.Create();
     sectorOrigin = Vector3Like.Create();
     dimension = 0;
+    volumeBounds = new BoundingBox();
     sectors = [];
     cursors = [];
     index = Flat3DIndex.GetXYZOrder();
@@ -29,6 +31,10 @@ export class SectionSnapshotCursor {
                 }
             }
         }
+        this.updateBounds();
+    }
+    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));
     }
     _snapShot;
     _centeralCursor = new SectionCursor();

package/World/WorldSpaces.js

@@ -137,13 +137,13 @@ class VoxelSpace {
 }
 class Hash {
     static hashVec3(vector3) {
-        return `${vector3.x}-${vector3.y}-${vector3.z}`;
+        return `${vector3.x}_${vector3.y}_${vector3.z}`;
     }
     static hashVec3Array(vector3) {
-        return `${vector3[0]}-${vector3[1]}-${vector3[2]}`;
+        return `${vector3[0]}_${vector3[1]}_${vector3[2]}`;
     }
     static hashXYZ(x, y, z) {
-        return `${x}-${y}-${z}`;
+        return `${x}_${y}_${z}`;
     }
 }
 export class WorldSpaces {

package/WorldSimulation/Dimensions/DimensionSimulation.d.ts

@@ -1,22 +1,26 @@
+import { VoxelFaces } from "../../Math";
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { DimensionSegment } from "./DimensionSegment";
 import { Vector3Like } from "@amodx/math";
 import { PriorityQueue } from "../../Util/PriorityQueue";
 import { VoxelUpdate } from "../Voxels/Behaviors";
+import { SimulationBrush } from "../Tools/SimulationBrush";
 declare class UpdatedBounds {
     displayMin: Vector3Like;
     displayMax: Vector3Like;
     dimension: number;
     start(dimension?: number): void;
     updateDisplay(x: number, y: number, z: number): void;
-    markDisplayDirty(): false | undefined;
+    markDisplayDirty(): boolean;
 }
 export declare class DimensionSimulation {
     dimension: DimensionSegment;
     private cursor;
     nDataCursor: WorldCursor;
     sDataCursor: WorldCursor;
+    tickCursor: Record<VoxelFaces, WorldCursor>;
     bounds: UpdatedBounds;
+    brush: SimulationBrush;
     updateQueue: PriorityQueue<VoxelUpdate>;
     constructor(dimension: DimensionSegment);
     setOrigin(x: number, y: number, z: number): void;

package/WorldSimulation/Dimensions/DimensionSimulation.js

@@ -1,4 +1,5 @@
 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";
@@ -62,6 +63,7 @@ class UpdatedBounds {
                 }
             }
         }
+        return true;
     }
 }
 export class DimensionSimulation {
@@ -69,10 +71,20 @@ export class DimensionSimulation {
     cursor = new WorldCursor();
     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(),
+    };
     bounds = new UpdatedBounds();
+    brush;
     updateQueue = new PriorityQueue();
     constructor(dimension) {
         this.dimension = dimension;
+        this.brush = dimension.getBrush();
     }
     setOrigin(x, y, z) {
         this.cursor.setFocalPoint(this.dimension.id, x, y, z);

package/WorldSimulation/Dimensions/Generator.d.ts

@@ -14,6 +14,7 @@ export declare class Generator {
     position: Vector3Like;
     _dimension: number;
     _building: boolean;
+    _generating: boolean;
     _isNew: boolean;
     _dirty: boolean;
     _waitingForCull: boolean;

package/WorldSimulation/Dimensions/Generator.js

@@ -5,6 +5,7 @@ export class Generator {
     position;
     _dimension = 0;
     _building = true;
+    _generating = true;
     _isNew = true;
     _dirty = true;
     _waitingForCull = false;

package/WorldSimulation/Dimensions/SimulationSector.d.ts

@@ -4,6 +4,7 @@ import { Sector } from "../../World/Sector";
 import { TickQueue } from "../Tick/TickQueue";
 import { DimensionSegment } from "./DimensionSegment";
 import { Thread } from "@amodx/threads";
+import { SectionCursor } from "../../World/Cursor/SectionCursor";
 export declare class SimulationSector {
     dimension: DimensionSegment;
     position: Vec3Array;
@@ -14,9 +15,11 @@ export declare class SimulationSector {
     sector: Sector | null;
     _rendered: boolean;
     _genAllDone: boolean;
+    _firstTick: boolean;
     /**An array of the last tick each section was built at */
     _displayTicks: Uint32Array<ArrayBuffer>;
     tickQueue: TickQueue;
+    sectionCursor: SectionCursor;
     neighbors: SimulationSector[];
     fullNeighbors: boolean;
     readonly maxNeighbors: number;

package/WorldSimulation/Dimensions/SimulationSector.js

@@ -5,9 +5,11 @@ import { WorldSpaces } from "../../World/WorldSpaces";
 import { WorldRegister } from "../../World/WorldRegister";
 import { WorldSimulationTasks } from "../Internal/WorldSimulationTasks";
 import { TickQueue } from "../Tick/TickQueue";
+import { VoxelBehaviorsRegister } from "../Voxels/Behaviors";
 import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
 import { WorldDataSyncIds } from "../../World/Types/WorldDataSyncIds";
 import { EngineSettings } from "../../Settings/EngineSettings";
+import { SectionCursor } from "../../World/Cursor/SectionCursor";
 const tempPosition = Vector3Like.Create();
 export class SimulationSector {
     dimension;
@@ -19,9 +21,11 @@ export class SimulationSector {
     sector = null;
     _rendered = false;
     _genAllDone = false;
+    _firstTick = false;
     /**An array of the last tick each section was built at */
     _displayTicks = new Uint32Array(WorldSpaces.sector.sectionVolumne);
     tickQueue;
+    sectionCursor = new SectionCursor();
     neighbors = [];
     fullNeighbors = false;
     maxNeighbors = MooreNeighborhood2D.length - 1;
@@ -114,48 +118,74 @@ export class SimulationSector {
             }
             this._rendered = true;
         }
-        /*   if (this.ticking) {
-          this.dimension.simulation.setOrigin(...this.position);
-          this.dimension.simulation.bounds.start();
-          this.tickQueue.run();
-    
-          const [min, max] = sector.getMinMax();
-          if (min == Math.abs(Infinity) || max == Math.abs(Infinity)) return true;
-    
-          const height = max - min + 1;
-          let attempts = 100;
-          let ticks = 20;
-          while (attempts) {
-            const randomX =
-              Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
-              this.sector.position[0];
-            const randomY =
-              Math.floor(height * Math.random()) + min + this.sector.position[1];
-            const randomZ =
-              Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
-              this.sector.position[2];
-            const voxel = this.dimension.simulation.nDataCursor.getVoxel(
-              randomX,
-              randomY,
-              randomZ
-            );
-            if (!voxel || voxel.isAir()) {
-              attempts--;
-              continue;
+        if (this.ticking) {
+            this.dimension.simulation.setOrigin(...this.position);
+            this.dimension.simulation.bounds.start(this.dimension.id);
+            this.tickQueue.run();
+            const [min, max] = sector.getMinMax();
+            if (min == Math.abs(Infinity) || max == Math.abs(Infinity))
+                return true;
+            const height = max - min + 1;
+            let attempts = 100;
+            let ticks = 20;
+            while (attempts) {
+                const randomX = Math.floor(WorldSpaces.section.bounds.x * Math.random()) +
+                    this.sector.position[0];
+                const randomY = Math.floor(height * Math.random()) + min + this.sector.position[1];
+                const randomZ = Math.floor(WorldSpaces.section.bounds.z * Math.random()) +
+                    this.sector.position[2];
+                const voxel = this.dimension.simulation.nDataCursor.getVoxel(randomX, randomY, randomZ);
+                if (!voxel || voxel.isAir()) {
+                    attempts--;
+                    continue;
+                }
+                const behavior = VoxelBehaviorsRegister.get(voxel.tags["dve_simulation_behavior"]);
+                behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
+                ticks--;
+                if (!ticks)
+                    break;
             }
-    
-            const behavior = VoxelBehaviorsRegister.get(
-              voxel.tags["dve_simulation_behavior"]
-            );
-            behavior.onTick(this.dimension.simulation, randomX, randomY, randomZ);
-    
-            ticks--;
-    
-            if (!ticks) break;
-          }
-    
-          this.dimension.simulation.bounds.markDisplayDirty();
-        } */
+            let allNeighborsTicking = true;
+            for (const neighbors of this.neighbors) {
+                if (!neighbors.ticking || !neighbors._genAllDone) {
+                    allNeighborsTicking = false;
+                    break;
+                }
+            }
+            if (!this._firstTick && this.renderering && allNeighborsTicking) {
+                for (const section of sector.sections) {
+                    this.sectionCursor.setSection(section);
+                    const [minY, maxY] = section.getMinMax();
+                    if (minY == Infinity && maxY == -Infinity) {
+                        continue;
+                    }
+                    const { x: cx, y: cy, z: cz } = this.sectionCursor._sectionPosition;
+                    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
+                    const startY = minY * slice;
+                    const endY = (maxY + 1) * slice;
+                    //  console.warn([startY,endY],{...this.sectionCursor._voxelPosition})
+                    for (let i = startY; i < endY; i++) {
+                        if (!(i % slice)) {
+                            const y = i / slice;
+                            if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
+                                i += slice - 1;
+                                continue;
+                            }
+                        }
+                        if (!section.ids[i] || section.getBuried(i))
+                            continue;
+                        const voxel = this.sectionCursor.getVoxelAtIndex(i);
+                        const x = cx + this.sectionCursor._voxelPosition.x;
+                        const y = cy + this.sectionCursor._voxelPosition.y;
+                        const z = cz + this.sectionCursor._voxelPosition.z;
+                        const behavior = VoxelBehaviorsRegister.get(voxel.tags["dve_simulation_behavior"]);
+                        behavior.needUpdate(this.dimension.simulation, x, y, z);
+                    }
+                }
+                this._firstTick = true;
+            }
+            this.dimension.simulation.bounds.markDisplayDirty();
+        }
         return true;
     }
     generateUpdate() {

package/WorldSimulation/Internal/WorldSimulationTasks.js

@@ -171,8 +171,11 @@ export class WorldSimulationTasks {
                 .sector?.getSection(location[1], location[2], location[3])
                 ?.setInProgress(true);
             if (EngineSettings.settings.memoryAndCPU.useSharedMemory) {
-                task.completeTask(taskId);
-                WorldSimulationTools.taskTool.build.section.run(location);
+                WorldSimulationTools.taskTool.build.section
+                    .runAsync(location)
+                    .then(() => {
+                    task.completeTask(taskId);
+                });
                 return;
             }
             const [dim, x, y, z] = location;

package/WorldSimulation/Procedures/BuildOnly.d.ts

@@ -0,0 +1,10 @@
+import { GeneratorData } from "../Dimensions/Generator";
+/**# InitalLoad
+ * ---
+ * Load the world without building.
+ */
+export declare function BuildOnly(props: {
+    dimension?: number;
+    logTasks?: true;
+    genData: Partial<GeneratorData>;
+}): Promise<unknown>;