@divinevoxel/vlox 0.0.2 → 0.0.3

package/Data/Cursor/World/ChunkCursor.js

@@ -0,0 +1,59 @@
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+export class ChunkCursor extends DataCursorInterface {
+    _chunk;
+    voxel = new WorldVoxelCursor(this);
+    _voxelIndex = 0;
+    _voxelPosition = Vector3Like.Create();
+    _chunkPosition = Vector3Like.Create();
+    inBounds(x, y, z) {
+        const maxX = this._chunkPosition.x + WorldSpaces.chunk._bounds.x;
+        const maxY = this._chunkPosition.y + WorldSpaces.chunk._bounds.y;
+        const maxZ = this._chunkPosition.z + WorldSpaces.chunk._bounds.z;
+        if (x < this._chunkPosition.x)
+            return false;
+        if (y < this._chunkPosition.y)
+            return false;
+        if (z < this._chunkPosition.z)
+            return false;
+        if (x > maxX)
+            return false;
+        if (y > maxY)
+            return false;
+        if (z > maxZ)
+            return false;
+        return true;
+    }
+    setChunk(chunkOrDimension, x, y, z) {
+        if (typeof chunkOrDimension == "object") {
+            this._chunk = chunkOrDimension;
+            const chunkPos = this._chunk.getPosition();
+            this._chunkPosition.x = chunkPos[0];
+            this._chunkPosition.y = chunkPos[1];
+            this._chunkPosition.z = chunkPos[2];
+            return;
+        }
+        WorldRegister.instance.setDimension(chunkOrDimension);
+        const chunk = WorldRegister.instance.chunk.get(x || 0, y || 0, z || 0);
+        if (!chunk)
+            return false;
+        this._chunk = chunk;
+        const chunkPos = this._chunk.getPosition();
+        this._chunkPosition.x = chunkPos[0];
+        this._chunkPosition.y = chunkPos[1];
+        this._chunkPosition.z = chunkPos[2];
+        return true;
+    }
+    getVoxel(x, y, z) {
+        if (!this._chunk)
+            return null;
+        const voxelIndex = WorldSpaces.voxel.getIndexXYZ(x, y, z);
+        Vector3Like.Copy(this._voxelPosition, WorldSpaces.voxel.getPositionXYZ(x, y, z));
+        this._voxelIndex = voxelIndex;
+        this.voxel.loadIn();
+        return this.voxel;
+    }
+}

package/Data/Cursor/World/ColumnCursor.d.ts

@@ -0,0 +1,16 @@
+import { Chunk, Column } from "../../World/Classes";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+export declare class ColumnCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+    _current: Column | null;
+    _chunk: Chunk | null;
+    private voxel;
+    _voxelIndex: number;
+    _voxelPosition: Vector3Like;
+    _columnPosition: Vector3Like;
+    inBounds(x: number, y: number, z: number): boolean;
+    setColumn(dimension: string, x: number, y: number, z: number): boolean;
+    getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
+}

package/Data/Cursor/World/ColumnCursor.js

@@ -0,0 +1,57 @@
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+export class ColumnCursor extends DataCursorInterface {
+    _current = null;
+    _chunk;
+    voxel = new WorldVoxelCursor(this);
+    _voxelIndex = 0;
+    _voxelPosition = Vector3Like.Create();
+    _columnPosition = Vector3Like.Create();
+    inBounds(x, y, z) {
+        const maxX = this._columnPosition.x + WorldSpaces.column._bounds.x;
+        const maxY = this._columnPosition.y + WorldSpaces.column._bounds.y;
+        const maxZ = this._columnPosition.z + WorldSpaces.column._bounds.z;
+        if (x < this._columnPosition.x)
+            return false;
+        if (y < this._columnPosition.y)
+            return false;
+        if (z < this._columnPosition.z)
+            return false;
+        if (x > maxX)
+            return false;
+        if (y > maxY)
+            return false;
+        if (z > maxZ)
+            return false;
+        return true;
+    }
+    setColumn(dimension, x, y, z) {
+        WorldRegister.instance.setDimension(dimension);
+        const column = WorldRegister.instance.column.get(x, y, z);
+        if (!column)
+            return false;
+        this._current = column;
+        this._columnPosition.x = column.location[1];
+        this._columnPosition.y = column.location[2];
+        this._columnPosition.z = column.location[3];
+        return true;
+    }
+    getVoxel(x, y, z) {
+        if (!this._current)
+            return null;
+        const chunk = this._current.chunks[WorldSpaces.chunk.getIndexXYZ(x, y, z)];
+        if (!chunk) {
+            this._chunk = null;
+            return null;
+        }
+        const voxelIndex = WorldSpaces.voxel.getIndexXYZ(x, y, z);
+        Vector3Like.Copy(this._voxelPosition, WorldSpaces.voxel.getPositionXYZ(x, y, z));
+        this._chunk = chunk;
+        this._voxelIndex = voxelIndex;
+        this.voxel.loadIn();
+        return this.voxel;
+    }
+}

