@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -1,27 +1,24 @@
 import { VoxelLightData } from "./VoxelLightData";
 import { RawVoxelData } from "../Types/Voxel.types";
 import { VoxelSubstanceTags, VoxelTags } from "../../Voxels/Data/VoxelTag.types";
-interface WritableArrayLike<T> {
-    length: number;
-    [index: number]: T;
-}
+import { VoxelSchema } from "../../Voxels/State/Schema/VoxelSchema";
+import { NumberArray } from "../../Util/Util.types";
 export declare abstract class VoxelCursorInterface {
-    _loadedId: number;
+    _voxelId: number;
     id: number;
     secondaryId: number;
-    _tags: VoxelTags;
-    _substanceTags: VoxelSubstanceTags;
-    __secondary: boolean;
+    schema: VoxelSchema;
+    tags: VoxelTags;
+    substanceTags: VoxelSubstanceTags;
+    __readingSecondaryVoxel: boolean;
     _index: number;
-    abstract ids: WritableArrayLike<number>;
-    abstract light: WritableArrayLike<number>;
-    abstract level: WritableArrayLike<number>;
-    abstract state: WritableArrayLike<number>;
-    abstract secondary: WritableArrayLike<number>;
-    abstract mod: WritableArrayLike<number>;
+    abstract ids: NumberArray;
+    abstract light: NumberArray;
+    abstract level: NumberArray;
+    abstract secondary: NumberArray;
     /**
      *
-     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried check only
+     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried and logic check only, 3 for propagatin check only
      */
     abstract updateVoxel(mode: 0 | 1 | 2): void;
     _lightData: VoxelLightData;
@@ -35,36 +32,43 @@ export declare abstract class VoxelCursorInterface {
     getSubstance(): string;
     getSubstanceData(): VoxelSubstanceTags;
     isOpaque(): boolean;
-    getMod(): number;
-    setMod(mod: number): this;
     getLevel(): number;
     setLevel(level: number): this;
     getLevelState(): number;
     setLevelState(state: number): this;
-    getState(): number;
-    setState(state: number): this;
     hasSecondaryVoxel(): boolean;
     canHaveSecondaryVoxel(): boolean;
     hasRGBLight(): boolean;
     hasSunLight(): boolean;
     getLight(): number;
     setLight(light: number): this;
-    isLightSource(): boolean;
+    isLightSource(): any;
+    doesVoxelAffectLogic(): boolean;
     getLightSourceValue(): number;
+    getPower(): number;
+    setPower(level: number): this;
+    isPowerSource(): any;
+    getPowerSourceValue(): number;
     noAO(): boolean;
     isRenderable(): boolean;
     isAir(): boolean;
     setAir(): this;
     getId(): number;
     setId(id: number): this;
-    setStringId(id: string): this;
+    getVoxelId(): number;
+    setVoxelId(id: number, state?: number, mod?: number): this;
+    setStringId(id: string, state?: number, mod?: number): this;
     getStringId(): string;
-    setName(name: string): this;
+    setName(name: string, state?: number, mod?: number): this;
     getName(): string;
+    getIndexData(): [voxelId: number, state: number, mod: number];
+    getMod(): number;
+    setMod(mod: number): this;
+    getState(): number;
+    setState(state: number): this;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;
-    copyRaw(raw: RawVoxelData): this;
+    setRaw(raw: RawVoxelData): this;
     getRaw(): RawVoxelData;
     getRawToRef(raw: RawVoxelData): RawVoxelData;
 }
-export {};

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -1,67 +1,54 @@
 import { VoxelLightData } from "./VoxelLightData";
 import { VoxelLevelReader } from "./VoxelLevelReader";
-import { VoxelTagStates } from "../Data/VoxelTagStates";
 import { VoxelTagIds, } from "../../Voxels/Data/VoxelTag.types";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
+import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
 export class VoxelCursorInterface {
-    _loadedId = 0;
+    _voxelId = 0;
     id = 0;
     secondaryId = 0;
-    _tags;
-    _substanceTags;
-    __secondary = false;
+    schema;
+    tags = {};
+    substanceTags = {};
+    __readingSecondaryVoxel = false;
     // private _section: Section;
     _index = 0;
     _lightData = new VoxelLightData();
     process() {
         this.id = this.ids[this._index];
         this.secondaryId = this.secondary[this._index];
-        if (this.secondaryId > 1) {
-            this.id = this.secondaryId;
-        }
-        else {
-            this.secondaryId = 0;
-        }
-        this._loadedId = this.getId();
-        this._tags = VoxelTagsRegister.VoxelTags[this._loadedId];
-        this._substanceTags =
-            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this._tags["dve_substance"])];
+        this._voxelId = this.getVoxelId();
+        this.tags = VoxelTagsRegister.VoxelTags[this._voxelId];
+        this.substanceTags =
+            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this.tags["dve_substance"])];
+        this.schema = SchemaRegister.getVoxelSchemas(this.getStringId());
     }
     setSecondary(enable) {
-        this.__secondary = enable;
-        VoxelTagIds;
-        VoxelTagsRegister;
-        this._loadedId = this.getId();
+        this.__readingSecondaryVoxel = enable;
         return this;
     }
     getRenderedMaterial() {
-        return this._tags[VoxelTagIds.renderedMaterial];
+        return this.tags[VoxelTagIds.renderedMaterial];
     }
     getMaterial() {
-        return this._tags[VoxelTagIds.voxelMaterial];
+        return this.tags[VoxelTagIds.voxelMaterial];
     }
     checkCollisions() {
-        return this._tags[VoxelTagIds.checkCollisions];
+        return this.tags[VoxelTagIds.checkCollisions];
     }
     getCollider() {
-        return this._tags[VoxelTagIds.colliderID];
+        return this.tags[VoxelTagIds.colliderID];
     }
     getSubstance() {
-        return this._tags[VoxelTagIds.substance];
+        return this.tags[VoxelTagIds.substance];
     }
     getSubstanceData() {
-        return this._substanceTags;
+        return this.substanceTags;
     }
     isOpaque() {
-        return !this._tags[VoxelTagIds.isTransparent];
-    }
-    getMod() {
-        return this.mod[this._index];
-    }
-    setMod(mod) {
-        this.mod[this._index] = mod;
-        return this;
+        return !this.tags[VoxelTagIds.isTransparent];
     }
     getLevel() {
         return VoxelLevelReader.getLevel(this.level[this._index]);
@@ -77,18 +64,11 @@ export class VoxelCursorInterface {
         this.level[this._index] = VoxelLevelReader.setLevelState(this.level[this._index], state);
         return this;
     }
-    getState() {
-        return this.state[this._index];
-    }
-    setState(state) {
-        this.state[this._index] = state;
-        return this;
-    }
     hasSecondaryVoxel() {
         return this.secondaryId > 1;
     }
     canHaveSecondaryVoxel() {
-        return this._tags[VoxelTagIds.canHaveSecondary];
+        return this.tags[VoxelTagIds.canHaveSecondary];
     }
     hasRGBLight() {
         const light = this.getLight();
@@ -103,16 +83,16 @@ export class VoxelCursorInterface {
         return this._lightData.hasSunLight(light);
     }
     getLight() {
-        if (this._loadedId == 0)
+        if (this._voxelId == 0)
             return this.light[this._index];
         if (this.isOpaque()) {
             if (this.isLightSource()) {
-                return this._tags[VoxelTagIds.lightValue];
+                return this.tags[VoxelTagIds.lightValue];
             }
             return -1;
         }
         if (this.isLightSource()) {
-            return this._lightData.mixLight(this.light[this._index], this._tags[VoxelTagIds.lightValue]);
+            return this._lightData.mixLight(this.light[this._index], this.tags[VoxelTagIds.lightValue]);
         }
         return this.light[this._index];
     }
@@ -121,21 +101,63 @@ export class VoxelCursorInterface {
         return this;
     }
     isLightSource() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return false;
-        return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isLightSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isLightSource, this.getState()) === true
-            : this._tags[VoxelTagIds.isLightSource];
+        if (VoxelLogicRegister.voxels[this._voxelId]?.hasTag(VoxelTagIds.isLightSource)) {
+            return VoxelLogicRegister.voxels[this._voxelId].getTagValue(VoxelTagIds.isLightSource, this);
+        }
+        return this.tags[VoxelTagIds.isLightSource];
+    }
+    doesVoxelAffectLogic() {
+        if (this.tags["dve_can_be_powered"] ||
+            this.tags["dve_can_hold_power"] ||
+            this.tags["dve_can_carry_power"] ||
+            this.tags["dve_is_power_source"])
+            return true;
+        return false;
     }
     getLightSourceValue() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return 0;
