@divinevoxel/vlox 0.0.77 → 0.0.79

package/Voxels/State/LogicStatementReader.js

@@ -1,50 +0,0 @@
-import { StateCompareOperations, StateLogiceOperations, } from "./State.types";
-export class LogicStatementReader {
-    schema;
-    statement;
-    constructor(schema, statement) {
-        this.schema = schema;
-        this.statement = statement;
-    }
-    getValue(treeReader) {
-        let currentOperation = -1;
-        let returnVaue = false;
-        let currentValue = false;
-        for (let i = 0; i < this.statement.length; i++) {
-            const node = this.statement[i];
-            if (node == StateLogiceOperations.And ||
-                node == StateLogiceOperations.Or) {
-                currentOperation = node;
-                continue;
-            }
-            const value = this.schema.nodes[node[0]].getValue(this.schema.voxel.getState());
-            switch (node[1]) {
-                case StateCompareOperations.Equals:
-                    currentValue = value == node[2];
-                    break;
-                case StateCompareOperations.NotEquals:
-                    currentValue = value != node[2];
-                    break;
-                case StateCompareOperations.GreaterThan:
-                    currentValue = value >= node[2];
-                    break;
-                case StateCompareOperations.LessThan:
-                    currentValue = value <= node[2];
-                    break;
-            }
-            if (currentOperation == -1) {
-                returnVaue = currentValue;
-                continue;
-            }
-            switch (currentOperation) {
-                case StateLogiceOperations.And:
-                    returnVaue = returnVaue && currentValue;
-                    break;
-                case StateLogiceOperations.Or:
-                    returnVaue = returnVaue || currentValue;
-                    break;
-            }
-        }
-        return returnVaue;
-    }
-}

package/Voxels/State/Schema/Conditions/SameVoxelConditions.js

@@ -1,19 +0,0 @@
-import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
-export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
-    data;
-    constructor(schema, data) {
-        super(schema);
-        this.data = data;
-    }
-    evulate() {
-        const nx = this.schema.position.x + this.data.direction[0];
-        const ny = this.schema.position.y + this.data.direction[1];
-        const nz = this.schema.position.z + this.data.direction[2];
-        if (!this.schema.dataCursor.inBounds(nx, ny, nz))
-            return false;
-        const nVoxel = this.schema.dataCursor.getVoxel(nx, ny, nz);
-        if (!nVoxel)
-            return false;
-        return this.schema.voxel.isSameVoxel(nVoxel);
-    }
-}

package/Voxels/State/Schema/Conditions/ShapeStateSchemaRelationsCondition.d.ts

@@ -1,6 +0,0 @@
-import { StateSchema } from "../StateSchema";
-export declare abstract class ShapeStateSchemaRelationsCondition {
-    schema: StateSchema;
-    constructor(schema: StateSchema);
-    abstract evulate(): boolean;
-}

package/Voxels/State/Schema/Conditions/ShapeStateSchemaRelationsCondition.js

@@ -1,6 +0,0 @@
-export class ShapeStateSchemaRelationsCondition {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-}

package/Voxels/State/Schema/ShapeStateRelationsNode.d.ts

@@ -1,10 +0,0 @@
-import { VoxelModelRelationsSchemaNodes } from "../State.types";
-import { ShapeStateSchemaRelationsCondition } from "./Conditions/ShapeStateSchemaRelationsCondition";
-import { StateSchema } from "./StateSchema";
-export declare class ShapeStateRelationsNode {
-    schema: StateSchema;
-    name: string;
-    conditions: ShapeStateSchemaRelationsCondition[];
-    constructor(schema: StateSchema, data: VoxelModelRelationsSchemaNodes);
-    getValue(): number;
-}

package/Voxels/State/Schema/ShapeStateRelationsNode.js

