@divinevoxel/vlox 0.0.74 → 0.0.75

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -0,0 +1,95 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { VoxelPickResult } from "../VoxelPickResult";
+import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
+const step = (val) => (val > 0 ? 1 : val < 0 ? -1 : 0);
+const calculateNormal = (intersectPoint, voxelMin, voxelMax) => {
+    const epsilon = 1e-4;
+    let normal = [0, 0, 0];
+    if (Math.abs(intersectPoint[0] - voxelMin[0]) < epsilon)
+        normal = [1, 0, 0];
+    else if (Math.abs(intersectPoint[0] - voxelMax[0]) < epsilon)
+        normal = [-1, 0, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMin[1]) < epsilon)
+        normal = [0, 1, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMax[1]) < epsilon)
+        normal = [0, -1, 0];
+    else if (Math.abs(intersectPoint[2] - voxelMin[2]) < epsilon)
+        normal = [0, 0, 1];
+    else if (Math.abs(intersectPoint[2] - voxelMax[2]) < epsilon)
+        normal = [0, 0, -1];
+    return normal;
+};
+/**
+ * # PickVoxel
+ * Used to a pick a voxel from any data cursor interface.
+ * The function assumes the data that is loaded into the cursor is available
+ */
+export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
+    const invDir = [
+        1 / rayDirection[0],
+        1 / rayDirection[1],
+        1 / rayDirection[2],
+    ];
+    const voxelSize = 1.0;
+    const tDelta = [
+        Math.abs(invDir[0]) * voxelSize,
+        Math.abs(invDir[1]) * voxelSize,
+        Math.abs(invDir[2]) * voxelSize,
+    ];
+    const tMax = [
+        (Math.floor(rayStart[0]) - rayStart[0] + (rayDirection[0] > 0 ? 1 : 0)) *
+            invDir[0],
+        (Math.floor(rayStart[1]) - rayStart[1] + (rayDirection[1] > 0 ? 1 : 0)) *
+            invDir[1],
+        (Math.floor(rayStart[2]) - rayStart[2] + (rayDirection[2] > 0 ? 1 : 0)) *
+            invDir[2],
+    ];
+    const pos = [
+        Math.floor(rayStart[0]),
+        Math.floor(rayStart[1]),
+        Math.floor(rayStart[2]),
+    ];
+    const stepDir = [
+        step(rayDirection[0]),
+        step(rayDirection[1]),
+        step(rayDirection[2]),
+    ];
+    for (let i = 0; i < rayLength; i++) {
+        const [tx, ty, tz] = tMax;
+        let axis = 0;
+        if (tx < ty) {
+            if (tx < tz)
+                axis = 0;
+            else
+                axis = 2;
+        }
+        else {
+            if (ty < tz)
+                axis = 1;
+            else
+                axis = 2;
+        }
+        pos[axis] += stepDir[axis];
+        tMax[axis] += tDelta[axis];
+        if (!cursor.inBounds(...pos))
+            continue;
+        const voxel = cursor.getVoxel(...pos);
+        if (voxel && voxel.isRenderable()) {
+            const normal = calculateNormal([
+                rayStart[0] + rayDirection[0] * tMax[axis],
+                rayStart[1] + rayDirection[1] * tMax[axis],
+                rayStart[2] + rayDirection[2] * tMax[axis],
+            ], [pos[0] * voxelSize, pos[1] * voxelSize, pos[2] * voxelSize], [
+                pos[0] * voxelSize + voxelSize,
+                pos[1] * voxelSize + voxelSize,
+                pos[2] * voxelSize + voxelSize,
+            ]);
+            const rd = Vector3Like.Create(...rayDirection);
+            const urd = Vector3Like.FromArray(closestUnitNormal(rd));
+            const n = Vector3Like.Create(...normal);
+            const un = Vector3Like.FromArray(closestUnitNormal(n));
+            return new VoxelPickResult(Vector3Like.Create(...rayStart), rd, rayLength, voxel.getRaw(), Vector3Like.Create(...pos), n, tMax[axis], Vector3Like.Create(...Vec3ArrayLike.Add(pos, normal)), Vector3Like.FromArray(closestUnitNormal(rd)), closestVoxelFace(urd), Vector3Like.FromArray(closestUnitNormal(n)), closestVoxelFace(un), 0);
+        }
+    }
+    return null;
+}

package/Voxels/Interaction/Functions/PickVoxelWorld.d.ts

