@divinevoxel/vlox 0.0.74 → 0.0.76

package/Templates/VoxelTemplate.js

@@ -1,135 +0,0 @@
-import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../Util/StringPalette";
-import { NumberPalette } from "../Util/NumberPalette";
-import { getPaletteArray } from "../Util/Binary/Palettes";
-import { VoxelPalettesRegister } from "../Voxels/Data/VoxelPalettesRegister";
-import { VoxelTagsRegister } from "../Voxels/Data/VoxelTagsRegister";
-export class VoxelTemplate {
-    index = Flat3DIndex.GetXZYOrder();
-    size;
-    ids;
-    level;
-    state;
-    mod;
-    secondary;
-    idPalette;
-    levelPalette;
-    statePalette;
-    modPalette;
-    secondaryIdPalette;
-    secondaryStatePalette;
-    constructor(data) {
-        this.size = [...data.size];
-        this.index.setBounds(...data.size);
-        this.idPalette = new StringPalette(data.palettes.id);
-        this.levelPalette = new NumberPalette(data.palettes.level);
-        this.statePalette = new NumberPalette(data.palettes.state);
-        this.modPalette = new NumberPalette(data.palettes.mod);
-        this.secondaryIdPalette = new StringPalette(data.palettes.secondaryId);
-        this.secondaryStatePalette = new NumberPalette(data.palettes.secondaryState);
-        typeof data.buffers.ids == "object"
-            ? (this.ids = getPaletteArray(data.palettes.id.length, data.buffers.ids))
-            : (this.ids = data.buffers.ids);
-        typeof data.buffers.level == "object"
-            ? (this.level = getPaletteArray(data.palettes.level.length, data.buffers.level))
-            : (this.level = data.buffers.level);
-        typeof data.buffers.state == "object"
-            ? (this.state = getPaletteArray(data.palettes.state.length, data.buffers.state))
-            : (this.state = data.buffers.state);
-        typeof data.buffers.mod == "object"
-            ? (this.mod = getPaletteArray(data.palettes.mod.length, data.buffers.mod))
-            : (this.mod = data.buffers.mod);
-        typeof data.buffers.secondary == "object"
-            ? (this.secondary = getPaletteArray(Math.max(data.palettes.secondaryState.length, data.palettes.secondaryId.length), data.buffers.secondary))
-            : (this.secondary = data.buffers.secondary);
-    }
-    getIndex(x, y, z) {
-        return this.index.getIndexXYZ(x, y, z);
-    }
-    getId(index) {
-        const ids = this.ids;
-        return VoxelPalettesRegister.voxels.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
-    }
-    getState(index) {
-        const state = this.state;
-        return this.statePalette.getValue(typeof state == "number" ? state : state[index]);
-    }
-    getLevel(index) {
-        const mod = this.mod;
-        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
-    }
-    getMod(index) {
-        const mod = this.mod;
-        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
-    }
-    getSecondary(id, index) {
-        const secondary = this.secondary;
-        if (VoxelTagsRegister.VoxelTags[id]["dve_can_have_secondary"]) {
-            return VoxelPalettesRegister.voxels.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
-        }
-        return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);
-    }
-    *traverse() {
-        const end = this.size;
-        const raw = [0, 0, 0, 0, 0, 0];
-        const curosr = {
-            position: [0, 0, 0],
-            raw,
-        };
-        for (const { x, y, z } of Traverse.FromToVec3([0, 0, 0], [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
-            const vindex = this.index.getIndexXYZ(x, y, z);
-            curosr.position[0] = x;
-            curosr.position[1] = y;
-            curosr.position[2] = z;
-            raw[0] = this.getId(vindex);
-            raw[1] = 0;
-            raw[2] = this.getLevel(vindex);
-            raw[3] = this.getState(vindex);
-            raw[4] = this.getMod(vindex);
-            raw[5] = this.getSecondary(raw[0], vindex);
-            if (raw[0] < 1 && raw[3] < 1)
-                continue;
-            yield curosr;
-        }
-    }
-    toJSON() {
-        return {
-            templatorVersion: 0,
-            version: 0,
-            size: this.size,
-            palettes: {
-                id: this.idPalette._palette,
-                level: Uint8Array.from(this.statePalette._palette),
-                state: Uint16Array.from(this.statePalette._palette),
-                mod: Uint16Array.from(this.modPalette._palette),
-                secondaryId: this.secondaryIdPalette._palette,
-                secondaryState: Uint16Array.from(this.secondaryStatePalette._palette),
-            },
-            buffers: {
-                ids: this.ids instanceof Uint16Array ||
-                    this.ids instanceof Uint8Array ||
-                    typeof this.ids == "number"
-                    ? this.ids
-                    : new Uint8Array(this.ids.buffer),
-                level: this.level instanceof Uint8Array || typeof this.level == "number"
-                    ? this.level
-                    : new Uint8Array(this.level.buffer),
-                mod: this.mod instanceof Uint16Array ||
-                    this.mod instanceof Uint8Array ||
-                    typeof this.mod == "number"
-                    ? this.mod
-                    : new Uint8Array(this.mod.buffer),
-                state: this.state instanceof Uint16Array ||
-                    this.state instanceof Uint8Array ||
-                    typeof this.state == "number"
-                    ? this.state
-                    : new Uint8Array(this.state.buffer),
-                secondary: this.secondary instanceof Uint16Array ||
-                    this.secondary instanceof Uint8Array ||
-                    typeof this.secondary == "number"
-                    ? this.secondary
-                    : new Uint8Array(this.secondary.buffer),
-            },
-        };
-    }
-}

package/Util/Binary/BinaryBuffer.d.ts

@@ -1,35 +0,0 @@
-export declare enum BinaryBufferTypes {
-    Value = 0,
-    BitArray = 1,
-    HalfNibbleArray = 2,
-    NibbleArray = 4,
-    ByteArray = 8,
-    ShortArray = 16
-}
-export interface BinaryBufferData {
-    type: BinaryBufferTypes;
-    buffer: number | ArrayBufferLike;
-}
-export interface BinaryBuffer extends BinaryBufferData {
-}
-export declare class BinaryBuffer {
-    static ByteArrayMax: number;
-    static NibbleArrayMax: number;
-    static HalfNibbleArrayMax: number;
-    static BitArrayMax: number;
-    static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
-    static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
-    static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
-    static GetIndexLength(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
-    static ReadBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number): number;
-    static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
-    static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
-    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
-    bufferView: Uint8Array | Uint16Array;
-    constructor(data: BinaryBufferData);
-    getValue(index: number): number;
-    toJSON(): {
-        buffer: number | ArrayBufferLike;
-        type: BinaryBufferTypes;
-    };
-}

package/Util/Binary/BinaryBuffer.js

@@ -1,136 +0,0 @@
-import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
-export var BinaryBufferTypes;
-(function (BinaryBufferTypes) {
-    BinaryBufferTypes[BinaryBufferTypes["Value"] = 0] = "Value";
-    BinaryBufferTypes[BinaryBufferTypes["BitArray"] = 1] = "BitArray";
-    BinaryBufferTypes[BinaryBufferTypes["HalfNibbleArray"] = 2] = "HalfNibbleArray";
-    BinaryBufferTypes[BinaryBufferTypes["NibbleArray"] = 4] = "NibbleArray";
-    BinaryBufferTypes[BinaryBufferTypes["ByteArray"] = 8] = "ByteArray";
-    BinaryBufferTypes[BinaryBufferTypes["ShortArray"] = 16] = "ShortArray";
-})(BinaryBufferTypes || (BinaryBufferTypes = {}));
-export class BinaryBuffer {
-    static ByteArrayMax = 256;
-    static NibbleArrayMax = 16;
-    static HalfNibbleArrayMax = 4;
-    static BitArrayMax = 2;
-    static DetermineSubByteArray = (paletteSize) => {
-        if (paletteSize == BinaryBuffer.BitArrayMax)
-            return BinaryBufferTypes.BitArray;
-        if (paletteSize > BinaryBuffer.BitArrayMax &&
-            paletteSize <= BinaryBuffer.HalfNibbleArrayMax)
-            return BinaryBufferTypes.HalfNibbleArray;
-        if (paletteSize > BinaryBuffer.HalfNibbleArrayMax &&
-            paletteSize <= BinaryBuffer.NibbleArrayMax)
-            return BinaryBufferTypes.NibbleArray;
-        if (paletteSize > BinaryBuffer.NibbleArrayMax &&
-            paletteSize <= BinaryBuffer.ByteArrayMax)
-            return BinaryBufferTypes.ByteArray;
-        return null;
-    };
-    static CreateBufferForType(type, length) {
-        if (type == BinaryBufferTypes.ShortArray)
-            return new Uint16Array(length);
-        return new Uint8Array(length);
-    }
-    static GetConvertedBufferSize(source, type) {
-        if (type == BinaryBufferTypes.ShortArray ||
-            type == BinaryBufferTypes.ByteArray)
-            return source.length;
-        if (type == BinaryBufferTypes.BitArray)
-            return source.length / 8;
-        if (type == BinaryBufferTypes.HalfNibbleArray)
-            return source.length / 4;
-        if (type == BinaryBufferTypes.NibbleArray)
-            return source.length / 2;
-        if (type == BinaryBufferTypes.Value)
-            return 1;
-        return source.length;
-    }
-    static GetIndexLength(source, type) {
-        if (type == BinaryBufferTypes.ShortArray ||
-            type == BinaryBufferTypes.ByteArray)
-            return source.length;
-        if (type == BinaryBufferTypes.BitArray)
-            return source.length * 8;
-        if (type == BinaryBufferTypes.HalfNibbleArray)
-            return source.length * 4;
-        if (type == BinaryBufferTypes.NibbleArray)
-            return source.length * 2;
-        if (type == BinaryBufferTypes.Value)
-            return 1;
-        return source.length;
-    }
-    static ReadBufferAtIndex(source, type, index) {
-        if (type == BinaryBufferTypes.ShortArray ||
-            type == BinaryBufferTypes.ByteArray)
-            return source[index];
-        if (type == BinaryBufferTypes.BitArray)
-            return getBitArrayIndex(source, index);
-        if (type == BinaryBufferTypes.NibbleArray)
-            return getNibbleArrayIndex(source, index);
-        if (type == BinaryBufferTypes.HalfNibbleArray)
-            return getHalfNibbleArrayIndex(source, index);
-        return source[index];
-    }
-    static SetBufferAtIndex(source, type, index, value) {
-        if (type == BinaryBufferTypes.ShortArray ||
-            type == BinaryBufferTypes.ByteArray) {
-            return (source[index] = value);
-        }
-        if (type == BinaryBufferTypes.BitArray)
-            return setBitArrayIndex(source, index, value);
-        if (type == BinaryBufferTypes.NibbleArray)
-            return setNibbleArrayIndex(source, index, value);
-        if (type == BinaryBufferTypes.HalfNibbleArray)
-            return setHalfNibbleArrayIndex(source, index, value);
-        return source[index];
-    }
-    static Convert(source, sourceType, destinationType) {
-        if (sourceType == destinationType ||
-            (sourceType == BinaryBufferTypes.ShortArray &&
-                destinationType == BinaryBufferTypes.ByteArray) ||
-            (sourceType == BinaryBufferTypes.ByteArray &&
-                destinationType == BinaryBufferTypes.ShortArray)) {
-            const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
-            destination.set(source);
-            return destination;
-        }
-        const length = this.GetIndexLength(source, sourceType);
-        const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
-        for (let i = 0; i < length; i++) {
-            this.SetBufferAtIndex(destination, destinationType, i, this.ReadBufferAtIndex(source, sourceType, i));
-        }
-        return destination;
-    }
-    static Create(data) {
-        return {
-            buffer: 0,
-            type: BinaryBufferTypes.Value,
-            ...data,
-        };
-    }
-    bufferView;
-    constructor(data) {
-        this.buffer = data.buffer;
-        this.type = data.type;
-        if (typeof this.buffer !== "number") {
-            if (this.type == BinaryBufferTypes.ShortArray) {
-                this.bufferView = new Uint16Array(this.buffer);
-            }
-            else {
-                this.bufferView = new Uint8Array(this.buffer);
-            }
-        }
-    }
-    getValue(index) {
-        if (typeof this.buffer == "number")
-            return this.buffer;
-        return BinaryBuffer.ReadBufferAtIndex(this.bufferView, this.type, index);
-    }
-    toJSON() {
-        return {
-            buffer: this.buffer,
-            type: this.type,
-        };
-    }
-}

package/Util/Binary/Palettes.d.ts

@@ -1,5 +0,0 @@
-import { BitArray } from "@amodx/binary/Arrays/BitArray";
-import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
-import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
-export declare const convertToPaletteBuffer: (paletteSize: number, data: any, sharedMemory?: boolean) => Uint16Array | Uint8Array;
-export declare const getPaletteArray: (size: number, buffer: ArrayBufferLike) => ArrayBuffer | NibbleArray | HalfNibbleArray | BitArray;

package/Util/Binary/Palettes.js

@@ -1,46 +0,0 @@
-import { BitArray } from "@amodx/binary/Arrays/BitArray";
-import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
-import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
-export const convertToPaletteBuffer = (paletteSize, data, sharedMemory = false) => {
-    let buffer = data;
-    if (paletteSize > 15 && paletteSize <= 255) {
-        buffer = Uint8Array.from(data);
-    }
-    else if (paletteSize > 4 && paletteSize <= 15) {
-        buffer = new Uint8Array(data.length / 2);
-        const nibbleArray = new NibbleArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            nibbleArray[i] = data[i];
-        }
-    }
-    else if (paletteSize > 2 && paletteSize <= 4) {
-        buffer = new Uint8Array(data.length / 4);
-        const halfNibbleArray = new HalfNibbleArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            halfNibbleArray[i] = data[i];
-        }
-    }
-    else if (paletteSize == 2) {
-        buffer = new Uint8Array(data.length / 8);
-        const bitArray = new BitArray(buffer);
-        for (let i = 0; i < data.length; i++) {
-            bitArray[i] = data[i];
-        }
-    }
-    if (sharedMemory && !(buffer.buffer instanceof SharedArrayBuffer)) {
-        const sharedBuffer = new SharedArrayBuffer(buffer.byteLength);
-        const sharedView = new Uint8Array(sharedBuffer);
-        sharedView.set(buffer);
-        return sharedView;
-    }
-    return buffer;
-};
-export const getPaletteArray = (size, buffer) => {
-    if (size == 2)
-        return new BitArray(buffer);
-    if (size > 2 && size <= 4)
-        return new HalfNibbleArray(buffer);
-    if (size > 4 && size <= 15)
-        return new NibbleArray(buffer);
-    return buffer;
-};

