@divinevoxel/vlox 0.0.73 → 0.0.75

package/Tasks/IWG/Internal/IWGTasks.js

@@ -1,129 +0,0 @@
-import { WorldRegister } from "../../../World/WorldRegister";
-import { Sector } from "../../../World/index";
-import { IWGTools } from "./IWGTools";
-import { TaskRegister } from "./TaskRegister";
-export class IWGTasks {
-    /**# Load Sectors
-     * ---
-     */
-    static worldLoadTasks = TaskRegister.addTasks({
-        id: "load",
-        propagationBlocking: true,
-        async run(location, onDone) {
-            const [dimension, x, y, z] = location;
-            const sector = WorldRegister.sectors.get(location[0], x, y, z);
-            if (sector)
-                return onDone();
-            if (!IWGTools.worldStorage) {
-                WorldRegister.sectors.new(location[0], x, y, z);
-                return onDone();
-            }
-            const loaded = await IWGTools.worldStorage.loadSector([
-                dimension,
-                x,
-                y,
-                z,
-            ]);
-            if (!loaded) {
-                WorldRegister.sectors.new(location[0], x, y, z);
-            }
-            onDone();
-        },
-    });
-    /**# Generate Sectors
-     * ---
-     */
-    static worldGenTasks = TaskRegister.addTasks({
-        id: "generate",
-        propagationBlocking: true,
-        async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
-                return onDone();
-            IWGTools.taskTool.generate.run([location, []], null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
-                onDone();
-            });
-        },
-    });
-    /**# Decorate Sectors
-     * ---
-     */
-    static worldDecorateTasks = TaskRegister.addTasks({
-        id: "decorate",
-        propagationBlocking: true,
-        async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
-                return onDone();
-            IWGTools.taskTool.decorate.run([location, []], null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
-                onDone();
-            });
-        },
-    });
-    /**# World Sun
-     * ---
-     */
-    static worldSunTasks = TaskRegister.addTasks({
-        id: "wolrd_sun",
-        propagationBlocking: true,
-        async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
-                return onDone();
-            IWGTools.taskTool.worldSun.run(location, null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldSunDone, true);
-                onDone();
-            });
-        },
-    });
-    /**# World Propagation
-     * ---
-     */
-    static worldPropagationTasks = TaskRegister.addTasks({
-        id: "propagation",
-        propagationBlocking: true,
-        async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(...location);
-            if (!sector)
-                throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
-            if (sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
-                return onDone();
-            IWGTools.taskTool.propagation.run(location, null, () => {
-                sector.setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
-                onDone();
-            });
-        },
-    });
-    /**# Save Sector
-     * ---
-     */
-    static saveTasks = TaskRegister.addTasks({
-        id: "save",
-        async run(location, onDone) {
-            if (!IWGTools.worldStorage)
-                return onDone();
-            await IWGTools.worldStorage.saveSector(location);
-            onDone();
-        },
-    });
-    /**# Save & Unload Sector
-     * ---
-     */
-    static saveAndUnloadTasks = TaskRegister.addTasks({
-        id: "save_and_unload",
-        async run(location, onDone) {
-            if (!IWGTools.worldStorage)
-                return onDone();
-            await IWGTools.worldStorage.unloadSector(location);
-            onDone();
-        },
-    });
-}

package/Tasks/IWG/Internal/IWGTools.d.ts

@@ -1,8 +0,0 @@
-import { Thread } from "@amodx/threads";
-import { TaskTool } from "../../../Tools/Tasks/TasksTool";
-import { WorldStorageInterface } from "../../../World/Types/WorldStorage.interface";
-export declare class IWGTools {
-    static taskTool: TaskTool;
-    static worldStorage: WorldStorageInterface | null;
-    static parent: Thread;
-}

package/Tasks/IWG/Internal/TaskRegister.d.ts