@@ -0,0 +1,8 @@
+import { Vec3Array } from "@amodx/math";
+import { WorldCursor } from "../../../World";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default function PickVoxelWorld(cursor: WorldCursor, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): Promise<import("../VoxelPickResult").VoxelPickResult | null>;

package/Voxels/Interaction/Functions/PickVoxelWorld.js

@@ -0,0 +1,66 @@
+import { Vector3Like } from "@amodx/math";
+import PickVoxel from "./PickVoxel";
+import { Axes } from "@amodx/math/Vectors/Axes";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectorCursor } from "../../../World/Cursor/SectorCursor";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
+    let t = 0;
+    const d = 8;
+    const rayPosition = Vector3Like.Create(...rayStart);
+    const rd = Vector3Like.Create(...rayDirection);
+    const rayRight = Vector3Like.Cross(rd, Axes.UpReadOnly());
+    const rayUp = Vector3Like.Cross(rayRight, rd);
+    const cubeSize = 16.0;
+    const halfSize = cubeSize / 2.0;
+    const rayDirectionScaled = Vector3Like.MultiplyScalar(rd, halfSize);
+    const rayRightScaled = Vector3Like.MultiplyScalar(rayRight, halfSize);
+    const rayUpScaled = Vector3Like.MultiplyScalar(rayUp, halfSize);
+    const finalRayCubeDirection = Vector3Like.Subtract(Vector3Like.Subtract(rayDirectionScaled, rayRightScaled), rayUpScaled);
+    const finalMin = Vector3Like.Create();
+    const finalMax = Vector3Like.Create();
+    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const visited = new Set();
+    const sectorCursor = new SectorCursor();
+    while (t < rayLength) {
+        rayPosition.x = rayStart[0] + t * rayDirection[0];
+        rayPosition.y = rayStart[1] + t * rayDirection[1];
+        rayPosition.z = rayStart[2] + t * rayDirection[2];
+        t += d;
+        const min = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Subtract(rayPosition, finalRayCubeDirection)));
+        const max = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Add(rayPosition, finalRayCubeDirection)));
+        max.x < min.x ? (finalMin.x = max.x) : (finalMin.x = min.x);
+        max.y < min.y ? (finalMin.y = max.y) : (finalMin.y = min.y);
+        max.z < min.z ? (finalMin.z = max.z) : (finalMin.z = min.z);
+        min.x > max.x ? (finalMax.x = min.x) : (finalMax.x = max.x);
+        min.y > max.y ? (finalMax.y = min.y) : (finalMax.y = max.y);
+        min.z > max.z ? (finalMax.z = min.z) : (finalMax.z = max.z);
+        const { x: sx, y: sy, z: sz } = finalMin;
+        const { x: ex, y: ey, z: ez } = finalMax;
+        for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
+            for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
+                for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    if (visited.has(sector))
+                        continue;
+                    visited.add(sector);
+                    await sector.waitTillCheckedIn();
+                    sectorCursor.loadSector(cursor.dimension, x, y, z);
+                    const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
+                    if (result !== null)
+                        return result;
+                }
+            }
+        }
+    }
+    return null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.d.ts