package/Data/Cursor/World/WorldCursor.d.ts

@@ -0,0 +1,12 @@
+import { Vector3Like } from "@amodx/math";
+import { ColumnCursor } from "./ColumnCursor";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+export declare class WorldCursor extends DataCursorInterface {
+    columnCursors: Map<number, Map<number, ColumnCursor>>;
+    origin: Vector3Like;
+    dimension: string;
+    setFocalPoint(dimension: string, x: number, y: number, z: number): void;
+    inBounds(x: number, y: number, z: number): boolean;
+    getColumn(x: number, y: number, z: number): ColumnCursor | null;
+    getVoxel(x: number, y: number, z: number): import("./WorldVoxelCursor").WorldVoxelCursor | null;
+}

package/Data/Cursor/World/WorldCursor.js

@@ -0,0 +1,50 @@
+import { ColumnCursor } from "./ColumnCursor";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { WorldBounds } from "../../../Data/World/WorldBounds";
+let cursorCache = [];
+export class WorldCursor extends DataCursorInterface {
+    columnCursors = new Map();
+    origin = { x: 0, y: 0, z: 0 };
+    dimension = "";
+    setFocalPoint(dimension, x, y, z) {
+        const columnPos = WorldSpaces.column.getPositionXYZ(x, y, z);
+        for (const [cx, row] of this.columnCursors) {
+            for (const [cz, col] of row) {
+                cursorCache.push(col);
+            }
+        }
+        this.columnCursors.clear();
+        this.dimension = dimension;
+        this.origin.x = columnPos.x / WorldSpaces.column._bounds.x;
+        this.origin.y = columnPos.y / WorldSpaces.column._bounds.y;
+        this.origin.z = columnPos.z / WorldSpaces.column._bounds.z;
+    }
+    inBounds(x, y, z) {
+        return WorldBounds.inBounds(x, y, z);
+    }
+    getColumn(x, y, z) {
+        const columnPos = WorldSpaces.column.getPositionXYZ(x, y, z);
+        const cx = columnPos.x / WorldSpaces.column._bounds.x - this.origin.x;
+        const cz = columnPos.z / WorldSpaces.column._bounds.z - this.origin.z;
+        let row = this.columnCursors.get(cx);
+        let cursor = row?.get(cz);
+        if (!cursor) {
+            cursor = cursorCache.length ? cursorCache.shift() : new ColumnCursor();
+            if (!cursor.setColumn(this.dimension, columnPos.x, columnPos.y, columnPos.z))
+                return null;
+            if (!row) {
+                row = new Map();
+                this.columnCursors.set(cx, row);
+            }
+            row.set(cz, cursor);
+        }
+        return cursor;
+    }
+    getVoxel(x, y, z) {
+        const section = this.getColumn(x, y, z);
+        if (!section)
+            return null;
+        return section.getVoxel(x, y, z);
+    }
+}

package/Data/Cursor/World/WorldSectionCursor.interface.d.ts

@@ -0,0 +1,7 @@
+import { Vector3Like } from "@amodx/math";
+import { Chunk } from "../../World/Classes";
+export interface WorldSectionCursorInterface {
+    _chunk: Chunk | null;
+    _voxelIndex: number;
+    _voxelPosition: Vector3Like;
+}

