@divinevoxel/vlox 0.0.2 → 0.0.4

package/{VoxelModels/Rules → Voxels}/Functions/BuildStateData.js

@@ -1,6 +1,9 @@
-import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../../State/State.types";
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
-import { VoxelModelManager } from "../VoxelModelManager";
+import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
+import { VoxelTagStates } from "../State/VoxelTagStates";
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { StateSchema } from "../State/Schema/StateSchema";
 function bitsNeeded(n) {
     if (n < 0)
         throw new Error("Input must be a non-negative integer.");
@@ -92,6 +95,7 @@ function reMapTree(schemaIdPalette, schemaValuePalette, baseObj, newObj, modelOr
             ? schemaValuePalette.get(key)
             : Number(key);
         if (propertyIndex === undefined) {
+            console.error(baseObj);
             throw new Error(`Unkown variable in state string ${key} | ${modelOrVodelId}`);
         }
         if (schemaValueIndex === undefined)
@@ -101,7 +105,7 @@ function reMapTree(schemaIdPalette, schemaValuePalette, baseObj, newObj, modelOr
             const valueIndex = typeof value === "string" && typeof schemaValueIndex == "object"
                 ? schemaValueIndex.getNumberId(value)
                 : Number(value);
-            if (typeof propertyValue == "object") {
+            if (typeof propertyValue == "object" && !Array.isArray(propertyValue)) {
                 reMapedChildren[valueIndex] = reMapTree(schemaIdPalette, schemaValuePalette, baseChild[value], [], modelOrVodelId);
                 continue;
             }
@@ -251,7 +255,7 @@ export function BuildStateData(model, geoPalette) {
                         statement.push([
                             schemaIdPalette.getNumberId(schemaId),
                             StateCompareOperationsMap[op],
-                            !schemaValuePalette.has(schemaId)
+                            schemaValuePalette.has(schemaId)
                                 ? schemaValuePalette.get(schemaId).getNumberId(value)
                                 : Number(value),
                         ]);
@@ -289,10 +293,49 @@ export function BuildStateData(model, geoPalette) {
     const shapeStateTreeData = shapeStateTree.toJSON();
     const newShapeStateTree = [];
     reMapTree(schemaIdPalette, schemaValuePalette, shapeStateTreeData, newShapeStateTree, model.data.id);
+    const modelEffects = [];
+    const tagEffects = [];
+    if (model.data.effects) {
+        for (const effect of model.data.effects) {
+            const tagStateTree = new StateTreeNode("root");
+            const treePalette = [];
+            for (const key in effect.values) {
+                const nodeData = effect.values[key];
+                treePalette.push(nodeData);
+                addPathToTree(tagStateTree, key
+                    .split(",")
+                    .map((pair) => pair.split("="))
+                    .flat(), treePalette.length - 1);
+            }
+            const tagStateTreeData = tagStateTree.toJSON();
+            const newTagStateTree = [];
+            reMapTree(schemaIdPalette, schemaValuePalette, tagStateTreeData, newTagStateTree, model.data.id);
+            if (effect.type == "tag") {
+                tagEffects.push({
+                    type: "tag",
+                    tagId: effect.tagId,
+                    tree: newTagStateTree,
+                    treePalette,
+                });
+            }
+            if (effect.type == "fx-points") {
+                modelEffects.push({
+                    type: "fx-points",
+                    effectId: effect.effectId,
+                    tree: newTagStateTree,
+                    treePalette,
+                });
+            }
+        }
+    }
+    const schema = new StateSchema(baseSchema);
     for (const [voxelId, voxelData] of model.voxels) {
         const modeStateTree = new StateTreeNode("root");
         const modStatePalette = [];
         const modStateRecord = {};
+        for (const tag of tagEffects) {
+            VoxelTagStates.register(VoxelPalette.ids.getNumberId(voxelId), tag.tagId, schema, tag.tree, tag.treePalette);
+        }
         const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(voxelData.modSchema || [], voxelData.modRelationSchema || []);
         for (const key in voxelData.inputs) {
             modStatePalette.push(voxelData.inputs[key]);
@@ -314,6 +357,7 @@ export function BuildStateData(model, geoPalette) {
     }
     const finalData = {
         schema: baseSchema,
+        effects: modelEffects,
         shapeStateGeometryPalette,
         condiotnalShapeStateGeometryPalette,
         shapeStateTree: newShapeStateTree,

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -0,0 +1,39 @@
+import { PaintVoxelData } from "../../Data/Types/WorldData.types";
+import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Voxel.types";
+export declare class VoxelNamedState {
+    voxelId: string;
+    data: VoxelNamedStateData;
+    tags: Map<string, any>;
+    compiled: {
+        mod: number;
+        modAny: boolean;
+        shapeState: number;
+        shapeStateAny: boolean;
+    };
+    constructor(voxelId: string, data: VoxelNamedStateData);
+    getPaintData(): PaintVoxelData;
+}
+export declare class VoxelNamedStateContainer {
+    voxelId: string;
+    states: Map<string, VoxelNamedState>;
+    stateArray: VoxelNamedState[];
+    constructor(voxelId: string, data: VoxelNamedState[]);
+}
+declare class TagIndex {
+    tagId: string;
+    states: Map<string, VoxelNamedState>;
+    valueMap: Map<string, any>;
+    values: Set<any>;
+    constructor(tagId: string);
+}
+export declare class VoxelIndex {
+    static instance: VoxelIndex;
+    dataMap: Map<string, VoxelData>;
+    states: Map<string, VoxelNamedStateContainer>;
+    stateArray: VoxelNamedStateContainer[];
+    tagIndexes: Map<string, TagIndex>;
+    constructor(data: VoxelData[]);
+    getStateFromPaintData(data: PaintVoxelData): VoxelNamedState | false;
+    getStateFromRawData(data: RawVoxelData): VoxelNamedState | false;
+}
+export {};

package/Voxels/Indexes/VoxelIndex.js

@@ -0,0 +1,133 @@
+import { PaintVoxelData } from "../../Data/Types/WorldData.types";
+import { SchemaRegister } from "../State/SchemaRegister";
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+export class VoxelNamedState {
+    voxelId;
+    data;
+    tags = new Map();
+    compiled = {
+        mod: 0,
+        modAny: false,
+        shapeState: 0,
+        shapeStateAny: false,
+    };
+    constructor(voxelId, data) {
+        this.voxelId = voxelId;
+        this.data = data;
+        for (const key in data.properties) {
+            this.tags.set(key, data.properties[key]);
+        }
+        if (SchemaRegister.voxelModSchemaData.has(this.voxelId)) {
+            const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
+            if (this.data.state == "*") {
+                this.compiled.shapeStateAny = true;
+            }
+            else if (this.data.state) {
+                this.compiled.shapeState = schema.shapeState.readString(this.data.state);
+            }
+            if (this.data.mod == "*") {
+                this.compiled.modAny = true;
+            }
+            else if (this.data.mod) {
+                this.compiled.mod = schema.modState.readString(this.data.mod);
+            }
+        }
+        else {
+            this.compiled.modAny = true;
+            this.compiled.shapeStateAny = true;
+        }
+    }
+    getPaintData() {
+        const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
+        return PaintVoxelData.Create({
+            id: this.voxelId,
+            level: 0,
+            levelState: 0,
+            shapeState: this.compiled.shapeState,
+            mod: this.compiled.mod,
+        });
+    }
+}
+export class VoxelNamedStateContainer {
+    voxelId;
+    states = new Map();
+    stateArray = [];
+    constructor(voxelId, data) {
+        this.voxelId = voxelId;
+        for (const state of data) {
+            this.states.set(state.data.id, state);
+            this.stateArray.push(state);
+        }
+    }
+}
+class TagIndex {
+    tagId;
+    states = new Map();
+    //maps named state to the value of the tag
+    valueMap = new Map();
+    values = new Set();
+    constructor(tagId) {
+        this.tagId = tagId;
+    }
+}
+export class VoxelIndex {
+    static instance;
+    dataMap = new Map();
+    states = new Map();
+    stateArray = [];
+    tagIndexes = new Map();
+    constructor(data) {
+        if (VoxelIndex.instance)
+            return VoxelIndex.instance;
+        if (!VoxelIndex.instance)
+            VoxelIndex.instance = this;
+        for (const voxelData of data) {
+            const namedStates = voxelData.properties["dve_named_states"];
+            if (!namedStates)
+                continue;
+            const states = new VoxelNamedStateContainer(voxelData.id, namedStates.map((_) => new VoxelNamedState(voxelData.id, _)));
+            this.dataMap.set(voxelData.id, voxelData);
+            this.stateArray.push(states);
+            this.states.set(voxelData.id, states);
+            for (const [id, state] of states.states) {
+                for (const tagId in state.data.properties) {
+                    const tagData = state.data.properties[tagId];
+                    let tag = this.tagIndexes.get(tagId);
+                    if (!tag) {
+                        tag = new TagIndex(tagId);
+                        this.tagIndexes.set(tagId, tag);
+                    }
+                    tag.states.set(state.data.id, state);
+                    tag.states.set(state.data.id, tagData);
+                    tag.values.add(tagData);
+                }
+            }
+        }
+    }
+    getStateFromPaintData(data) {
+        const conatiner = this.states.get(data.id);
+        if (!conatiner)
+            return false;
+        const { mod, 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;
+        }
+        return false;
+    }
+    getStateFromRawData(data) {
+        const [id, light, shapeState, secondary, mod] = data;
+        const conatiner = this.states.get(VoxelPalette.ids.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;
+        }
+        return false;
+    }
+}

package/Voxels/Indexes/VoxelModelIndex.d.ts

@@ -0,0 +1,18 @@
+import { CachedDisplayIndex } from "../../Cache/Cache.types";
+import { CompactMeshData } from "../../Mesher/Types/Mesher.types";
+export declare class VoxelModelIndex {
+    static voxelModels: Map<string, Map<string, {
+        model: CompactMeshData;
+        material: string;
+    }>>;
+    static voxelMaterials: Map<string, Map<string, any>>;
+    static registerModel(voxelId: string, namedStateId: string, model: CompactMeshData, materialId: string, material?: any): void;
+    static registerMaterial(voxelId: string, namedStateId: string, material?: any): void;
+    static getModel(voxelId: string, namedStateId: string): false | {
+        model: CompactMeshData;
+        material: string;
+    };
+    static getMaterial(voxelId: string, namedStateId: string): any;
+    static loadData(data: CachedDisplayIndex["meshes"]): void;
+    static cacheData(): CachedDisplayIndex["meshes"];
+}

package/Voxels/Indexes/VoxelModelIndex.js

@@ -0,0 +1,59 @@
+export class VoxelModelIndex {
+    static voxelModels = new Map();
+    static voxelMaterials = new Map();
+    static registerModel(voxelId, namedStateId, model, materialId, material) {
+        let voxelMap = this.voxelModels.get(voxelId);
+        if (!voxelMap) {
+            voxelMap = new Map();
+            this.voxelModels.set(voxelId, voxelMap);
+        }
+        if (material) {
+            this.registerMaterial(voxelId, namedStateId, material);
+        }
+        voxelMap.set(namedStateId, { model, material: materialId });
+    }
+    static registerMaterial(voxelId, namedStateId, material) {
+        let voxelMap = this.voxelMaterials.get(voxelId);
+        if (!voxelMap) {
+            voxelMap = new Map();
+            this.voxelMaterials.set(voxelId, voxelMap);
+        }
+        voxelMap.set(namedStateId, material);
+    }
+    static getModel(voxelId, namedStateId) {
+        const voxelMap = this.voxelModels.get(voxelId);
+        if (!voxelMap)
+            return false;
+        const source = voxelMap.get(namedStateId);
+        if (!source)
+            return false;
+        return source;
+    }
+    static getMaterial(voxelId, namedStateId) {
+        const voxelMap = this.voxelMaterials.get(voxelId);
+        if (!voxelMap)
+            return false;
+        const source = voxelMap.get(namedStateId);
+        if (!source)
+            return false;
+        return source;
+    }
+    static loadData(data) {
+        for (const vid in data) {
+            const voxels = data[vid];
+            for (const sid in voxels) {
+                this.registerModel(vid, sid, voxels[sid].model, voxels[sid].material);
+            }
+        }
+    }
+    static cacheData() {
+        const meshes = {};
+        for (const [voxelId, vmap] of this.voxelModels) {
+            for (const [stateId, model] of vmap) {
+                meshes[voxelId] ??= {};
+                meshes[voxelId][stateId] = model;
+            }
+        }
+        return meshes;
+    }
+}

package/Voxels/Indexes/VoxelTextureIndex.d.ts

@@ -0,0 +1,8 @@
+import { CachedDisplayIndex } from "../../Cache/Cache.types";
+export declare class VoxelTextureIndex {
+    static voxelImages: Map<string, Map<string, HTMLImageElement>>;
+    static registerImage(voxelId: string, namedStateId: string, source: string): void;
+    static getImage(voxelId: string, namedStateId: string): false | HTMLImageElement;
+    static loadData(data: CachedDisplayIndex["textures"]): void;
+    static cacheData(): CachedDisplayIndex["textures"];
+}

package/Voxels/Indexes/VoxelTextureIndex.js

@@ -0,0 +1,40 @@
+export class VoxelTextureIndex {
+    static voxelImages = new Map();
+    static registerImage(voxelId, namedStateId, source) {
+        let voxelMap = this.voxelImages.get(voxelId);
+        if (!voxelMap) {
+            voxelMap = new Map();
+            this.voxelImages.set(voxelId, voxelMap);
+        }
+        const img = document.createElement("img");
+        img.src = source;
+        voxelMap.set(namedStateId, img);
+    }
+    static getImage(voxelId, namedStateId) {
+        const voxelMap = this.voxelImages.get(voxelId);
+        if (!voxelMap)
+            return false;
+        const source = voxelMap.get(namedStateId);
+        if (!source)
+            return false;
+        return source;
+    }
+    static loadData(data) {
+        for (const vid in data) {
+            const voxels = data[vid];
+            for (const sid in voxels) {
+                this.registerImage(vid, sid, voxels[sid]);
+            }
+        }
+    }
+    static cacheData() {
+        const meshes = {};
+        for (const [voxelId, vmap] of this.voxelImages) {
+            for (const [stateId, image] of vmap) {
+                meshes[voxelId] ??= {};
+                meshes[voxelId][stateId] = image.src;
+            }
+        }
+        return meshes;
+    }
+}

package/Voxels/InitVoxelData.d.ts

@@ -0,0 +1,9 @@
+import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
+import { VoxelData } from "./Voxel.types";
+import { ConstructorVoxelModelSyncData } from "./VoxelSyncData";
+export type InitVoxelDataProps = {
+    geometry?: VoxelGeometryData[];
+    models?: VoxelModelData[];
+    voxels: VoxelData[];
+};
+export declare function InitVoxelData(data: InitVoxelDataProps): ConstructorVoxelModelSyncData;

package/{VoxelModels/InitVoxelModels.js → Voxels/InitVoxelData.js}

@@ -1,30 +1,52 @@
-import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Examples";
-import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Defaults/CubeVoxelGeometry";
-import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "./Defaults/CubeVoxelModels";
-import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "./Defaults/PanelVoxelGeometry";
-import { stair } from "./Defaults/StairVoxelModel";
-import { VoxelModelManager } from "./Rules/VoxelModelManager";
-import { BuildRules } from "./Rules/Functions/BuildRules";
-import { BuildStateData } from "./Rules/Functions/BuildStateData";
-import { BuildGeomtryInputs } from "./Rules/Functions/BuildGeomtryInputs";
-import { BuildFinalInputs } from "./Rules/Functions/BuildFinalInputs";
-import { SchemaRegister } from "./State/SchemaRegister";
-import { simpleCrossedPannel, simpleThinPannel, } from "./Defaults/PanelVoxelModels";
-export function InitVoxelModels(data) {
+import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "../Models/Examples";
+import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "../Models/Defaults/CubeVoxelGeometry";
+import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "../Models/Defaults/CubeVoxelModels";
+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 { BuildRules } from "../Models/Rules/Functions/BuildRules";
+import { BuildStateData } from "./Functions/BuildStateData";
+import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
+import { SchemaRegister } from "../Voxels/State/SchemaRegister";
+import { simpleCrossedPannel, simpleThinPannel, } from "../Models/Defaults/PanelVoxelModels";
+import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
+import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
+import { CacheManager } from "../Cache/CacheManager";
+export function InitVoxelData(data) {
+    if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
+        console.warn("load sync data");
+        const syncData = CacheManager.cachedData.models;
+        for (let i = 0; i < syncData.models.length; i++) {
+            const model = syncData.models[i];
+            SchemaRegister.registerModel(model.id, model.schema);
+        }
+        for (let i = 0; i < syncData.voxels.length; i++) {
+            const voxel = syncData.voxels[i];
+            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
+        }
+        VoxelTagStates.load(syncData.tagState);
+        const t = performance.now();
+        console.log("sent the data", performance.now() - t);
+        const t2 = performance.now();
+        const voxelIndex = new VoxelIndex(data.voxels);
+        console.log("built the index", performance.now() - t2);
+        return syncData;
+    }
     const initTime = performance.now();
-    VoxelModelManager.registerGeometry(cube, fencePost, fenceEastWest, fenceNorthsouth, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, ...leverGeometry, ...(data.geometry || []));
-    VoxelModelManager.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, fence, stair, simpleCrossedPannel, candlesModel, leverModel, ...(data.models || []));
+    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 || []));
     const syncData = {
         geometryPalette: VoxelModelManager.geometryPalette._palette,
         geometry: [],
         models: [],
         voxels: [],
+        tagState: [],
     };
     for (const voxel of data.voxels) {
-        const data = voxel.tags.find((_) => _[0] == "#dve_model_data");
-        if (!data)
+        const voxelData = voxel.properties["dve_model_data"];
+        if (!voxelData)
             continue;
-        const voxelData = data[1];
         VoxelModelManager.registerVoxel(voxel.id, voxelData);
         const model = VoxelModelManager.models.get(voxelData.id);
         if (!model)
@@ -57,6 +79,7 @@ export function InitVoxelModels(data) {
         SchemaRegister.registerModel(mainKey, stateData.schema);
         syncData.models.push({
             id: mainKey,
+            effects: stateData.effects,
             schema: stateData.schema,
             geoLinkMap: stateData.geometryLinkStateMap,
             shapeStateMap: stateData.shapeStatePalette,
@@ -72,9 +95,9 @@ export function InitVoxelModels(data) {
             condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
         });
     }
-    for (const [mainKey, geometry] of VoxelModelManager.geometry) {
-        BuildGeomtryInputs(geometry);
-    }
+    /*   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) {
@@ -91,10 +114,16 @@ export function InitVoxelModels(data) {
             });
         }
     }
-    data.world.runAsyncTasks("sync-voxel-model-data", syncData);
-    data.constructors.runTasksForAll("sync-voxel-model-data", syncData);
+    syncData.tagState = VoxelTagStates.toJSON();
+    if (CacheManager.cacheStoreEnabled) {
+        console.warn("Store sync data", syncData);
+        CacheManager.cachedModelData = syncData;
+    }
+    console.log(syncData);
+    console.log(syncData.voxels.find((_) => _.id == "dve_liquid_dream_ether"));
     console.log("done building inputs", performance.now() - inputStartTime);
     console.log("init voxel models done | totle time: ", performance.now() - initTime);
+    const voxelIndex = new VoxelIndex(data.voxels);
     /*
     const blob = new Blob([JSON.stringify(output, null, 1)], {});
     const url = URL.createObjectURL(blob);
@@ -106,4 +135,5 @@ export function InitVoxelModels(data) {
     document.body.removeChild(a);
     URL.revokeObjectURL(url);
    */
+    return syncData;
 }

package/{VoxelModels → Voxels}/State/CondiotnalTreeReader.d.ts

@@ -6,5 +6,5 @@ export declare class CondtionalTreeReader {
     tree: any[];
     statements: LogicStatementReader[];
     constructor(schema: StateSchema, statements: StateLogicStatement[], tree: any[]);
-    getState(shapeState: number): number;
+    getState(): number;
 }

package/{VoxelModels → Voxels}/State/CondiotnalTreeReader.js

@@ -10,12 +10,13 @@ export class CondtionalTreeReader {
             this.statements.push(new LogicStatementReader(schema, statement));
         }
     }
-    getState(shapeState) {
+    getState() {
         if (!this.tree.length)
             return -1;
         let curretNode = this.tree;
         for (let i = 0; i < this.statements.length; i++) {
-            curretNode = curretNode[this.statements[i].getValue(shapeState) ? 1 : 0];
+            const value = this.statements[i].getValue(this);
+            curretNode = curretNode[value ? 1 : 0];
         }
         return curretNode;
     }

package/{VoxelModels → Voxels}/State/LogicStatementReader.d.ts

@@ -1,8 +1,9 @@
+import { CondtionalTreeReader } from "./CondiotnalTreeReader";
 import { StateSchema } from "./Schema/StateSchema";
 import { StateLogicStatement } from "./State.types";
 export declare class LogicStatementReader {
     schema: StateSchema;
     statement: StateLogicStatement;
     constructor(schema: StateSchema, statement: StateLogicStatement);
-    getValue(shapeState: number): boolean;
+    getValue(treeReader: CondtionalTreeReader): boolean;
 }

package/{VoxelModels → Voxels}/State/LogicStatementReader.js

@@ -6,7 +6,7 @@ export class LogicStatementReader {
         this.schema = schema;
         this.statement = statement;
     }
-    getValue(shapeState) {
+    getValue(treeReader) {
         let currentOperation = -1;
         let returnVaue = false;
         let currentValue = false;
@@ -17,7 +17,7 @@ export class LogicStatementReader {
                 currentOperation = node;
                 continue;
             }
-            const value = this.schema.nodes[node[0]].getValue(shapeState);
+            const value = this.schema.nodes[node[0]].getValue(this.schema.voxel.getShapeState());
             switch (node[1]) {
                 case StateCompareOperations.Equals:
                     currentValue = value == node[2];

package/{VoxelModels → Voxels}/State/Schema/BinarySchema.d.ts

@@ -5,7 +5,9 @@ export declare class BinarySchema {
     nodes: BinarySchemaNode[];
     constructor(schema: BinarySchemaNodeData[]);
     private _value;
-    startEncoding(): this;
+    readString(stateString: string): number;
+    compareString(stateString: string, ecnoded: number): boolean;
+    startEncoding(value?: number): this;
     getNmber(id: string): number;
     getValue(id: string): string;
     setNumber(id: string, value: number): this;