package/Util/LocationVisitedMap.d.ts

@@ -1,9 +0,0 @@
-import { LocationData } from "../Math/index.js";
-export declare class LocationVisitedMap {
-    _map: Map<string, boolean>;
-    get size(): number;
-    has(location: LocationData): boolean;
-    add(location: LocationData): void;
-    remove(location: LocationData): void;
-    clear(): void;
-}

package/Util/LocationVisitedMap.js

@@ -1,18 +0,0 @@
-export class LocationVisitedMap {
-    _map = new Map();
-    get size() {
-        return this._map.size;
-    }
-    has(location) {
-        return this._map.has(location.toString());
-    }
-    add(location) {
-        this._map.set(location.toString(), true);
-    }
-    remove(location) {
-        this._map.delete(location.toString());
-    }
-    clear() {
-        this._map.clear();
-    }
-}

package/Util/VisistedMap.d.ts

@@ -1,10 +0,0 @@
-export declare class VisitedMap {
-    _map: Map<string, boolean>;
-    get size(): number;
-    _getKey(x: number, y: number, z: number): string;
-    inMap(x: number, y: number, z: number): boolean;
-    add(x: number, y: number, z: number): void;
-    remove(x: number, y: number, z: number): void;
-    removeDiffernce(map: VisitedMap): VisitedMap;
-    clear(): void;
-}