package/Data/Cursor/World/WorldVoxelCursor.d.ts

@@ -0,0 +1,22 @@
+import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+export declare class WorldVoxelCursor extends VoxelCursorInterface {
+    dataCursor: WorldSectionCursorInterface;
+    private _chunk;
+    get ids(): Uint16Array;
+    get light(): Uint16Array;
+    get state(): Uint16Array;
+    get secondary(): Uint16Array;
+    get mod(): Uint16Array;
+    constructor(dataCursor: WorldSectionCursorInterface);
+    loadIn(): void;
+    /**
+     *
+     * @param mode 0 for add 1 for remove
+     * @param x
+     * @param y
+     * @param z
+     * @returns
+     */
+    updateHeightMap(mode: 0 | 1): boolean;
+}

package/Data/Cursor/World/WorldVoxelCursor.js

@@ -0,0 +1,55 @@
+import { Chunk } from "../../World/Classes";
+import { ChunkStructProperties } from "../../Structs/Constants/ChunkStructProperties";
+import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+export class WorldVoxelCursor extends VoxelCursorInterface {
+    dataCursor;
+    _chunk;
+    get ids() {
+        return this._chunk.ids;
+    }
+    get light() {
+        return this._chunk.light;
+    }
+    get state() {
+        return this._chunk.state;
+    }
+    get secondary() {
+        return this._chunk.secondary;
+    }
+    get mod() {
+        return this._chunk.mod;
+    }
+    constructor(dataCursor) {
+        super();
+        this.dataCursor = dataCursor;
+    }
+    loadIn() {
+        if (!this.dataCursor._chunk)
+            return;
+        this._chunk = this.dataCursor._chunk;
+        this._index = this.dataCursor._voxelIndex;
+        this.process();
+    }
+    /**
+     *
+     * @param mode 0 for add 1 for remove
+     * @param x
+     * @param y
+     * @param z
+     * @returns
+     */
+    updateHeightMap(mode) {
+        Chunk.StateStruct.setBuffer(this._chunk.chunkState);
+        const voxelPos = this.dataCursor._voxelPosition;
+        if (mode == 0) {
+            Chunk.StateStruct.setArrayPropertyValue(ChunkStructProperties.heightMap, voxelPos.y, 1);
+            return true;
+        }
+        if (mode == 1) {
+            Chunk.StateStruct.setArrayPropertyValue(ChunkStructProperties.dirtyMap, voxelPos.y, 1);
+            Chunk.StateStruct.setArrayPropertyValue(ChunkStructProperties.heightMap, voxelPos.y, 0);
+            return true;
+        }
+        return false;
+    }
+}

package/Data/Palettes/MaterialPalette.d.ts

@@ -0,0 +1,9 @@
+import { StringPalette } from "../../Util/StringPalette";
+export declare class MaterialPalette {
+    static palette: StringPalette;
+    static setPalette(palette: string[]): void;
+    static id: {
+        stringFromNumber: (id: number) => string;
+        numberFromString: (id: string) => number;
+    };
+}

package/Data/Palettes/MaterialPalette.js

@@ -0,0 +1,11 @@
+import { StringPalette } from "../../Util/StringPalette";
+export class MaterialPalette {
+    static palette;
+    static setPalette(palette) {
+        this.palette = new StringPalette(palette);
+    }
+    static id = {
+        stringFromNumber: (id) => this.palette.getStringId(id),
+        numberFromString: (id) => this.palette.getNumberId(id),
+    };
+}

package/Data/Palettes/SubstancePalette.d.ts

@@ -0,0 +1,9 @@
+import { StringPalette } from "../../Util/StringPalette";
+export declare class SubstancePalette {
+    static palette: StringPalette;
+    static setPalette(palette: string[]): void;
+    static id: {
+        stringFromNumber: (id: number) => string;
+        numberFromString: (id: string) => number;
+    };
+}

package/Data/Palettes/SubstancePalette.js

