pw-js-world 0.4.0 → 0.4.1-dev.766d8c6

package/cm/Block.d.ts

@@ -0,0 +1,119 @@
+import type { BlockArg, Point, SendableBlockPacket } from "./types/index.js";
+import BufferReader, { ComponentTypeHeader } from "./BufferReader.js";
+import { LayerType } from "./Constants.js";
+import { type BlockKeys } from "pw-js-api";
+export default class Block {
+    bId: number;
+    args: BlockArg[];
+    constructor(bId: number | BlockKeys | string, args?: BlockArg[]);
+    /**
+     * I mean... Just use .args.length !== 0 to see if it has args.
+     *
+     * But anyway, this will return true if there is at least one args, otherwise false.
+     */
+    hasArgs(): boolean;
+    /**
+     * For helper.
+     *
+     * This is in Block class for organisation.
+     *
+     * This will deserialise by using the reader to get the block ID then retrieve the args, if applicable.
+     */
+    static deserialize(reader: BufferReader): Block;
+    protected deserializeArgs(reader: BufferReader, flag?: boolean): this;
+    /**
+     * For helper.
+     *
+     * This is in Block class for organisation.
+     */
+    static deserializeArgs(reader: BufferReader): BlockArg[];
+    /**
+     * Serializes the block into a buffer. This is used to convert
+     * the block into a binary format that can be sent over the game
+     * server. As this is static, block id and args are required.
+     *
+     * - Little Endian
+     * - With Id
+     * - Type Byte omitted
+     */
+    static serializeArgs(bId: number, args: BlockArg[]): Buffer;
+    /**
+     * Serializes the block into a buffer. This is used to convert
+     * the block into a binary format that can be sent over the game
+     * server. As this is static, block id and args are required.
+     *
+     * - Big Endian
+     * - No Id
+     * - Type Byte included
+     */
+    static serializeArgs(bId: number, args: BlockArg[], options: {
+        endian: "big";
+        writeId: false;
+        readTypeByte: true;
+    }): Buffer;
+    static serializeArgs(bId: number, args: BlockArg[], options: {
+        endian: "little";
+        writeId: false;
+        readTypeByte: true;
+    }): Buffer;
+    /**
+     *
+     * @param pos List of points (X and Y)
+     */
+    toPacket(pos: Point[], layer: LayerType): SendableBlockPacket;
+    toPacket(x: number, y: number, layer: LayerType): SendableBlockPacket;
+    /**
+     * This will return the block name in UPPER_CASE form.
+     *
+     * For eg EFFECTS_INVULNERABILITY.
+     *
+     * @throws {MissingBlockError}
+     * If the ID of this block is not known.
+     */
+    get name(): string;
+    /**
+     * Returns a copy of the block.
+     */
+    clone(obj?: false): Block;
+    clone(obj: true): {
+        bId: number;
+        args: BlockArg[];
+        name: string;
+    };
+    /**
+     * This can be convenient as it will always return the ID if it exists, and it will throw an error if it doesn't.
+     *
+     * This expects the name sent to be in full upper capital form though.
+     *
+     * @throws {MissingBlockError}
+     * If the connection is unknown, this can be because you're trying to use this function when Api#getListBlocks has never been invoked, or the object is missing.
+     */
+    static getIdByName(paletteId: string): number;
+    /**
+     * This will return the corresponding palette id by the ID of that block.
+     *
+     * The name sent will be in full upper capital if it exists.
+     *
+     * @throws {MissingBlockError}
+     * If the connection is unknown, this can be because you're trying to use this function when Api#getListBlocks has never been invoked, or the object is missing.
+     */
+    static getPaletteIdById(blockId: number): string;
+    /**
+     * Returns the arg types for that block by given block ID.
+     *
+     * If a block don't have args, it will return an empty array.
+     *
+     * If the block don't exist, it may throw an exception.
+     */
+    static getArgTypesByBlockId(blockId: number): ComponentTypeHeader[];
+    /**
+     * Returns the arg types for that block by given palette ID (full upper case).
+     *
+     * For eg "EMPTY" or "SIGN_GOLD"
+     *
+     * If a block don't have args, it will return an empty array.
+     *
+     * If the block don't exist, it may throw an exception.
+     */
+    static getArgTypesByPaletteId(paletteId: string): ComponentTypeHeader[];
+}

