mca-json 1.0.0

package/src/bin/nbt-get-player-location.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import debug from 'debug';
+import getStdin from 'get-stdin';
+import neodoc from 'neodoc';
+import { inflate } from 'pako';
+import { Nbt } from '../nbt/nbt';
+import { readFile } from 'node:fs/promises';
+
+const debugLog = debug('mca-trim-chunks-without-signs');
+main();
+
+async function main() {
+const args: {
+    'NBT_FILE'?: string[];
+} = neodoc.run(
+`Usage: nbt-get-player-locations NBT_FILE...
+
+Scans a player NBT data file for the player location and prints it to stdout.
+NBT files can be compressed or uncompressed and this tool can handle both. If the filename is "-" or not provided, this will read from stdin.
+
+The output shows the following tab delimited fields:
+
+* Dimension: "minecraft:overworld", "minecraft:the_nether", or "minecraft:the_end"
+* X: The player's X coordinate, rounded
+* Y: The player's Y coordinate, rounded
+* Z: The player's Z coordinate, rounded
+* chunkX: The player's chunk X coordinate
+* chunkZ: The player's chunk Z coordinate
+
+Options:
+    -h, --help      Show this message.
+`,
+    {
+        argv: [...process.argv].slice(2),
+        laxPlacement: true,
+    }
+);
+
+    if (!args.NBT_FILE?.length) {
+        args.NBT_FILE = ['-'];
+    }
+
+    for (const file of args.NBT_FILE) {
+        try {
+            await processFile(file);
+        } catch (e) {
+            console.error(`Error processing file ${file}: ${e}`);
+
+            process.exit(1);
+        }
+    }
+}
+
+async function readInput(filename: string | undefined) {
+    if (!filename || filename === '-') {
+        debugLog(`Reading from stdin`);
+        return await getStdin.buffer();
+    }
+
+    debugLog(`Reading file: ${filename}`);
+
+    return readFile(filename);
+}
+
+async function processFile(filename: string) {
+    const inputBuffer = await readInput(filename);
+
+    if (inputBuffer.length === 0) {
+        if (filename === '-') {
+            console.error('Input (stdin) is empty.');
+        } else {
+            console.error(`Input file is empty: ${filename}`);
+        }
+        console.error('Aborting. Use --help for usage.');
+        process.exit(1);
+    }
+
+    let buffer = inputBuffer.buffer as ArrayBufferLike;
+
+    try {
+        buffer = inflate(inputBuffer).buffer;
+    } catch (_ignore) {}
+
+    const nbt = Nbt.fromBuffer(buffer);
+
+    const dimension = nbt.findChild('Dimension')?.data;
+    const x = nbt.findChild('Pos/0')?.data;
+    const y = nbt.findChild('Pos/1')?.data;
+    const z = nbt.findChild('Pos/2')?.data;
+
+    if (typeof dimension !== 'string' || typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number') {
+        console.error(`NBT file ${filename} does not contain valid player location data.`);
+        process.exit(1);
+    }
+
+    const chunkX = Math.floor(x / 16);
+    const chunkZ = Math.floor(z / 16);
+
+    const output = [dimension, Math.round(x), Math.round(y), Math.round(z), chunkX, chunkZ];
+    console.log(output.join('\t'));
+}

