@divinevoxel/vlox 0.0.73 → 0.0.74

package/Voxels/Functions/BuildStateData.js

@@ -170,14 +170,14 @@ 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;
@@ -186,8 +186,8 @@ export function BuildStateData(model, geoPalette) {
         }
     }
     //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;
@@ -195,31 +195,31 @@ export function BuildStateData(model, geoPalette) {
             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(VoxelModelRuleBuilderRegister.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(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
+            stateRelativeGeometryMap[stateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
             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,13 +227,13 @@ 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(VoxelModelRuleBuilderRegister.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(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] =
                 relativeGeoId;
@@ -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,11 +1,15 @@
 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);
         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) {
                 tags[tag] = VoxelTagsRegister.VoxelTagDefaults[tag] || false;
@@ -41,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;

package/Voxels/Indexes/VoxelIndex.js

@@ -8,8 +8,8 @@ export class VoxelNamedState {
     compiled = {
         mod: 0,
         modAny: false,
-        shapeState: 0,
-        shapeStateAny: false,
+        state: 0,
+        stateAny: false,
     };
     constructor(voxelId, data) {
         this.voxelId = voxelId;
@@ -20,10 +20,10 @@ export class VoxelNamedState {
         if (SchemaRegister.voxelModSchemaData.has(this.voxelId)) {
             const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
             if (this.data.state == "*") {
-                this.compiled.shapeStateAny = true;
+                this.compiled.stateAny = true;
             }
             else if (this.data.state) {
-                this.compiled.shapeState = schema.state.readString(this.data.state);
+                this.compiled.state = schema.state.readString(this.data.state);
             }
             if (this.data.mod == "*") {
                 this.compiled.modAny = true;
@@ -34,7 +34,7 @@ export class VoxelNamedState {
         }
         else {
             this.compiled.modAny = true;
-            this.compiled.shapeStateAny = true;
+            this.compiled.stateAny = true;
         }
     }
     getPaintData() {
@@ -43,7 +43,7 @@ export class VoxelNamedState {
             id: this.voxelId,
             level: 0,
             levelState: 0,
-            state: this.compiled.shapeState,
+            state: this.compiled.state,
             mod: this.compiled.mod,
         });
     }
@@ -108,25 +108,23 @@ export class VoxelIndex {
         const conatiner = this.states.get(data.id);
         if (!conatiner)
             return false;
-        const { mod, state: shapeState } = data;
-        for (const state of conatiner?.stateArray) {
-            if ((mod == state.compiled.mod || state.compiled.modAny) &&
-                (shapeState == state.compiled.shapeState ||
-                    state.compiled.shapeStateAny))
-                return state;
+        const { mod, state } = data;
+        for (const modelState of conatiner?.stateArray) {
+            if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
+                (state == modelState.compiled.state || modelState.compiled.stateAny))
+                return modelState;
         }
         return false;
     }
     getStateFromRawData(data) {
-        const [id, light, shapeState, secondary, mod] = data;
+        const [id, light, state, secondary, mod] = data;
         const conatiner = this.states.get(VoxelPalettesRegister.voxels.getStringId(id));
         if (!conatiner)
             return false;
-        for (const state of conatiner?.stateArray) {
-            if ((mod == state.compiled.mod || state.compiled.modAny) &&
-                (shapeState == state.compiled.shapeState ||
-                    state.compiled.shapeStateAny))
-                return state;
+        for (const modelState of conatiner?.stateArray) {
+            if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
+                (state == modelState.compiled.state || modelState.compiled.stateAny))
+                return modelState;
         }
         return false;
     }

package/Voxels/InitVoxelData.js

@@ -16,6 +16,7 @@ import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
 import { VoxelTagIds } from "./Data/VoxelTag.types";
 import { BuildTagAndPaletteData } from "./Functions/BuildTagAndPaletteData";
+import { VoxelLogicRegister } from "./Logic/VoxelLogicRegister";
 function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
         const syncData = CacheManager.cachedData.models;
@@ -74,15 +75,15 @@ function GetModelData(data) {
             effects: stateData.effects,
             schema: stateData.schema,
             geoLinkMap: stateData.geometryLinkStateMap,
-            shapeStateMap: stateData.shapeStatePalette,
-            shapeStateGeometryMap: stateData.shapeStateGeometryPalette,
-            shapeStateTree: stateData.shapeStateTree,
+            stateMap: stateData.statePalette,
+            stateGeometryMap: stateData.stateGeometryPalette,
+            stateTree: stateData.stateTree,
             condiotnalStateTree: stateData.condiotnalNodeStateTree,
             condiotnalStatements: stateData.condiotnalStatements,
-            condiotnalStateMap: stateData.condiotnalShapeStatePalette,
+            condiotnalStateMap: stateData.condiotnalStatePalette,
             condiotnalShapeStateMap: stateData.condiotanlStatePalette,
             condiotnalShapeStateGeometryMap: stateData.condiotanlGeometryStatePalette,
-            shapeStateRelativeGeometryMap: stateData.shapeStateRelativeGeometryMap,
+            stateRelativeGeometryMap: stateData.stateRelativeGeometryMap,
             relativeGeometryByteIndexMap: stateData.relativeGeometryByteIndexMap,
             condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
         });
@@ -91,8 +92,8 @@ function GetModelData(data) {
       BuildGeomtryInputs(geometry);
     } */
     for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
-        const { shapeStateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
-        for (const v in shapeStateVoxelInputs) {
+        const { stateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
+        for (const v in stateVoxelInputs) {
             const stateData = model.voxelModData.get(v);
             SchemaRegister.registerVoxel(v, mainKey, stateData.modSchema);
             syncData.voxels.push({
@@ -102,7 +103,7 @@ function GetModelData(data) {
                 transparentFaceIndex: transparentVoxelFaceIndexes[v].data,
                 modSchema: stateData.modSchema,
                 modStateTree: stateData.modStateTree,
-                baseGeometryInputMap: shapeStateVoxelInputs[v],
+                baseGeometryInputMap: stateVoxelInputs[v],
                 condiotnalGeometryInputMap: conditionalShapeStateVoxelInputs[v],
             });
         }
@@ -243,6 +244,9 @@ export function InitVoxelData(data) {
         materials,
     });
     let models = GetModelData(data);
+    for (const id in voxelData.data.logic) {
+        VoxelLogicRegister.register(id, voxelData.data.logic[id]);
+    }
     return {
         models,
         ...voxelData,

package/Voxels/Logic/Classes/Default/Types/VoxelPoweredLogicType.d.ts

@@ -0,0 +1,5 @@
+import { VoxelCursorInterface } from "../../../../../Voxels/Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../../VoxelLogicType";
+export declare class VoxelPoweredLogicType extends VoxelLogicType {
+    run(voxel: VoxelCursorInterface): boolean;
+}

package/Voxels/Logic/Classes/Default/Types/VoxelPoweredLogicType.js

@@ -0,0 +1,6 @@
+import { VoxelLogicType } from "../../VoxelLogicType";
+export class VoxelPoweredLogicType extends VoxelLogicType {
+    run(voxel) {
+        return voxel.getPower() > 0;
+    }
+}

package/Voxels/Logic/Classes/VoxelLogic.d.ts

@@ -0,0 +1,11 @@
+import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
+import { VoxelLogicData } from "../VoxelLogic.types";
+import { VoxelLogicType } from "./VoxelLogicType";
+export declare class VoxelLogic {
+    types: VoxelLogicType[];
+    effectedTags: Map<string, VoxelLogicType[]>;
+    constructor(data: VoxelLogicData[]);
+    getTagValue(tagId: string, cursor: VoxelCursorInterface): any;
+    registerEffectOnTag(tagId: string, effect: VoxelLogicType): void;
+    hasTag(tag: string): boolean;
+}

package/Voxels/Logic/Classes/VoxelLogic.js

@@ -0,0 +1,49 @@
+import { VoxelLogicRegister } from "../VoxelLogicRegister";
+export class VoxelLogic {
+    types = [];
+    effectedTags = new Map();
+    constructor(data) {
+        for (const type of data) {
+            const logicType = VoxelLogicRegister.types.get(type.type);
+            this.types.push(logicType);
+            if (type.type == "powered") {
+                for (const effect of type.on)
+                    if (effect.type == "tag")
+                        this.registerEffectOnTag(effect.tagId, logicType);
+                for (const effect of type.off)
+                    if (effect.type == "tag")
+                        this.registerEffectOnTag(effect.tagId, logicType);
+            }
+            if (type.type == "state") {
+                for (const effect of type.true)
+                    if (effect.type == "tag")
+                        this.registerEffectOnTag(effect.tagId, logicType);
+                for (const effect of type.false)
+                    if (effect.type == "tag")
+                        this.registerEffectOnTag(effect.tagId, logicType);
+            }
+        }
+    }
+    getTagValue(tagId, cursor) {
+        let effects = this.effectedTags.get(tagId);
+        if (!effects)
+            return null;
+        let finalValue = null;
+        for (let i = 0; i < effects.length; i++) {
+            const effect = effects[i];
+            finalValue = effect.run(cursor);
+        }
+        return finalValue;
+    }
+    registerEffectOnTag(tagId, effect) {
+        let effects = this.effectedTags.get(tagId);
+        if (!effects) {
+            effects = [];
+            this.effectedTags.set(tagId, effects);
+        }
+        effects.push(effect);
+    }
+    hasTag(tag) {
+        return this.effectedTags.has(tag);
+    }
+}

package/Voxels/Logic/Classes/VoxelLogicType.d.ts

@@ -0,0 +1,4 @@
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+export declare abstract class VoxelLogicType {
+    abstract run(task: VoxelCursorInterface): boolean;
+}

package/Voxels/Logic/Classes/VoxelLogicType.js

@@ -0,0 +1,2 @@
+export class VoxelLogicType {
+}

package/Voxels/Logic/VoxelLogic.types.d.ts

@@ -0,0 +1,23 @@
+export type VoxelLogicEffects = {
+    type: "tag";
+    tagId: string;
+    value: any;
+} | {
+    type: "state";
+    key: string;
+    value: string | number;
+} | {
+    type: "mod";
+    key: string;
+    value: string | number;
+};
+export type VoxelLogicData = {
+    type: "powered";
+    on: VoxelLogicEffects[];
+    off: VoxelLogicEffects[];
+} | {
+    type: "state";
+    value: string;
+    true: VoxelLogicEffects[];
+    false: VoxelLogicEffects[];
+};

package/Voxels/Logic/VoxelLogic.types.js

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

package/Voxels/Logic/VoxelLogicRegister.d.ts

@@ -0,0 +1,9 @@
+import { VoxelLogic } from "./Classes/VoxelLogic";
+import { VoxelLogicData } from "./VoxelLogic.types";
+import { VoxelLogicType } from "./Classes/VoxelLogicType";
+export declare class VoxelLogicRegister {
+    static voxels: VoxelLogic[];
+    static types: Map<string, VoxelLogicType>;
+    static register(id: string, logicData: VoxelLogicData[]): void;
+    static registerType(id: string, logic: VoxelLogicType): void;
+}

package/Voxels/Logic/VoxelLogicRegister.js

@@ -0,0 +1,15 @@
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLogic } from "./Classes/VoxelLogic";
+import { VoxelPoweredLogicType } from "./Classes/Default/Types/VoxelPoweredLogicType";
+export class VoxelLogicRegister {
+    static voxels = [];
+    static types = new Map();
+    static register(id, logicData) {
+        const voxelId = VoxelPalettesRegister.voxels.getNumberId(id);
+        this.voxels[voxelId] = new VoxelLogic(logicData);
+    }
+    static registerType(id, logic) {
+        this.types.set(id, logic);
+    }
+}
+VoxelLogicRegister.registerType("powered", new VoxelPoweredLogicType());

package/Voxels/State/SchemaRegister.js

@@ -9,7 +9,12 @@ export class SchemaRegister {
     static voxelModelMap = new Map();
     static voxelSchemas = new Map();
     static hasVoxelSchema(voxelId) {
-        return this.voxelSchemas.has(voxelId);
+        if (this.voxelSchemas.has(voxelId))
+            return true;
+        if (this.modelStateSchemaData.has(this.voxelModelMap.get(voxelId) || "") &&
+            this.voxelModSchemaData.has(voxelId))
+            return true;
+        return false;
     }
     static getVoxelSchemas(voxelId) {
         if (this.voxelSchemas.has(voxelId)) {
@@ -18,12 +23,12 @@ export class SchemaRegister {
         const modelId = this.voxelModelMap.get(voxelId);
         if (!modelId)
             throw new Error(`Voxel ${voxelId} is not registered`);
-        let shapeStateSchema = this.modelStaeSchemas.get(modelId);
-        if (!shapeStateSchema) {
+        let stateSchema = this.modelStaeSchemas.get(modelId);
+        if (!stateSchema) {
             const schemaData = this.modelStateSchemaData.get(modelId);
             if (!schemaData)
                 throw new Error(`Model ${modelId} is not registered`);
-            shapeStateSchema = new BinarySchema(schemaData);
+            stateSchema = new BinarySchema(schemaData);
         }
         let modSchema = this.voxelModSchemas.get(voxelId);
         if (!modSchema) {
@@ -32,7 +37,7 @@ export class SchemaRegister {
                 throw new Error(`Voxel ${voxelId} is not registered`);
             modSchema = new BinarySchema(schemaData);
         }
-        const voxelSchema = new VoxelSchema(voxelId, shapeStateSchema, modSchema);
+        const voxelSchema = new VoxelSchema(voxelId, stateSchema, modSchema);
         this.voxelSchemas.set(voxelId, voxelSchema);
         return voxelSchema;
     }

package/Voxels/State/State.types.d.ts

@@ -2,7 +2,7 @@ import { Vec3Array } from "@amodx/math";
 export interface VoxelStateStringSchemaData {
     name: string;
     type: "string";
-    values: Record<number, string>;
+    values: string[];
 }
 export interface VoxelStateNumberSchemaData {
     name: string;

package/Voxels/State/StateTreeReader.d.ts

@@ -5,5 +5,5 @@ export declare class StateTreeReader {
     tree: any[];
     startingIndex: number;
     constructor(schema: StateSchema, defaultValue: number | undefined, tree: any[]);
-    getState(shapeState: number): number;
+    getState(state: number): number;
 }

package/Voxels/State/StateTreeReader.js

@@ -8,15 +8,14 @@ export class StateTreeReader {
         this.defaultValue = defaultValue;
         this.tree = tree;
     }
-    getState(shapeState) {
+    getState(state) {
         if (!this.tree.length)
             return this.defaultValue;
         let found = -1;
         let index = this.startingIndex;
         let curretNode = this.tree;
         while (found == -1) {
-            curretNode =
-                curretNode[index][this.schema.nodes[index].getValue(shapeState)];
+            curretNode = curretNode[index][this.schema.nodes[index].getValue(state)];
             if (typeof curretNode == "number") {
                 return curretNode;
             }

package/Voxels/Types/Voxel.types.d.ts

@@ -1,6 +1,7 @@
 import { TextureId } from "../../Textures/index";
 import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
 import { VoxelTags } from "../Data/VoxelTag.types";
+import { VoxelLogicData } from "../Logic/VoxelLogic.types";
 export interface VoxelDataArrays {
     /**The runtime numeric voxel ids */
     ids: Uint16Array;
@@ -65,6 +66,8 @@ export type RawVoxelData = [
 ];
 interface VoxelProperties extends Partial<VoxelTags> {
     [key: string]: any;
+    /**Logic data for a the voxel */
+    dve_logic_data?: VoxelLogicData[];
     /** Named states associated with the voxel. */
     dve_named_states?: VoxelNamedStateData[];
     /** Model data used to construct the voxel's appearance. */

package/Voxels/Types/VoxelModelCompiledData.types.d.ts

@@ -7,8 +7,10 @@ import { VoxelGeometryData, VoxelGeometryNodes } from "../../Models/VoxelModel.t
 import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
 import { VoxelTagStatesData } from "../Data/VoxelTagStates";
 import { VoxelSubstanceTags, VoxelTags } from "../Data/VoxelTag.types";
+import { VoxelLogicData } from "../../Voxels/Logic/VoxelLogic.types";
 export type CompiledVoxelTagAndPaletteData = {
     data: {
+        logic: Record<string, VoxelLogicData[]>;
         tags: VoxelTags[];
         palette: string[];
         nameToIdMap: [string, string][];
@@ -60,10 +62,10 @@ export interface CompiledVoxelModelData {
     schema: VoxelModelStateSchemaData[];
     effects: VoxelEffectSyncData[];
     geoLinkMap: number[];
-    shapeStateTree: any[];
-    shapeStateMap: number[][];
-    shapeStateGeometryMap: number[][];
-    shapeStateRelativeGeometryMap: number[][];
+    stateTree: any[];
+    stateMap: number[][];
+    stateGeometryMap: number[][];
+    stateRelativeGeometryMap: number[][];
     relativeGeometryByteIndexMap: number[];
     condiotnalStatements: StateLogicStatement[];
     condiotnalStateMap: number[][];