@divinevoxel/vlox 0.0.1 → 0.0.3

package/Data/Structs/Constants/ChunkStructProperties.d.ts

@@ -0,0 +1,10 @@
+export declare enum ChunkStructProperties {
+    minHeight = "dve_min_height",
+    maxHeight = "dve_max_height",
+    heightMap = "dve_height_map",
+    dirtyMap = "dve_dirty_map",
+    voxelIDSegment = "dve_voxel_id",
+    voxelLightSegment = "dve_voxel_light",
+    voxelStateSegment = "dve_voxel_state",
+    voxelSecondaryIDSegment = "dve_voxel_secondary_id"
+}

package/Data/Structs/Constants/ChunkStructProperties.js

@@ -0,0 +1,11 @@
+export var ChunkStructProperties;
+(function (ChunkStructProperties) {
+    ChunkStructProperties["minHeight"] = "dve_min_height";
+    ChunkStructProperties["maxHeight"] = "dve_max_height";
+    ChunkStructProperties["heightMap"] = "dve_height_map";
+    ChunkStructProperties["dirtyMap"] = "dve_dirty_map";
+    ChunkStructProperties["voxelIDSegment"] = "dve_voxel_id";
+    ChunkStructProperties["voxelLightSegment"] = "dve_voxel_light";
+    ChunkStructProperties["voxelStateSegment"] = "dve_voxel_state";
+    ChunkStructProperties["voxelSecondaryIDSegment"] = "dve_voxel_secondary_id";
+})(ChunkStructProperties || (ChunkStructProperties = {}));

package/Data/Structs/Constants/SubstanceStructIds.js

@@ -0,0 +1 @@
+"use strict";

package/Data/Structs/Constants/WorldDataStructProperties.d.ts

@@ -0,0 +1,8 @@
+export declare enum WorldDataStructProperties {
+    header = "dve_header",
+    dataType = "dve_data_type",
+    dimensionId = "dve_dimension_id",
+    positionX = "dve_p_x",
+    positionY = "dve_p_y",
+    positionZ = "dve_p_z"
+}

package/Data/Structs/Constants/WorldDataStructProperties.js

@@ -0,0 +1,9 @@
+export var WorldDataStructProperties;
+(function (WorldDataStructProperties) {
+    WorldDataStructProperties["header"] = "dve_header";
+    WorldDataStructProperties["dataType"] = "dve_data_type";
+    WorldDataStructProperties["dimensionId"] = "dve_dimension_id";
+    WorldDataStructProperties["positionX"] = "dve_p_x";
+    WorldDataStructProperties["positionY"] = "dve_p_y";
+    WorldDataStructProperties["positionZ"] = "dve_p_z";
+})(WorldDataStructProperties || (WorldDataStructProperties = {}));

package/{Contexts/World/Data → Data}/Structs/RegionStruct.d.ts

@@ -1,4 +1,3 @@
 import { BinaryStruct } from "@amodx/binary/";
-export declare const RegionStateStruct: BinaryStruct;
 export declare const RegionHeaderTagManager: BinaryStruct;
 export declare function InitalizeRegionTags(): void;

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

@@ -1,11 +1,11 @@
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
+import { WorldSpaces } from "../World/WorldSpaces.js";
 import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