@@ -0,0 +1,11 @@
+import { StringPalette } from "../../Util/StringPalette";
+export class SubstancePalette {
+    static palette;
+    static setPalette(palette) {
+        this.palette = new StringPalette(palette);
+    }
+    static id = {
+        stringFromNumber: (id) => this.palette.getStringId(id),
+        numberFromString: (id) => this.palette.getNumberId(id),
+    };
+}

package/Data/Palettes/VoxelPalette.d.ts

@@ -0,0 +1,11 @@
+import { StringPalette } from "../../Util/StringPalette";
+export declare class VoxelPalette {
+    static _nameToIdMap: Map<string, string>;
+    static _idToNameMap: Map<string, string>;
+    static ids: StringPalette;
+    static loadIn(voxelPalette: string[], nameToIdMap: Record<string, string>, idToNameMap: Record<string, string>): void;
+    static name: {
+        getId: (name: string) => string;
+        getName: (id: string) => string;
+    };
+}

package/Data/Palettes/VoxelPalette.js

@@ -0,0 +1,15 @@
+import { StringPalette } from "../../Util/StringPalette";
+export class VoxelPalette {
+    static _nameToIdMap = new Map();
+    static _idToNameMap = new Map();
+    static ids;
+    static loadIn(voxelPalette, nameToIdMap, idToNameMap) {
+        this.ids = new StringPalette(voxelPalette);
+        this._nameToIdMap = new Map(Object.entries(nameToIdMap));
+        this._idToNameMap = new Map(Object.entries(idToNameMap));
+    }
+    static name = {
+        getId: (name) => this._nameToIdMap.get(name),
+        getName: (id) => this._idToNameMap.get(id),
+    };
+}

package/Data/Register/MappedDataRegister.js

@@ -4,5 +4,6 @@ export class MappedDataRegister {
     static objectMaps = new MappedRegisterBase();
 }
 MappedDataRegister.stringMaps.addSegment("voxel");
+MappedDataRegister.objectMaps.addSegment("voxel");
 MappedDataRegister.stringMaps.addSegment("substance");
 MappedDataRegister.objectMaps.addSegment("substance");

package/{Contexts/World/Data/Classes → Data/Structs/Builder}/StructBuilder.d.ts

@@ -1,6 +1,7 @@
-import type { TagBuilderNodes } from "Types/StructBuilder.types.js";
+import type { TagBuilderNodes } from "Data/Types/StructBuilder.types.js";
 import { BinaryStructData, BinraryStructBase } from "@amodx/binary/";
 import { BinaryStruct } from "@amodx/binary/";
+import { DataSyncMapsData } from "../../../Contexts/Base/Remote/Sync/DataSync.types";
 export declare class StructBuilder {
     id: string;
     dataSegment: string;
@@ -27,5 +28,5 @@ export declare class StructBuilder {
     hasNode(id: string): boolean;
     setNode(id: string, value: any, tagManager: BinraryStructBase): false | undefined;
     build(totalTagIndexes?: number): BinaryStruct;
-    sync(): void;
+    getMaps(): DataSyncMapsData;
 }

package/{Contexts/World/Data/Classes → Data/Structs/Builder}/StructBuilder.js

@@ -1,7 +1,5 @@
 import { BinaryNumberTypes, } from "@amodx/binary/";
 import { BinaryStruct } from "@amodx/binary/";
-import { MappedDataRegister } from "../../../../Data/Register/MappedDataRegister.js";
-import { DivineVoxelEngineWorld } from "../../DivineVoxelEngineWorld.js";
 export class StructBuilder {
     id;
     dataSegment;
@@ -142,32 +140,18 @@ export class StructBuilder {
         });
         return tags;
     }
