@divinevoxel/vlox 0.0.73 → 0.0.75

package/WorldSimulation/Dimensions/DimensionSegment.d.ts

@@ -0,0 +1,38 @@
+import { Vector3Like } from "@amodx/math";
+import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { TaskSegment } from "../Tasks/TaskSegment";
+import { Generator } from "./Generator";
+import { SimulationSector } from "./SimulationSector";
+import { DimensionSimulation } from "./DimensionSimulation";
+import { SimulationBrush } from "../Tools/SimulationBrush";
+declare class ActiveSectors {
+    dimension: DimensionSegment;
+    _sectors: SimulationSector[];
+    _map: Map<string, SimulationSector>;
+    constructor(dimension: DimensionSegment);
+    add(x: number, y: number, z: number): false | undefined;
+    get(x: number, y: number, z: number): SimulationSector | null | undefined;
+    remove(x: number, y: number, z: number): false | undefined;
+}
+export declare class DimensionSegment {
+    id: number;
+    taskTool: TaskTool;
+    private tick;
+    tasks: Map<string, TaskSegment>;
+    activeSectors: ActiveSectors;
+    generators: Generator[];
+    simulation: DimensionSimulation;
+    _updatePosition: Vector3Like;
+    constructor(id: number, taskTool: TaskTool);
+    getBrush(): SimulationBrush;
+    incrementTick(): void;
+    getTick(): number;
+    addGenerator(generator: Generator): void;
+    removeGenerator(generator: Generator): void;
+    getUpdatePosition(): Vector3Like;
+    addTask(id: string, generationTask: boolean): void;
+    getTask(id: string): TaskSegment;
+    clearAllTasks(): void;
+    logTasks(): string;
+}
+export {};

package/WorldSimulation/Dimensions/DimensionSegment.js

@@ -0,0 +1,120 @@
+import { Vector3Like } from "@amodx/math";
+import { TaskSegment } from "../Tasks/TaskSegment";
+import { SimulationSector } from "./SimulationSector";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { DimensionSimulation } from "./DimensionSimulation";
+import { SimulationBrush } from "../Tools/SimulationBrush";
+const tempPosition = Vector3Like.Create();
+class ActiveSectors {
+    dimension;
+    _sectors = [];
+    _map = new Map();
+    constructor(dimension) {
+        this.dimension = dimension;
+    }
+    add(x, y, z) {
+        WorldSpaces.sector.getPosition(x, y, z, tempPosition);
+        const key = WorldSpaces.hash.hashVec3(tempPosition);
+        if (this._map.has(key))
+            return false;
+        const newSector = new SimulationSector(this.dimension);
+        newSector.position[0] = tempPosition.x;
+        newSector.position[1] = tempPosition.y;
+        newSector.position[2] = tempPosition.z;
+        this._sectors.push(newSector);
+        this._map.set(key, newSector);
+    }
+    get(x, y, z) {
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
+        if (!this._map.has(key))
+            return null;
+        return this._map.get(key);
+    }
+    remove(x, y, z) {
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition));
+        if (!this._map.has(key))
+            return false;
+        for (let i = 0; i < this._sectors.length; i++) {
+            if (this._sectors[i])
+                this._sectors.splice(i, 1);
+        }
+    }
+}
+export class DimensionSegment {
+    id;
+    taskTool;
+    tick = 0;
+    tasks = new Map();
+    activeSectors = new ActiveSectors(this);
+    generators = [];
+    simulation = new DimensionSimulation(this);
+    _updatePosition = Vector3Like.Create();
+    constructor(id, taskTool) {
+        this.id = id;
+        this.taskTool = taskTool;
+    }
+    getBrush() {
+        return new SimulationBrush(this);
+    }
+    incrementTick() {
+        this.tick++;
+    }
+    getTick() {
+        return this.tick;
+    }
+    addGenerator(generator) {
+        this.generators.push(generator);
+    }
+    removeGenerator(generator) {
+        for (let i = 0; i < this.generators.length; i++) {
+            if (this.generators[i] == generator)
+                this.generators.splice(i, 1);
+        }
+    }
+    getUpdatePosition() {
+        const numGenerators = this.generators.length;
+        if (numGenerators === 0) {
+            this._updatePosition.x = 0;
+            this._updatePosition.y = 0;
+            this._updatePosition.z = 0;
+            return this._updatePosition;
+        }
+        if (numGenerators === 1) {
+            this._updatePosition.x = this.generators[0].position.x;
+            this._updatePosition.y = this.generators[0].position.y;
+            this._updatePosition.z = this.generators[0].position.z;
+            return this._updatePosition;
+        }
+        let sumX = 0, sumY = 0, sumZ = 0;
+        for (let i = 0; i < numGenerators; i++) {
+            sumX += this.generators[i].position.x;
+            sumY += this.generators[i].position.y;
+            sumZ += this.generators[i].position.z;
+        }
+        this._updatePosition.x = sumX / numGenerators;
+        this._updatePosition.y = sumY / numGenerators;
+        this._updatePosition.z = sumZ / numGenerators;
+        return this._updatePosition;
+    }
+    addTask(id, generationTask) {
+        this.tasks.set(id, new TaskSegment(this, generationTask));
+    }
+    getTask(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            throw new Error(`Task with id [${id}] not registered in dimension segment ${this.id}`);
+        return task;
+    }
+    clearAllTasks() {
+        for (const [key, task] of this.tasks) {
+            task.clear();
+        }
+    }
+    logTasks() {
+        const tasks = [];
+        for (const [key, task] of this.tasks) {
+            tasks.push(`${key} | ${task.waitingFor}`);
+        }
+        return tasks.join("\n");
+    }
+}

