@divinevoxel/vlox 0.0.72 → 0.0.74

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

@@ -4,7 +4,7 @@ import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "../Models
 import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "../Models/Defaults/PanelVoxelGeometry";
 import { stair } from "../Models/Defaults/StairVoxelModel";
 import { liquidGeometry, liquidModel, } from "../Models/Defaults/LiquidVoxelModel";
-import { VoxelModelManager } from "../Models/Rules/VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildRules } from "../Models/Rules/Functions/BuildRules";
 import { BuildStateData } from "./Functions/BuildStateData";
 import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
@@ -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;
@@ -30,10 +31,10 @@ function GetModelData(data) {
         VoxelTagStates.load(syncData.tagState);
         return syncData;
     }
-    VoxelModelManager.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...(data.geometry || []));
-    VoxelModelManager.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...(data.models || []));
+    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...(data.geometry || []));
+    VoxelModelRuleBuilderRegister.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...(data.models || []));
     const syncData = {
-        geometryPalette: VoxelModelManager.geometryPalette._palette,
+        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
         geometry: [],
         models: [],
         voxels: [],
@@ -43,13 +44,13 @@ function GetModelData(data) {
         const voxelData = voxel.properties["dve_model_data"];
         if (!voxelData)
             continue;
-        VoxelModelManager.registerVoxel(voxel.id, voxelData);
-        const model = VoxelModelManager.models.get(voxelData.id);
+        VoxelModelRuleBuilderRegister.registerVoxel(voxel.id, voxelData);
+        const model = VoxelModelRuleBuilderRegister.models.get(voxelData.id);
         if (!model)
             throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
         model.voxels.set(voxel.id, voxelData);
     }
-    for (const [mainKey, mainGeo] of VoxelModelManager.geometry) {
+    for (const [mainKey, mainGeo] of VoxelModelRuleBuilderRegister.geometry) {
         if (mainGeo.data.ogData.doNotBuildRules) {
             syncData.geometry.push({
                 id: mainKey,
@@ -58,15 +59,15 @@ function GetModelData(data) {
             });
             continue;
         }
-        const output = BuildRules(mainGeo, VoxelModelManager.geometryPalette);
+        const output = BuildRules(mainGeo, VoxelModelRuleBuilderRegister.geometryPalette);
         syncData.geometry.push({
             id: mainKey,
             nodes: mainGeo.data.nodes,
             ...output,
         });
     }
-    for (const [mainKey, model] of VoxelModelManager.models) {
-        const stateData = BuildStateData(model, VoxelModelManager.geometryPalette);
+    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
+        const stateData = BuildStateData(model, VoxelModelRuleBuilderRegister.geometryPalette);
         model.stateData = stateData;
         SchemaRegister.registerModel(mainKey, stateData.schema);
         syncData.models.push({
@@ -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,
         });
@@ -90,9 +91,9 @@ function GetModelData(data) {
     /*   for (const [mainKey, geometry] of VoxelModelManager.geometry) {
       BuildGeomtryInputs(geometry);
     } */
-    for (const [mainKey, model] of VoxelModelManager.models) {
-        const { shapeStateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
-        for (const v in shapeStateVoxelInputs) {
+    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
+        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],
             });
         }
@@ -115,8 +116,7 @@ function GetModelData(data) {
 }
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
-    const voxelIndex = new VoxelIndex(data.voxels);
-    console.warn(voxelIndex, voxelIndex.dataMap);
+    new VoxelIndex(data.voxels);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },
@@ -244,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/Schema/StateSchema.d.ts

@@ -1,7 +1,7 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { VoxelModelStateSchemaData } from "../State.types";
-import { DataCursorInterface } from "../../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
 import { Vector3Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 export declare class StateSchema {

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,23 @@
 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;
+    /**The light data for voxels stored as 4 nibbles. 0 -> sun light 1 -> red light 2 -> green light 3 -> blue light */
+    light: Uint16Array;
+    /**The levels of the voxel. Used mainly for waterflow now. */
+    level: Uint8Array;
+    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
+    state: Uint16Array;
+    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
+    mod: Uint16Array;
+    /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
+     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
+     */
+    secondary: Uint16Array;
+}
 export type VoxelNamedStateData = {
     id: string;
     name?: string;
@@ -20,11 +37,13 @@ export type VoxelNamedStateData = {
 };
 export declare class PaintVoxelData {
     id: string;
+    name: string;
     mod: number;
     state: number;
     level: number;
     levelState: number;
     secondaryVoxelId: string;
+    secondaryVoxeName: string;
     static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
     private constructor();
 }
@@ -47,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/Voxel.types.js

@@ -1,19 +1,23 @@
 export class PaintVoxelData {
     id;
+    name;
     mod;
     state;
     level;
     levelState;
     secondaryVoxelId;
+    secondaryVoxeName;
     static Create(data) {
-        return new PaintVoxelData(data.id, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId);
+        return new PaintVoxelData(data.id, data.name, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId, data.secondaryVoxeName);
     }
-    constructor(id = "dve_air", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air") {
+    constructor(id = "dve_air", name = "", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryVoxeName = "") {
         this.id = id;
+        this.name = name;
         this.mod = mod;
         this.state = state;
         this.level = level;
         this.levelState = levelState;
         this.secondaryVoxelId = secondaryVoxelId;
+        this.secondaryVoxeName = secondaryVoxeName;
     }
 }

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