-        return this._tags[VoxelTagIds.lightValue];
+        return this.tags[VoxelTagIds.lightValue];
+    }
+    getPower() {
+        if (this._voxelId == 0)
+            return -1;
+        if (this.substanceTags["dve_is_liquid"])
+            return -1;
+        if (!this.tags["dve_can_carry_power"] &&
+            !this.tags["dve_can_hold_power"] &&
+            !this.tags["dve_can_be_powered"] &&
+            !this.tags["dve_is_power_source"])
+            return -1;
+        const level = VoxelLevelReader.getLevel(this.level[this._index]);
+        if (this.tags["dve_is_power_source"] &&
+            this.tags["dve_power_value"] > level)
+            return this.tags["dve_power_value"];
+        return level;
+    }
+    setPower(level) {
+        this.level[this._index] = VoxelLevelReader.setLevel(this.level[this._index], level);
+        return this;
+    }
+    isPowerSource() {
+        if (this._voxelId <= 0)
+            return false;
+        if (VoxelLogicRegister.voxels[this._voxelId]?.hasTag(VoxelTagIds.isPowerSource)) {
+            return VoxelLogicRegister.voxels[this._voxelId].getTagValue(VoxelTagIds.isPowerSource, this);
+        }
+        return this.tags[VoxelTagIds.isPowerSource];
+    }
+    getPowerSourceValue() {
+        if (this._voxelId <= 0)
+            return 0;
+        return this.tags[VoxelTagIds.powerValue];
     }
     noAO() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return false;