package/WorldSimulation/Dimensions/DimensionSimulation.d.ts

@@ -0,0 +1,26 @@
+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";
+declare class UpdatedBounds {
+    displayMin: Vector3Like;
+    displayMax: Vector3Like;
+    dimension: number;
+    start(dimension?: number): void;
+    updateDisplay(x: number, y: number, z: number): void;
+    markDisplayDirty(): false | undefined;
+}
+export declare class DimensionSimulation {
+    dimension: DimensionSegment;
+    private cursor;
+    nDataCursor: WorldCursor;
+    sDataCursor: WorldCursor;
+    bounds: UpdatedBounds;
+    updateQueue: PriorityQueue<VoxelUpdate>;
+    constructor(dimension: DimensionSegment);
+    setOrigin(x: number, y: number, z: number): void;
+    getVoxelForUpdate(x: number, y: number, z: number): import("../../World/Cursor/WorldVoxelCursor").WorldVoxelCursor;
+    scheduleUpdate(type: string, x: number, y: number, z: number, delay: number, data?: null): void;
+}
+export {};

package/WorldSimulation/Dimensions/DimensionSimulation.js

@@ -0,0 +1,95 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldRegister } from "../../World/WorldRegister";
+import { Vector3Like } from "@amodx/math";
+import { VoxelTickUpdate } from "../Voxels/Ticks/VoxelTickUpdate";
+import { PriorityQueue } from "../../Util/PriorityQueue";
+const NegativeInfinityVec3 = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
+const tempPosition = Vector3Like.Create();
+class UpdatedBounds {
+    displayMin = Vector3Like.Clone(InfinityVec3);
+    displayMax = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = 0;
+    start(dimension) {
+        this.dimension = dimension || 0;
+        Vector3Like.Copy(this.displayMin, InfinityVec3);
+        Vector3Like.Copy(this.displayMax, NegativeInfinityVec3);
+    }
+    updateDisplay(x, y, z) {
+        if (x < this.displayMin.x)
+            this.displayMin.x = x;
+        if (y < this.displayMin.y)
+            this.displayMin.y = y;
+        if (z < this.displayMin.z)
+            this.displayMin.z = z;
+        if (x > this.displayMax.x)
+            this.displayMax.x = x;
+        if (y > this.displayMax.y)
+            this.displayMax.y = y;
+        if (z > this.displayMax.z)
+            this.displayMax.z = z;
+    }
+    markDisplayDirty() {
+        if (this.displayMax.x == -Infinity ||
+            this.displayMax.y == -Infinity ||
+            this.displayMax.z == -Infinity)
+            return false;
+        if (this.displayMin.x == Infinity ||
+            this.displayMin.y == Infinity ||
+            this.displayMin.z == Infinity)
+            return false;
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x - 1, this.displayMin.y - 1, this.displayMin.z - 1, tempPosition);
+        const minX = minSectionPos.x;
+        const minY = minSectionPos.y;
+        const minZ = minSectionPos.z;
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x + 1, this.displayMax.y + 1, this.displayMax.z + 1, tempPosition);
+        const maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
+                for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(this.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(x, y, z);
+                    if (!section.canRender())
+                        continue;
+                    section.incrementTick(section._Ticks.displayDirty);
+                }
+            }
+        }
+    }
+}
+export class DimensionSimulation {
+    dimension;
+    cursor = new WorldCursor();
+    nDataCursor = new WorldCursor();
+    sDataCursor = new WorldCursor();
+    bounds = new UpdatedBounds();
+    updateQueue = new PriorityQueue();
+    constructor(dimension) {
+        this.dimension = dimension;
+    }
+    setOrigin(x, y, z) {
+        this.cursor.setFocalPoint(this.dimension.id, x, y, z);
+        this.nDataCursor.setFocalPoint(this.dimension.id, x, y, z);
+        this.sDataCursor.setFocalPoint(this.dimension.id, x, y, z);
+    }
+    getVoxelForUpdate(x, y, z) {
+        const voxel = this.cursor.getVoxel(x, y, z);
+        if (!voxel)
+            throw new Error(`Tried to run tick update on voxel that does not exist at [${x} ${y} ${z}]`);
+        return voxel;
+    }
+    scheduleUpdate(type, x, y, z, delay, data = null) {
+        const active = this.dimension.activeSectors.get(x, y, z);
+        if (!active)
+            throw new Error(`Tried to schedule a voxel update on a non loaded active sector`);
+        const update = new VoxelTickUpdate(type, x, y, z, data);
+        active.tickQueue.addTick(update, delay);
+    }
+}