@@ -1,26 +0,0 @@
-import { SameVoxelCondition } from "./Conditions/SameVoxelConditions";
-export class ShapeStateRelationsNode {
-    schema;
-    name;
-    conditions = [];
-    constructor(schema, data) {
-        this.schema = schema;
-        this.name = data.name;
-        for (const cond of data.conditions) {
-            if (cond.type == "same-voxel") {
-                this.conditions.push(new SameVoxelCondition(schema, cond));
-            }
-        }
-    }
-    getValue() {
-        let value = 1;
-        const conditionsLength = this.conditions.length;
-        for (let i = 0; i < conditionsLength; i++) {
-            if (!this.conditions[i].evulate()) {
-                value = 0;
-                break;
-            }
-        }
-        return value;
-    }
-}

package/Voxels/State/Schema/StateSchema.d.ts

@@ -1,13 +0,0 @@
-import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
-import { BinarySchemaNode } from "./BinarySchemaNode";
-import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
-import { Vector3Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
-import { VoxelStateSchemaData } from "../State.types";
-export declare class StateSchema {
-    nodes: (BinarySchemaNode | ShapeStateRelationsNode)[];
-    position: Vector3Like;
-    voxel: VoxelCursorInterface;
-    dataCursor: DataCursorInterface;
-    constructor(schema: VoxelStateSchemaData);
-}

package/Voxels/State/Schema/StateSchema.js

@@ -1,17 +0,0 @@
-import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
-import { BinarySchemaNode } from "./BinarySchemaNode";
-import { Vector3Like } from "@amodx/math";
-export class StateSchema {
-    nodes = [];
-    position = Vector3Like.Create();
-    voxel;
-    dataCursor;
-    constructor(schema) {
-        for (const binary of schema.binary) {
-            this.nodes.push(new BinarySchemaNode(binary));
-        }
-        for (const relational of schema.relational) {
-            this.nodes.push(new ShapeStateRelationsNode(this, relational));
-        }
-    }
-}

package/Voxels/State/Schema/VoxelSchema.d.ts

@@ -1,7 +0,0 @@
-import { BinarySchema } from "./BinarySchema";
-export declare class VoxelSchema {
-    id: string;
-    state: BinarySchema;
-    mod: BinarySchema;
-    constructor(id: string, state: BinarySchema, mod: BinarySchema);
-}

package/Voxels/State/Schema/VoxelSchema.js

@@ -1,10 +0,0 @@
-export class VoxelSchema {
-    id;
-    state;
-    mod;
-    constructor(id, state, mod) {
-        this.id = id;
-        this.state = state;
-        this.mod = mod;
-    }
-}

package/Voxels/State/SchemaRegister.d.ts

@@ -1,18 +0,0 @@
-import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSchema } from "./Schema/VoxelSchema";
-import { VoxelStateSchemaData, VoxelBinaryStateSchemaNode } from "./State.types";
-export declare class SchemaRegister {
-    static modelStaeBaseSchemaData: Map<string, VoxelStateSchemaData>;
-    static stateSchemaData: Map<string, VoxelBinaryStateSchemaNode[]>;
-    static modSchemaData: Map<string, VoxelBinaryStateSchemaNode[]>;
-    static modelStaeSchemas: Map<string, BinarySchema>;
-    static voxelModSchemas: Map<string, BinarySchema>;
-    static voxelModelMap: Map<string, string>;
-    static voxelSchemas: Map<string, VoxelSchema>;
-    static hasVoxelSchema(voxelId: string): boolean;
-    static getModelSchema(modelId: string): BinarySchema;
-    static getVoxelModSchema(voxelId: string): BinarySchema;
-    static getVoxelSchemas(voxelId: string): VoxelSchema;
-    static registerModel(id: string, data: VoxelStateSchemaData): void;
-    static registerVoxel(id: string, modelId: string, data: VoxelStateSchemaData): void;
-}

package/Voxels/State/SchemaRegister.js