package/Util/VisistedMap.js

@@ -1,29 +0,0 @@
-export class VisitedMap {
-    _map = new Map();
-    get size() {
-        return this._map.size;
-    }
-    _getKey(x, y, z) {
-        return `${x}_${y}_${z}`;
-    }
-    inMap(x, y, z) {
-        return this._map.has(this._getKey(x, y, z));
-    }
-    add(x, y, z) {
-        this._map.set(this._getKey(x, y, z), true);
-    }
-    remove(x, y, z) {
-        this._map.delete(this._getKey(x, y, z));
-    }
-    removeDiffernce(map) {
-        for (const [key] of map._map) {
-            if (this._map.has(key)) {
-                this._map.delete(key);
-            }
-        }
-        return map;
-    }
-    clear() {
-        this._map.clear();
-    }
-}

package/Voxels/Data/VoxelTagStates.d.ts

@@ -1,22 +0,0 @@
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-export type VoxelTagStatesData = Record<string, {
-    tree: any;
-    treePalette: any;
-}>[];
-export declare class VoxelTagStates {
-    static voxelTags: Record<string, {
-        tree: StateTreeReader;
-        treePalette: any[];
-    }>[];
-    static toJSON(): VoxelTagStatesData;
-    static load(data: VoxelTagStatesData): void;
-    static register(voxel: number, id: string, stateSchema: StateSchema, tree: any[], treePalette: any[]): void;
-    static isRegistered(voxel: number, id: string): boolean;
-    static getData(voxel: number, id: string): {
-        tree: StateTreeReader;
-        treePalette: any[];
-    };
-    static getState(voxel: number, id: string, state: number): number;
-    static getValue(voxel: number, id: string, state: number): any;
-}