@@ -1,7 +0,0 @@
-import { DimensionSegment } from "./Classes/DimensionSegment";
-import { IWGTaskBase, IWGTasksData } from "./Classes/IWGTaskBase";
-export declare class TaskRegister {
-    static readonly tasks: IWGTaskBase[];
-    static addTasks(data: IWGTasksData): IWGTaskBase;
-    static addToDimension(dimension: DimensionSegment): void;
-}

package/Tasks/Propagation/Explosion/ExplosionManager.d.ts

@@ -1,4 +0,0 @@
-import { UpdateTask } from "../../Update/UpdateTask.js";
-export declare const ExplosionManager: {
-    runExplosion(tasks: UpdateTask, radius: number): void;
-};

package/Tasks/Propagation/Explosion/ExplosionManager.js

@@ -1,117 +0,0 @@
-//data
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
-//objects
-//functions
-import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
-import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate.js";
-import { FlowManager } from "../Flow/FlowManager.js";
-import { VisitedMap } from "../../../Util/VisistedMap";
-import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
-const lightData = new VoxelLightData();
-export const ExplosionManager = {
-    runExplosion(tasks, radius) {
-        const [dimension, sx, sy, sz] = tasks.origin;
-        FlowManager.setDimension(dimension);
-        const queue = [];
-        const map = new VisitedMap();
-        queue.push([sx, sy, sz]);
-        while (queue.length) {
-            const node = queue.shift();
-            if (!node)
-                break;
-            const x = node[0];
-            const y = node[1];
-            const z = node[2];
-            if (!map.inMap(x + 1, y, z)) {
-                if (tasks.sDataCursor.getVoxel(x + 1, y, z)) {
-                    const d = Distance3D(sx, sy, sz, x + 1, y, z);
-                    if (d <= radius) {
-                        queue.push([x + 1, y, z]);
-                    }
-                    map.add(x + 1, y, z);
-                }
-            }
-            if (!map.inMap(x - 1, y, z)) {
-                if (tasks.sDataCursor.getVoxel(x - 1, y, z)) {
-                    const d = Distance3D(sx, sy, sz, x - 1, y, z);
-                    if (d <= radius) {
-                        queue.push([x - 1, y, z]);
-                    }
-                }
-                map.add(x - 1, y, z);
-            }
-            if (!map.inMap(x, y, z + 1)) {
-                if (tasks.sDataCursor.getVoxel(x, y, z + 1)) {
-                    const d = Distance3D(sx, sy, sz, x, y, z + 1);
-                    if (d <= radius) {
-                        queue.push([x, y, z + 1]);
-                    }
-                }
-                map.add(x, y, z + 1);
-            }
-            if (!map.inMap(x, y, z - 1)) {
-                if (tasks.sDataCursor.getVoxel(x, y, z - 1)) {
-                    const d = Distance3D(sx, sy, sz, x, y, z - 1);
-                    if (d <= radius) {
-                        queue.push([x, y, z - 1]);
-                    }
-                }
-                map.add(x, y, z - 1);
-            }
-            if (!map.inMap(x, y + 1, z)) {
-                if (tasks.sDataCursor.getVoxel(x, y + 1, z)) {
-                    const d = Distance3D(sx, sy, sz, x, y + 1, z);
-                    if (d <= radius) {
-                        queue.push([x, y + 1, z]);
-                    }
-                }
-                map.add(x, y + 1, z);
-            }
-            if (!map.inMap(x, y - 1, z)) {
-                if (tasks.sDataCursor.getVoxel(x, y - 1, z)) {
-                    const d = Distance3D(sx, sy, sz, x, y - 1, z);
-                    if (d <= radius) {
-                        queue.push([x, y - 1, z]);
-                    }
-                }
-                map.add(x, y - 1, z);
-            }
-            const voxel = tasks.sDataCursor.getVoxel(x, y, z);
-            if (voxel) {
-                if (voxel.isRenderable()) {
-                    for (const n of $3dCardinalNeighbors) {
-                        const nx = x + n[0];
-                        const ny = y + n[1];
-                        const nz = z + n[2];
-                        const nvoxel = tasks.nDataCursor.getVoxel(x, y, z);
-                        if (nvoxel) {
-                            const l = nvoxel.getLight();
-                            if (l > 0) {
-                                if (lightData.getS(l) > 0) {
-                                    tasks.sun.remove.push(nx, ny, nz);
-                                }
-                                if (lightData.hasRGBLight(l)) {
-                                    tasks.rgb.remove.push(nx, ny, nz);
-                                }
-                            }
-                        }
-                    }
-                    tasks.bounds.update(x, y, z);
-                    /*           if (
-                                voxel.getHardness() > 10_000 ||
-                                voxel.getSubstnaceData().isLiquid()
-                              ) {
-                                continue;
-                              } */
-                    voxel.setAir().updateVoxel(1);
-                }
-            }
-        }
-        RGBRemove(tasks);
-        SunRemove(tasks);
-        RGBUpdate(tasks);
-        SunUpdate(tasks);
-        // tasks.runRebuildQueue();
-    },
-};

