@divinevoxel/vlox 0.0.73 → 0.0.74

package/Util/Binary/BinaryBuffer.js

@@ -1,90 +1,96 @@
 import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
-const excludeStore = ["16-bit", "8-bit", "value"];
+export var BinaryBufferTypes;
+(function (BinaryBufferTypes) {
+    BinaryBufferTypes[BinaryBufferTypes["Value"] = 0] = "Value";
+    BinaryBufferTypes[BinaryBufferTypes["BitArray"] = 1] = "BitArray";
+    BinaryBufferTypes[BinaryBufferTypes["HalfNibbleArray"] = 2] = "HalfNibbleArray";
+    BinaryBufferTypes[BinaryBufferTypes["NibbleArray"] = 4] = "NibbleArray";
+    BinaryBufferTypes[BinaryBufferTypes["ByteArray"] = 8] = "ByteArray";
+    BinaryBufferTypes[BinaryBufferTypes["ShortArray"] = 16] = "ShortArray";
+})(BinaryBufferTypes || (BinaryBufferTypes = {}));
 export class BinaryBuffer {
-    static BytePaletteMax = 256;
-    static NibblePaletteMax = 16;
-    static HalfNibblePaletteMax = 4;
-    static BitPaletteMax = 2;
+    static ByteArrayMax = 256;
+    static NibbleArrayMax = 16;
+    static HalfNibbleArrayMax = 4;
+    static BitArrayMax = 2;
     static DetermineSubByteArray = (paletteSize) => {
-        if (paletteSize == BinaryBuffer.BitPaletteMax)
-            return "1-bit";
-        if (paletteSize > BinaryBuffer.BitPaletteMax &&
-            paletteSize <= BinaryBuffer.HalfNibblePaletteMax)
-            return "2-bit";
-        if (paletteSize > BinaryBuffer.HalfNibblePaletteMax &&
-            paletteSize <= BinaryBuffer.NibblePaletteMax)
-            return "4-bit";
-        if (paletteSize > BinaryBuffer.NibblePaletteMax &&
-            paletteSize <= BinaryBuffer.BytePaletteMax)
-            return "8-bit";
+        if (paletteSize == BinaryBuffer.BitArrayMax)
+            return BinaryBufferTypes.BitArray;
+        if (paletteSize > BinaryBuffer.BitArrayMax &&
+            paletteSize <= BinaryBuffer.HalfNibbleArrayMax)
+            return BinaryBufferTypes.HalfNibbleArray;
+        if (paletteSize > BinaryBuffer.HalfNibbleArrayMax &&
+            paletteSize <= BinaryBuffer.NibbleArrayMax)
+            return BinaryBufferTypes.NibbleArray;
+        if (paletteSize > BinaryBuffer.NibbleArrayMax &&
+            paletteSize <= BinaryBuffer.ByteArrayMax)
+            return BinaryBufferTypes.ByteArray;
         return null;
     };
     static CreateBufferForType(type, length) {
-        if (type == "16-bit")
+        if (type == BinaryBufferTypes.ShortArray)
             return new Uint16Array(length);
-        if (type == "8-bit")
-            return new Uint8Array(length);
-        if (type == "1-bit")
-            return new Uint8Array(length);
-        if (type == "2-bit")
-            return new Uint8Array(length);
-        if (type == "4-bit")
-            return new Uint8Array(length);
         return new Uint8Array(length);
     }
     static GetConvertedBufferSize(source, type) {
-        if (type == "16-bit" || type == "8-bit")
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
             return source.length;
-        if (type == "1-bit")
+        if (type == BinaryBufferTypes.BitArray)
             return source.length / 8;
-        if (type == "4-bit")
-            return source.length / 2;
-        if (type == "2-bit")
+        if (type == BinaryBufferTypes.HalfNibbleArray)
             return source.length / 4;
-        if (type == "value")
+        if (type == BinaryBufferTypes.NibbleArray)
+            return source.length / 2;
+        if (type == BinaryBufferTypes.Value)
             return 1;
         return source.length;
     }
     static GetIndexLength(source, type) {
-        if (type == "16-bit" || type == "8-bit")
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
             return source.length;
-        if (type == "1-bit")
+        if (type == BinaryBufferTypes.BitArray)
             return source.length * 8;
-        if (type == "4-bit")
-            return source.length * 2;
-        if (type == "2-bit")
+        if (type == BinaryBufferTypes.HalfNibbleArray)
             return source.length * 4;
-        if (type == "value")
+        if (type == BinaryBufferTypes.NibbleArray)
+            return source.length * 2;
+        if (type == BinaryBufferTypes.Value)
             return 1;
         return source.length;
     }
     static ReadBufferAtIndex(source, type, index) {
-        if (type == "16-bit" || type == "8-bit")
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
             return source[index];
-        if (type == "1-bit")
+        if (type == BinaryBufferTypes.BitArray)
             return getBitArrayIndex(source, index);
-        if (type == "4-bit")
+        if (type == BinaryBufferTypes.NibbleArray)
             return getNibbleArrayIndex(source, index);
-        if (type == "2-bit")
+        if (type == BinaryBufferTypes.HalfNibbleArray)
             return getHalfNibbleArrayIndex(source, index);
         return source[index];
     }
     static SetBufferAtIndex(source, type, index, value) {
-        if (type == "16-bit" || type == "8-bit") {
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray) {
             return (source[index] = value);
         }
-        if (type == "1-bit")
+        if (type == BinaryBufferTypes.BitArray)
             return setBitArrayIndex(source, index, value);
-        if (type == "4-bit")
+        if (type == BinaryBufferTypes.NibbleArray)
             return setNibbleArrayIndex(source, index, value);
-        if (type == "2-bit")
+        if (type == BinaryBufferTypes.HalfNibbleArray)
             return setHalfNibbleArrayIndex(source, index, value);
         return source[index];
     }
     static Convert(source, sourceType, destinationType) {
         if (sourceType == destinationType ||
-            (sourceType == "16-bit" && destinationType == "8-bit") ||
-            (sourceType == "8-bit" && destinationType == "16-bit")) {
+            (sourceType == BinaryBufferTypes.ShortArray &&
+                destinationType == BinaryBufferTypes.ByteArray) ||
+            (sourceType == BinaryBufferTypes.ByteArray &&
+                destinationType == BinaryBufferTypes.ShortArray)) {
             const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
             destination.set(source);
             return destination;
@@ -99,32 +105,32 @@ export class BinaryBuffer {
     static Create(data) {
         return {
             buffer: 0,
+            type: BinaryBufferTypes.Value,
             ...data,
         };
     }
+    bufferView;
     constructor(data) {
         this.buffer = data.buffer;
-        if (data.type) {
-            this.type = data.type;
-        }
-        else {
-            if (typeof data.buffer === "number")
-                this.type = "value";
-            if (data.buffer instanceof Uint16Array)
-                this.type = "16-bit";
-            if (data.buffer instanceof Uint8Array)
-                this.type = "8-bit";
+        this.type = data.type;
+        if (typeof this.buffer !== "number") {
+            if (this.type == BinaryBufferTypes.ShortArray) {
+                this.bufferView = new Uint16Array(this.buffer);
+            }
+            else {
+                this.bufferView = new Uint8Array(this.buffer);
+            }
         }
     }
     getValue(index) {
         if (typeof this.buffer == "number")
             return this.buffer;
-        return BinaryBuffer.ReadBufferAtIndex(this.buffer, this.type, index);
+        return BinaryBuffer.ReadBufferAtIndex(this.bufferView, this.type, index);
     }
     toJSON() {
         return {
             buffer: this.buffer,
-            ...(excludeStore.includes(this.type) ? {} : { type: this.type }),
+            type: this.type,
         };
     }
 }

package/Util/Binary/BinaryTree.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A class to help with indexing a full flat binary tree defined by the number of levels it has.
+ */
+export declare class FlatBinaryTreeIndex {
+    levels: number;
+    constructor(levels: number);
+    /** Gets the number of nodes at a level of the tree */
+    getLevelSize(level: number): number;
+    /**
+     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
+     */
+    getIndexAtLevel(level: number, node: number): number;
+    /**
+     * Gets the level and relative index of a node's flat index.
+     */
+    getLevelAndIndex(index: number): [level: number, relativeIndex: number];
+    /**
+     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getLeftChildAtLevel(level: number, node: number): number;
+    /**
+     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getRightChildAtLevel(level: number, node: number): number;
+    /**
+     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if level has no parent
+     */
+    getParentAtLevel(level: number, node: number): number;
+    /** Gets the flat index of the left child of the node.
+     * @returns -1 if no child exist
+     */
+    getLeftChild(node: number): number;
+    /** Gets the flat index of the right child of the node.
+     * @returns -1 if no child exist
+     */
+    getRightChild(node: number): number;
+    /** Gets the flat index of the parent of the node.
+     * @returns -1 if no parent exist
+     */
+    getParent(node: number): number;
+    /** Gets the total number of nodes in the tree */
+    getTotalSize(): number;
+}

package/Util/Binary/BinaryTree.js

@@ -0,0 +1,104 @@
+/**
+ * A class to help with indexing a full flat binary tree defined by the number of levels it has.
+ */
+export class FlatBinaryTreeIndex {
+    levels;
+    constructor(levels) {
+        this.levels = levels;
+    }
+    /** Gets the number of nodes at a level of the tree */
+    getLevelSize(level) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        return 1 << level; // Equivalent to 2^level
+    }
+    /**
+     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
+     */
+    getIndexAtLevel(level, node) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        const levelSize = this.getLevelSize(level);
+        if (node < 0 || node >= levelSize) {
+            throw new Error("Invalid node index at the given level");
+        }
+        return (1 << level) - 1 + node;
+    }
+    /**
+     * Gets the level and relative index of a node's flat index.
+     */
+    getLevelAndIndex(index) {
+        const totalNodes = (1 << this.levels) - 1;
+        if (index < 0 || index >= totalNodes) {
+            throw new Error("Invalid node index");
+        }
+        const level = Math.floor(Math.log2(index + 1));
+        const firstIndexAtLevel = (1 << level) - 1;
+        const relativeIndex = index - firstIndexAtLevel;
+        return [level, relativeIndex];
+    }
+    /**
+     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getLeftChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getLeftChild(nodeIndex);
+    }
+    /**
+     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getRightChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getRightChild(nodeIndex);
+    }
+    /**
+     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if level has no parent
+     */
+    getParentAtLevel(level, node) {
+        if (level === 0) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getParent(nodeIndex);
+    }
+    /** Gets the flat index of the left child of the node.
+     * @returns -1 if no child exist
+     */
+    getLeftChild(node) {
+        const leftChildIndex = 2 * node + 1;
+        const totalNodes = (1 << this.levels) - 1;
+        return leftChildIndex < totalNodes ? leftChildIndex : -1;
+    }
+    /** Gets the flat index of the right child of the node.
+     * @returns -1 if no child exist
+     */
+    getRightChild(node) {
+        const rightChildIndex = 2 * node + 2;
+        const totalNodes = (1 << this.levels) - 1;
+        return rightChildIndex < totalNodes ? rightChildIndex : -1;
+    }
+    /** Gets the flat index of the parent of the node.
+     * @returns -1 if no parent exist
+     */
+    getParent(node) {
+        if (node === 0) {
+            return -1; // Root node has no parent
+        }
+        return Math.floor((node - 1) / 2);
+    }
+    /** Gets the total number of nodes in the tree */
+    getTotalSize() {
+        return (1 << this.levels) - 1; // Equivalent to 2^levels - 1
+    }
+}

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -21,7 +21,7 @@ export declare abstract class VoxelCursorInterface {
     abstract mod: WritableArrayLike<number>;
     /**
      *
-     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried check only
+     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried and logic check only
      */
     abstract updateVoxel(mode: 0 | 1 | 2): void;
     _lightData: VoxelLightData;
@@ -49,8 +49,13 @@ export declare abstract class VoxelCursorInterface {
     hasSunLight(): boolean;
     getLight(): number;
     setLight(light: number): this;
-    isLightSource(): boolean;
+    isLightSource(): any;
+    doesVoxelAffectLogic(): boolean;
     getLightSourceValue(): number;
+    getPower(): number;
+    setPower(level: number): this;
+    isPowerSource(): boolean;
+    getPowerSourceValue(): number;
     noAO(): boolean;
     isRenderable(): boolean;
     isAir(): boolean;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -4,12 +4,13 @@ import { VoxelTagStates } from "../Data/VoxelTagStates";
 import { VoxelTagIds, } from "../../Voxels/Data/VoxelTag.types";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
 export class VoxelCursorInterface {
     _loadedId = 0;
     id = 0;
     secondaryId = 0;
-    _tags;
-    _substanceTags;
+    _tags = {};
+    _substanceTags = {};
     __secondary = false;
     // private _section: Section;
     _index = 0;
@@ -123,15 +124,58 @@ export class VoxelCursorInterface {
     isLightSource() {
         if (this._loadedId <= 0)
             return false;
+        if (VoxelLogicRegister.voxels[this._loadedId]?.hasTag(VoxelTagIds.isLightSource)) {
+            return VoxelLogicRegister.voxels[this._loadedId].getTagValue(VoxelTagIds.isLightSource, this);
+        }
         return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isLightSource)
             ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isLightSource, this.getState()) === true
             : this._tags[VoxelTagIds.isLightSource];
     }
+    doesVoxelAffectLogic() {
+        if (this._tags["dve_can_be_powered"] ||
+            this._tags["dve_can_hold_power"] ||
+            this._tags["dve_can_carry_power"] ||
+            this._tags["dve_is_power_source"])
+            return true;
+        return false;
+    }
     getLightSourceValue() {
         if (this._loadedId <= 0)
             return 0;
         return this._tags[VoxelTagIds.lightValue];
     }
+    getPower() {
+        if (this._loadedId == 0)
+            return -1;
+        if (this._substanceTags["dve_is_liquid"])
+            return -1;
+        if (!this._tags["dve_can_carry_power"] &&
+            !this._tags["dve_can_hold_power"] &&
+            !this._tags["dve_can_be_powered"] &&
+            !this._tags["dve_is_power_source"])
+            return -1;
+        const level = VoxelLevelReader.getLevel(this.level[this._index]);
+        if (this._tags["dve_is_power_source"] &&
+            this._tags["dve_power_value"] > level)
+            return this._tags["dve_power_value"];
+        return level;
+    }
+    setPower(level) {
+        this.level[this._index] = VoxelLevelReader.setLevel(this.level[this._index], level);
+        return this;
+    }
+    isPowerSource() {
+        if (this._loadedId <= 0)
+            return false;
+        return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isPowerSource)
+            ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isPowerSource, this.getState()) === true
+            : this._tags[VoxelTagIds.isPowerSource];
+    }
+    getPowerSourceValue() {
+        if (this._loadedId <= 0)
+            return 0;
+        return this._tags[VoxelTagIds.powerValue];
+    }
     noAO() {
         if (this._loadedId <= 0)
             return false;

package/Voxels/Cursor/VoxelLightData.js

@@ -3,7 +3,7 @@
  * Used to decode light color info.
  */
 export class VoxelLightData {
-    _lightValues = new Uint16Array([0, 0, 0, 0]);
+    _lightValues = [0, 0, 0, 0];
     sumRGB(value) {
         return this.getR(value) + this.getG(value) + this.getB(value);
     }

package/Voxels/Data/VoxelTag.types.d.ts

@@ -6,10 +6,15 @@ export declare enum VoxelTagIds {
     colliderID = "dve_collider_id",
     checkCollisions = "dve_check_collisions",
     isLightSource = "dve_is_light_source",
+    lightValue = "dve_light_value",
     noAO = "dve_no_ao",
     isTransparent = "dve_is_transparent",
-    lightValue = "dve_light_value",
-    canHaveSecondary = "dve_can_have_secondary"
+    canHaveSecondary = "dve_can_have_secondary",
+    canBePowered = "dve_can_be_powered",
+    canCarryPower = "dve_can_carry_power",
+    canHoldPower = "dve_can_hold_power",
+    isPowerSource = "dve_is_power_source",
+    powerValue = "dve_power_value"
 }
 export interface VoxelTags {
     /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
@@ -37,6 +42,16 @@ export interface VoxelTags {
     [VoxelTagIds.canHaveSecondary]: boolean;
     /** The hardness level of the voxel, affecting how it is broken or interacted with. */
     [VoxelTagIds.hardness]: number;
+    /** Whether or not the voxel can be powered */
+    [VoxelTagIds.canBePowered]: boolean;
+    /** Whether or not the voxel can carry power */
+    [VoxelTagIds.canCarryPower]: boolean;
+    /** Whether or not the voxel can hold power. */
+    [VoxelTagIds.canHoldPower]: boolean;
+    /** Whether or not the voxel is a power source*/
+    [VoxelTagIds.isPowerSource]: boolean;
+    /** If the voxel is a power source this is its value */
+    [VoxelTagIds.powerValue]: number;
 }
 export declare enum VoxelSubstanceTagIdds {
     parent = "dve_parent_substance",

package/Voxels/Data/VoxelTag.types.js

@@ -7,10 +7,15 @@ export var VoxelTagIds;
     VoxelTagIds["colliderID"] = "dve_collider_id";
     VoxelTagIds["checkCollisions"] = "dve_check_collisions";
     VoxelTagIds["isLightSource"] = "dve_is_light_source";
+    VoxelTagIds["lightValue"] = "dve_light_value";
     VoxelTagIds["noAO"] = "dve_no_ao";
     VoxelTagIds["isTransparent"] = "dve_is_transparent";
-    VoxelTagIds["lightValue"] = "dve_light_value";
     VoxelTagIds["canHaveSecondary"] = "dve_can_have_secondary";
+    VoxelTagIds["canBePowered"] = "dve_can_be_powered";
+    VoxelTagIds["canCarryPower"] = "dve_can_carry_power";
+    VoxelTagIds["canHoldPower"] = "dve_can_hold_power";
+    VoxelTagIds["isPowerSource"] = "dve_is_power_source";
+    VoxelTagIds["powerValue"] = "dve_power_value";
 })(VoxelTagIds || (VoxelTagIds = {}));
 export var VoxelSubstanceTagIdds;
 (function (VoxelSubstanceTagIdds) {

package/Voxels/Data/VoxelTagsRegister.js

@@ -12,6 +12,11 @@ export class VoxelTagsRegister {
         VoxelTagIds.noAO,
         VoxelTagIds.isTransparent,
         VoxelTagIds.canHaveSecondary,
+        VoxelTagIds.isPowerSource,
+        VoxelTagIds.canBePowered,
+        VoxelTagIds.canCarryPower,
+        VoxelTagIds.canHoldPower,
+        VoxelTagIds.powerValue
     ];
     static IncludedSubstnacesTags = [
         VoxelSubstanceTagIds.parent,

package/Voxels/Functions/BuildStateData.d.ts

@@ -5,21 +5,21 @@ import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
 export declare function BuildStateData(model: VoxelRulesModoel, geoPalette: StringPalette): {
     schema: (BinarySchemaNodeData | VoxelRelationsScehmaNodeData)[];
     effects: VoxelEffectSyncData[];
-    shapeStateGeometryPalette: number[][];
+    stateGeometryPalette: number[][];
     condiotnalShapeStateGeometryPalette: number[][];
-    shapeStateTree: any[];
+    stateTree: any[];
     geometryLinkPalette: Record<string, number>;
     geometryLinkStateMap: number[];
     relativeByteCount: number;
-    shapeStatePalette: number[][];
-    shapeStateRecord: Record<string, number>;
+    statePalette: number[][];
+    stateRecord: Record<string, number>;
     condiotnalNodeStateTree: any;
     condiotnalStatements: StateLogicStatement[];
-    condiotnalShapeStatePalette: number[][];
+    condiotnalStatePalette: number[][];
     condiotnalShapeStateRecord: Record<string, number>;
     condiotanlStatePalette: number[][][];
     condiotanlGeometryStatePalette: number[][][];
-    shapeStateRelativeGeometryMap: number[][];
+    stateRelativeGeometryMap: number[][];
     relativeGeometryByteIndexMap: number[];
     condiotnalShapeStateRelativeGeometryMap: number[][];
 };