package/src/bin/nbt-json.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import getStdin from 'get-stdin';
+import neodoc from 'neodoc';
+import { inflate } from 'pako';
+import { Nbt } from '../nbt/nbt';
+import { readFile, writeFile } from 'node:fs/promises';
+
+async function readInput(filename: string | undefined) {
+    if (!filename || filename === '-') {
+        return await getStdin.buffer();
+    }
+
+    return readFile(filename);
+}
+
+const args: {
+    '--compact'?: boolean;
+    '--condense'?: boolean;
+    '<input>'?: string;
+    '<output>'?: string;
+} = neodoc.run(
+`Usage: nbt-json [OPTIONS] [<input> [<output>]]
+
+Shows NBT data in a JSON format. Both input and output are optional. If input
+is not provided, this reads from stdin. If output is not provided, this writes
+to stdout.
+
+NBT files can be compressed or uncompressed. This tool can handle both. One
+example NBT file is the player.dat file.
+
+Options:
+    --compact       Do not use pretty-printing in the JSON output.
+    --condense      Condense arrays of bytes, ints, and longs to a single line.
+                    This significantly cuts down on the size of the generated
+                    JSON.
+    -h, --help      Show this message.
+`,
+    {
+        argv: [...process.argv].slice(2),
+        laxPlacement: true,
+    }
+);
+
+readInput(args['<input>'])
+    .then((inputBuffer) => {
+        if (inputBuffer.length === 0) {
+            console.error('No input provided. Use --help for usage.');
+            process.exit(1);
+        }
+
+        let buffer = inputBuffer.buffer as ArrayBufferLike;
+
+        try {
+            buffer = inflate(inputBuffer).buffer;
+        } catch (_ignore) {}
+
+        const nbt = Nbt.fromBuffer(buffer);
+
+        let jsonObject = nbt.toObject();
+
+        if (args['--compact']) {
+            return JSON.stringify(jsonObject);
+        }
+
+        let content = JSON.stringify(jsonObject, null, 4);
+
+        if (args['--condense']) {
+            content = content.replace(
+                /: \[(\n\s*"?-?\d+"?,?)*\n\s*\]/g,
+                (match) => {
+                    return match.replace(/\n\s*/g, ' ');
+                }
+            );
+        }
+
+        return content;
+    })
+    .then((output: string) => {
+        if (args['<output>']) {
+            writeFile(args['<output>'], output);
+        } else {
+            console.log(output);
+        }
+    });

package/src/block/banner.ts

@@ -0,0 +1,50 @@
+import { HasEntityData } from './has-entity-data';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { NbtList } from '../nbt/nbt-list';
+import { NbtString } from '../nbt/nbt-string';
+
+export interface BannerPatternDefinition {
+    asset_id: string;
+    translation_key: string;
+}
+
+export interface BannerPattern {
+    color: string;
+    pattern: string | BannerPatternDefinition;
+}
+
+export class Banner extends HasEntityData {
+    patterns(): BannerPattern[] {
+        const patterns =
+            this.entityData.findChild<NbtList<NbtCompound>>('Patterns');
+
+        if (!patterns) {
+            throw new Error('Unable to find patterns in banner');
+        }
+
+        return patterns.data.map((compound) => {
+            const color = compound.findChild<NbtString>('Color');
+            const pattern = compound.findChild<NbtString | NbtCompound>(
+                'Pattern'
+            );
+
+            if (!color || !pattern) {
+                throw new Error('Color or pattern not found in banner pattern');
+            }
+
+            if (pattern instanceof NbtString) {
+                return { color: color.data, pattern: pattern.data };
+            }
+
+            return {
+                color: color.data,
+                pattern: {
+                    asset_id:
+                        pattern.findChild<NbtString>('Pattern')?.data ?? '',
+                    translation_key:
+                        pattern.findChild<NbtString>('Pattern')?.data ?? '',
+                },
+            };
+        });
+    }
+}

package/src/block/barrel.ts

@@ -0,0 +1,34 @@
+import { HasEntityData } from './has-entity-data';
+import { CustomName } from './mixins/custom-name';
+import { Lock } from './mixins/lock';
+import { Mixin } from './mixins/mixin';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { NbtList } from '../nbt/nbt-list';
+import { NbtLong } from '../nbt/nbt-long';
+import { NbtString } from '../nbt/nbt-string';
+
+export class Barrel extends Mixin(
+    HasEntityData,
+    CustomName,
+    Lock,
+    class extends HasEntityData {
+        items(): NbtList<NbtCompound> {
+            const items =
+                this.entityData.findChild<NbtList<NbtCompound>>('Items');
+
+            if (!items) {
+                throw new Error('Barrel is missing items tag');
+            }
+
+            return items;
+        }
+
+        lootTable(): string | undefined {
+            return this.entityData.findChild<NbtString>('LootTable')?.data;
+        }
+
+        lootTableSeed(): bigint | undefined {
+            return this.entityData.findChild<NbtLong>('LootTableSeed')?.data;
+        }
+    }
+) {}