-import { WorldDataStructProperties } from "../../../../Data/Constants/Structs/WorldDataStructProperties.js";
-import { Region } from "../../../../Data/World/Classes/Region.js";
-import { RegionHeaderTags } from "../../../../Data/RegionHeaderRegister.js";
-export const RegionStateStruct = new BinaryStruct("region-tags");
+import { WorldDataStructProperties } from "../Structs/Constants/WorldDataStructProperties.js";
+import { Region } from "../World/Classes/Region.js";
+import { RegionHeaderTags } from "../World/RegionHeaderRegister.js";
+const RegionStateStruct = new BinaryStruct("region-tags");
 RegionStateStruct.registerProperty({
-    id: "#dve_total_players",
+    id: "dve_total_players",
     type: "typed-number",
     numberType: BinaryNumberTypes.Uint16,
 }, {
@@ -28,17 +28,17 @@ export function InitalizeRegionTags() {
     });
     Region.StateStruct.init(initData);
     RegionHeaderTagManager.registerProperty({
-        id: "#dved-column-sector-index",
+        id: "dved-column-sector-index",
         type: "typed-number-array",
         numberType: BinaryNumberTypes.Uint16,
         length: WorldSpaces.region.getColumnVolume(),
     }, {
-        id: "#dved-column-legnth-index",
+        id: "dved-column-legnth-index",
         type: "typed-number-array",
         numberType: BinaryNumberTypes.Uint16,
         length: WorldSpaces.region.getColumnVolume(),
     }, {
-        id: "#dved-column-save-timestamp",
+        id: "dved-column-save-timestamp",
         type: "typed-number-array",
         numberType: BinaryNumberTypes.Uint32,
         length: WorldSpaces.region.getColumnVolume(),

package/Data/Structs/SubstanceStruct.d.ts

@@ -0,0 +1,16 @@
+import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
+import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+export interface SubstanceStruct {
+    [SubstanceStructIds.parent]: number;
+    [SubstanceStructIds.isSolid]: number;
+    [SubstanceStructIds.isTransparent]: number;
+    [SubstanceStructIds.isLiquid]: number;
+    [SubstanceStructIds.flowRate]: number;
+    [SubstanceStructIds.isWindAffected]: number;
+}
+export declare class SubstanceStruct extends InstantiatedStruct<SubstanceStruct> {
+    static instance: SubstanceStruct;
+    static init(data: BinaryStructData): void;
+    static setSubstance(id: string | number): void;
+    static initData: BinaryStructData;
+}

package/Data/{Substance → Structs}/SubstanceStruct.js

@@ -1,6 +1,6 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { SubstanceTagIds } from "../../Data/Constants/SubstanceTagIds.js";
-import { SubstancePaletteReader } from "./SubstancePalette.js";
+import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstancePalette } from "../Palettes/SubstancePalette.js";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class SubstanceStruct extends InstantiatedStruct {
     static instance;
@@ -12,7 +12,7 @@ export class SubstanceStruct extends InstantiatedStruct {
     }
     static setSubstance(id) {
         this.instance.setIndex(typeof id == "string"
-            ? SubstancePaletteReader.id.numberFromString(id)
+            ? SubstancePalette.id.numberFromString(id)
             : id);
     }
     static initData;

package/Data/Structs/VoxelStruct.d.ts

@@ -0,0 +1,27 @@
+import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
+import { VoxelStructIds } from "../../Voxels/Voxel.types";
+export interface VoxelStruct {
+    [VoxelStructIds.substance]: number;
+    [VoxelStructIds.shapeID]: number;
+    [VoxelStructIds.renderedMaterial]: number;
+    [VoxelStructIds.voxelMaterial]: number;
+    [VoxelStructIds.hardness]: number;
+    [VoxelStructIds.colliderID]: number;
+    [VoxelStructIds.checkCollisions]: number;
+    [VoxelStructIds.isLightSource]: number;
+    [VoxelStructIds.noAO]: number;
+    [VoxelStructIds.lightValue]: number;
+    [VoxelStructIds.isRich]: number;
+    [VoxelStructIds.canHaveSecondary]: number;
+    [VoxelStructIds.isTransparent]: number;
+}
+export declare class VoxelStruct extends InstantiatedStruct<VoxelStruct> {
+    static instance: VoxelStruct;
+    static init(data: BinaryStructData): void;
+    static clone(): InstantiatedStruct<VoxelStruct> & VoxelStruct;
+    static sync(voxelMap: Uint16Array): void;
+    static setVoxel(id: number): void;
+    static setStringVoxel(id: string): void;
+    static voxelIndex: Uint16Array;
+    static initData: BinaryStructData;
+}

package/Data/{Voxel → Structs}/VoxelStruct.js

@@ -1,6 +1,6 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
-import { VoxelPalette } from "./VoxelPalette";
+import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class VoxelStruct extends InstantiatedStruct {
     static instance;

package/Data/Types/WorldData.types.d.ts

@@ -1,10 +1,10 @@
-export declare class AddVoxelData {
+export declare class PaintVoxelData {
     id: string;
     mod: number;
     shapeState: number;
     level: number;
     levelState: number;
     secondaryVoxelId: string;
-    static Create(data: Partial<AddVoxelData>): AddVoxelData;
+    static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
     private constructor();
 }

package/Data/Types/WorldData.types.js

@@ -1,4 +1,4 @@
-export class AddVoxelData {
+export class PaintVoxelData {
     id;
     mod;
     shapeState;
@@ -6,7 +6,7 @@ export class AddVoxelData {
     levelState;
     secondaryVoxelId;
     static Create(data) {
-        return new AddVoxelData(data.id, data.mod, data.shapeState, data.level, data.levelState, data.secondaryVoxelId);
+        return new PaintVoxelData(data.id, data.mod, data.shapeState, data.level, data.levelState, data.secondaryVoxelId);
     }
     constructor(id = "dve_air", mod = 0, shapeState = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air") {
         this.id = id;

package/Data/World/Classes/Chunk.d.ts

@@ -1,4 +1,6 @@
 import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Column } from "./Column.js";
+import { Vec3Array } from "@amodx/math";
 export interface VoxelDataArrays {
     ids: Uint16Array;
     light: Uint16Array;
@@ -7,15 +9,18 @@ export interface VoxelDataArrays {
     mod: Uint16Array;
 }
 export interface ChunkData extends VoxelDataArrays {
-    stateBuffer: ArrayBuffer;
+    buffer: ArrayBufferLike;
 }
 export interface Chunk extends ChunkData {
 }
 export declare class Chunk {
+    column: Column;
+    index: number;
     static CreateNew(): ChunkData;
-    static toObject(data: ChunkData): Chunk;
+    static toObject(column: Column, index: number, data: ChunkData): Chunk;
     static StateStruct: RemoteBinaryStruct;
     chunkState: DataView;
-    constructor(data: ChunkData);
+    constructor(column: Column, index: number, data: ChunkData);
+    getPosition(): Readonly<Vec3Array>;
     serialize(): ChunkData;
 }

package/Data/World/Classes/Chunk.js

@@ -1,22 +1,37 @@
 import { RemoteBinaryStruct } from "@amodx/binary/";
 import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+const position = [0, 0, 0];
 export class Chunk {
+    column;
+    index;
     static CreateNew() {
-        const stateBuffer = new SharedArrayBuffer(Chunk.StateStruct.structSize);
-        Chunk.StateStruct.setBuffer(stateBuffer);
         const voxelSize = WorldSpaces.chunk.getVolume();
-        const idsBuffers = new SharedArrayBuffer(voxelSize * 2);
-        const ids = new Uint16Array(idsBuffers);
-        const lightBuffers = new SharedArrayBuffer(voxelSize * 2);
-        const light = new Uint16Array(lightBuffers);
-        const stateBuffers = new SharedArrayBuffer(voxelSize * 2);
-        const state = new Uint16Array(stateBuffers);
-        const modBuffer = new SharedArrayBuffer(voxelSize * 2);
-        const mod = new Uint16Array(modBuffer);
-        const secondaryBuffers = new SharedArrayBuffer(voxelSize * 2);
-        const secondary = new Uint16Array(secondaryBuffers);
+        const chunkBuffer = new SharedArrayBuffer(Chunk.StateStruct.structSize +
+            //ids
+            voxelSize * 2 +
+            //light
+            voxelSize * 2 +
+            //state
+            voxelSize * 2 +
+            //mod
+            voxelSize * 2 +
+            //secondary
+            voxelSize * 2);
+        let bufferStart = 0;
+        Chunk.StateStruct.setBuffer(chunkBuffer);
+        bufferStart = Chunk.StateStruct.structSize;
+        const ids = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const light = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const state = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const mod = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const secondary = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
         return {
-            stateBuffer,
+            buffer: chunkBuffer,
             ids,
             light,
             state,
@@ -24,18 +39,32 @@ export class Chunk {
             mod,
         };
     }
-    static toObject(data) {
-        return new Chunk(data);
+    static toObject(column, index, data) {
+        return new Chunk(column, index, data);
     }
     static StateStruct = new RemoteBinaryStruct("chunk-tags");
     chunkState;
-    constructor(data) {
-        this.chunkState = new DataView(data.stateBuffer);
-        return Object.assign(this, data);
+    constructor(column, index, data) {
+        this.column = column;
+        this.index = index;
+        this.chunkState = new DataView(data.buffer);
+        this.buffer = data.buffer;
+        this.ids = data.ids;
+        this.light = data.light;
+        this.secondary = data.secondary;
+        this.state = data.state;
+        this.mod = data.mod;
+    }
+    getPosition() {
+        position[0] = this.column.location[1];
+        position[1] =
+            this.column.location[2] + this.index * WorldSpaces.chunk._bounds.y;
+        position[2] = this.column.location[3];
+        return position;
     }
     serialize() {
         return {
-            stateBuffer: this.stateBuffer,
+            buffer: this.buffer,
             ids: this.ids,
             light: this.light,
             secondary: this.secondary,

package/Data/World/Classes/Column.d.ts

@@ -1,17 +1,19 @@
 import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Chunk, ChunkData } from "./Chunk.js";
+import { LocationData } from "Math/index.js";
 export interface ColumnData {
-    stateBuffer: ArrayBuffer;
+    stateBuffer: ArrayBufferLike;
     chunks: ChunkData[];
 }
 export interface Column extends ColumnData {
 }
 export declare class Column {
+    location: LocationData;
     static StateStruct: RemoteBinaryStruct;
     static CreateNew(data: Partial<ColumnData>): ColumnData;
-    static toObject(data: ColumnData): Column;
+    static toObject(location: LocationData, data: ColumnData): Column;
     chunks: Chunk[];
     columnState: DataView;
-    constructor(data: ColumnData);
+    constructor(location: LocationData, data: ColumnData);
     toJSON(): ColumnData;
 }

package/Data/World/Classes/Column.js

@@ -1,26 +1,30 @@
 import { RemoteBinaryStruct } from "@amodx/binary/";
 import { Chunk } from "./Chunk.js";
 export class Column {
+    location;
     static StateStruct = new RemoteBinaryStruct("column-tags");
     static CreateNew(data) {
         const stateBuffer = new SharedArrayBuffer(Column.StateStruct.structSize);
         Column.StateStruct.setBuffer(stateBuffer);
-        Column.StateStruct.setProperty("#dve_is_stored", 0);
+        Column.StateStruct.setProperty("dve_is_stored", 0);
         return {
             stateBuffer,
             chunks: [],
             ...data,
         };
     }
-    static toObject(data) {
-        return new Column(data);
+    static toObject(location, data) {
+        return new Column(location, data);
     }
-    chunks;
+    chunks = [];
     columnState;
-    constructor(data) {
+    constructor(location, data) {
+        this.location = location;
         this.columnState = new DataView(data.stateBuffer);
         this.stateBuffer = data.stateBuffer;
-        this.chunks = data.chunks.map((_) => _ && new Chunk(_));
+        for (let i = 0; i < data.chunks.length; i++) {
+            this.chunks[i] = new Chunk(this, i, data.chunks[i]);
+        }
     }
     toJSON() {
         return {

package/Data/World/Classes/Region.js

@@ -1,5 +1,5 @@
 import { RemoteBinaryStruct } from "@amodx/binary/";
-import { WorldDataStructProperties } from "../../Constants/Structs/WorldDataStructProperties";
+import { WorldDataStructProperties } from "../../Structs/Constants/WorldDataStructProperties";
 import { WorldSpaces } from "../../../Data/World/WorldSpaces";
 export class Region {
     static CreateNew() {

package/Data/World/DimensionsRegister.js

@@ -1,4 +1,4 @@
-import { DataHooks } from "../DataHooks.js";
+import { DataHooks } from "../../Contexts/Base/DataHooks";
 import { WorldRegister } from "./WorldRegister.js";
 export class DimensionsRegister {
     static instance;

package/Data/{RegionHeaderRegister.d.ts → World/RegionHeaderRegister.d.ts}

@@ -1,4 +1,4 @@
-import type { LocationData } from "../Math";
+import type { LocationData } from "../../Math";
 import { RemoteBinaryStruct } from "@amodx/binary/";
 export declare const RegionHeaderTags: RemoteBinaryStruct;
 type RegionHeaderData = Map<string, Map<string, {

package/Data/{RegionHeaderRegister.js → World/RegionHeaderRegister.js}

@@ -1,6 +1,6 @@
 ;
 import { RemoteBinaryStruct } from "@amodx/binary/";
-import { WorldSpaces } from "../Data/World/WorldSpaces";
+import { WorldSpaces } from "./WorldSpaces";
 export const RegionHeaderTags = new RemoteBinaryStruct("region-header-tags");
 export const RegionHeaderRegister = {
     _headers: new Map(),
@@ -49,7 +49,7 @@ export const RegionHeaderRegister = {
             return -1;
         RegionHeaderTags.setBuffer(header.data);
         const columnIndex = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
-        return RegionHeaderTags.getArrayPropertyValue("#dved-column-save-timestamp", columnIndex) != 0
+        return RegionHeaderTags.getArrayPropertyValue("dved-column-save-timestamp", columnIndex) != 0
             ? 1
             : 0;
     },

package/Data/World/WorldBounds.d.ts

@@ -8,6 +8,7 @@ export declare class WorldBounds {
         MaxY: number;
     };
     static setWorldBounds(minX: number, maxX: number, minZ: number, maxZ: number, minY: number, maxY: number): void;
+    static inBounds(x: number, y: number, z: number): boolean;
     static getWorldWidth(): number;
     static getWorldDepth(): number;
     static getWorldHeightY(): number;

package/Data/World/WorldBounds.js

@@ -15,6 +15,21 @@ export class WorldBounds {
         this.bounds.MinY = minY;
         this.bounds.MaxY = maxY;
     }
+    static inBounds(x, y, z) {
+        if (x < this.bounds.MinX)
+            return false;
+        if (y < this.bounds.MinY)
+            return false;
+        if (z < this.bounds.MinZ)
+            return false;
+        if (x > this.bounds.MaxX)
+            return false;
+        if (y > this.bounds.MaxY)
+            return false;
+        if (z > this.bounds.MaxZ)
+            return false;
+        return true;
+    }
     static getWorldWidth() {
         return this.bounds.MaxX - this.bounds.MinX;
     }

package/Data/World/WorldPainter.d.ts

@@ -1,11 +1,12 @@
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { AddVoxelData } from "Data/Types/WorldData.types.js";
+import { PaintVoxelData } from "../../Data/Types/WorldData.types.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
 export declare class WorldPainter {
     static instance: WorldPainter;
     constructor();
-    dataTool: DataTool;
-    data: AddVoxelData;
-    dimenion: string;
+    dataCursor: WorldCursor;
+    substanceData: SubstanceDataTool;
+    data: PaintVoxelData;
     paintVoxel(x: number, y: number, z: number): false | undefined;
     eraseVoxel(x: number, y: number, z: number): void;
 }

package/Data/World/WorldPainter.js

@@ -1,7 +1,7 @@
-import { WorldRegister } from "./WorldRegister.js";
-import { DataHooks } from "../DataHooks.js";
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
+import { VoxelPalette } from "../Palettes/VoxelPalette.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+const air = [0, 0, 0, 0, 0];
 export class WorldPainter {
     static instance;
     constructor() {
@@ -9,63 +9,48 @@ export class WorldPainter {
             return WorldPainter.instance;
         WorldPainter.instance = this;
     }
-    dataTool = new DataTool();
+    dataCursor = new WorldCursor();
+    substanceData = new SubstanceDataTool();
     data;
-    dimenion = "main";
     paintVoxel(x, y, z) {
-        let chunk = WorldRegister.instance.chunk.get(x, y, z);
-        if (!chunk) {
-            let buffer = DataHooks.chunk.onGetSync.pipe({
-                location: [this.dimenion, x, y, z],
-                chunk: null,
-            });
-            if (!buffer.chunk)
-                return;
-            chunk = WorldRegister.instance.chunk.add(x, y, z, buffer.chunk);
-        }
-        if (!this.dataTool.setDimension(this.dimenion).setXYZ(x, y, z).loadIn())
+        const voxel = this.dataCursor.getVoxel(x, y, z);
+        if (!voxel)
             return;
         const id = VoxelPalette.ids.getNumberId(this.data.id);
         if (id < 0)
             return false;
-        this.dataTool.setId(id);
-        this.dataTool.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
-        if (this.dataTool.getSubstnaceData().isLiquid()) {
-            this.dataTool.setLevel(7);
+        voxel.setId(id);
+        voxel.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
+        this.substanceData.setSubstance(voxel.getSubstance());
+        if (this.substanceData.isLiquid()) {
+            voxel.setLevel(7);
         }
-        this.dataTool.setMod(this.data.mod);
+        voxel.setMod(this.data.mod);
         if (this.data.secondaryVoxelId &&
             this.data.secondaryVoxelId != "dve_air" &&
-            this.dataTool.canHaveSecondaryVoxel()) {
+            voxel.canHaveSecondaryVoxel()) {
             const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
             if (vid > 0) {
-                this.dataTool.setSecondary(true);
-                this.dataTool.setId(vid);
-                this.dataTool.setSecondary(false);
+                voxel.setSecondary(true);
+                voxel.setId(vid);
+                voxel.setSecondary(false);
             }
         }
-        if (this.dataTool.isLightSource() && this.dataTool.getLightSourceValue()) {
-            this.dataTool.setLight(this.dataTool.getLightSourceValue());
-        }
-        if (this.dataTool.isRich()) {
-            DataHooks.paint.onRichVoxelPaint.notify([
-                this.dataTool.getStringId(),
-                [this.dimenion, x, y, z],
-            ]);
+        if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+            voxel.setLight(voxel.getLightSourceValue());
         }
-        this.dataTool.commit(1);
+        /*    if (this.voxelCursor.isRich()) {
+          DataHooks.paint.onRichVoxelPaint.notify([
+            this.voxelCursor.getStringId(),
+            [this.dimenion, x, y, z],
+          ]);
+        } */
+        voxel.updateHeightMap(0);
     }
     eraseVoxel(x, y, z) {
-        this.dataTool.setDimension(this.dimenion);
-        if (!this.dataTool.loadInAt(x, y, z))
-            return;
-        if (!this.dataTool.isRenderable())
+        const voxel = this.dataCursor.getVoxel(x, y, z);
+        if (!voxel || !voxel.isRenderable())
             return;
-        this.dataTool.data.raw[0] = 0;
-        this.dataTool.data.raw[1] = 0;
-        this.dataTool.data.raw[2] = 0;
-        this.dataTool.data.raw[3] = 0;
-        this.dataTool.data.raw[4] = 0;
-        this.dataTool.commit(2);
+        voxel.copyRaw(air).updateHeightMap(1);
     }
 }

package/Data/World/WorldRegister.js

@@ -1,6 +1,5 @@
-import { DataHooks } from "../../Data/DataHooks.js";
+import { DataHooks } from "../../Contexts/Base/DataHooks";
 import { Chunk, Column, Dimension, Region, } from "./Classes/";
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { DimensionsRegister } from "./DimensionsRegister.js";
 import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
 import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
@@ -82,7 +81,7 @@ class WorldRegisterColumns {
                 z,
             ]);
         }
-        const newColumn = Column.toObject(column);
+        const newColumn = Column.toObject([this._register._currentDimension, x, y, z], column);
         region.columns.set(region.getColumnIndex(x, y, z), newColumn);
         return newColumn;
     }
@@ -118,18 +117,26 @@ class WorldRegisterColumns {
         return true;
     }
     fill(x, y, z) {
-        for (let cy = WorldBounds.bounds.MinY; cy < WorldBounds.bounds.MaxY; cy += WorldSpaces.chunk._bounds.y) {
-            let y = cy;
-            if (!this._register.chunk.get(x, y, z)) {
-                const newChunk = DataHooks.chunk.onGetSync.pipe({
-                    location: [this._register._currentDimension, x, y, z],
-                    chunk: null,
-                });
+        let column = this.get(x, y, z);
+        if (!column) {
+            column = this.add(x, y, z, Column.CreateNew({}));
+        }
+        const data = {
+            location: [this._register._currentDimension, x, y, z],
+            chunk: null,
+        };
+        const maxChunkIndex = WorldSpaces.column._bounds.y / WorldSpaces.chunk._bounds.y;
+        for (let i = 0; i < maxChunkIndex; i++) {
+            if (!column.chunks[i]) {
+                data.location[1] = y + i * WorldSpaces.chunk._bounds.y;
+                data.chunk = null;
+                const newChunk = DataHooks.chunk.onGetSync.pipe(data);
                 if (!newChunk.chunk)
                     continue;
-                this._register.chunk.add(x, y, z, newChunk.chunk);
+                column.chunks[i] = new Chunk(column, i, newChunk.chunk);
             }
         }
+        DataHooks.column.onNew.notify([this._register._currentDimension, x, y, z]);
     }
 }
 class WorldRegisterChunks {
@@ -156,8 +163,9 @@ class WorldRegisterChunks {
         }
         if (!column)
             return;
-        const newChunk = Chunk.toObject(chunk);
-        column.chunks[WorldSpaces.chunk.getIndexXYZ(x, y, z)] = newChunk;
+        const index = WorldSpaces.chunk.getIndexXYZ(x, y, z);
+        const newChunk = Chunk.toObject(column, index, chunk);
+        column.chunks[index] = newChunk;
         DataHooks.chunk.onNew.notify([this._register._currentDimension, x, y, z]);
         return newChunk;
     }