@divinevoxel/vlox 0.0.7 → 0.0.72

package/World/Section/Section.js

@@ -1,6 +1,6 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { WorldSpaces } from "../WorldSpaces.js";
 import { Sector } from "../Sector/Sector.js";
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BitArray.js";
 function forceMultipleOf2(n) {
     return n % 2 === 0 ? n : n + 1;
 }
@@ -10,7 +10,20 @@ export class Section {
     index;
     static GetBufferSize() {
         const voxelSize = WorldSpaces.section.volumne;
-        return forceMultipleOf2(forceMultipleOf2(Section.StateStruct.structSize) +
+        const height = WorldSpaces.section.bounds.y;
+        return forceMultipleOf2(
+        //-----
+        //voxelMap
+        height / 8 +
+            //dirtyMap
+            height / 8 +
+            //-----
+            //cache
+            voxelSize / 8 +
+            //exposed
+            voxelSize * 2 +
+            //-----
+            //voxel data
             //ids
             voxelSize * 2 +
             //light
@@ -25,13 +38,18 @@ export class Section {
             voxelSize * 2);
     }
     static GetArrayStartIndex(index) {
-        return (index * Section.GetBufferSize() +
-            Sector.GetHeaderSize() +
-            forceMultipleOf2(Section.StateStruct.structSize));
+        return index * Section.GetBufferSize() + Sector.GetHeaderSize();
     }
     static CreateNew(index, sectorBuffer) {
         const voxelSize = WorldSpaces.section.volumne;
         let bufferStart = this.GetArrayStartIndex(index);
+        const height = WorldSpaces.section.bounds.y;
+        const voxelMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
+        bufferStart += height / 8;
+        const dirtyMap = new Uint8Array(sectorBuffer, bufferStart, height / 8);
+        bufferStart += height / 8;
+        const buried = new Uint8Array(sectorBuffer, bufferStart, voxelSize / 8);
+        bufferStart += voxelSize / 8;
         const ids = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
         const light = new Uint16Array(sectorBuffer, bufferStart, voxelSize);
@@ -45,6 +63,9 @@ export class Section {
         const level = new Uint8Array(sectorBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize;
         return {
+            voxelMap,
+            dirtyMap,
+            buried,
             ids,
             light,
             level,
@@ -56,12 +77,12 @@ export class Section {
     static toObject(sector, index, data) {
         return new Section(sector, index, data);
     }
-    static StateStruct = new RemoteBinaryStruct("section-tags");
-    sectionState;
     constructor(sector, index, data) {
         this.sector = sector;
         this.index = index;
-        this.sectionState = new DataView(sector.buffer, index * Section.GetBufferSize() + Sector.GetHeaderSize(), Section.StateStruct.structSize);
+        this.voxelMap = data.voxelMap;
+        this.dirtyMap = data.dirtyMap;
+        this.buried = data.buried;
         this.ids = data.ids;
         this.level = data.level;
         this.light = data.light;
@@ -76,8 +97,43 @@ export class Section {
         position[2] = this.sector.position[2];
         return position;
     }
-    serialize() {
+    getBuried(index) {
+        return getBitArrayIndex(this.buried, index) == 1;
+    }
+    setBuried(index, value) {
+        return setBitArrayIndex(this.buried, index, value ? 1 : 0);
+    }
+    setHasVoxel(y, hasVoxel) {
+        return setBitArrayIndex(this.voxelMap, y, hasVoxel ? 1 : 0);
+    }
+    getHasVoxel(y) {
+        return getBitArrayIndex(this.voxelMap, y) == 1;
+    }
+    setHasVoxelDirty(y, dirty) {
+        return setBitArrayIndex(this.dirtyMap, y, dirty ? 1 : 0);
+    }
+    getHasVoxelDirty(y) {
+        return getBitArrayIndex(this.dirtyMap, y) == 1;
+    }
+    getMinMax() {
+        let min = Infinity;
+        let max = -Infinity;
+        let i = WorldSpaces.section.bounds.y;
+        while (i--) {
+            if (this.getHasVoxel(i) || this.getHasVoxelDirty(i)) {
+                if (i < min)
+                    min = i;
+                if (i > max)
+                    max = i;
+            }
+        }
+        return [min, max];
+    }
+    toJSON() {
         return {
+            voxelMap: this.voxelMap,
+            dirtyMap: this.dirtyMap,
+            buried: this.buried,
             ids: this.ids,
             light: this.light,
             level: this.level,

package/World/Sector/Sector.d.ts

@@ -1,23 +1,30 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
-import { Section, VoxelDataArrays } from "../Section/Section.js";
+import { Section, SectionData } from "../Section/Section.js";
 import { Vec3Array } from "@amodx/math";
+import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
 export interface SectorData {
     position: Vec3Array;
     buffer: ArrayBufferLike;
-    sections: VoxelDataArrays[];
+    /**Array of timestamps for the sector */
+    timeStampArray: Uint32Array;
+    /**Array of bit flags for the sector*/
+    flagArray: Uint8Array;
+    sections: SectionData[];
 }
 export interface Sector extends SectorData {
 }
 export declare class Sector {
-    static StateStruct: RemoteBinaryStruct;
+    static FlagIds: typeof SectorStateFlags;
+    static TimeStampIds: typeof SectorTimestampFlags;
     static GetHeaderSize(): number;
     static GetBufferSize(): number;
     static CreateNew(): SectorData;
     sections: Section[];
     bufferView: Uint8Array;
-    sectorState: DataView;
-    position: Vec3Array;
     constructor(data: SectorData);
     getSection(y: number): Section;
+    setBitFlag(index: number, value: boolean): void;
+    getBitFlag(index: number): boolean;
+    setTimeStamp(index: number, value: number): void;
+    getTimeStamp(index: number): number;
     toJSON(): SectorData;
 }

package/World/Sector/Sector.js

@@ -1,13 +1,19 @@
-import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Section } from "../Section/Section.js";
 import { WorldSpaces } from "../WorldSpaces";
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BitArray.js";
+import { SectorStateFlags, SectorTimestampFlags } from "./SectorState.js";
 function forceMultipleOf2(n) {
     return n % 2 === 0 ? n : n + 1;
 }
 export class Sector {
-    static StateStruct = new RemoteBinaryStruct("sector-tags");
+    static FlagIds = SectorStateFlags;
+    static TimeStampIds = SectorTimestampFlags;
     static GetHeaderSize() {
-        return forceMultipleOf2(Sector.StateStruct.structSize);
+        return forceMultipleOf2(
+        //12 bytes fot flags
+        12 +
+            //12 * 4 bytes for time stamps
+            12 * 4);
     }
     static GetBufferSize() {
         const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
@@ -15,8 +21,8 @@ export class Sector {
     }
     static CreateNew() {
         const buffer = new SharedArrayBuffer(this.GetBufferSize());
-        Sector.StateStruct.setBuffer(buffer);
-        Sector.StateStruct.setProperty("dve_is_stored", 0);
+        const flagArray = new Uint8Array(buffer, 0, 12);
+        const timeStampArray = new Uint32Array(buffer, 12, 12 * 4);
         const sections = [];
         const totalSections = WorldSpaces.sector.bounds.y / WorldSpaces.section.bounds.y;
         for (let i = 0; i < totalSections; i++) {
@@ -25,16 +31,17 @@ export class Sector {
         return {
             position: [0, 0, 0],
             buffer,
+            flagArray,
+            timeStampArray,
             sections,
         };
     }
     sections = [];
     bufferView;
-    sectorState;
-    position;
     constructor(data) {
         this.position = data.position;
-        this.sectorState = new DataView(data.buffer);
+        this.flagArray = data.flagArray;
+        this.timeStampArray = data.timeStampArray;
         this.buffer = data.buffer;
         this.bufferView = new Uint8Array(data.buffer);
         for (let i = 0; i < data.sections.length; i++) {
@@ -46,14 +53,28 @@ export class Sector {
         const index = ry / WorldSpaces.section.bounds.y;
         return this.sections[index];
     }
+    setBitFlag(index, value) {
+        setBitArrayIndex(this.flagArray, index, value ? 1 : 0);
+    }
+    getBitFlag(index) {
+        return getBitArrayIndex(this.flagArray, index) == 1;
+    }
+    setTimeStamp(index, value) {
+        this.timeStampArray[index] = value;
+    }
+    getTimeStamp(index) {
+        return this.timeStampArray[index];
+    }
     toJSON() {
         const sections = [];
         for (const section of this.sections) {
-            sections.push(section.serialize());
+            sections.push(section.toJSON());
         }
         return {
             position: this.position,
             buffer: this.buffer,
+            flagArray: this.flagArray,
+            timeStampArray: this.timeStampArray,
             sections,
         };
     }

package/World/Sector/SectorHeightMap.js

@@ -1,5 +1,4 @@
 import { $2dMooreNeighborhood } from "../../Math/CardinalNeighbors";
-import { SectionHeightMap } from "../Section/SectionHeightMap";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
@@ -32,9 +31,8 @@ export class SectorHeightMap {
             const section = sector.sections[i];
             if (!section)
                 continue;
-            SectionHeightMap.setSection(section);
             const sectionPOS = y + i * WorldSpaces.section.bounds.y;
-            let [sectionMin, sectionMax] = SectionHeightMap.getMinMax();
+            let [sectionMin, sectionMax] = section.getMinMax();
             if (Math.abs(sectionMax) == Infinity)
                 continue;
             sectionMax = sectionPOS + sectionMax;

package/World/Sector/SectorState.d.ts

@@ -0,0 +1,13 @@
+export declare enum SectorStateFlags {
+    isWorldGenDone = 0,
+    isWorldDecorDone = 1,
+    isWorldPropagationDone = 2,
+    isWorldSunDone = 3,
+    isDirty = 4,
+    isStored = 5,
+    persistent = 6
+}
+export declare enum SectorTimestampFlags {
+    lastSaveTimestamp = 0,
+    lastAnalyzerUpdateTimestamp = 1
+}

package/World/Sector/SectorState.js

@@ -0,0 +1,15 @@
+export var SectorStateFlags;
+(function (SectorStateFlags) {
+    SectorStateFlags[SectorStateFlags["isWorldGenDone"] = 0] = "isWorldGenDone";
+    SectorStateFlags[SectorStateFlags["isWorldDecorDone"] = 1] = "isWorldDecorDone";
+    SectorStateFlags[SectorStateFlags["isWorldPropagationDone"] = 2] = "isWorldPropagationDone";
+    SectorStateFlags[SectorStateFlags["isWorldSunDone"] = 3] = "isWorldSunDone";
+    SectorStateFlags[SectorStateFlags["isDirty"] = 4] = "isDirty";
+    SectorStateFlags[SectorStateFlags["isStored"] = 5] = "isStored";
+    SectorStateFlags[SectorStateFlags["persistent"] = 6] = "persistent";
+})(SectorStateFlags || (SectorStateFlags = {}));
+export var SectorTimestampFlags;
+(function (SectorTimestampFlags) {
+    SectorTimestampFlags[SectorTimestampFlags["lastSaveTimestamp"] = 0] = "lastSaveTimestamp";
+    SectorTimestampFlags[SectorTimestampFlags["lastAnalyzerUpdateTimestamp"] = 1] = "lastAnalyzerUpdateTimestamp";
+})(SectorTimestampFlags || (SectorTimestampFlags = {}));

package/World/WorldSpaces.d.ts

@@ -38,7 +38,9 @@ declare class VoxelSpace {
     static bounds: Vector3Like;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
     static getIndex(x: number, y: number, z: number): number;
+    static getIndexFromPosition(x: number, y: number, z: number): number;
 }
 declare class Hash {
     static hashVec3(vector3: Vector3Like): string;

package/World/WorldSpaces.js

@@ -1,7 +1,7 @@
 //types
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { Vector3Like } from "@amodx/math";
-import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, } from "../Math/Indexing.js";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, } from "../Math/Indexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
 class WorldBounds {
@@ -100,10 +100,16 @@ class VoxelSpace {
         refPosition[2] = z - refPosition[2];
         return refPosition;
     }
+    static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
+        return GetYXZOrderArrayPositionVec3(index, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, 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);
     }
+    static getIndexFromPosition(x, y, z) {
+        return GetYXZOrderArrayIndex(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+    }
 }
 class Hash {
     static hashVec3(vector3) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.07",
+  "version": "0.0.72",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Data/Register/MappedDataRegister.d.ts

@@ -1,5 +0,0 @@
-import { MappedRegisterBase } from "./MappedRegisterBase.js";
-export declare class MappedDataRegister {
-    static stringMaps: MappedRegisterBase<string>;
-    static objectMaps: MappedRegisterBase<any>;
-}

package/Data/Register/MappedDataRegister.js

@@ -1,9 +0,0 @@
-import { MappedRegisterBase } from "./MappedRegisterBase.js";
-export class MappedDataRegister {
-    static stringMaps = new MappedRegisterBase();
-    static objectMaps = new MappedRegisterBase();
-}
-MappedDataRegister.stringMaps.addSegment("voxel");
-MappedDataRegister.objectMaps.addSegment("voxel");
-MappedDataRegister.stringMaps.addSegment("substance");
-MappedDataRegister.objectMaps.addSegment("substance");

package/Data/Register/MappedRegisterBase.d.ts

@@ -1,14 +0,0 @@
-declare class MappedRegisterSegment<Data> extends EventTarget {
-    entries: Map<string, Data[]>;
-    onEntryAdded(id: string, run: (data: Data[]) => void): void;
-    add(id: string, data: Data[]): void;
-    get(id: string): Data[] | undefined;
-}
-export declare class MappedRegisterBase<Data> {
-    segments: Map<string, MappedRegisterSegment<Data>>;
-    addSegment(id: string): MappedRegisterSegment<Data>;
-    getSegment(id: string): MappedRegisterSegment<Data>;
-    sync(segment: string, id: string, value: Data[]): void;
-    get(segment: string, id: string, index: number): Data | null;
-}
-export {};

package/Data/Register/MappedRegisterBase.js

@@ -1,50 +0,0 @@
-const getSyncId = (id) => `entry-synced-${id}`;
-class MappedRegisterSegment extends EventTarget {
-    entries = new Map();
-    onEntryAdded(id, run) {
-        const entrySyncedId = getSyncId(id);
-        const listener = () => {
-            run(this.entries.get(id));
-            this.removeEventListener(entrySyncedId, listener);
-        };
-        this.addEventListener(entrySyncedId, listener);
-    }
-    add(id, data) {
-        this.entries.set(id, data);
-        this.dispatchEvent(new Event(getSyncId(id)));
-    }
-    get(id) {
-        return this.entries.get(id);
-    }
-}
-export class MappedRegisterBase {
-    segments = new Map();
-    addSegment(id) {
-        if (this.segments.has(id))
-            return this.segments.get(id);
-        const newSegment = new MappedRegisterSegment();
-        this.segments.set(id, newSegment);
-        return newSegment;
-    }
-    getSegment(id) {
-        const segment = this.segments.get(id);
-        if (!segment)
-            throw new Error(`Segment with id ${id} does not exist`);
-        return segment;
-    }
-    sync(segment, id, value) {
-        const segmentMap = this.addSegment(segment);
-        segmentMap.add(id, value);
-        return;
-    }
-    get(segment, id, index) {
-        const segmentMap = this.segments.get(segment);
-        if (!segmentMap)
-            return null;
-        const mapped = segmentMap.get(id);
-        if (!mapped) {
-            return null;
-        }
-        return mapped[index];
-    }
-}

package/Data/Structs/StructBuilder.d.ts

@@ -1,34 +0,0 @@
-import type { TagBuilderNodes } from "Data/Structs/StructBuilder.types.js";
-import { BinaryStructData, BinraryStructBase } from "@amodx/binary/";
-import { BinaryStruct } from "@amodx/binary/";
-export declare class StructBuilder {
-    id: string;
-    dataSegment: string;
-    _built: boolean;
-    _nodeMap: Map<string, TagBuilderNodes>;
-    _stringMaps: Map<string, {
-        count: number;
-        found: Record<string, number>;
-        map: string[];
-        allowedComms: string[];
-    }>;
-    _objectMaps: Map<string, {
-        count: number;
-        found: Record<string, number>;
-        map: any[];
-        allowedComms: string[];
-    }>;
-    _defaults: Map<string, number>;
-    _initData: BinaryStructData;
-    constructor(id: string, dataSegment: string);
-    addNode(node: TagBuilderNodes | TagBuilderNodes[]): void;
-    getNode(id: string): TagBuilderNodes | undefined;
-    setDefaults(tagManager: BinraryStructBase): void;
-    hasNode(id: string): boolean;
-    setNode(id: string, value: any, tagManager: BinraryStructBase): false | undefined;
-    build(totalTagIndexes?: number): BinaryStruct;
-    getMaps(): {
-        objectMaps: Record<string, any[]>;
-        stringMaps: Record<string, string[]>;
-    };
-}

package/Data/Structs/StructBuilder.js

@@ -1,157 +0,0 @@
-import { BinaryNumberTypes, } from "@amodx/binary/";
-import { BinaryStruct } from "@amodx/binary/";
-export class StructBuilder {
-    id;
-    dataSegment;
-    _built = false;
-    _nodeMap = new Map();
-    _stringMaps = new Map();
-    _objectMaps = new Map();
-    _defaults = new Map();
-    _initData;
-    constructor(id, dataSegment) {
-        this.id = id;
-        this.dataSegment = dataSegment;
-    }
-    addNode(node) {
-        if (Array.isArray(node)) {
-            for (const n of node) {
-                this._nodeMap.set(n.id, n);
-            }
-            return;
-        }
-        this._nodeMap.set(node.id, node);
-    }
-    getNode(id) {
-        return this._nodeMap.get(id);
-    }
-    setDefaults(tagManager) {
-        for (const [key, node] of this._nodeMap) {
-            const defaultValue = this._defaults.get(key);
-            if (!defaultValue)
-                continue;
-            tagManager.setProperty(key, Number(defaultValue));
-        }
-    }
-    hasNode(id) {
-        return this._nodeMap.has(id);
-    }
-    setNode(id, value, tagManager) {
-        const node = this.getNode(id);
-        if (!node)
-            return;
-        if (node.type == "number") {
-            tagManager.setProperty(node.id, Number(value));
-        }
-        if (node.type == "boolean") {
-            tagManager.setProperty(node.id, Number(value));
-        }
-        if (node.type == "number-array") {
-            if (!Array.isArray(value))
-                return false;
-            let i = value.length;
-            while (i--) {
-                tagManager.setArrayPropertyValue(node.id, i, value[i]);
-            }
-        }
-        if (node.type == "string-map") {
-            const data = this._stringMaps.get(node.id);
-            if (!data)
-                return false;
-            const v = String(value).trim();
-            if (data.found[v] === undefined) {
-                data.map.push(v);
-                data.found[v] = data.count;
-                data.count++;
-            }
-            tagManager.setProperty(node.id, data.found[v]);
-        }
-        if (node.type == "object-map") {
-            const data = this._objectMaps.get(node.id);
-            if (!data)
-                return false;
-            const v = JSON.stringify(value);
-            if (data.found[v] === undefined) {
-                data.map[data.count] = value;
-                data.found[v] = data.count;
-                data.count++;
-            }
-            tagManager.setProperty(node.id, data.found[v]);
-        }
-    }
-    build(totalTagIndexes = 0) {
-        const tags = new BinaryStruct(this.id);
-        for (const [key, node] of this._nodeMap) {
-            if (node.type == "number") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: node.numberType,
-                });
-                this._defaults.set(node.id, node.default);
-                continue;
-            }
-            if (node.type == "number-array") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number-array",
-                    numberType: node.numberType,
-                    length: node.length,
-                });
-                continue;
-            }
-            if (node.type == "boolean") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "boolean",
-                });
-                this._defaults.set(node.id, node.default ? 1 : 0);
-            }
-            if (node.type == "string-map") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: BinaryNumberTypes.Uint16,
-                });
-                this._stringMaps.set(node.id, {
-                    count: 0,
-                    found: {},
-                    map: [],
-                    allowedComms: node.allowedComms,
-                });
-            }
-            if (node.type == "object-map") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: BinaryNumberTypes.Uint16,
-                });
-                this._objectMaps.set(node.id, {
-                    count: 0,
-                    found: {},
-                    map: [],
-                    allowedComms: node.allowedComms,
-                });
-            }
-        }
-        tags.init({
-            indexBufferMode: "shared",
-            numberOfIndexes: totalTagIndexes,
-        });
-        return tags;
-    }
-    getMaps() {
-        const objectMaps = {};
-        const stringMaps = {};
-        for (const [key, value] of this._stringMaps) {
-            stringMaps[key] = value.map;
-        }
-        for (const [key, value] of this._objectMaps) {
-            objectMaps[key] = value.map;
-        }
-        return {
-            objectMaps,
-            stringMaps,
-        };
-    }
-}

package/Data/Structs/StructBuilder.types.d.ts

@@ -1,30 +0,0 @@
-import type { BinaryNumberTypes } from "@amodx/binary/";
-type TagBuilderNodeBase = {
-    id: string;
-};
-type TagBuilderNumberNode = {
-    type: "number";
-    numberType: BinaryNumberTypes;
-    default: number;
-} & TagBuilderNodeBase;
-type TagBuilderNumberArrayNode = {
-    type: "number-array";
-    numberType: BinaryNumberTypes;
-    length: number;
-} & TagBuilderNodeBase;
-type TagBuilderStringMapNode = {
-    type: "string-map";
-    allowedComms: string[];
-    default?: string;
-} & TagBuilderNodeBase;
-type TagBuilderObjectMapNode = {
-    type: "object-map";
-    allowedComms: string[];
-    default?: any;
-} & TagBuilderNodeBase;
-type TagBuilderBooleanNode = {
-    type: "boolean";
-    default: boolean;
-} & TagBuilderNodeBase;
-export type TagBuilderNodes = TagBuilderNumberNode | TagBuilderNumberArrayNode | TagBuilderStringMapNode | TagBuilderBooleanNode | TagBuilderObjectMapNode;
-export {};

package/Data/Structs/StructBuilder.types.js

@@ -1 +0,0 @@
-export {};

package/Tools/Data/SubstanceDataTool.d.ts

@@ -1,13 +0,0 @@
-import { SubstanceStruct } from "../../Voxels/Structs/SubstanceStruct.js";
-export declare class SubstanceDataTool {
-    static tags: typeof SubstanceStruct;
-    substanceTagIndex: number;
-    setSubstanceFromString(substance: string): this;
-    setSubstance(substance: number): this;
-    getSubstanceStringId(): string;
-    isSolid(): boolean;
-    isLiquid(): boolean;
-    isWindAffected(): boolean;
-    getParent(): string;
-    getFlowRate(): number;
-}