@@ -1,76 +0,0 @@
-import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSchema } from "./Schema/VoxelSchema";
-export class SchemaRegister {
-    static modelStaeBaseSchemaData = new Map();
-    static stateSchemaData = new Map([
-        ["dve_air", []],
-    ]);
-    static modSchemaData = new Map([
-        ["dve_air", []],
-    ]);
-    static modelStaeSchemas = new Map();
-    static voxelModSchemas = new Map();
-    static voxelModelMap = new Map([["dve_air", "dve_air"]]);
-    static voxelSchemas = new Map();
-    static hasVoxelSchema(voxelId) {
-        if (this.voxelSchemas.has(voxelId))
-            return true;
-        if (this.stateSchemaData.has(this.voxelModelMap.get(voxelId) || "") &&
-            this.modSchemaData.has(voxelId))
-            return true;
-        return false;
-    }
-    static getModelSchema(modelId) {
-        let stateSchema = this.modelStaeSchemas.get(modelId);
-        if (!stateSchema) {
-            const schemaData = this.stateSchemaData.get(modelId);
-            if (!schemaData)
-                throw new Error(`Model ${modelId} is not registered`);
-            stateSchema = new BinarySchema(schemaData);
-        }
-        return stateSchema;
-    }
-    static getVoxelModSchema(voxelId) {
-        let modSchema = this.voxelModSchemas.get(voxelId);
-        if (!modSchema) {
-            const schemaData = this.modSchemaData.get(voxelId);
-            if (!schemaData)
-                throw new Error(`Voxel mod sceham [${voxelId}] is not registered`);
-            modSchema = new BinarySchema(schemaData);
-        }
-        return modSchema;
-    }
-    static getVoxelSchemas(voxelId) {
-        if (this.voxelSchemas.has(voxelId)) {
-            return this.voxelSchemas.get(voxelId);
-        }
-        const modelId = this.voxelModelMap.get(voxelId);
-        if (!modelId)
-            throw new Error(`Voxel ${voxelId} is not registered`);
-        let stateSchema = this.modelStaeSchemas.get(modelId);
-        if (!stateSchema) {
-            const schemaData = this.stateSchemaData.get(modelId);
-            if (!schemaData)
-                throw new Error(`Model ${modelId} is not registered`);
-            stateSchema = new BinarySchema(schemaData);
-        }
-        let modSchema = this.voxelModSchemas.get(voxelId);
-        if (!modSchema) {
-            const schemaData = this.modSchemaData.get(voxelId);
-            if (!schemaData)
-                throw new Error(`Voxel ${voxelId} is not registered`);
-            modSchema = new BinarySchema(schemaData);
-        }
-        const voxelSchema = new VoxelSchema(voxelId, stateSchema, modSchema);
-        this.voxelSchemas.set(voxelId, voxelSchema);
-        return voxelSchema;
-    }
-    static registerModel(id, data) {
-        this.modelStaeBaseSchemaData.set(id, data);
-        this.stateSchemaData.set(id, data.binary);
-    }
-    static registerVoxel(id, modelId, data) {
-        this.voxelModelMap.set(id, modelId);
-        this.modSchemaData.set(id, data.binary);
-    }
-}

package/Voxels/State/StateTreeReader.d.ts

@@ -1,9 +0,0 @@
-import { StateSchema } from "./Schema/StateSchema";
-export declare class StateTreeReader {
-    schema: StateSchema;
-    defaultValue: number;
-    tree: any[];
-    startingIndex: number;
-    constructor(schema: StateSchema, defaultValue: number | undefined, tree: any[]);
-    getState(state: number): number;
-}

package/Voxels/State/StateTreeReader.js

@@ -1,37 +0,0 @@
-export class StateTreeReader {
-    schema;
-    defaultValue;
-    tree;
-    startingIndex = 0;
-    constructor(schema, defaultValue = 0, tree) {
-        this.schema = schema;
-        this.defaultValue = defaultValue;
-        this.tree = tree;
-    }
-    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(state)];
-            if (typeof curretNode == "number") {
-                return curretNode;
-            }
-            if (curretNode === undefined) {
-                return -1;
-            }
-            for (let i = 0; i < curretNode.length; i++) {
-                if (curretNode[i]) {
-                    index = i;
-                    break;
-                }
-            }
-            if (typeof curretNode == "number") {
-                return curretNode;
-            }
-        }
-        return found;
-    }
-}