@@ -0,0 +1,9 @@
+import { VoxelFaceNames } from "../../../Math";
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelPickResult } from "../VoxelPickResult";
+export declare class VoxelModelPlacingStrategy {
+    _faceMap: Map<VoxelFaceNames, VoxelPlacingStrategyData[]>;
+    _defaultState: string;
+    constructor(data: VoxelPlacingStrategyData[] | string);
+    getState(picked: VoxelPickResult, alt?: number | null): string | null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.js

@@ -0,0 +1,58 @@
+import { VoxelFaceNameArray } from "../../../Math";
+export class VoxelModelPlacingStrategy {
+    _faceMap = new Map();
+    _defaultState;
+    constructor(data) {
+        if (typeof data == "string") {
+            this._defaultState = data;
+        }
+        else {
+            for (const stragety of data) {
+                let faceArray = this._faceMap.get(stragety.face);
+                if (!faceArray) {
+                    faceArray = [];
+                    this._faceMap.set(stragety.face, faceArray);
+                }
+                faceArray.push(stragety);
+            }
+        }
+    }
+    getState(picked, alt = null) {
+        if (this._defaultState)
+            return this._defaultState;
+        const face = picked.unitNormalFace;
+        const delta = picked.delta;
+        const direction = picked.unitRayDirection;
+        const stragetegies = this._faceMap.get(typeof face == "number" ? VoxelFaceNameArray[face] : face);
+        if (!stragetegies)
+            return null;
+        let match = true;
+        for (const strat of stragetegies) {
+            if (alt !== null) {
+                if (strat.alt == undefined) {
+                    match = false;
+                }
+                if (strat.alt !== alt) {
+                    match = false;
+                }
+            }
+            if (strat.delta) {
+                if (!delta) {
+                    match = false;
+                }
+                else if (!(delta >= strat.delta[0] && delta <= strat.delta[1])) {
+                    match = false;
+                }
+            }
+            if (strat.direction[0] !== direction.x)
+                match = false;
+            if (strat.direction[1] !== direction.y)
+                match = false;
+            if (strat.direction[2] !== direction.z)
+                match = false;
+            if (match)
+                return strat.state;
+        }
+        return null;
+    }
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.d.ts

@@ -0,0 +1,15 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelFaceNames } from "../../../Math";
+/** Defines the state the model should be placed in given the parameters. */
+export interface VoxelPlacingStrategyData {
+    /** The closest voxel face of the intersected voxel model. */
+    face: VoxelFaceNames;
+    /** The direction of the ray that intersected the voxel that is being placed upon.  */
+    direction: Vec3Array;
+    /** The delta of the virtual voxel cube face intersected. If it was intersected halfway, it would be 0.5. */
+    delta?: [min: number, max: number];
+    /** Defines an alternative ID to override the same parameters. */
+    alt?: number;
+    /** The resulting state string of the model. */
+    state: string;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.js

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

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.d.ts

@@ -0,0 +1,7 @@
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export declare class VoxelPlacingStrategyRegister {
+    static _stragies: Map<string, VoxelModelPlacingStrategy>;
+    static register(id: string, data: VoxelPlacingStrategyData[] | string): void;
+    static get(id: string): VoxelModelPlacingStrategy | null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.js

@@ -0,0 +1,13 @@
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export class VoxelPlacingStrategyRegister {
+    static _stragies = new Map();
+    static register(id, data) {
+        this._stragies.set(id, new VoxelModelPlacingStrategy(data));
+    }
+    static get(id) {
+        const stragety = this._stragies.get(id);
+        if (!stragety)
+            return null;
+        return stragety;
+    }
+}

package/Voxels/Interaction/VoxelPickResult.d.ts

@@ -0,0 +1,50 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../Math";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export interface VoxelPickResultData {
+    /**The origin of the ray */
+    rayOrigin: Vector3Like;
+    /**The direction of the ray */
+    rayDirection: Vector3Like;
+    /**The length of the ray */
+    rayLength: number;
+    /**The space position of the voxel */
+    position: Vector3Like;
+    /**The normal of the unit voxel that was hit */
+    normal: Vector3Like;
+    /**The distance from the ray start to the intersection point */
+    distance: number;
+    /**Position + the unit  normal */
+    normalPosition: Vector3Like;
+    /**The voxel data */
+    voxelData: RawVoxelData;
+    /**Closest unit normal of the ray direction */
+    unitRayDirection: Vector3Like;
+    /**Closest voxel face of the ray direction */
+    unitRayVoxelFace: VoxelFaces;
+    /**Closest unit normal of the picked normal */
+    unitNormal: Vector3Like;
+    /**Closest voxel face of the picked normal */
+    unitNormalFace: VoxelFaces;
+    delta: number;
+}
+export declare class VoxelPickResult implements VoxelPickResultData {
+    rayOrigin: Vector3Like;
+    rayDirection: Vector3Like;
+    rayLength: number;
+    voxelData: RawVoxelData;
+    position: Vector3Like;
+    normal: Vector3Like;
+    distance: number;
+    normalPosition: Vector3Like;
+    unitRayDirection: Vector3Like;
+    unitRayVoxelFace: VoxelFaces;
+    unitNormal: Vector3Like;
+    unitNormalFace: VoxelFaces;
+    delta: number;
+    voxel: VoxelCursor;
+    static FromJSON(data: VoxelPickResultData): VoxelPickResult;
+    constructor(rayOrigin: Vector3Like, rayDirection: Vector3Like, rayLength: number, voxelData: RawVoxelData, position: Vector3Like, normal: Vector3Like, distance: number, normalPosition: Vector3Like, unitRayDirection: Vector3Like, unitRayVoxelFace: VoxelFaces, unitNormal: Vector3Like, unitNormalFace: VoxelFaces, delta: number);
+    toJSON(): VoxelPickResultData;
+}

package/Voxels/Interaction/VoxelPickResult.js

@@ -0,0 +1,55 @@
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export class VoxelPickResult {
+    rayOrigin;
+    rayDirection;
+    rayLength;
+    voxelData;
+    position;
+    normal;
+    distance;
+    normalPosition;
+    unitRayDirection;
+    unitRayVoxelFace;
+    unitNormal;
+    unitNormalFace;
+    delta;
+    voxel;
+    static FromJSON(data) {
+        return new VoxelPickResult(data.rayOrigin, data.rayDirection, data.rayLength, data.voxelData, data.position, data.normal, data.distance, data.normalPosition, data.unitRayDirection, data.unitRayVoxelFace, data.unitNormal, data.unitNormalFace, data.delta);
+    }
+    constructor(rayOrigin, rayDirection, rayLength, voxelData, position, normal, distance, normalPosition, unitRayDirection, unitRayVoxelFace, unitNormal, unitNormalFace, delta) {
+        this.rayOrigin = rayOrigin;
+        this.rayDirection = rayDirection;
+        this.rayLength = rayLength;
+        this.voxelData = voxelData;
+        this.position = position;
+        this.normal = normal;
+        this.distance = distance;
+        this.normalPosition = normalPosition;
+        this.unitRayDirection = unitRayDirection;
+        this.unitRayVoxelFace = unitRayVoxelFace;
+        this.unitNormal = unitNormal;
+        this.unitNormalFace = unitNormalFace;
+        this.delta = delta;
+        this.voxel = new VoxelCursor();
+        this.voxel.setRaw(voxelData);
+        this.voxel.loadIn();
+    }
+    toJSON() {
+        return {
+            rayOrigin: { ...this.rayOrigin },
+            rayDirection: { ...this.rayDirection },
+            rayLength: this.rayLength,
+            position: { ...this.position },
+            normal: { ...this.normal },
+            distance: this.distance,
+            normalPosition: { ...this.normalPosition },
+            unitRayDirection: { ...this.unitRayDirection },
+            unitRayVoxelFace: this.unitRayVoxelFace,
+            unitNormal: { ...this.unitNormal },
+            unitNormalFace: this.unitNormalFace,
+            voxelData: [...this.voxelData],
+            delta: this.delta,
+        };
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.d.ts

@@ -0,0 +1,8 @@
+import { VoxelLogicEffects, VoxelLogicPoweredData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicPoweredType extends VoxelLogicType<VoxelLogicPoweredData> {
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.js

@@ -0,0 +1,13 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicPoweredType extends VoxelLogicType {
+    init() { }
+    run(voxel) {
+        return voxel.getPower() > 0;
+    }
+    *getEffects() {
+        for (const effect of this.data.on)
+            yield effect;
+        for (const effect of this.data.off)
+            yield effect;
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.d.ts

@@ -0,0 +1,9 @@
+import { VoxelLogicEffects, VoxelLogicStateData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicStateType extends VoxelLogicType<VoxelLogicStateData> {
+    keys: string[];
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.js

@@ -0,0 +1,23 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicStateType extends VoxelLogicType {
+    keys;
+    init() {
+        this.keys = Object.keys(this.data.value);
+    }
+    run(voxel) {
+        this.voxelLogic.schema.state.startEncoding(voxel.getState());
+        for (let i = 0; i < this.keys.length; i++) {
+            const key = this.keys[i];
+            if (this.data.value[key] !== this.voxelLogic.schema.state.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    *getEffects() {
+        for (const effect of this.data.true)
+            yield effect;
+        for (const effect of this.data.false)
+            yield effect;
+    }
+}

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

@@ -1,11 +1,14 @@
+import { VoxelSchema } from "../../State/Schema/VoxelSchema";
 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[]);
+    voxelId: string;
+    types: VoxelLogicType<any>[];
+    effectedTags: Map<string, VoxelLogicType<any>[]>;
+    schema: VoxelSchema;
+    constructor(voxelId: string, data: VoxelLogicData[]);
     getTagValue(tagId: string, cursor: VoxelCursorInterface): any;
-    registerEffectOnTag(tagId: string, effect: VoxelLogicType): void;
+    registerEffectOnTag(tagId: string, effect: VoxelLogicType<any>): void;
     hasTag(tag: string): boolean;
 }

package/Voxels/Logic/Classes/VoxelLogic.js

@@ -1,28 +1,33 @@
 import { VoxelLogicRegister } from "../VoxelLogicRegister";
+import { SchemaRegister } from "../../State/SchemaRegister";
 export class VoxelLogic {
+    voxelId;
     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);
+    schema;
+    constructor(voxelId, data) {
+        this.voxelId = voxelId;
+        this.schema = SchemaRegister.getVoxelSchemas(voxelId);
+        for (const logicData of data) {
+            const LogicTypeClass = VoxelLogicRegister.get(logicData.type);
+            const newLogicType = new LogicTypeClass(this, logicData);
+            this.types.push(newLogicType);
+            for (const effect of newLogicType.getEffects()) {
+                if (effect.type == "tag") {
+                    let effects = this.effectedTags.get(effect.tagId);
+                    if (!effects) {
+                        effects = [];
+                        this.effectedTags.set(effect.tagId, effects);
+                    }
+                    if (!effects.includes(newLogicType)) {
+                        effects.push(newLogicType);
+                    }
+                }
             }
         }
+        for (const type of this.types) {
+            type.init();
+        }
     }
     getTagValue(tagId, cursor) {
         let effects = this.effectedTags.get(tagId);
@@ -35,14 +40,7 @@ export class VoxelLogic {
         }
         return finalValue;
     }
-    registerEffectOnTag(tagId, effect) {
-        let effects = this.effectedTags.get(tagId);
-        if (!effects) {
-            effects = [];
-            this.effectedTags.set(tagId, effects);
-        }
-        effects.push(effect);
-    }
+    registerEffectOnTag(tagId, effect) { }
     hasTag(tag) {
         return this.effectedTags.has(tag);
     }

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

@@ -1,4 +1,14 @@
 import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
-export declare abstract class VoxelLogicType {
+import { VoxelLogicEffects } from "../VoxelLogic.types";
+import { VoxelLogic } from "./VoxelLogic";
+export interface VoxelLogicTypeConstructor<Data> {
+    new (voxelLogic: VoxelLogic, data: Data): VoxelLogicType<Data>;
+}
+export declare abstract class VoxelLogicType<Data> {
+    voxelLogic: VoxelLogic;
+    data: Data;
+    constructor(voxelLogic: VoxelLogic, data: Data);
+    abstract init(): void;
     abstract run(task: VoxelCursorInterface): boolean;
+    abstract getEffects(): Generator<VoxelLogicEffects>;
 }

package/Voxels/Logic/Classes/VoxelLogicType.js

@@ -1,2 +1,8 @@
 export class VoxelLogicType {
+    voxelLogic;
+    data;
+    constructor(voxelLogic, data) {
+        this.voxelLogic = voxelLogic;
+        this.data = data;
+    }
 }

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

@@ -11,13 +11,15 @@ export type VoxelLogicEffects = {
     key: string;
     value: string | number;
 };
-export type VoxelLogicData = {
+export type VoxelLogicPoweredData = {
     type: "powered";
     on: VoxelLogicEffects[];
     off: VoxelLogicEffects[];
-} | {
+};
+export type VoxelLogicStateData = {
     type: "state";
-    value: string;
+    value: Record<string, number | string>;
     true: VoxelLogicEffects[];
     false: VoxelLogicEffects[];
 };
+export type VoxelLogicData = VoxelLogicPoweredData | VoxelLogicStateData;

package/Voxels/Logic/VoxelLogicRegister.d.ts

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

package/Voxels/Logic/VoxelLogicRegister.js

@@ -1,15 +1,23 @@
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelLogic } from "./Classes/VoxelLogic";
-import { VoxelPoweredLogicType } from "./Classes/Default/Types/VoxelPoweredLogicType";
+import { VoxelLogicPoweredType } from "./Classes/Types/VoxelLogicPoweredType";
+import { VoxelLogicStateType } from "./Classes/Types/VoxelLogicStateType";
 export class VoxelLogicRegister {
     static voxels = [];
     static types = new Map();
+    static get(id) {
+        const typeClass = VoxelLogicRegister.types.get(id);
+        if (!typeClass)
+            throw new Error(`Logic type ${id} does not exist`);
+        return typeClass;
+    }
     static register(id, logicData) {
-        const voxelId = VoxelPalettesRegister.voxels.getNumberId(id);
-        this.voxels[voxelId] = new VoxelLogic(logicData);
+        const voxelId = VoxelPalettesRegister.voxelIds.getNumberId(id);
+        this.voxels[voxelId] = new VoxelLogic(id, logicData);
     }
     static registerType(id, logic) {
         this.types.set(id, logic);
     }
 }
-VoxelLogicRegister.registerType("powered", new VoxelPoweredLogicType());
+VoxelLogicRegister.registerType("powered", VoxelLogicPoweredType);
+VoxelLogicRegister.registerType("state", VoxelLogicStateType);