package/cm/Block.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const BufferReader_js_1 = tslib_1.__importDefault(require("./BufferReader.js"));
+const pw_js_api_1 = require("pw-js-api");
+const Error_js_1 = require("./util/Error.js");
+class Block {
+    constructor(bId, args) {
+        this.args = [];
+        if (typeof bId === "number")
+            this.bId = bId;
+        else {
+            this.bId = Block.getIdByName(bId);
+        }
+        if (args)
+            this.args = args;
+    }
+    /**
+     * I mean... Just use .args.length !== 0 to see if it has args.
+     *
+     * But anyway, this will return true if there is at least one args, otherwise false.
+     */
+    hasArgs() {
+        return this.args.length !== 0;
+    }
+    /**
+     * For helper.
+     *
+     * This is in Block class for organisation.
+     *
+     * This will deserialise by using the reader to get the block ID then retrieve the args, if applicable.
+     */
+    static deserialize(reader) {
+        return new Block(reader.readUInt32LE()).deserializeArgs(reader);
+    }
+    deserializeArgs(reader, flag = false) {
+        var _a;
+        const format = Block.getArgTypesByBlockId(this.bId); //(BlockArgsHeadings as any)[this.name];
+        for (let i = 0; i < ((_a = format === null || format === void 0 ? void 0 : format.length) !== null && _a !== void 0 ? _a : 0); i++) {
+            if (flag) {
+                reader.expectUInt8(format[i]);
+            }
+            this.args[i] = reader.read(format[i], !flag);
+        }
+        return this;
+    }
+    /**
+     * For helper.
+     *
+     * This is in Block class for organisation.
+     */
+    static deserializeArgs(reader) {
+        // const args = 
+        return reader.deserialize();
+        // for (let i = 0; i < (format?.length ?? 0); i++) {
+        //     if (flag) {
+        //         reader.expectUInt8(format[i]);
+        //     }
+        //     args[i] = reader.read(format[i], !flag);
+        // }
+        // return args;
+    }
+    static serializeArgs(bId, args, options) {
+        options || (options = {
+            endian: "little",
+            writeId: true,
+            readTypeByte: false,
+        });
+        const buffer = [];
+        if (options.writeId) {
+            const idBuffer = Buffer.alloc(4);
+            idBuffer.writeUInt32LE(bId);
+            buffer.push(idBuffer);
+        }
+        const blockData = Block.getArgTypesByBlockId(bId);
+        for (let i = 0, len = blockData.length; i < len; i++) {
+            const entry = BufferReader_js_1.default.Dynamic(blockData[i], args[i]);
+            buffer.push(entry);
+        }
+        return Buffer.concat(buffer);
+    }
+    toPacket(pos, y, layer) {
+        if (typeof pos === "number") {
+            pos = [{
+                    x: pos, y
+                }];
+            layer = layer !== null && layer !== void 0 ? layer : 0;
+        }
+        else
+            layer = y !== null && y !== void 0 ? y : 0;
+        return {
+            isFillOperation: false,
+            blockId: this.bId,
+            layer,
+            positions: pos,
+            extraFields: Block.serializeArgs(this.bId, this.args, { endian: "big", writeId: false, readTypeByte: true })
+        };
+    }
+    /**
+     * This will return the block name in UPPER_CASE form.
+     *
+     * For eg EFFECTS_INVULNERABILITY.
+     *
+     * @throws {MissingBlockError}
+     * If the ID of this block is not known.
+     */
+    get name() {
+        var _a;
+        const block = (_a = pw_js_api_1.PWApiClient.listBlocks) === null || _a === void 0 ? void 0 : _a[this.bId];
+        if (block === undefined)
+            throw new Error_js_1.MissingBlockError("Current block data is missing, run Api#listBlocks first?", this.bId);
+        return block.PaletteId.toUpperCase();
+    }
+    clone(obj = false) {
+        if (obj === true)
+            return { bId: this.bId, args: this.args, name: this.name };
+        return new Block(this.bId, this.args);
+    }
+    /**
+     * This can be convenient as it will always return the ID if it exists, and it will throw an error if it doesn't.
+     *
+     * This expects the name sent to be in full upper capital form though.
+     *
+     * @throws {MissingBlockError}
+     * If the connection is unknown, this can be because you're trying to use this function when Api#getListBlocks has never been invoked, or the object is missing.
+     */
+    static getIdByName(paletteId) {
+        var _a;
+        const block = (_a = pw_js_api_1.PWApiClient.listBlocksObj) === null || _a === void 0 ? void 0 : _a[paletteId];
+        if (block === undefined)
+            throw new Error_js_1.MissingBlockError("Current block data is missing, run Api#listBlocks first?", paletteId);
+        return block.Id;
+    }
+    /**
+     * This will return the corresponding palette id by the ID of that block.
+     *
+     * The name sent will be in full upper capital if it exists.
+     *
+     * @throws {MissingBlockError}
+     * If the connection is unknown, this can be because you're trying to use this function when Api#getListBlocks has never been invoked, or the object is missing.
+     */
+    static getPaletteIdById(blockId) {
+        var _a;
+        const block = (_a = pw_js_api_1.PWApiClient.listBlocks) === null || _a === void 0 ? void 0 : _a[blockId];
+        if (block === undefined)
+            throw new Error_js_1.MissingBlockError("Current block data is missing, run Api#listBlocks first?", blockId);
+        return block.PaletteId.toUpperCase();
+    }
+    /**
+     * Returns the arg types for that block by given block ID.
+     *
+     * If a block don't have args, it will return an empty array.
+     *
+     * If the block don't exist, it may throw an exception.
+     */
+    static getArgTypesByBlockId(blockId) {
+        var _a, _b;
+        return (_b = (_a = pw_js_api_1.PWApiClient.listBlocks) === null || _a === void 0 ? void 0 : _a[blockId].BlockDataArgs) !== null && _b !== void 0 ? _b : [];
+        // const block = PWApiClient.listBlocks?.[blockId];
+        // return block ? MissingBlockData[block?.PaletteId.toUpperCase()] ?? (block.BlockDataArgs) as ComponentTypeHeader[] ?? [] : [];
+    }
+    /**
+     * Returns the arg types for that block by given palette ID (full upper case).
+     *
+     * For eg "EMPTY" or "SIGN_GOLD"
+     *
+     * If a block don't have args, it will return an empty array.
+     *
+     * If the block don't exist, it may throw an exception.
+     */
+    static getArgTypesByPaletteId(paletteId) {
+        var _a, _b;
+        return (_b = (_a = pw_js_api_1.PWApiClient.listBlocksObj) === null || _a === void 0 ? void 0 : _a[paletteId].BlockDataArgs) !== null && _b !== void 0 ? _b : [];
+        //MissingBlockData[paletteId] ?? (PWApiClient.listBlocksObj?.[paletteId].BlockDataArgs) as ComponentTypeHeader[] ?? []
+    }
+}
+exports.default = Block;
+// Temporary fix as some blocks currently have incorrect args
+// const MissingBlockData = {
+//     SWITCH_LOCAL_ACTIVATOR: [ComponentTypeHeader.Int32, ComponentTypeHeader.Byte],
+//     SWITCH_GLOBAL_ACTIVATOR: [ComponentTypeHeader.Int32, ComponentTypeHeader.Byte],
+// } as Record<string, ComponentTypeHeader[]>;
+//# sourceMappingURL=data:application/json;base64,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