package/Tasks/Update/InitTasks.d.ts

@@ -1,5 +0,0 @@
-import { Thread } from "@amodx/threads";
-import { UpdateTask } from "./UpdateTask";
-export default function (props: {
-    onDone(taks: UpdateTask, origin: Thread): void;
-}): void;

package/Tasks/Update/InitTasks.js

@@ -1,23 +0,0 @@
-import { Threads } from "@amodx/threads";
-import { TasksIds } from "../TasksIds";
-import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
-export default function (props) {
-    Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
-        const tasks = await VoxelUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-    Threads.registerTask(TasksIds.VoxelErease, async (data, origin) => {
-        const tasks = await EreaseAndUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-    Threads.registerTask(TasksIds.VoxelPaint, async (data, origin) => {
-        const tasks = await PaintAndUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-}

package/Tasks/Update/VoxelUpdate.d.ts

@@ -1,6 +0,0 @@
-import { VoxelUpdateTasks } from "../Tasks.types.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { LocationData } from "../../Math/index.js";
-export declare function EreaseAndUpdate(location: LocationData): Promise<false | UpdateTask>;
-export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
-export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -1,177 +0,0 @@
-import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-import { UpdateTask } from "./UpdateTask.js";
-import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
-import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
-import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
-const tasks = new UpdateTask();
-const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    const [dimension, x, y, z] = tasks.origin;
-    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
-    for (const n of $3dCardinalNeighbors) {
-        const nx = n[0] + x;
-        const ny = n[1] + y;
-        const nz = n[2] + z;
-        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-        if (!nVoxel)
-            continue;
-        if (doRGB) {
-            if (nVoxel.hasRGBLight()) {
-                tasks.rgb.update.push(nx, ny, nz);
-            }
-        }
-        if (doSun) {
-            if (nVoxel.hasSunLight()) {
-                tasks.sun.update.push(nx, ny, nz);
-            }
-        }
-    }
-};
-export async function EreaseAndUpdate(location) {
-    const [dimension, x, y, z] = location;
-    tasks.setOrigin(location);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const substanceData = voxel.getSubstanceData();
-    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData["dve_is_liquid"]) {
-            FlowRemove(tasks);
-            return tasks;
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const light = voxel.getLight();
-    const isLightSource = voxel.isLightSource();
-    voxel.setSecondary(true).setId(0).setSecondary(false);
-    voxel
-        .setLight(light > 0 ? light : 0)
-        .setId(0)
-        .setLevel(0)
-        .setLevelState(0)
-        .setState(0)
-        .setMod(0)
-        .updateVoxel(1);
-    if (ES.doLight) {
-        if (ES.doRGBPropagation && isLightSource) {
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-        }
-        updateLightTask(tasks);
-        if (ES.doRGBPropagation) {
-            RGBUpdate(tasks);
-        }
-        if (ES.doSunPropagation) {
-            SunUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
-export async function PaintAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const raw = data[1];
-    const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    lighttest: if (ES.doLight) {
-        const light = voxel.getLight();
-        if (light <= 0)
-            break lighttest;
-        if (doSun) {
-            if (voxel.hasSunLight()) {
-                tasks.sun.remove.push(x, y, z);
-                SunRemove(tasks);
-            }
-        }
-        if (doRGB) {
-            if (voxel.hasRGBLight() && isOpaque) {
-                tasks.rgb.remove.push(x, y, z);
-                RGBRemove(tasks);
-            }
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const id = raw[0];
-    if (id < 0)
-        return false;
-    voxel.setId(id);
-    voxel.setLevel(raw[2]);
-    voxel.setState(raw[3]);
-    voxel.setMod(raw[4]);
-    voxel.process();
-    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
-        voxel.setSecondary(true);
-        voxel.setId(raw[5]);
-        voxel.setSecondary(false);
-    }
-    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
-        voxel.setLight(voxel.getLightSourceValue());
-    }
-    voxel.updateVoxel(0);
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            SunUpdate(tasks);
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow) {
-        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}
-export async function VoxelUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    const voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            tasks.sun.update.push(x, y, z);
-            SunUpdate(tasks);
-        }
-    }
-    if (ES.doFlow) {
-        if (voxel.getSubstanceData()["dve_is_solid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    return tasks;
-}

package/Templates/FullVoxelTemplate.d.ts

@@ -1,14 +0,0 @@
-import { Flat3DIndex, Vec3Array } from "@amodx/math";
-import { FullVoxelTemplateData } from "./VoxelTemplates.types";
-export declare class FullVoxelTemplate {
-    static CreateNew(size: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
-    index: Flat3DIndex;
-    size: Vec3Array;
-    ids: Uint16Array;
-    level: Uint8Array;
-    state: Uint16Array;
-    light: Uint16Array;
-    mod: Uint16Array;
-    secondary: Uint16Array;
-    constructor(data: FullVoxelTemplateData);
-}

package/Templates/FullVoxelTemplate.js

@@ -1,61 +0,0 @@
-import { Flat3DIndex } from "@amodx/math";
-export class FullVoxelTemplate {
-    static CreateNew(size, baseLightValue = 0) {
-        const voxelSize = size[0] * size[1] * size[2];
-        const sectionBuffer = new SharedArrayBuffer(
-        //ids
-        voxelSize * 2 +
-            //light
-            voxelSize * 2 +
-            //state
-            voxelSize * 2 +
-            //mod
-            voxelSize * 2 +
-            //secondary
-            voxelSize * 2 +
-            //level
-            voxelSize);
-        let bufferStart = 0;
-        const ids = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const light = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        if (baseLightValue)
-            light.fill(baseLightValue);
-        const state = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const mod = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const secondary = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const level = new Uint8Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize;
-        return {
-            size,
-            ids,
-            light,
-            level,
-            state,
-            secondary,
-            mod,
-        };
-    }
-    index = Flat3DIndex.GetXZYOrder();
-    size;
-    ids;
-    level;
-    state;
-    light;
-    mod;
-    secondary;
-    constructor(data) {
-        this.size = [...data.size];
-        this.index.setBounds(...data.size);
-        this.ids = data.ids;
-        this.level = data.level;
-        this.state = data.state;
-        this.light = data.light;
-        this.mod = data.mod;
-        this.secondary = data.secondary;
-    }
-}

package/Templates/Functions/CreateTemplate.d.ts

@@ -1,3 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelTemplate } from "../VoxelTemplate";
-export default function CreateTemplate(dimension: string, start: Vec3Array, end: Vec3Array): VoxelTemplate;