-    sync() {
-        for (const [key, map] of this._stringMaps) {
-            const data = [this.dataSegment, key, map.map];
-            if (map.allowedComms.includes("world")) {
-                MappedDataRegister.stringMaps.sync(data[0], data[1], data[2]);
-            }
-            DivineVoxelEngineWorld.instance.dataSync.loopThroughComms((comm) => {
-                if (comm.name == "world")
-                    return;
-                if (map.allowedComms.includes(comm.name)) {
-                    DivineVoxelEngineWorld.instance.dataSync.maps.strings.syncInThread(comm.name, data);
-                }
-            });
+    getMaps() {
+        const objectMaps = {};
+        const stringMaps = {};
+        for (const [key, value] of this._stringMaps) {
+            stringMaps[key] = value.map;
         }
-        for (const [key, map] of this._objectMaps) {
-            const data = [this.dataSegment, key, map.map];
-            if (map.allowedComms.includes("world")) {
-                MappedDataRegister.objectMaps.sync(data[0], data[1], data[2]);
-            }
-            DivineVoxelEngineWorld.instance.dataSync.loopThroughComms((comm) => {
-                if (comm.name == "world")
-                    return;
-                if (map.allowedComms.includes(comm.name)) {
-                    DivineVoxelEngineWorld.instance.dataSync.maps.objects.syncInThread(comm.name, data);
-                }
-            });
+        for (const [key, value] of this._objectMaps) {
+            objectMaps[key] = value.map;
         }
+        return {
+            objectMaps,
+            stringMaps,
+        };
     }
 }

package/Data/Structs/Builder/SubstanceStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "./StructBuilder.js";
+export declare const SubstanceStructBuilder: StructBuilder;

package/Data/Structs/Builder/SubstanceStructBuilder.js

@@ -0,0 +1,42 @@
+import { BinaryNumberTypes } from "@amodx/binary";
+import { SubstanceStructIds } from "../../../Voxels/VoxelSubstances.types";
+import { StructBuilder } from "./StructBuilder.js";
+export const SubstanceStructBuilder = new StructBuilder("substance-tag-manager", "substance");
+SubstanceStructBuilder.addNode([
+    {
+        id: SubstanceStructIds.parent,
+        type: "string-map",
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
+    },
+    /*   {
+        id: SubstanceStructIds.culledSubstnaces,
+        type: "object-map",
+        allowedComms: ["constructor"],
+      }, */
+    {
+        id: SubstanceStructIds.isTransparent,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceStructIds.isSolid,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceStructIds.isLiquid,
+        type: "boolean",
+        default: false,
+    },
+    {
+        id: SubstanceStructIds.flowRate,
+        type: "number",
+        numberType: BinaryNumberTypes.Float32,
+        default: 1,
+    },
+    {
+        id: SubstanceStructIds.isWindAffected,
+        type: "boolean",
+        default: false,
+    },
+]);

package/Data/Structs/Builder/VoxelStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "./StructBuilder.js";
+export declare const VoxelStructBuilder: StructBuilder;

package/{Contexts/World/Data/StructBuilders → Data/Structs/Builder}/VoxelStructBuilder.js

@@ -1,66 +1,71 @@
 import { BinaryNumberTypes } from "@amodx/binary";
-import { VoxelTagIDs } from "../../../../Data/Constants/VoxelTagIds.js";
-import { StructBuilder } from "../Classes/StructBuilder.js";
-export const VoxelTagBuilder = new StructBuilder("voxel-tag-manager", "voxel");
-VoxelTagBuilder.addNode([
+import { VoxelStructIds } from "../../../Voxels/Voxel.types";
+import { StructBuilder } from "./StructBuilder.js";
+export const VoxelStructBuilder = new StructBuilder("voxel-tag-manager", "voxel");
+VoxelStructBuilder.addNode([
     {
-        id: VoxelTagIDs.substance,
+        id: VoxelStructIds.substance,
         type: "string-map",
         allowedComms: ["constructor", "nexus", "fx", "world", "render"],
     },
     {
-        id: VoxelTagIDs.shapeID,
+        id: VoxelStructIds.shapeID,
         type: "string-map",
         allowedComms: ["constructor"],
     },
     {
-        id: VoxelTagIDs.colliderID,
+        id: VoxelStructIds.colliderID,
         type: "string-map",
         allowedComms: ["nexus"],
     },
     {
-        id: VoxelTagIDs.checkCollisions,
+        id: VoxelStructIds.checkCollisions,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.material,
+        id: VoxelStructIds.renderedMaterial,
         type: "string-map",
-        allowedComms: ["nexus"],
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
+    },
+    {
+        id: VoxelStructIds.voxelMaterial,
+        type: "string-map",
+        allowedComms: ["constructor", "nexus", "fx", "world", "render"],
     },
     {
-        id: VoxelTagIDs.isLightSource,
+        id: VoxelStructIds.isLightSource,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.noAO,
+        id: VoxelStructIds.noAO,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.lightValue,
+        id: VoxelStructIds.lightValue,
         type: "number",
         numberType: BinaryNumberTypes.Uint16,
         default: 0,
     },
     {
-        id: VoxelTagIDs.isRich,
+        id: VoxelStructIds.isRich,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.isTransparent,
+        id: VoxelStructIds.isTransparent,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.canHaveSecondary,
+        id: VoxelStructIds.canHaveSecondary,
         type: "boolean",
         default: false,
     },
     {
-        id: VoxelTagIDs.hardness,
+        id: VoxelStructIds.hardness,
         type: "number",
         numberType: BinaryNumberTypes.Uint32,
         default: 0,

package/Data/Structs/ChunkStruct.d.ts

@@ -0,0 +1 @@
+export declare function InitalizeChunkTags(): void;

package/{Contexts/World/Data → Data}/Structs/ChunkStruct.js

@@ -1,8 +1,8 @@
 import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
-import { ChunkStructProperties } from "../../../../Data/Constants/Structs/ChunkStructProperties.js";
-import { Chunk } from "../../../../Data/World/Classes/Chunk.js";
-export const ChunkStatStruct = new BinaryStruct("chunk-tags");
+import { WorldSpaces } from "../World/WorldSpaces.js";
+import { ChunkStructProperties } from "../Structs/Constants/ChunkStructProperties.js";
+import { Chunk } from "../World/Classes/Chunk.js";
+const ChunkStatStruct = new BinaryStruct("chunk-tags");
 ChunkStatStruct.registerProperty({
     id: ChunkStructProperties.minHeight,
     type: "typed-number",

package/Data/Structs/ColumnStruct.d.ts

@@ -0,0 +1 @@
+export declare function InitalizeColumnTags(): void;

package/{Contexts/World/Data → Data}/Structs/ColumnStruct.js

@@ -1,40 +1,40 @@
 import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
-import { Column } from "../../../../Data/World/Classes/Column.js";
-export const ColumnStateStruct = new BinaryStruct("column-tags");
+import { Column } from "../World/Classes/Column.js";
+const ColumnStateStruct = new BinaryStruct("column-tags");
 ColumnStateStruct.registerProperty({
-    id: "#dve_last_save_timestamp",
+    id: "dve_last_save_timestamp",
     type: "typed-number",
     numberType: BinaryNumberTypes.Uint32,
 }, {
-    id: "#dve_last_analyzer_update_timestamp",
+    id: "dve_last_analyzer_update_timestamp",
     type: "typed-number",
     numberType: BinaryNumberTypes.Uint32,
 }, {
-    id: "#dve_has_rich_data",
+    id: "dve_has_rich_data",
     type: "boolean",
 }, {
-    id: "#dve_has_entity_data",
+    id: "dve_has_entity_data",
     type: "boolean",
 }, {
-    id: "#dve_is_stored",
+    id: "dve_is_stored",
     type: "boolean",
 }, {
-    id: "#dve_is_world_gen_done",
+    id: "dve_is_world_gen_done",
     type: "boolean",
 }, {
-    id: "#dve_is_world_decor_done",
+    id: "dve_is_world_decor_done",
     type: "boolean",
 }, {
-    id: "#dve_is_world_sun_done",
+    id: "dve_is_world_sun_done",
     type: "boolean",
 }, {
-    id: "#dve_is_world_propagation_done",
+    id: "dve_is_world_propagation_done",
     type: "boolean",
 }, {
-    id: "#dve_is_dirty",
+    id: "dve_is_dirty",
     type: "boolean",
 }, {
-    id: "#dve_persistent",
+    id: "dve_persistent",
     type: "boolean",
 });
 export function InitalizeColumnTags() {