Support Minecraft 1.26.50 (protocol 2193)

devapp/src/index.ts

@@ -1,5 +1,6 @@
-import { Serenity, LevelDBProvider } from "@serenityjs/core";
+import { Serenity, LevelDBProvider, NetworkBound } from "@serenityjs/core";
 import { Pipeline } from "@serenityjs/plugins";
+import { Packet } from "@serenityjs/protocol";
 
 // Create a new Serenity instance
 const serenity = new Serenity({
@@ -20,3 +21,13 @@ serenity.registerProvider(LevelDBProvider, { path: "./worlds" });
 serenity.start().catch((reason) => {
   serenity.logger.error("Failed to start SerenityJS server:", reason);
 });
+
+// serenity.network.on("all", ({ bound, packet }) => {
+//   if (bound !== NetworkBound.Client) return;
+
+//   if (packet.getId() === Packet.LevelChunk) return;
+//   if (packet.getId() === Packet.NetworkChunkPublisherUpdate) return;
+//   if (packet.getId() === Packet.BossEvent) return;
+
+//   console.log(`sending packet ${Packet[packet.getId()]} to client`);
+// });

packages/core/src/block/block.ts

@@ -7,6 +7,8 @@ import {
   Gamemode,
   LevelEvent,
   LevelEventPacket,
+  LevelSoundEvent,
+  LevelSoundEventPacket,
   UpdateBlockLayerType,
   Vector3f
 } from "@serenityjs/protocol";
@@ -48,6 +50,28 @@ import { BlockLevelStorage } from "./storage";
 import { BlockDirectionTrait, BlockTrait } from "./traits";
 import { BlockState } from "./types";
 
+/**
+ * The blocks that a placed block takes the place of, rather than going beside, besides air and liquids.
+ */
+const ReplaceableBlocks = new Set<string>([
+  BlockIdentifier.Fire,
+  BlockIdentifier.SoulFire,
+  BlockIdentifier.ShortGrass,
+  BlockIdentifier.Fern,
+  BlockIdentifier.Deadbush,
+  BlockIdentifier.Seagrass,
+  BlockIdentifier.CrimsonRoots,
+  BlockIdentifier.WarpedRoots,
+  BlockIdentifier.NetherSprouts,
+  BlockIdentifier.HangingRoots,
+  BlockIdentifier.GlowLichen,
+  BlockIdentifier.Vine,
+  BlockIdentifier.StructureVoid,
+  "minecraft:bush",
+  "minecraft:short_dry_grass",
+  "minecraft:tall_dry_grass"
+]);
+
 /**
  * Block is a class the represents an instance of a block in a dimension of a world.
  * The Block instance contains its position, dimension, type, permutation, components, traits, and nbt data.
@@ -160,6 +184,22 @@ class Block {
     return this.permutation.type.solid;
   }
 
+  /**
+   * Whether or not a placed block takes the place of this block, rather than going beside it.
+   * This is the case for air, liquids, fire, and plants like short grass; snow only while it is one layer deep.
+   */
+  public get isReplaceable(): boolean {
+    // Air and liquids are always replaced
+    if (this.isAir || this.isLiquid) return true;
+
+    // Snow is replaced only while it is one layer deep
+    if (this.identifier === BlockIdentifier.SnowLayer)
+      return this.getState<number>("height") === 0;
+
+    // Check if the block is one that is replaced
+    return ReplaceableBlocks.has(this.identifier);
+  }
+
   /**
    * Whether or not the block is loggable.
    * Depening on the value, this will determine if the block can be logged with a fluid type block.
@@ -309,6 +349,13 @@ class Block {
         continue;
       }
 
+      // Check if the block type provides the trait, which is added below.
+      // Older saves stored these with the block too, so remove it from the storage.
+      if (this.isTypeTrait(traitType)) {
+        this.peekStorage()?.removeTrait(identifier);
+        continue;
+      }
+
       // Add the trait to the block.
       const trait = this.addTrait(traitType);
 
@@ -463,6 +510,13 @@ class Block {
           continue;
         }
 
+        // Check if the block type provides the trait, which is added below.
+        // Older saves stored these with the block too, so remove it from the storage.
+        if (this.isTypeTrait(traitType)) {
+          storage.removeTrait(identifier);
+          continue;
+        }
+
         // Add the trait to the block.
         const trait = this.addTrait(traitType);
 
@@ -474,14 +528,18 @@ class Block {
     }
 
     // Push the nbt data of the permutation to the block's nbt.
-    if (permutation.nbt.size > 0) this.getStorage().push(...permutation.nbt.values());
+    if (permutation.nbt.size > 0)
+      this.getStorage().push(...permutation.nbt.values());
 
     // Iterate over all the traits and apply them to the block
     for (const [, trait] of permutation.type.traits) this.addTrait(trait);
 
     // Check if the block should be cached.
     const blockStorage = this.peekStorage();
-    if (((blockStorage?.size ?? 0) > 0 || this.traits.size > 0) && !permutation.type.air) {
+    if (
+      ((blockStorage?.size ?? 0) > 0 || this.traits.size > 0) &&
+      !permutation.type.air
+    ) {
       // Calculate the block hash using the position
       const hash = BlockPosition.hash(this.position);
 
@@ -653,8 +711,9 @@ class Block {
         ? instance.identifier + "@" + instance.state
         : instance.identifier;
 
-      // Add the trait to the block's storage
-      this.getStorage().addTrait(identifier);
+      // Add the trait to the block's storage, unless the block type provides it,
+      // as those are added to the block again whenever it is loaded
+      if (!this.isTypeTrait(trait)) this.getStorage().addTrait(identifier);
 
       // Return the trait that was added
       return instance;
@@ -673,6 +732,15 @@ class Block {
     }
   }
 
+  /**
+   * Whether a trait is provided by the block's type, rather than added to the block itself.
+   * @param trait The trait to check.
+   * @returns Whether the block's type provides the trait.
+   */
+  private isTypeTrait(trait: typeof BlockTrait): boolean {
+    return this.type.traits.get(trait.identifier) === trait;
+  }
+
   /**
    * Get all traits currently applied to the block.
    * @returns An array of all traits currently applied to the block.
@@ -699,7 +767,9 @@ class Block {
   public peekStorage(): BlockLevelStorage | null {
     if (this.storage) return this.storage;
 
-    this.storage = this.chunk.getBlockStorage(this.position) as BlockLevelStorage | null;
+    this.storage = this.chunk.getBlockStorage(
+      this.position
+    ) as BlockLevelStorage | null;
 
     return this.storage;
   }
@@ -800,6 +870,33 @@ class Block {
     this.dimension.broadcast(packet);
   }
 
+  /**
+   * Plays a sound from the middle of the block to all players in the dimension.
+   * The client plays the sound from the sound set of the block the data names, so a lever clicks as a lever does.
+   * @param event The sound to play.
+   * @param data The network id of the block making the sound; defaults to this block's.
+   */
+  public playSound(
+    event: LevelSoundEvent,
+    data = this.permutation.networkId
+  ): void {
+    // Get the position of the block
+    const { x, y, z } = this.position;
+
+    // Create a new LevelSoundEventPacket
+    const packet = new LevelSoundEventPacket();
+    packet.event = event;
+    packet.position = new Vector3f(x + 0.5, y + 0.5, z + 0.5);
+    packet.data = data;
+    packet.actorIdentifier = ":";
+    packet.isBabyMob = false;
+    packet.isGlobal = false;
+    packet.uniqueActorId = -1n;
+
+    // Send the packet to all players in the dimension
+    this.dimension.broadcast(packet);
+  }
+
   /**
    * Gets the tool type required to break the block.
    * @returns
@@ -1078,6 +1175,9 @@ class Block {
       // Check if the drop is air, if so we will skip it.
       if (drop.type === BlockIdentifier.Air) continue;
 
+      // Skip drops with no item, as blocks like fire have none
+      if (!this.world.itemPalette.getType(drop.type)) continue;
+
       // Roll the drop amount.
       const stackSize = drop.roll();
 

packages/core/src/block/identity/type.ts

@@ -1,3 +1,4 @@
+import { BinaryStream } from "@serenityjs/binarystream";
 import { CompoundTag, ListTag, StringTag } from "@serenityjs/nbt";
 import { NetworkBlockTypeDefinition } from "@serenityjs/protocol";
 import {
@@ -9,6 +10,7 @@ import {
 
 import { BlockIdentifier, BlockMaterialSound } from "../../enums";
 import { BlockTypeDefinition, BlockTypeProperties } from "../../types";
+import { BlockItems } from "../../constants/block-items";
 import { BlockState } from "../types";
 
 import { ItemDrop } from "./drops";
@@ -17,6 +19,11 @@ import { BlockPermutation } from "./permutation";
 
 import type { BlockTrait } from "../traits";
 
+/**
+ * Matches the identifiers of double slabs.
+ */
+const DoubleSlabPattern = /double.*_slab$/;
+
 /**
  * BlockType represents a block type in the game, which hold all possible permutations the block can have.
  * 
@@ -73,8 +80,13 @@ class BlockType {
           instance.drops.push(itemDrop);
         }
       }
-      // Register the default drop for the block type.
-      else instance.drops.push(new ItemDrop(type.identifier, 1, 1, 1));
+      // Register the default drop for the block type, which is its item.
+      // Blocks like signs drop an item of another name, and double slabs drop two of their slab.
+      else {
+        const item = BlockItems[type.identifier] ?? type.identifier;
+        const amount = DoubleSlabPattern.test(type.identifier) ? 2 : 1;
+        instance.drops.push(new ItemDrop(item, amount, amount, 1));
+      }
 
       // Set the block type in the registry.
       this.types.set(type.identifier as BlockIdentifier, instance);
@@ -107,6 +119,20 @@ class BlockType {
       // Register the block permutation in the registry.
       BlockPermutation.permutations.set(instance.networkId, instance);
     }
+
+    // Iterate over the vanilla block types that are defined by data.
+    // The client only knows these from the definitions the server sends,
+    // which are added after the permutations, as creating those would add to them.
+    for (const type of BLOCK_TYPES) {
+      if (!("properties" in type) || !type.properties) continue;
+
+      // Read the definition of the block type.
+      const stream = new BinaryStream(Buffer.from(type.properties, "base64"));
+      const definition = CompoundTag.read(stream);
+
+      // Add the definition to the block type properties.
+      this.types.get(type.identifier)?.properties.push(...definition.values());
+    }
   }
 
   /**
@@ -240,11 +266,14 @@ class BlockType {
   public getPermutation(state?: BlockState): BlockPermutation {
     if (!state) return this.permutations[0] as BlockPermutation;
 
-    const cached = this.permutationStateIndex.get(this.getPermutationStateKey(state));
+    const cached = this.permutationStateIndex.get(
+      this.getPermutationStateKey(state)
+    );
     if (cached) return cached;
 
     for (const permutation of this.permutations)
-      if (permutation.matches(state as BlockState)) return permutation as BlockPermutation;
+      if (permutation.matches(state as BlockState))
+        return permutation as BlockPermutation;
 
     return this.permutations[0] as BlockPermutation;
   }

packages/core/src/block/palette.ts

@@ -44,6 +44,20 @@ class BlockPalette {
     return this.getAllTypes().filter((type) => type instanceof CustomBlockType);
   }
 
+  /**
+   * Gets the block types the client only knows from the definitions the server sends:
+   * custom block types, and the vanilla block types defined by data, like the wool and concrete stairs.
+   * Other vanilla block types are known to the client, and a definition sent for one replaces what it knows, like its sounds.
+   * @returns The block types defined by data.
+   */
+  public getAllDataDrivenTypes(): Array<BlockType> {
+    return this.getAllTypes().filter(
+      (type) =>
+        type instanceof CustomBlockType ||
+        type.properties.has("vanilla_block_data")
+    );
+  }
+
   /**
    * Gets all block permutations from the palette.
    * @returns All block permutations from the palette.

packages/core/src/block/storage.ts

@@ -395,6 +395,9 @@ class BlockLevelStorage extends CompoundTag {
     if (index !== -1) {
       traits.splice(index, 1);
 
+      // Remove the list once it is empty, so an empty list is not stored
+      if (traits.length === 0) super.delete("traits");
+
       // Mark the chunk as needing to be saved
       if (this.size > 0) this.chunk.dirty = true;
     }