package/src/block/beacon.ts

@@ -0,0 +1,20 @@
+import { CustomName } from './mixins/custom-name';
+import { HasEntityData } from './has-entity-data';
+import { Lock } from './mixins/lock';
+import { Mixin } from './mixins/mixin';
+import { NbtString } from '../nbt/nbt-string';
+
+export class Beacon extends Mixin(
+    HasEntityData,
+    CustomName,
+    Lock,
+    class extends HasEntityData {
+        primaryEffect(): string | undefined {
+            return this.entityData.findChild<NbtString>('LootTable')?.data;
+        }
+
+        secondaryEffect(): string | undefined {
+            return this.entityData.findChild<NbtString>('LootTableSeed')?.data;
+        }
+    }
+) {}

package/src/block/bed.ts

@@ -0,0 +1,3 @@
+import { HasEntityData } from './has-entity-data';
+
+export class Bed extends HasEntityData {}

package/src/block/beehive.ts

@@ -0,0 +1,17 @@
+import { Coords3d } from '../types/coords';
+import { HasEntityData } from './has-entity-data';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { NbtIntArray } from '../nbt/nbt-int-array';
+import { NbtList } from '../nbt/nbt-list';
+
+export class Beehive extends HasEntityData {
+    bees(): NbtList<NbtCompound> | undefined {
+        return this.entityData.findChild<NbtList<NbtCompound>>('bees');
+    }
+
+    flowerPos(): Coords3d | undefined {
+        return this.entityData.findChild<NbtIntArray>('flower_pos')?.data as
+            | Coords3d
+            | undefined;
+    }
+}

package/src/block/bell.ts

@@ -0,0 +1,3 @@
+import { HasEntityData } from './has-entity-data';
+
+export class Bell extends HasEntityData {}

package/src/block/block.ts

@@ -0,0 +1,62 @@
+import { Banner } from './banner';
+import { Barrel } from './barrel';
+import { Beacon } from './beacon';
+import { Bed } from './bed';
+import { Beehive } from './beehive';
+import { Bell } from './bell';
+import { Coords3d } from '../types/coords';
+import { Generic } from './generic';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { Sign } from './sign';
+
+export type BlockInstance = Banner | Barrel | Beacon | Bed | Beehive | Bell | Generic | Sign;
+
+export class Block {
+    static blockConstructor = new Map<(name: string) => boolean, typeof Generic>([
+        [Block.isBanner, Banner],
+        [Block.isBarrel, Barrel],
+        [Block.isBeacon, Beacon],
+        [Block.isBed, Bed],
+        [Block.isBeehive, Beehive],
+        [Block.isBell, Bell],
+        [Block.isSign, Sign]
+    ]);
+
+    static create(name: string, coords: Coords3d, entityData?: NbtCompound): Generic {
+        for (const [isBlock, blockConstructor] of Block.blockConstructor) {
+            if (isBlock(name)) {
+                return new blockConstructor(name, coords, entityData);
+            }
+        }
+
+        return new Generic(name, coords, entityData);
+    }
+
+    static isBanner(name: string): boolean {
+        return !!name.match(/^minecraft:.+_banner$/);
+    }
+
+    static isBarrel(name: string): boolean {
+        return name === 'minecraft:barrel';
+    }
+
+    static isBeacon(name: string): boolean {
+        return name === 'minecraft:beacon';
+    }
+
+    static isBed(name: string): boolean {
+        return !!name.match(/^minecraft:.+_bed$/);
+    }
+
+    static isBeehive(name: string): boolean {
+        return name === 'minecraft:beehive' || name === 'minecraft:bee_nest';
+    }
+
+    static isBell(name: string): boolean {
+        return name === 'minecraft:bell';
+    }
+
+    static isSign(name: string): boolean {
+        return !!name.match(/^minecraft:.+_sign$/);
+    }
+}

package/src/block/generic.ts

@@ -0,0 +1,14 @@
+import { Coords3d } from '../types/coords';
+import { NbtCompound } from '../nbt/nbt-compound';
+
+export class Generic {
+    constructor(
+        public name: string,
+        public coords: Coords3d,
+        public entityData?: NbtCompound
+    ) {}
+
+    components(): NbtCompound | undefined {
+        return this.entityData?.findChild<NbtCompound>('components');
+    }
+}