-        return this._tags[VoxelTagIds.noAO];
+        return this.tags[VoxelTagIds.noAO];
     }
     isRenderable() {
         if (this.id > 0)
@@ -148,57 +170,78 @@ export class VoxelCursorInterface {
         return 0 == this.ids[this._index];
     }
     setAir() {
-        this.ids[0] = 0;
+        this.ids[this._index] = 0;
         return this;
     }
     getId() {
-        if (this.__secondary) {
+        if (this.__readingSecondaryVoxel) {
             return this.secondaryId;
         }
         return this.id;
     }
     setId(id) {
-        if (this.__secondary) {
+        if (this.__readingSecondaryVoxel) {
             this.secondary[this._index] = id;
             return this;
         }
         this.ids[this._index] = id;
         return this;
     }
-    setStringId(id) {
-        return this.setId(VoxelPalettesRegister.voxels.getNumberId(id));
+    getVoxelId() {
+        return this.getIndexData()[0];
+    }
+    setVoxelId(id, state = 0, mod = 0) {
+        return this.setId(VoxelPalettesRegister.getVoxelId(id, state, mod));
+    }
+    setStringId(id, state = 0, mod = 0) {
+        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(id), state, mod);
     }
     getStringId() {
-        if (this.__secondary) {
-            return VoxelPalettesRegister.voxels.getStringId(this.secondaryId);
-        }
-        return VoxelPalettesRegister.voxels.getStringId(this.id);
+        return VoxelPalettesRegister.voxelIds.getStringId(this.getIndexData()[0]);
     }
-    setName(name) {
-        return this.setStringId(VoxelPalettesRegister.voxelNametoIdMap.get(name));
+    setName(name, state = 0, mod = 0) {
+        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(VoxelPalettesRegister.voxelNametoIdMap.get(name)), state, mod);
     }
     getName() {
         return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
     }
+    getIndexData() {
+        if (this.__readingSecondaryVoxel) {
+            return VoxelPalettesRegister.voxels[this.secondary[this._index]];
+        }
+        return VoxelPalettesRegister.voxels[this.ids[this._index]];
+    }
+    getMod() {
+        return VoxelPalettesRegister.voxels[this.ids[this._index]][2];
+    }
+    setMod(mod) {
+        const index = VoxelPalettesRegister.voxels[this.ids[this._index]];
+        this.setId(VoxelPalettesRegister.getVoxelId(index[0], index[1], mod));
+        return this;
+    }
+    getState() {
+        return this.getIndexData()[1];
+    }
+    setState(state) {
+        const index = this.getIndexData();
+        this.setId(VoxelPalettesRegister.getVoxelId(index[0], state, index[2]));
+        return this;
+    }
     isSameVoxel(voxel) {
-        return this.getId() == voxel.getId();
+        return this.getIndexData()[0] == voxel.getIndexData()[0];
     }
     copy(cursor) {
         this.ids[this._index] = cursor.ids[cursor._index];
         this.light[this._index] = cursor.light[cursor._index];
         this.level[this._index] = cursor.level[cursor._index];
-        this.state[this._index] = cursor.state[cursor._index];
-        this.mod[this._index] = cursor.mod[cursor._index];
         this.secondary[this._index] = cursor.secondary[cursor._index];
         return this;
     }
-    copyRaw(raw) {
+    setRaw(raw) {
         this.ids[this._index] = raw[0];
         this.light[this._index] = raw[1];
         this.level[this._index] = raw[2];
-        this.state[this._index] = raw[3];
-        this.secondary[this._index] = raw[4];
-        this.mod[this._index] = raw[5];
+        this.secondary[this._index] = raw[3];
         return this;
     }
     getRaw() {
@@ -206,8 +249,6 @@ export class VoxelCursorInterface {
             this.ids[this._index],
             this.light[this._index],
             this.level[this._index],
-            this.state[this._index],
-            this.mod[this._index],
             this.secondary[this._index],
         ];
     }
@@ -215,9 +256,7 @@ export class VoxelCursorInterface {
         raw[0] = this.ids[this._index];
         raw[1] = this.light[this._index];
         raw[2] = this.level[this._index];
-        raw[3] = this.state[this._index];
-        raw[4] = this.mod[this._index];
-        raw[5] = this.secondary[this._index];
+        raw[3] = this.secondary[this._index];
         return raw;
     }
 }

package/Voxels/Cursor/VoxelCursor.js

@@ -3,25 +3,35 @@ import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelLevelReader } from "./VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
-        const id = (data.id !== undefined &&
-            VoxelPalettesRegister.voxels.getNumberId(data.id)) ||
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        const id = (stringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
             0;
-        const secondaryId = (data.secondaryVoxelId !== undefined &&
-            VoxelPalettesRegister.voxels.getNumberId(data.secondaryVoxelId)) ||
+        const secondaryId = (secondaryStringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, data.state || 0, data.mod || 0)) ||
             0;
         let levleData = 0;
         if (data.level !== undefined)
             levleData = VoxelLevelReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
             levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
-        return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
+        return [id, light, levleData, secondaryId];
+    }
+    ids = [];
+    light = [];
+    level = [];
+    secondary = [];
+    loadIn() {
+        this.process();
     }
-    ids = new Uint16Array(1);
-    light = new Uint16Array(1);
-    level = new Uint8Array(1);
-    state = new Uint16Array(1);
-    mod = new Uint16Array(1);
-    secondary = new Uint16Array(1);
-    loadIn() { }
     updateVoxel(mode) { }
 }

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -4,6 +4,8 @@ type AllLight = [s: number, r: number, g: number, b: number];
  * Used to decode light color info.
  */
 export declare class VoxelLightData {
+    /**The rate at which sun light falls off. RGB light falls off at a default of 1 and sun has a default of 2. */
+    static SunFallOffValue: number;
     _lightValues: AllLight;
     sumRGB(value: number): number;
     getS(value: number): number;

package/Voxels/Cursor/VoxelLightData.js

@@ -3,7 +3,9 @@
  * Used to decode light color info.
  */
 export class VoxelLightData {
-    _lightValues = new Uint16Array([0, 0, 0, 0]);
+    /**The rate at which sun light falls off. RGB light falls off at a default of 1 and sun has a default of 2. */
+    static SunFallOffValue = 2;
+    _lightValues = [0, 0, 0, 0];
     sumRGB(value) {
         return this.getR(value) + this.getG(value) + this.getB(value);
     }

package/Voxels/Data/VoxelPalettesRegister.d.ts

@@ -1,8 +1,18 @@
+import { NumberPalette } from "../../Util/NumberPalette";
 import { StringPalette } from "../../Util/StringPalette";
 export declare class VoxelPalettesRegister {
     static material: StringPalette;
     static substance: StringPalette;
-    static voxels: StringPalette;
+    static voxelIds: StringPalette;
     static voxelNametoIdMap: Map<string, string>;
     static voxelIdToNameMap: Map<string, string>;
+    static state: NumberPalette;
+    static mod: NumberPalette;
+    static getVoxelId(id: number, state?: number, mod?: number): number;
+    static getVoxelIdFromString(id: string, state?: number, mod?: number): number;
+    static getVoxelIdFromName(name: string, state?: number, mod?: number): number;
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels: [voxelId: number, state: number, mod: number][];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord: number[][][];
 }

package/Voxels/Data/VoxelPalettesRegister.js

@@ -1,8 +1,24 @@
+import { NumberPalette } from "../../Util/NumberPalette";
 import { StringPalette } from "../../Util/StringPalette";
 export class VoxelPalettesRegister {
     static material = new StringPalette();
     static substance = new StringPalette();
-    static voxels = new StringPalette();
+    static voxelIds = new StringPalette();
     static voxelNametoIdMap = new Map();
     static voxelIdToNameMap = new Map();
+    static state = new NumberPalette();
+    static mod = new NumberPalette();
+    static getVoxelId(id, state = 0, mod = 0) {
+        return this.voxelRecord[id][mod][state];
+    }
+    static getVoxelIdFromString(id, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(id)][mod][state];
+    }
+    static getVoxelIdFromName(name, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(this.voxelNametoIdMap.get(name))][mod][state];
+    }
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels = [];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord = [];
 }