package/{Tasks/IWG/Internal/Classes → WorldSimulation/Dimensions}/Generator.d.ts

@@ -1,32 +1,30 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
-import { BuildQueue } from "./BuildQueue";
-import { TaskTool } from "../../../../Tools/Tasks/TasksTool";
 export interface GeneratorData {
-    dimension: string;
+    dimension: number;
     building?: boolean;
     culling?: boolean;
     position: Vector3Like;
     renderRadius: number;
     generationRadius: number;
+    tickRadius: number;
     maxRadius: number;
 }
 export declare class Generator {
-    taskTool: TaskTool;
     position: Vector3Like;
-    _dimension: string;
+    _dimension: number;
     _building: boolean;
-    _positonChanged: boolean;
+    _isNew: boolean;
+    _dirty: boolean;
     _waitingForCull: boolean;
     _cullTime: number;
     _culling: boolean;
     _cachedPosition: Vector3Like;
     _sectorPosition: Vector3Like;
     _genCircle: Circle;
+    _tickCircle: Circle;
     _renderCircle: Circle;
     _maxCircle: Circle;
-    buildQueue: BuildQueue;
-    constructor(taskTool: TaskTool, data: GeneratorData);
+    constructor(data: GeneratorData);
     update(): void;
-    tick(): void;
 }

package/{Tasks/IWG/Internal/Classes → WorldSimulation/Dimensions}/Generator.js