package/src/block/has-entity-data.ts

@@ -0,0 +1,20 @@
+import { Generic } from './generic';
+import { Coords3d } from '../types/coords';
+import { NbtCompound } from '../nbt/nbt-compound';
+
+export class HasEntityData extends Generic {
+    override entityData: NbtCompound;
+
+    constructor(
+        name: string,
+        coords: Coords3d,
+        entityData?: NbtCompound
+    ) {
+        if (!entityData) {
+            throw new Error('Block is supposed to have entity data');
+        }
+
+        super(name, coords, entityData);
+        this.entityData = entityData;
+    }
+}

package/src/block/mixins/custom-name.ts

@@ -0,0 +1,8 @@
+import { HasEntityData } from '../has-entity-data';
+import { NbtString } from '../../nbt/nbt-string';
+
+export class CustomName extends HasEntityData {
+    customName(): string | undefined {
+        return this.entityData.findChild<NbtString>('CustomName')?.data;
+    }
+}

package/src/block/mixins/lock.ts

@@ -0,0 +1,8 @@
+import { HasEntityData } from '../has-entity-data';
+import { NbtString } from '../../nbt/nbt-string';
+
+export class Lock extends HasEntityData {
+    lock(): string | undefined {
+        return this.entityData.findChild<NbtString>('Lock')?.data;
+    }
+}

package/src/block/mixins/mixin.ts

@@ -0,0 +1,53 @@
+/**
+ * Mixin function to combine multiple classes together.
+ *
+ * Described at https://catchts.com/oop-style#typed_inheritance
+ * Credits Wilco: https://stackoverflow.com/users/5291/wilco
+ * Credits @jcalz - https://stackoverflow.com/a/50375286
+ *
+ * Using the modified version where all classes extend a base class. The
+ * constructor is UNABLE to be modified by mixins.
+ *
+ * Usage:
+ *
+ *     export class Whatever extends Mixin(
+ *         BaseClass,
+ *         Mixin1,
+ *         Mixin2,
+ *         ...,
+ *         class extends BaseClass {
+ *             // class definition
+ *         }
+ *     ) {}
+ */
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+    k: infer I
+) => void
+    ? I
+    : never;
+
+type ClassType = new (...args: any[]) => any;
+
+export function Mixin<T extends ClassType, R extends T[]>(
+    BaseType: T,
+    ...classRefs: [...R]
+): new (
+    ...args: ConstructorParameters<T>
+) => UnionToIntersection<InstanceType<[...R][number]>> {
+    const derived = class extends BaseType {};
+    classRefs.forEach((classRef) => {
+        Object.getOwnPropertyNames(classRef.prototype).forEach((name) => {
+            const descriptor = Object.getOwnPropertyDescriptor(
+                classRef.prototype,
+                name
+            );
+
+            if (name !== 'constructor' && descriptor) {
+                Object.defineProperty(derived.prototype, name, descriptor);
+            }
+        });
+    });
+
+    return derived;
+}

package/src/block/sign.ts

