@divinevoxel/vlox 0.0.72 → 0.0.74

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/DataCursor.interface.d.ts

@@ -0,0 +1,5 @@
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+export interface DataCursorInterface {
+    getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
+    inBounds(x: number, y: number, z: number): boolean;
+}

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;
@@ -59,7 +64,7 @@ export declare abstract class VoxelCursorInterface {
     setId(id: number): this;
     setStringId(id: string): this;
     getStringId(): string;
-    setName(name: string): void;
+    setName(name: string): this;
     getName(): string;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;

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;
@@ -54,7 +55,7 @@ export class VoxelCursorInterface {
         return this._substanceTags;
     }
     isOpaque() {
-        return this._tags[VoxelTagIds.isTransparent];
+        return !this._tags[VoxelTagIds.isTransparent];
     }
     getMod() {
         return this.mod[this._index];
@@ -105,17 +106,14 @@ export class VoxelCursorInterface {
     getLight() {
         if (this._loadedId == 0)
             return this.light[this._index];
-        const lightValue = this._tags[VoxelTagIds.lightValue];
         if (this.isOpaque()) {
-            if (this.isLightSource() && lightValue) {
-                return lightValue;
-            }
-            else {
-                return -1;
+            if (this.isLightSource()) {
+                return this._tags[VoxelTagIds.lightValue];
             }
+            return -1;
         }
-        if (this.isLightSource() && lightValue) {
-            return this._lightData.mixLight(this.light[this._index], lightValue);
+        if (this.isLightSource()) {
+            return this._lightData.mixLight(this.light[this._index], this._tags[VoxelTagIds.lightValue]);
         }
         return this.light[this._index];
     }
@@ -126,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;
@@ -178,10 +219,10 @@ export class VoxelCursorInterface {
         return VoxelPalettesRegister.voxels.getStringId(this.id);
     }
     setName(name) {
-        this.setStringId(VoxelPalettesRegister.voxelName.getId(name));
+        return this.setStringId(VoxelPalettesRegister.voxelNametoIdMap.get(name));
     }
     getName() {
-        return this.getStringId();
+        return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
     }
     isSameVoxel(voxel) {
         return this.getId() == voxel.getId();

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/VoxelPalettesRegister.d.ts

@@ -5,9 +5,4 @@ export declare class VoxelPalettesRegister {
     static voxels: StringPalette;
     static voxelNametoIdMap: Map<string, string>;
     static voxelIdToNameMap: Map<string, string>;
-    static loadInVoxel(voxelPalette: string[], nameToIdMap: Record<string, string>, idToNameMap: Record<string, string>): void;
-    static voxelName: {
-        getId: (name: string) => string;
-        getName: (id: string) => string;
-    };
 }

package/Voxels/Data/VoxelPalettesRegister.js

@@ -5,13 +5,4 @@ export class VoxelPalettesRegister {
     static voxels = new StringPalette();
     static voxelNametoIdMap = new Map();
     static voxelIdToNameMap = new Map();
-    static loadInVoxel(voxelPalette, nameToIdMap, idToNameMap) {
-        this.voxels = new StringPalette(voxelPalette);
-        this.voxelNametoIdMap = new Map(Object.entries(nameToIdMap));
-        this.voxelIdToNameMap = new Map(Object.entries(idToNameMap));
-    }
-    static voxelName = {
-        getId: (name) => this.voxelNametoIdMap.get(name),
-        getName: (id) => this.voxelIdToNameMap.get(id),
-    };
 }

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

@@ -1,4 +1,4 @@
-import { VoxelSubstanceTagIdds, VoxelTagIds, } from "./VoxelTag.types";
+import { VoxelSubstanceTagIdds as VoxelSubstanceTagIds, VoxelTagIds, } from "./VoxelTag.types";
 export class VoxelTagsRegister {
     static IncludedVoxelTags = [
         VoxelTagIds.substance,
@@ -12,14 +12,19 @@ export class VoxelTagsRegister {
         VoxelTagIds.noAO,
         VoxelTagIds.isTransparent,
         VoxelTagIds.canHaveSecondary,
+        VoxelTagIds.isPowerSource,
+        VoxelTagIds.canBePowered,
+        VoxelTagIds.canCarryPower,
+        VoxelTagIds.canHoldPower,
+        VoxelTagIds.powerValue
     ];
     static IncludedSubstnacesTags = [
-        VoxelSubstanceTagIdds.parent,
-        VoxelSubstanceTagIdds.isSolid,
-        VoxelSubstanceTagIdds.isTransparent,
-        VoxelSubstanceTagIdds.isLiquid,
-        VoxelSubstanceTagIdds.flowRate,
-        VoxelSubstanceTagIdds.isWindAffected,
+        VoxelSubstanceTagIds.parent,
+        VoxelSubstanceTagIds.isSolid,
+        VoxelSubstanceTagIds.isTransparent,
+        VoxelSubstanceTagIds.isLiquid,
+        VoxelSubstanceTagIds.flowRate,
+        VoxelSubstanceTagIds.isWindAffected,
     ];
     static VoxelTagDefaults = {
         [VoxelTagIds.renderedMaterial]: "dve_solid",

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[][];
 };

package/Voxels/Functions/BuildStateData.js

@@ -1,6 +1,6 @@
 import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../../Models/Rules/VoxelModelRuleBuilderRegister";
 import { VoxelTagStates } from "../Data/VoxelTagStates";
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
 import { StateSchema } from "../State/Schema/StateSchema";
@@ -170,56 +170,56 @@ function buildSchemas(binaryNodes, relationNodes) {
 }
 export function BuildStateData(model, geoPalette) {
     const data = model.data;
-    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.shapeStateSchema, data.relationsSchema);
+    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.stateSchema, data.relationsSchema);
     const geometryLinkPalette = new StringPalette();
     //maps geo link ids to geomtry ids
     const geometryLinkStateMap = [];
     const log = model.data.id == "dve_simple_stair";
     //add geomtry from main shape states
-    for (const key in data.shapeStatesNodes) {
-        const nodeData = data.shapeStatesNodes[key];
+    for (const key in data.stateNodes) {
+        const nodeData = data.stateNodes[key];
         for (const node of nodeData) {
             if (geometryLinkPalette.isRegistered(node.id))
                 continue;
             const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     //add geomtry from condiotnal  shape states
-    for (const key in data.shapeStatesConditonalNodes) {
-        const nodeData = data.shapeStatesConditonalNodes[key];
+    for (const key in data.conditonalNodes) {
+        const nodeData = data.conditonalNodes[key];
         for (const node of nodeData) {
             if (geometryLinkPalette.isRegistered(node.id))
                 continue;
             const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
-    const shapeStateRelativeGeometryMap = [];
+    const stateRelativeGeometryMap = [];
     const relativeGeometryByteIndexMap = [];
     //build state trees
-    const shapeStateTree = new StateTreeNode("root");
-    const shapeStateGeoLinkPalette = [];
-    const shapeStateGeometryPalette = [];
+    const stateTree = new StateTreeNode("root");
+    const stateGeoLinkPalette = [];
+    const stateGeometryPalette = [];
     let relativeGeoId = 0;
     let relativeByteCount = 0;
-    const shapeStateRecord = {};
-    for (const key in data.shapeStatesNodes) {
-        shapeStateGeoLinkPalette.push(data.shapeStatesNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        shapeStateGeometryPalette.push(data.shapeStatesNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
-        shapeStateRecord[key] = shapeStateGeometryPalette.length - 1;
-        shapeStateRelativeGeometryMap[shapeStateRecord[key]] ??= [];
-        const nodeData = data.shapeStatesNodes[key];
+    const stateRecord = {};
+    for (const key in data.stateNodes) {
+        stateGeoLinkPalette.push(data.stateNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        stateGeometryPalette.push(data.stateNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
+        stateRecord[key] = stateGeometryPalette.length - 1;
+        stateRelativeGeometryMap[stateRecord[key]] ??= [];
+        const nodeData = data.stateNodes[key];
         for (const node of nodeData) {
-            shapeStateRelativeGeometryMap[shapeStateRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] = relativeGeoId;
+            stateRelativeGeometryMap[stateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
-        addPathToTree(shapeStateTree, key
+        addPathToTree(stateTree, key
             .split(",")
             .map((pair) => pair.split("="))
-            .flat(), shapeStateGeoLinkPalette.length - 1);
+            .flat(), stateGeoLinkPalette.length - 1);
     }
     const condiotnalShapeStateRelativeGeometryMap = [];
     const condiotnalShapeStateNodePalette = [];
@@ -227,19 +227,19 @@ export function BuildStateData(model, geoPalette) {
     const condiotnalShapeStateNodeRecord = {};
     const condiotnalStatements = [];
     const compareOperations = Object.keys(StateCompareOperationsMap);
-    for (const key in data.shapeStatesConditonalNodes) {
-        condiotnalShapeStateNodePalette.push(data.shapeStatesConditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        condiotnalShapeStateGeometryPalette.push(data.shapeStatesConditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
+    for (const key in data.conditonalNodes) {
+        condiotnalShapeStateNodePalette.push(data.conditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        condiotnalShapeStateGeometryPalette.push(data.conditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         condiotnalShapeStateNodeRecord[key] =
             condiotnalShapeStateGeometryPalette.length - 1;
         condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
-        const nodeData = data.shapeStatesConditonalNodes[key];
+        const nodeData = data.conditonalNodes[key];
         for (const node of nodeData) {
-            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] =
+            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] =
                 relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         const statement = [];
         const nodes = key.split(" ");
@@ -290,9 +290,9 @@ export function BuildStateData(model, geoPalette) {
         condiotanlStatePalette.push(newStateCombo);
         condiotanlGeometryStatePalette.push(newGeoCombo);
     }
-    const shapeStateTreeData = shapeStateTree.toJSON();
+    const stateTreeData = stateTree.toJSON();
     const newShapeStateTree = [];
-    reMapTree(schemaIdPalette, schemaValuePalette, shapeStateTreeData, newShapeStateTree, model.data.id);
+    reMapTree(schemaIdPalette, schemaValuePalette, stateTreeData, newShapeStateTree, model.data.id);
     const modelEffects = [];
     const tagEffects = [];
     if (model.data.effects) {
@@ -358,21 +358,21 @@ export function BuildStateData(model, geoPalette) {
     const finalData = {
         schema: baseSchema,
         effects: modelEffects,
-        shapeStateGeometryPalette,
+        stateGeometryPalette: stateGeometryPalette,
         condiotnalShapeStateGeometryPalette,
-        shapeStateTree: newShapeStateTree,
+        stateTree: newShapeStateTree,
         geometryLinkPalette: geometryLinkPalette._map,
         geometryLinkStateMap,
         relativeByteCount,
-        shapeStatePalette: shapeStateGeoLinkPalette,
-        shapeStateRecord,
+        statePalette: stateGeoLinkPalette,
+        stateRecord: stateRecord,
         condiotnalNodeStateTree,
         condiotnalStatements,
-        condiotnalShapeStatePalette: condiotnalShapeStateNodePalette,
+        condiotnalStatePalette: condiotnalShapeStateNodePalette,
         condiotnalShapeStateRecord: condiotnalShapeStateNodeRecord,
         condiotanlStatePalette,
         condiotanlGeometryStatePalette,
-        shapeStateRelativeGeometryMap,
+        stateRelativeGeometryMap: stateRelativeGeometryMap,
         relativeGeometryByteIndexMap,
         condiotnalShapeStateRelativeGeometryMap,
     };

package/Voxels/Functions/BuildTagAndPaletteData.js

@@ -1,12 +1,14 @@
 import { VoxelTagsRegister } from "../Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
 export function BuildTagAndPaletteData(props) {
+    const logic = {};
     for (const voxel of props.voxels) {
         const tags = {};
         const voxelId = VoxelPalettesRegister.voxels.register(voxel.id);
-        if (voxel.name) {
-            VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
-            VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || "", voxel.id);
+        VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
+        VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
+        if (voxel.properties["dve_logic_data"]) {
+            logic[voxel.id] = voxel.properties["dve_logic_data"];
         }
         for (const tag of VoxelTagsRegister.IncludedVoxelTags) {
             if (voxel.properties[tag] === undefined) {
@@ -43,6 +45,7 @@ export function BuildTagAndPaletteData(props) {
     }
     return {
         data: {
+            logic,
             palette: VoxelPalettesRegister.voxels._palette,
             tags: VoxelTagsRegister.VoxelTags,
             idToNameMap: [...VoxelPalettesRegister.voxelIdToNameMap.entries()],

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -7,8 +7,8 @@ export declare class VoxelNamedState {
     compiled: {
         mod: number;
         modAny: boolean;
-        shapeState: number;
-        shapeStateAny: boolean;
+        state: number;
+        stateAny: boolean;
     };
     constructor(voxelId: string, data: VoxelNamedStateData);
     getPaintData(): PaintVoxelData;