package/cm/BufferReader.d.ts

@@ -0,0 +1,330 @@
+/**
+ * CREDIT: Anatoly for making this Buffer Reader so I don't have to!
+ * Source: https://github.com/Anatoly03/pixelwalker.js/blob/9bb3c7e39a45006086a2abae8c515599bd3db835/src/util/buffer-reader.ts
+ * License: ISC
+ */
+/**
+ * Data during the communication in the process is dynamic
+ * typed. Every entry is followed by a byte identifying the
+ * type, followed by data. The type header is noted by its'
+ * 7-bit notation.
+ */
+export declare enum ComponentTypeHeader {
+    String = 0,
+    Byte = 1,
+    Int16 = 2,
+    Int32 = 3,
+    Int64 = 4,
+    Float = 5,
+    Double = 6,
+    Boolean = 7,
+    ByteArray = 8,
+    UInt32 = 9
+}
+/**
+ * A Buffer reader is a special buffer extension made to perform
+ * game-specific tasks in the field of communication.
+ *
+ * @implements Buffer
+ */
+export default class BufferReader {
+    private buffer;
+    private offset;
+    /**
+     *
+     */
+    private constructor();
+    /**
+     *
+     */
+    static from(from: Uint8Array | Buffer): BufferReader;
+    /**
+     *
+     */
+    static alloc(amount: number): BufferReader;
+    /**
+     * @param {string} value
+     * @returns {Buffer}
+     */
+    static String(value?: string): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Byte(value?: number): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Int16(value?: number): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Int32(value?: number): Buffer;
+    /**
+     * @param {bigint} value
+     * @returns {Buffer}
+     */
+    static Int64(value?: bigint): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Float(value?: number): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Double(value?: number): Buffer;
+    /**
+     * @param {boolean} value
+     * @returns {Buffer}
+     */
+    static Boolean(value?: boolean): Buffer;
+    /**
+     * @param {Uint8Array} buffer
+     * @returns {Buffer}
+     */
+    static ByteArray(buffer?: Buffer): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static UInt32(value?: number): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Magic(value: number): Buffer;
+    /**
+     * @param {number} value
+     * @returns {Buffer}
+     */
+    static Bit7(value?: number): Buffer;
+    /**
+     * @param tt
+     * @param value
+     */
+    static Dynamic(tt: ComponentTypeHeader, value: boolean | number | bigint | string | Buffer): Buffer;
+    /**
+     *
+     */
+    get length(): number;
+    /**
+     *
+     */
+    subarray(start?: number, end?: number): BufferReader;
+    /**
+     *
+     */
+    write(value: string): number;
+    /**
+     *
+     */
+    writeBigInt64BE(value: bigint): number;
+    /**
+     *
+     */
+    writeBigInt64LE(value: bigint): number;
+    /**
+     *
+     */
+    writeUInt8(value: number): number;
+    /**
+     *
+     */
+    writeUInt16LE(value: number): number;
+    /**
+     *
+     */
+    writeUInt16BE(value: number): number;
+    /**
+     *
+     */
+    writeUInt32LE(value: number): number;
+    /**
+     *
+     */
+    writeUInt32BE(value: number): number;
+    /**
+     *
+     */
+    writeInt8(value: number): number;
+    /**
+     *
+     */
+    writeInt16LE(value: number): number;
+    /**
+     *
+     */
+    writeInt16BE(value: number): number;
+    /**
+     *
+     */
+    writeInt32LE(value: number): number;
+    /**
+     *
+     */
+    writeInt32BE(value: number): number;
+    /**
+     *
+     */
+    writeFloatLE(value: number): number;
+    /**
+     *
+     */
+    writeFloatBE(value: number): number;
+    /**
+     *
+     */
+    writeDoubleLE(value: number): number;
+    /**
+     *
+     */
+    writeDoubleBE(value: number): number;
+    /**
+     *
+     */
+    readBigUInt64BE(): bigint;
+    /**
+     *
+     */
+    readBigUInt64LE(): bigint;
+    /**
+     *
+     */
+    readBigInt64BE(): bigint;
+    /**
+     *
+     */
+    readBigInt64LE(): bigint;
+    /**
+     *
+     */
+    expectUInt8(value: number): number;
+    /**
+     *
+     */
+    readUInt8(): number;
+    /**
+     *
+     */
+    readUInt16LE(): number;
+    /**
+     *
+     */
+    readUInt16BE(): number;
+    /**
+     *
+     */
+    readUInt32LE(): number;
+    /**
+     *
+     */
+    readUInt32BE(): number;
+    /**
+     *
+     */
+    readInt8(): number;
+    /**
+     *
+     */
+    readInt16LE(): number;
+    /**
+     *
+     */
+    readInt16BE(): number;
+    /**
+     *
+     */
+    readInt32LE(): number;
+    /**
+     *
+     */
+    readInt32BE(): number;
+    /**
+     *
+     */
+    readFloatLE(): number;
+    /**
+     *
+     */
+    readFloatBE(): number;
+    /**
+     *
+     */
+    readDoubleLE(): number;
+    /**
+     *
+     */
+    readDoubleBE(): number;
+    read(tt: ComponentTypeHeader, littleEndian?: boolean): string | number | bigint | boolean | Buffer;
+    read(tt: ComponentTypeHeader.String, littleEndian?: boolean): string;
+    read(tt: ComponentTypeHeader.Byte, littleEndian?: boolean): number;
+    read(tt: ComponentTypeHeader.Int16, littleEndian?: boolean): number;
+    read(tt: ComponentTypeHeader.Int32, littleEndian?: boolean): number;
+    read(tt: ComponentTypeHeader.Int64, littleEndian?: boolean): bigint;
+    read(tt: ComponentTypeHeader.Float, littleEndian?: boolean): number;
+    read(tt: ComponentTypeHeader.Double, littleEndian?: boolean): number;
+    read(tt: ComponentTypeHeader.Boolean, littleEndian?: boolean): boolean;
+    read(tt: ComponentTypeHeader.ByteArray, littleEndian?: boolean): Buffer;
+    /**
+     *
+     */
+    toBuffer(): Buffer;
+    /**
+     * https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer
+     */
+    toArrayBuffer(): ArrayBuffer;
+    /**
+     *
+     */
+    at(idx: number): number;
+    /**
+     * Advanced the buffer reader by pffset.
+     */
+    advanceOffset(relativeOffset?: number): this;
+    /**
+     * This function reads how many bytes a normal integer would take
+     * as a 7-bit number
+     *
+     * 1(000 0001) 0(111 1110)
+     */
+    static length7BitInt(value: number): number;
+    /**
+     * Reads in an integer in 7-bit notation. A 7-bit integer
+     * encoding splits a number into a variable size of bits,
+     * in which the first bit is set while bytes are following.
+     *
+     * @example
+     *
+     * ```
+     * 1111 0000 1010 1010 1000 0000 0000 0001 Reading In
+     * ^--- ---- ^--- ---- ^--- ---- ^--- ----
+     *  111 0000  010 1010  000 0000  000 0001 Writing Out
+     * ```
+     */
+    read7BitInt(): number;
+    /**
+     * Write a normal integer value into buffer at offset.
+     */
+    write7BitInt(value: number): void;
+    /**
+     * Reads a dynamic buffer which is prepended by its' length
+     * in 7-bit encoding.
+     */
+    readDynamicBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Append a buffer to the current buffer. Asserts the cursor
+     * to be at the end of the current buffer.
+     */
+    append(buffer: Buffer): this;
+    /**
+     * Keep Deserializing the buffer for typed data until
+     * you reach the end of the buffer. Typed data consists
+     * of a type indicator in 7-bit-encoding and data following
+     * accordingly.
+     */
+    deserialize(): (string | number | bigint | boolean | Buffer<ArrayBufferLike>)[];
+}