@@ -0,0 +1,121 @@
+import { HasEntityData } from './has-entity-data';
+import { Nbt } from '../nbt/nbt';
+import { NbtByte } from '../nbt/nbt-byte';
+import { NbtList } from '../nbt/nbt-list';
+import { NbtString } from '../nbt/nbt-string';
+import { NbtTagType } from '../nbt/nbt-tag-type';
+
+type SignText = [string, string, string, string];
+
+export class Sign extends HasEntityData {
+    backColor(): string | undefined {
+        // 1.20+
+        return this.entityData.findChild<NbtString>('back_text/color')?.data;
+    }
+
+    backGlowingText(): boolean | undefined {
+        // 1.20+
+        const byte = this.entityData.findChild<NbtByte>(
+            'back_text/has_glowing_text'
+        );
+
+        if (byte) {
+            return byte.data !== 0;
+        }
+
+        // Up to 1.19
+        return;
+    }
+
+    backText(): SignText | undefined {
+        // 1.20+
+        const backSnbt = this.entityData
+            .findChild<NbtList<NbtString>>('back_text/messages')
+            ?.data.map((tag) => tag.data);
+
+        if (this.isSignText(backSnbt)) {
+            return this.snbtToText(backSnbt);
+        }
+
+        // Up to 1.19
+        return;
+    }
+
+    frontColor(): string | undefined {
+        return (
+            // 1.20+
+            this.entityData.findChild<NbtString>('front_text/color')?.data ||
+            // Up to 1.19
+            this.entityData.findChild<NbtString>('Color')?.data
+        );
+    }
+
+    frontGlowingText(): boolean | undefined {
+        const byte =
+            // 1.20+
+            this.entityData.findChild<NbtByte>('front_text/has_glowing_text') ||
+            // Up to 1.19
+            this.entityData.findChild<NbtByte>('GlowingText');
+
+        if (byte) {
+            return byte.data !== 0;
+        }
+
+        return;
+    }
+
+    frontText(): SignText {
+        // 1.20+
+        const frontSnbt = this.entityData
+            .findChild<NbtList<NbtString>>('front_text/messages')
+            ?.data.map((tag) => tag.data);
+
+        if (this.isSignText(frontSnbt)) {
+            return this.snbtToText(frontSnbt);
+        }
+
+        // Up to 1.19
+        const frontOldSnbt = [
+            this.entityData.findChild<NbtString>('Text1')?.data,
+            this.entityData.findChild<NbtString>('Text2')?.data,
+            this.entityData.findChild<NbtString>('Text3')?.data,
+            this.entityData.findChild<NbtString>('Text4')?.data,
+        ].filter((tag): tag is string => !!tag);
+
+        if (this.isSignText(frontOldSnbt)) {
+            return this.snbtToText(frontOldSnbt);
+        }
+
+        throw new Error('Unknown format for sign text');
+    }
+
+    isWaxed(): boolean | undefined {
+        const tag = this.entityData.findChild<NbtByte>('waxed');
+
+        if (!tag) {
+            // Up to 1.19
+            return;
+        }
+
+        // 1.20+
+        return tag.data !== 0;
+    }
+
+    private isSignText(value?: string[]): value is SignText {
+        return value?.length === 4;
+    }
+
+    private snbtToText(snbtList: SignText): SignText {
+        return snbtList.map((snbt) => {
+            const tag = Nbt.fromSnbt(snbt);
+
+            // 1.20 and newer
+            if (tag.type === NbtTagType.STRING) {
+                return tag.data;
+            }
+
+            // Up to 1.19
+            return tag.findChild<NbtString>('text')?.data ?? '';
+        }) as SignText;
+    }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+export * from './block/banner';
+export * from './block/barrel';
+export * from './block/beacon';
+export * from './block/bed';
+export * from './block/beehive';
+export * from './block/bell';
+export * from './block/block';
+export * from './block/generic';
+export * from './block/has-entity-data';
+export * from './block/mixins/custom-name';
+export * from './block/mixins/lock';
+export * from './block/mixins/mixin';
+export * from './block/sign';
+export * from './lib/anvil';
+export * from './lib/binary-data';
+export * from './lib/bit-data';
+export * from './lib/block-data';
+export * from './lib/chunk';
+export * from './nbt/nbt';
+export * from './nbt/nbt-base';
+export * from './nbt/nbt-byte';
+export * from './nbt/nbt-byte-array';
+export * from './nbt/nbt-compound';
+export * from './nbt/nbt-double';
+export * from './nbt/nbt-end';
+export * from './nbt/nbt-float';
+export * from './nbt/nbt-int';
+export * from './nbt/nbt-int-array';
+export * from './nbt/nbt-list';
+export * from './nbt/nbt-long';
+export * from './nbt/nbt-long-array';
+export * from './nbt/nbt-short';
+export * from './nbt/nbt-string';
+export * from './nbt/nbt-tag-type';
+export * from './nbt/snbt-data';
+export * from './nbt/snbt-parse';
+export * from './nbt/snbt-to-nbt';
+export * from './types/coords';