package/Voxels/Data/VoxelPropertiesRegister.d.ts

@@ -0,0 +1,4 @@
+import { VoxelProperties } from "../Types/Voxel.types";
+export declare class VoxelPropertiesRegister {
+    static VoxelProperties: VoxelProperties[];
+}

package/Voxels/Data/VoxelPropertiesRegister.js

@@ -0,0 +1,3 @@
+export class VoxelPropertiesRegister {
+    static VoxelProperties = [];
+}

package/Voxels/Data/VoxelTag.types.d.ts

@@ -3,15 +3,25 @@ export declare enum VoxelTagIds {
     renderedMaterial = "dve_rendered_material",
     voxelMaterial = "dve_voxel_material",
     hardness = "dve_hardness",
+    modelId = "dve_model_id",
     colliderID = "dve_collider_id",
     checkCollisions = "dve_check_collisions",
     isLightSource = "dve_is_light_source",
+    lightValue = "dve_light_value",
     noAO = "dve_no_ao",
     isTransparent = "dve_is_transparent",
-    lightValue = "dve_light_value",
-    canHaveSecondary = "dve_can_have_secondary"
+    canHaveSecondary = "dve_can_have_secondary",
+    canBePowered = "dve_can_be_powered",
+    canCarryPower = "dve_can_carry_power",
+    canHoldPower = "dve_can_hold_power",
+    isPowerSource = "dve_is_power_source",
+    powerValue = "dve_power_value",
+    fullBlock = "dve_full_block",
+    simulationBehavior = "dve_simulation_behavior"
 }
 export interface VoxelTags {
+    [VoxelTagIds.simulationBehavior]: string;
+    [VoxelTagIds.fullBlock]: boolean;
     /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
     [VoxelTagIds.renderedMaterial]: string;
     /** A description of the material used for the voxel. Not used by the engine directly. */
@@ -29,6 +39,7 @@ export interface VoxelTags {
     [VoxelTagIds.noAO]: boolean;
     /** Defines the light value emitted by the voxel (r, g, z). */
     [VoxelTagIds.lightValue]: [r: number, g: number, z: number] | number;
+    [VoxelTagIds.modelId]: string;
     /** The collider ID for the voxel, used for collision detection. */
     [VoxelTagIds.colliderID]: string;
     /** Specifies if the voxel participates in collision checks. */
@@ -37,6 +48,16 @@ export interface VoxelTags {
     [VoxelTagIds.canHaveSecondary]: boolean;
     /** The hardness level of the voxel, affecting how it is broken or interacted with. */
     [VoxelTagIds.hardness]: number;
+    /** Whether or not the voxel can be powered */
+    [VoxelTagIds.canBePowered]: boolean;
+    /** Whether or not the voxel can carry power */
+    [VoxelTagIds.canCarryPower]: boolean;
+    /** Whether or not the voxel can hold power. */
+    [VoxelTagIds.canHoldPower]: boolean;
+    /** Whether or not the voxel is a power source*/
+    [VoxelTagIds.isPowerSource]: boolean;
+    /** If the voxel is a power source this is its value */
+    [VoxelTagIds.powerValue]: number;
 }
 export declare enum VoxelSubstanceTagIdds {
     parent = "dve_parent_substance",

package/Voxels/Data/VoxelTag.types.js

@@ -4,13 +4,21 @@ export var VoxelTagIds;
     VoxelTagIds["renderedMaterial"] = "dve_rendered_material";
     VoxelTagIds["voxelMaterial"] = "dve_voxel_material";
     VoxelTagIds["hardness"] = "dve_hardness";
+    VoxelTagIds["modelId"] = "dve_model_id";
     VoxelTagIds["colliderID"] = "dve_collider_id";
     VoxelTagIds["checkCollisions"] = "dve_check_collisions";
     VoxelTagIds["isLightSource"] = "dve_is_light_source";
+    VoxelTagIds["lightValue"] = "dve_light_value";
     VoxelTagIds["noAO"] = "dve_no_ao";
     VoxelTagIds["isTransparent"] = "dve_is_transparent";
-    VoxelTagIds["lightValue"] = "dve_light_value";
     VoxelTagIds["canHaveSecondary"] = "dve_can_have_secondary";
+    VoxelTagIds["canBePowered"] = "dve_can_be_powered";
+    VoxelTagIds["canCarryPower"] = "dve_can_carry_power";
+    VoxelTagIds["canHoldPower"] = "dve_can_hold_power";
+    VoxelTagIds["isPowerSource"] = "dve_is_power_source";
+    VoxelTagIds["powerValue"] = "dve_power_value";
+    VoxelTagIds["fullBlock"] = "dve_full_block";
+    VoxelTagIds["simulationBehavior"] = "dve_simulation_behavior";
 })(VoxelTagIds || (VoxelTagIds = {}));
 export var VoxelSubstanceTagIdds;
 (function (VoxelSubstanceTagIdds) {

package/Voxels/Data/VoxelTagsRegister.js

@@ -12,6 +12,13 @@ export class VoxelTagsRegister {
         VoxelTagIds.noAO,
         VoxelTagIds.isTransparent,
         VoxelTagIds.canHaveSecondary,
+        VoxelTagIds.isPowerSource,
+        VoxelTagIds.canBePowered,
+        VoxelTagIds.canCarryPower,
+        VoxelTagIds.canHoldPower,
+        VoxelTagIds.powerValue,
+        VoxelTagIds.fullBlock,
+        VoxelTagIds.simulationBehavior,
     ];
     static IncludedSubstnacesTags = [
         VoxelSubstanceTagIds.parent,
@@ -25,6 +32,7 @@ export class VoxelTagsRegister {
         [VoxelTagIds.renderedMaterial]: "dve_solid",
         [VoxelTagIds.substance]: "dve_solid",
         [VoxelTagIds.colliderID]: "dve_cube",
+        [VoxelTagIds.simulationBehavior]: "dve_default",
     };
     static VoxelTags = [];
     static SubstanceStagDefaults = {};

package/Voxels/Functions/BuildPaletteData.d.ts

@@ -0,0 +1,6 @@
+import { FinalCompiledVoxelModelData } from "../Models/CompiledVoxelModel.types";
+type BuildPaletteDataProps = {
+    models: FinalCompiledVoxelModelData;
+};
+export declare function BuildPaletteData(props: BuildPaletteDataProps): void;
+export {};