@divinevoxel/vlox 0.0.0

package/Tools/Classes/LocationBoundTool.d.ts

@@ -0,0 +1,20 @@
+import type { LocationData } from "../../Math";
+import type { Vec3Array } from "@amodx/math";
+export declare class LocationBoundTool {
+    private _location;
+    get location(): LocationData;
+    dimension: string;
+    x: number;
+    y: number;
+    z: number;
+    setDimension(dimensionId: string): this;
+    getLocation(): LocationData;
+    getXYZAsArray(): Vec3Array;
+    getXYZ(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    setXYZ(x: number, y: number, z: number): this;
+    setLocation(location: LocationData): this;
+}

package/Tools/Classes/LocationBoundTool.js

@@ -0,0 +1,45 @@
+export class LocationBoundTool {
+    _location = ["main", 0, 0, 0];
+    get location() {
+        this._location[0] = this.dimension;
+        this._location[1] = this.x;
+        this._location[2] = this.y;
+        this._location[3] = this.z;
+        return this._location;
+    }
+    dimension = "main";
+    x = 0;
+    y = 0;
+    z = 0;
+    setDimension(dimensionId) {
+        this.dimension = dimensionId;
+        //  this.location[0] = dimensionId;
+        return this;
+    }
+    getLocation() {
+        return [this.dimension, this.x, this.y, this.z];
+    }
+    getXYZAsArray() {
+        return [this.x, this.y, this.z];
+    }
+    getXYZ() {
+        return {
+            x: this.x,
+            y: this.y,
+            z: this.z,
+        };
+    }
+    setXYZ(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    setLocation(location) {
+        this.dimension = location[0];
+        this.x = location[1];
+        this.y = location[2];
+        this.z = location[3];
+        return this;
+    }
+}

package/Tools/Classes/RichDataToolBase.d.ts

@@ -0,0 +1,10 @@
+import { RichDataSchema } from "../../Data/Types/RichWorldData.types.js";
+import { DataToolBase } from "./DataToolBase.js";
+export declare abstract class RichDataSegmentTool extends DataToolBase {
+    sceham: RichDataSchema;
+    segment: string;
+    constructor();
+    setSegment(segment: string): this;
+    getSegment(): false | Record<string, any>;
+    getAll(): false | RichDataSchema;
+}

package/Tools/Classes/RichDataToolBase.js

@@ -0,0 +1,26 @@
+import { DataToolBase } from "./DataToolBase.js";
+export class RichDataSegmentTool extends DataToolBase {
+    sceham = {};
+    segment = "voxel";
+    constructor() {
+        super();
+    }
+    setSegment(segment) {
+        this.segment = segment;
+        if (!this.sceham[segment]) {
+            this.sceham[segment] = {};
+        }
+        return this;
+    }
+    getSegment() {
+        const segment = this.sceham[this.segment];
+        if (segment)
+            return segment;
+        return false;
+    }
+    getAll() {
+        if (this.sceham)
+            return this.sceham;
+        return false;
+    }
+}

package/Tools/Data/DataTool.d.ts

@@ -0,0 +1,101 @@
+import type { RawVoxelData } from "../../Data/Types/VoxelData.types";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
+import { ChunkDataTool } from "./WorldData/ChunkDataTool.js";
+import { HeightMapTool } from "./WorldData/HeightMapTool.js";
+import { DataToolBase } from "../Classes/DataToolBase.js";
+import { ColumnDataTool } from "./WorldData/ColumnDataTool.js";
+import { SubstanceDataTool } from "./SubstanceDataTool.js";
+import { AddVoxelData } from "../../Data/Types/WorldData.types.js";
+export declare enum DataToolModes {
+    /**# World Data Mode
+     * ---
+     * Read data directly from the world.
+     */
+    WORLD = 0,
+    /**# Voxel Matrix Mode
+     * ---
+     * Read from a voxel matrix.
+     */
+    VOXEL_MATRIX = 1,
+    /**# Voxel Data Mode
+     * ---
+     * Read data from a single voxel passed in via `loadInRaw`
+     */
+    VOXEL_DATA = 2
+}
+export declare class DataTool extends DataToolBase {
+    static GetVoxelIDFromString(id: string): number;
+    static GetVoxelIDFromNumber(id: number): string;
+    static IsSameVoxel(dataTool1: DataTool, dataTool2: DataTool): boolean;
+    static VoxelDataToRaw(data: Partial<AddVoxelData>, light?: number): RawVoxelData;
+    static Modes: typeof DataToolModes;
+    static _heightMapTool: HeightMapTool;
+    static _columntool: ColumnDataTool;
+    _chunkTool: ChunkDataTool;
+    _substanceTool: SubstanceDataTool;
+    _loadedIn: boolean;
+    _mode: DataToolModes;
+    data: {
+        raw: RawVoxelData;
+        id: number;
+        secondaryId: number;
+    };
+    /**## secondary
+     * If the data tool is processing secondary voxoels
+     */
+    __secondary: boolean;
+    private _loadedId;
+    constructor();
+    setMode(mode: DataToolModes): this;
+    clear(): this;
+    setDimension(dimensionId: string | number): this;
+    setSecondary(enable: boolean): this;
+    getSubstnaceData(): SubstanceDataTool;
+    getRaw(): RawVoxelData;
+    waitTillCanLoad(maxWaitTime?: number): Promise<boolean>;
+    loadInRaw(rawData: RawVoxelData): this;
+    loadInData(data: Partial<AddVoxelData>, light?: number): void;
+    __struct: VoxelStruct;
+    private __process;
+    loadIn(): boolean;
+    commit(heightMapUpdate?: number): boolean;
+    hasRGBLight(): boolean;
+    hasSunLight(): boolean;
+    getLight(): number;
+    setLight(light: number): this;
+    isOpaque(): boolean;
+    getMod(): number;
+    setMod(mod: number): this;
+    getLevel(): number;
+    setLevel(level: number): this;
+    getLevelState(): number;
+    setLevelState(state: number): this;
+    getShapeState(): number;
+    setShapeState(state: number): this;
+    hasSecondaryVoxel(): boolean;
+    canHaveSecondaryVoxel(): boolean;
+    getShapeId(): number;
+    getShapeStringId(): string | null;
+    isLightSource(): boolean;
+    noAO(): boolean;
+    getLightSourceValue(): number;
+    getSubstanceStringId(): string;
+    getSubstance(): number;
+    getMaterial(): string | null;
+    getHardness(): number;
+    getCollider(): string | null;
+    checkCollisions(): boolean;
+    isRich(): boolean | 0;
+    setAir(): this;
+    isAir(): boolean;
+    setBarrier(): this;
+    isBarrier(): boolean;
+    getId(base?: boolean): number;
+    setId(id: number): this;
+    setStringId(id: string): this;
+    getStringId(): string;
+    setName(name: string): void;
+    getName(): string;
+    isRenderable(): boolean;
+    isSameVoxel(dataTool: DataTool): boolean;
+}

package/Tools/Data/DataTool.js

@@ -0,0 +1,431 @@
+import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
+import { VoxelStateReader } from "../../Data/VoxelStateReader.js";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
+import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
+import { ChunkDataTool } from "./WorldData/ChunkDataTool.js";
+import { HeightMapTool } from "./WorldData/HeightMapTool.js";
+import { DataToolBase } from "../Classes/DataToolBase.js";
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { ColumnDataTool } from "./WorldData/ColumnDataTool.js";
+import { LightData } from "../../Data/LightData.js";
+import { VoxelStructProperties } from "../../Data/Constants/Structs/VoxelStructProperties.js";
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
+import { SubstanceDataTool } from "./SubstanceDataTool.js";
+import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
+import { SafePromise } from "@amodx/core/Promises/SafePromise.js";
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds.js";
+import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
+export var DataToolModes;
+(function (DataToolModes) {
+    /**# World Data Mode
+     * ---
+     * Read data directly from the world.
+     */
+    DataToolModes[DataToolModes["WORLD"] = 0] = "WORLD";
+    /**# Voxel Matrix Mode
+     * ---
+     * Read from a voxel matrix.
+     */
+    DataToolModes[DataToolModes["VOXEL_MATRIX"] = 1] = "VOXEL_MATRIX";
+    /**# Voxel Data Mode
+     * ---
+     * Read data from a single voxel passed in via `loadInRaw`
+     */
+    DataToolModes[DataToolModes["VOXEL_DATA"] = 2] = "VOXEL_DATA";
+})(DataToolModes || (DataToolModes = {}));
+export class DataTool extends DataToolBase {
+    static GetVoxelIDFromString(id) {
+        return VoxelPalette.ids.getNumberId(id);
+    }
+    static GetVoxelIDFromNumber(id) {
+        return VoxelPalette.ids.getStringId(id);
+    }
+    static IsSameVoxel(dataTool1, dataTool2) {
+        return dataTool1.getId(true) == dataTool2.getId(true);
+    }
+    static VoxelDataToRaw(data, light = 0) {
+        const id = (data.id !== undefined && VoxelPalette.ids.getNumberId(data.id)) || 0;
+        const secondaryId = (data.secondaryVoxelId !== undefined &&
+            VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
+            0;
+        let stateData = 0;
+        if (data.level !== undefined)
+            stateData = VoxelStateReader.setLevel(stateData, data.level);
+        if (data.levelState !== undefined)
+            stateData = VoxelStateReader.setLevelState(stateData, data.levelState);
+        if (data.shapeState !== undefined)
+            stateData = VoxelStateReader.setShapeState(stateData, data.shapeState);
+        return [id, light, stateData, secondaryId, data.mod || 0];
+    }
+    static Modes = DataToolModes;
+    static _heightMapTool = new HeightMapTool();
+    static _columntool = new ColumnDataTool();
+    _chunkTool = new ChunkDataTool();
+    _substanceTool = new SubstanceDataTool();
+    _loadedIn = false;
+    _mode = DataToolModes.WORLD;
+    data = {
+        raw: Uint16Array.from([0, 0, 0, 0, 0]),
+        id: 0,
+        secondaryId: 0,
+    };
+    /**## secondary
+     * If the data tool is processing secondary voxoels
+     */
+    __secondary = false;
+    _loadedId = 0;
+    constructor() {
+        super();
+    }
+    setMode(mode) {
+        this._mode = mode;
+        return this;
+    }
+    clear() {
+        this._loadedIn = false;
+        let i = this.data.raw.length;
+        while (i--) {
+            this.data.raw[i] = 0;
+        }
+        this.data.id = 0;
+        this.data.secondaryId = 0;
+        return this;
+    }
+    setDimension(dimensionId) {
+        this.dimension =
+            DimensionsRegister.instance.getDimensionStringId(dimensionId);
+        return this;
+    }
+    setSecondary(enable) {
+        this.__secondary = enable;
+        if (enable) {
+            this.__struct.setIndex(VoxelStruct.voxelIndex[this.data.secondaryId]);
+        }
+        else {
+            this.__struct.setIndex(VoxelStruct.voxelIndex[this.data.id]);
+        }
+        this._loadedId = this.getId(true);
+        return this;
+    }
+    getSubstnaceData() {
+        this._substanceTool.setSubstance(this.getSubstance());
+        return this._substanceTool;
+    }
+    getRaw() {
+        return this.data.raw;
+    }
+    async waitTillCanLoad(maxWaitTime = 60_000) {
+        WorldRegister.instance.setDimension(this.dimension);
+        if (WorldRegister.instance.chunk.get(this.x, this.y, this.z))
+            return true;
+        return new SafePromise("wait-till-can-load", (resolve, reject, prom) => {
+            const inte = new SafeInterval();
+            prom.observers.died.subscribe(resolve, () => inte.stop());
+            prom.observers.canceled.subscribe(resolve, () => inte.stop());
+            prom.observers.finally.subscribe(resolve, () => inte.stop());
+            inte.setOnRun(() => {
+                WorldRegister.instance.setDimension(this.dimension);
+                if (WorldRegister.instance.chunk.get(this.x, this.y, this.z)) {
+                    resolve(true);
+                }
+            });
+        }, maxWaitTime).run();
+    }
+    loadInRaw(rawData) {
+        this.data.raw[0] = rawData[0];
+        this.data.raw[1] = rawData[1];
+        this.data.raw[2] = rawData[2];
+        this.data.raw[3] = rawData[3];
+        this.data.raw[4] = rawData[4];
+        this.__process();
+        return this;
+    }
+    loadInData(data, light = 0) {
+        this.loadInRaw(DataTool.VoxelDataToRaw(data, light));
+    }
+    __struct;
+    __process() {
+        if (!this.__struct)
+            this.__struct = VoxelStruct.clone();
+        this.data.id = this.data.raw[0];
+        this.data.secondaryId = this.data.raw[3];
+        if (this.data.secondaryId > 1) {
+            this.data.id = this.data.secondaryId;
+        }
+        else {
+            this.data.secondaryId = 0;
+        }
+        this.__struct.setIndex(VoxelStruct.voxelIndex[this.data.id]);
+        this._loadedId = this.getId(true);
+    }
+    loadIn() {
+        if (this._mode == DataTool.Modes.WORLD) {
+            if (!this._chunkTool
+                .setDimension(this.dimension)
+                .setXYZ(this.x, this.y, this.z)
+                .loadIn())
+                return false;
+            const index = WorldSpaces.voxel.getIndexXYZ(this.x, this.y, this.z);
+            this._chunkTool.loadInRaw(index, this.data.raw);
+            this.__process();
+            this._loadedIn = true;
+            return true;
+        }
+        if (this._mode == DataTool.Modes.VOXEL_MATRIX) {
+            return false;
+        }
+        if (this._mode == DataTool.Modes.VOXEL_DATA) {
+            this.data.raw[0] = 0;
+            this.data.raw[1] = LightData.getS(0xff);
+            this.data.raw[2] = 0;
+            return false;
+        }
+        return false;
+    }
+    commit(heightMapUpdate = 0) {
+        if (!this._loadedIn)
+            return false;
+        if (this._mode == DataTool.Modes.WORLD) {
+            const index = WorldSpaces.voxel.getIndexXYZ(this.x, this.y, this.z);
+            this._chunkTool.setRaw(index, this.data.raw);
+            if (DataTool._columntool
+                .setDimension(this.dimension)
+                .loadInAt(this.x, this.y, this.z)) {
+                DataTool._columntool.markAsNotStored();
+            }
+            if (heightMapUpdate) {
+                DataTool._heightMapTool.chunk._c = this._chunkTool._c;
+                //on add
+                if (heightMapUpdate == 1) {
+                    DataTool._heightMapTool.chunk.setY(this.y).setHasVoxels(true);
+                    //  DataTool._heightMapTool.chunk.update("add", substance, this.location);
+                }
+                //on remove
+                if (heightMapUpdate == 2) {
+                    DataTool._heightMapTool.chunk.setY(this.y).setDirty(true);
+                    //   DataTool._heightMapTool.chunk.update("remove", substance, this.location);
+                }
+            }
+            this._loadedIn = false;
+            return true;
+        }
+        if (this._mode == DataTool.Modes.VOXEL_MATRIX) {
+            return false;
+        }
+        if (this._mode == DataTool.Modes.VOXEL_DATA) {
+            return false;
+        }
+        return false;
+    }
+    hasRGBLight() {
+        const light = this.getLight();
+        if (light <= 0)
+            false;
+        return LightData.hasRGBLight(light);
+    }
+    hasSunLight() {
+        const light = this.getLight();
+        if (light <= 0)
+            false;
+        return LightData.hasSunLight(light);
+    }
+    getLight() {
+        if (this._mode == DataTool.Modes.VOXEL_DATA)
+            return 0xf;
+        const vID = this._loadedId;
+        if (vID == 0)
+            return this.data.raw[1];
+        if (vID < 2)
+            return -1;
+        const lightValue = this.__struct[VoxelTagIDs.lightValue];
+        if (this.isOpaque()) {
+            if (this.__struct[VoxelTagIDs.isLightSource] && lightValue) {
+                return lightValue;
+            }
+            else {
+                return -1;
+            }
+        }
+        if (this.__struct[VoxelTagIDs.isLightSource] && lightValue) {
+            return LightData.mixLight(this.data.raw[1], lightValue);
+        }
+        return this.data.raw[1];
+    }
+    setLight(light) {
+        this.data.raw[1] = light;
+        return this;
+    }
+    isOpaque() {
+        return this.__struct[VoxelTagIDs.isTransparent] == 0;
+    }
+    getMod() {
+        return this.data.raw[4];
+    }
+    setMod(mod) {
+        this.data.raw[4] = mod;
+        return this;
+    }
+    getLevel() {
+        return VoxelStateReader.getLevel(this.data.raw[2]);
+    }
+    setLevel(level) {
+        this.data.raw[2] = VoxelStateReader.setLevel(this.data.raw[2], level);
+        return this;
+    }
+    getLevelState() {
+        return VoxelStateReader.getLevelState(this.data.raw[2]);
+    }
+    setLevelState(state) {
+        this.data.raw[2] = VoxelStateReader.setLevelState(this.data.raw[2], state);
+        return this;
+    }
+    getShapeState() {
+        return VoxelStateReader.getShapeState(this.data.raw[2]);
+    }
+    setShapeState(state) {
+        this.data.raw[2] = VoxelStateReader.setShapeState(this.data.raw[2], state);
+        return this;
+    }
+    hasSecondaryVoxel() {
+        return this.data.secondaryId > 1;
+    }
+    canHaveSecondaryVoxel() {
+        return this.__struct[VoxelTagIDs.canHaveSecondary] == 1;
+    }
+    //voxel data
+    getShapeId() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return -1;
+        return this.__struct[VoxelTagIDs.shapeID];
+    }
+    getShapeStringId() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return "";
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.shapeID, this.__struct[VoxelTagIDs.shapeID]);
+    }
+    isLightSource() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return false;
+        return this.__struct[VoxelTagIDs.isLightSource] == 1;
+    }
+    noAO() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return false;
+        return this.__struct[VoxelTagIDs.noAO] == 1;
+    }
+    getLightSourceValue() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return 0;
+        return this.__struct[VoxelTagIDs.lightValue];
+    }
+    getSubstanceStringId() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return "#dve_transparent";
+        return SubstancePaletteReader.id.stringFromNumber(this.getSubstance());
+    }
+    getSubstance() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return -1;
+        return this.__struct[VoxelTagIDs.substance];
+    }
+    getMaterial() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return "none";
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.material, this.__struct[VoxelTagIDs.material]);
+    }
+    getHardness() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return 0;
+        return this.__struct[VoxelTagIDs.hardness];
+    }
+    getCollider() {
+        const vID = this._loadedId;
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.colliderID, this.__struct[VoxelTagIDs.colliderID]);
+    }
+    checkCollisions() {
+        const vID = this._loadedId;
+        if (vID == 0)
+            return false;
+        if (vID == 1)
+            return true;
+        return this.__struct[VoxelTagIDs.checkCollisions] == 1;
+    }
+    isRich() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return 0;
+        return this.__struct[VoxelTagIDs.isRich] == 1;
+    }
+    //util
+    setAir() {
+        this.data.raw[0] = 0;
+        this.__process();
+        return this;
+    }
+    isAir() {
+        return 0 == this.data.raw[0];
+    }
+    setBarrier() {
+        this.data.raw[0] = 1;
+        this.__process();
+        return this;
+    }
+    isBarrier() {
+        return 1 == this.data.raw[0];
+    }
+    //voxel id
+    getId(base = false) {
+        if (this.__secondary) {
+            if (!base)
+                return this.data.secondaryId;
+            return this.data.secondaryId;
+        }
+        if (!base)
+            return this.data.id;
+        return this.data.id;
+    }
+    setId(id) {
+        if (this.__secondary) {
+            this.data.raw[3] = id;
+            this.__process();
+            return this;
+        }
+        this.data.raw[0] = id;
+        this.__process();
+        return this;
+    }
+    setStringId(id) {
+        return this.setId(VoxelPalette.ids.getNumberId(id));
+    }
+    getStringId() {
+        if (this.__secondary) {
+            return VoxelPalette.ids.getStringId(this.data.secondaryId);
+        }
+        return VoxelPalette.ids.getStringId(this.data.id);
+    }
+    setName(name) {
+        this.setStringId(VoxelPalette.name.getId(name));
+    }
+    getName() {
+        return this.getStringId();
+    }
+    //util
+    isRenderable() {
+        if (this.data.id < 2 && this.data.secondaryId < 2)
+            return false;
+        return true;
+    }
+    isSameVoxel(dataTool) {
+        return DataTool.IsSameVoxel(this, dataTool);
+    }
+}