package/Voxels/Data/VoxelTagStates.js

@@ -1,47 +0,0 @@
-import { VoxelPalettesRegister } from "./VoxelPalettesRegister";
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-import { SchemaRegister } from "../State/SchemaRegister";
-export class VoxelTagStates {
-    static voxelTags = [];
-    static toJSON() {
-        const data = [];
-        this.voxelTags.forEach((v, index) => {
-            data[index] = Object.fromEntries(Object.keys(v).map((k) => [
-                k,
-                { tree: v[k].tree.tree, treePalette: v[k].treePalette },
-            ]));
-        });
-        return data;
-    }
-    static load(data) {
-        data.forEach((v, index) => {
-            if (!v)
-                return;
-            const stateSceham = new StateSchema(SchemaRegister.modelStaeBaseSchemaData.get(SchemaRegister.voxelModelMap.get(VoxelPalettesRegister.voxels.getStringId(index))));
-            for (const tag in v) {
-                this.register(index, tag, stateSceham, v[tag].tree, v[tag].treePalette);
-            }
-        });
-    }
-    static register(voxel, id, stateSchema, tree, treePalette) {
-        let tags = this.voxelTags[voxel];
-        if (!tags) {
-            tags = {};
-            this.voxelTags[voxel] = tags;
-        }
-        tags[id] = { tree: new StateTreeReader(stateSchema, 0, tree), treePalette };
-    }
-    static isRegistered(voxel, id) {
-        return this.voxelTags[voxel] && this.voxelTags[voxel][id] !== undefined;
-    }
-    static getData(voxel, id) {
-        return this.voxelTags[voxel][id];
-    }
-    static getState(voxel, id, state) {
-        return this.voxelTags[voxel][id].tree.getState(state);
-    }
-    static getValue(voxel, id, state) {
-        return this.voxelTags[voxel][id].treePalette[this.voxelTags[voxel][id].tree.getState(state)];
-    }
-}

package/Voxels/Logic/Classes/Default/Types/VoxelPoweredLogicType.d.ts

@@ -1,5 +0,0 @@
-import { VoxelCursorInterface } from "../../../../../Voxels/Cursor/VoxelCursor.interface";
-import { VoxelLogicType } from "../../VoxelLogicType";
-export declare class VoxelPoweredLogicType extends VoxelLogicType {
-    run(voxel: VoxelCursorInterface): boolean;
-}

package/Voxels/Logic/Classes/Default/Types/VoxelPoweredLogicType.js

@@ -1,6 +0,0 @@
-import { VoxelLogicType } from "../../VoxelLogicType";
-export class VoxelPoweredLogicType extends VoxelLogicType {
-    run(voxel) {
-        return voxel.getPower() > 0;
-    }
-}