@@ -1,25 +1,22 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { BuildQueue } from "./BuildQueue";
+import { WorldSpaces } from "../../World/WorldSpaces";
 export class Generator {
-    taskTool;
     position;
-    _dimension = "main";
+    _dimension = 0;
     _building = true;
-    _positonChanged = false;
+    _isNew = true;
+    _dirty = true;
     _waitingForCull = false;
     _cullTime = 0;
     _culling = true;
     _cachedPosition = Vector3Like.Create();
     _sectorPosition = Vector3Like.Create();
     _genCircle = new Circle({ x: 0, y: 0 }, 0);
+    _tickCircle = new Circle({ x: 0, y: 0 }, 0);
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
-    buildQueue;
-    constructor(taskTool, data) {
-        this.taskTool = taskTool;
-        console.warn("make generator", taskTool);
+    constructor(data) {
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -27,27 +24,23 @@ export class Generator {
         this._culling = typeof data.culling !== "undefined" ? data.culling : true;
         this._renderCircle.radius = data.renderRadius;
         this._genCircle.radius = data.generationRadius;
+        this._tickCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
-        this.buildQueue = new BuildQueue(taskTool);
     }
     update() {
-        this._positonChanged = false;
+        this._dirty = false;
         WorldSpaces.section.getPosition(this.position.x, 0, this.position.z, this._sectorPosition);
         if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
-            this._positonChanged = true;
+            this._dirty = true;
             Vector3Like.Copy(this._cachedPosition, this._sectorPosition);
         }
         this._renderCircle.center.x = this._sectorPosition.x;
         this._renderCircle.center.y = this._sectorPosition.z;
         this._genCircle.center.x = this._sectorPosition.x;
         this._genCircle.center.y = this._sectorPosition.z;
+        this._tickCircle.center.x = this._sectorPosition.x;
+        this._tickCircle.center.y = this._sectorPosition.z;
         this._maxCircle.center.x = this._sectorPosition.x;
         this._maxCircle.center.y = this._sectorPosition.z;
     }
-    tick() {
-        if (this._building) {
-            this.buildQueue.sort(this.position.x, this.position.y, this.position.z);
-            this.buildQueue.run(25);
-        }
-    }
 }

package/{Tasks/IWG/Internal/Classes → WorldSimulation/Dimensions}/SectorState.d.ts

@@ -1,4 +1,6 @@
+import { SimulationSector } from "./SimulationSector";
 export declare class SectorState {
+    simSector: SimulationSector;
     isLoaded: boolean;
     isGenerated: boolean;
     genAlldone: boolean;
@@ -7,5 +9,7 @@ export declare class SectorState {
     nDecorAllDone: boolean;
     nSunAllDone: boolean;
     nPropagtionAllDone: boolean;
+    constructor(simSector: SimulationSector);
     resset(): void;
+    update(): this;
 }

package/WorldSimulation/Dimensions/SectorState.js

@@ -0,0 +1,56 @@
+import { Sector } from "../../World/Sector";
+export class SectorState {
+    simSector;
+    isLoaded = true;
+    isGenerated = true;
+    genAlldone = true;
+    allLoaded = true;
+    nWorldGenAllDone = true;
+    nDecorAllDone = true;
+    nSunAllDone = true;
+    nPropagtionAllDone = true;
+    constructor(simSector) {
+        this.simSector = simSector;
+    }
+    resset() {
+        this.isLoaded = true;
+        this.isGenerated = true;
+        this.genAlldone = true;
+        this.allLoaded = true;
+        this.nWorldGenAllDone = true;
+        this.nDecorAllDone = true;
+        this.nSunAllDone = true;
+        this.nPropagtionAllDone = true;
+    }
+    update() {
+        if (!this.simSector.sector)
+            throw new Error(`Sector must be set`);
+        const state = this;
+        state.resset();
+        for (const simSector of this.simSector.neighbors) {
+            const sector = simSector.sector;
+            if (!sector || sector.isCheckedOut()) {
+                state.genAlldone = false;
+                state.nWorldGenAllDone = false;
+                state.nPropagtionAllDone = false;
+                state.nSunAllDone = false;
+                state.nDecorAllDone = false;
+                state.allLoaded = false;
+                break;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
+                state.nWorldGenAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
+                state.nDecorAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
+                state.nSunAllDone = false;
+            }
+            if (!sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
+                state.nPropagtionAllDone = false;
+            }
+        }
+        return this;
+    }
+}

package/WorldSimulation/Dimensions/SimulationSector.d.ts

@@ -0,0 +1,30 @@
+import { Vec3Array } from "@amodx/math";
+import { SectorState } from "./SectorState";
+import { Sector } from "../../World/Sector";
+import { TickQueue } from "../Tick/TickQueue";
+import { DimensionSegment } from "./DimensionSegment";
+import { Thread } from "@amodx/threads";
+export declare class SimulationSector {
+    dimension: DimensionSegment;
+    position: Vec3Array;
+    renderering: boolean;
+    generating: boolean;
+    ticking: boolean;
+    state: SectorState;
+    sector: Sector | null;
+    _rendered: boolean;
+    _genAllDone: boolean;
+    /**An array of the last tick each section was built at */
+    _displayTicks: Uint32Array;
+    tickQueue: TickQueue;
+    neighbors: SimulationSector[];
+    fullNeighbors: boolean;
+    readonly maxNeighbors: number;
+    constructor(dimension: DimensionSegment);
+    updateNeighbors(): void;
+    canCheckOut(): boolean;
+    checkOut(thread: Thread): void;
+    checkIn(thread: Thread): void;
+    tickUpdate(): boolean;
+    generateUpdate(): boolean | undefined;
+}