package/Tools/Data/RichDataTool.d.ts

@@ -0,0 +1,25 @@
+import { Thread } from "@amodx/threads/";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+export declare class RichDataTool extends LocationBoundTool {
+    segment: string;
+    comm: Thread;
+    _enabled: boolean;
+    constructor();
+    isEnabled(): boolean;
+    setSegment(segment: string): this;
+    columnHasData(check: (hasData: boolean) => void): void;
+    columnHasDataAsync(): Promise<boolean>;
+    getData<T = any>(onDone: (data: T | false) => void): void;
+    getDataAsync<T = any>(): Promise<T | false>;
+    setData<T = any>(data: T, onDone?: (data: boolean) => void): void;
+    setDataAsync<T = any>(data: T): Promise<boolean>;
+    removeData(onDone: (removed: boolean) => void): void;
+    removeDataAsync<T = any>(): Promise<boolean>;
+    removeColumn(onDone: (removed: boolean) => void): void;
+    removeColumnAsync<T = any>(): Promise<boolean>;
+    getColumn(onDone: (data: ArrayBuffer) => void): void;
+    getColumnAsync(): Promise<ArrayBuffer>;
+    setColumn(column: ArrayBuffer, onDone: (success: boolean) => void): void;
+    setColumnAsync(column: ArrayBuffer): Promise<boolean>;
+    releaeAllData(): void;
+}