Implemented budding amethyst and amethyst clusters

src/block/AmethystCluster.php

@@ -0,0 +1,133 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\utils\AmethystTrait;
+use pocketmine\block\utils\AnyFacingTrait;
+use pocketmine\block\utils\FortuneDropHelper;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\BlockTransaction;
+
+final class AmethystCluster extends Transparent{
+	use AmethystTrait;
+	use AnyFacingTrait;
+
+	public const STAGE_SMALL_BUD = 0;
+	public const STAGE_MEDIUM_BUD = 1;
+	public const STAGE_LARGE_BUD = 2;
+	public const STAGE_CLUSTER = 3;
+
+	private int $stage = self::STAGE_CLUSTER;
+
+	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
+		$w->boundedInt(2, self::STAGE_SMALL_BUD, self::STAGE_CLUSTER, $this->stage);
+	}
+
+	public function getStage() : int{ return $this->stage; }
+
+	public function setStage(int $stage) : self{
+		if($stage < self::STAGE_SMALL_BUD || $stage > self::STAGE_CLUSTER){
+			throw new \InvalidArgumentException("Size must be in range " . self::STAGE_SMALL_BUD . " ... " . self::STAGE_CLUSTER);
+		}
+		$this->stage = $stage;
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return match($this->stage){
+			self::STAGE_SMALL_BUD => 1,
+			self::STAGE_MEDIUM_BUD => 2,
+			self::STAGE_LARGE_BUD => 4,
+			self::STAGE_CLUSTER => 5,
+			default => throw new AssumptionFailedError("Invalid stage $this->stage"),
+		};
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		$myAxis = Facing::axis($this->facing);
+
+		$box = AxisAlignedBB::one();
+		foreach([Axis::Y, Axis::Z, Axis::X] as $axis){
+			if($axis === $myAxis){
+				continue;
+			}
+			$box->squash($axis, $this->stage === self::STAGE_SMALL_BUD ? 4 / 16 : 3 / 16);
+		}
+		$box->trim($this->facing, 1 - ($this->stage === self::STAGE_CLUSTER ? 7 / 16 : ($this->stage + 3) / 16));
+
+		return [$box];
+	}
+
+	private function canBeSupportedAt(Block $block, int $facing) : bool{
+		return $block->getAdjacentSupportType($facing) === SupportType::FULL;
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
+			return false;
+		}
+
+		$this->facing = $face;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing))){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		if($this->stage === self::STAGE_CLUSTER){
+			return [VanillaItems::AMETHYST_SHARD()->setCount(FortuneDropHelper::weighted($item, min: 4, maxBase: 4))];
+		}
+
+		return [];
+	}
+
+	public function getDropsForIncompatibleTool(Item $item) : array{
+		if($this->stage === self::STAGE_CLUSTER){
+			return [VanillaItems::AMETHYST_SHARD()->setCount(FortuneDropHelper::weighted($item, min: 2, maxBase: 2))];
+		}
+
+		return [];
+	}
+}

src/block/BlockTypeIds.php

@@ -562,10 +562,10 @@ final class BlockTypeIds{
 	public const WEIGHTED_PRESSURE_PLATE_HEAVY = 10532;
 	public const WEIGHTED_PRESSURE_PLATE_LIGHT = 10533;
 	public const WHEAT = 10534;
-
+	public const BUDDING_AMETHYST = 10535;
 	public const WHITE_TULIP = 10536;
 	public const WOOL = 10537;
-
+	public const AMETHYST_CLUSTER = 10538;
 	public const GLAZED_TERRACOTTA = 10539;
 	public const AMETHYST = 10540;
 	public const ANCIENT_DEBRIS = 10541;

src/block/BuddingAmethyst.php

@@ -0,0 +1,67 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\utils\AmethystTrait;
+use pocketmine\block\utils\BlockEventHelper;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use function mt_rand;
+
+final class BuddingAmethyst extends Opaque{
+	use AmethystTrait;
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if(mt_rand(1, 5) === 1){
+			$face = Facing::ALL[array_rand(Facing::ALL)];
+
+			$adjacent = $this->getSide($face);
+			//TODO: amethyst buds can spawn in water - we need waterlogging support for this
+
+			$newStage = null;
+
+			if($adjacent->getTypeId() === BlockTypeIds::AIR){
+				$newStage = AmethystCluster::STAGE_SMALL_BUD;
+			}elseif(
+				$adjacent->getTypeId() === BlockTypeIds::AMETHYST_CLUSTER &&
+				$adjacent instanceof AmethystCluster &&
+				$adjacent->getStage() < AmethystCluster::STAGE_CLUSTER &&
+				$adjacent->getFacing() === $face
+			){
+				$newStage = $adjacent->getStage() + 1;
+			}
+			if($newStage !== null){
+				BlockEventHelper::grow($adjacent, VanillaBlocks::AMETHYST_CLUSTER()->setStage($newStage)->setFacing($face), null);
+			}
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+}

src/block/VanillaBlocks.php

@@ -54,6 +54,7 @@ use pocketmine\block\tile\NormalFurnace as TileNormalFurnace;
 use pocketmine\block\tile\Note as TileNote;
 use pocketmine\block\tile\ShulkerBox as TileShulkerBox;
 use pocketmine\block\tile\Smoker as TileSmoker;
+use pocketmine\block\utils\AmethystTrait;
 use pocketmine\block\utils\LeavesType;
 use pocketmine\block\utils\SaplingType;
 use pocketmine\block\utils\WoodType;
@@ -96,6 +97,7 @@ use function strtolower;
  * @method static Flower ALLIUM()
  * @method static MushroomStem ALL_SIDED_MUSHROOM_STEM()
  * @method static Opaque AMETHYST()
+ * @method static AmethystCluster AMETHYST_CLUSTER()
  * @method static Opaque ANCIENT_DEBRIS()
  * @method static Opaque ANDESITE()
  * @method static Slab ANDESITE_SLAB()
@@ -149,6 +151,7 @@ use function strtolower;
  * @method static Wall BRICK_WALL()
  * @method static BrownMushroom BROWN_MUSHROOM()
  * @method static BrownMushroomBlock BROWN_MUSHROOM_BLOCK()
+ * @method static BuddingAmethyst BUDDING_AMETHYST()
  * @method static Cactus CACTUS()
  * @method static Cake CAKE()
  * @method static CakeWithCandle CAKE_WITH_CANDLE()
@@ -1546,12 +1549,12 @@ final class VanillaBlocks{
 
 	private static function registerBlocksR17() : void{
 		//in java this can be acquired using any tool - seems to be a parity issue in bedrock
-		self::register("amethyst", new class(new BID(Ids::AMETHYST), "Amethyst", new Info(BreakInfo::pickaxe(1.5, ToolTier::WOOD))) extends Opaque{
-			public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
-				$this->position->getWorld()->addSound($this->position, new AmethystBlockChimeSound());
-				$this->position->getWorld()->addSound($this->position, new BlockPunchSound($this));
-			}
+		$amethystInfo = new Info(BreakInfo::pickaxe(1.5, ToolTier::WOOD));
+		self::register("amethyst", new class(new BID(Ids::AMETHYST), "Amethyst", $amethystInfo) extends Opaque{
+			use AmethystTrait;
 		});
+		self::register("budding_amethyst", new BuddingAmethyst(new BID(Ids::BUDDING_AMETHYST), "Budding Amethyst", $amethystInfo));
+		self::register("amethyst_cluster", new AmethystCluster(new BID(Ids::AMETHYST_CLUSTER), "Amethyst Cluster", $amethystInfo));
 
 		self::register("calcite", new Opaque(new BID(Ids::CALCITE), "Calcite", new Info(BreakInfo::pickaxe(0.75, ToolTier::WOOD))));
 		self::register("tuff", new Opaque(new BID(Ids::TUFF), "Tuff", new Info(BreakInfo::pickaxe(1.5, ToolTier::WOOD, 30.0))));

src/block/utils/AmethystTrait.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block\utils;
+
+use pocketmine\block\Block;
+use pocketmine\entity\projectile\Projectile;
+use pocketmine\math\RayTraceResult;
+use pocketmine\world\sound\AmethystBlockChimeSound;
+use pocketmine\world\sound\BlockPunchSound;
+
+trait AmethystTrait{
+	/**
+	 * @see Block::onProjectileHit()
+	 */
+	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
+		$this->position->getWorld()->addSound($this->position, new AmethystBlockChimeSound());
+		$this->position->getWorld()->addSound($this->position, new BlockPunchSound($this));
+	}
+}

src/data/bedrock/block/convert/BlockObjectToStateSerializer.php

@@ -24,6 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\data\bedrock\block\convert;
 
 use pocketmine\block\ActivatorRail;
+use pocketmine\block\AmethystCluster;
 use pocketmine\block\Anvil;
 use pocketmine\block\Bamboo;
 use pocketmine\block\BambooSapling;
@@ -718,6 +719,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::BOOKSHELF(), Ids::BOOKSHELF);
 		$this->mapSimple(Blocks::BRICKS(), Ids::BRICK_BLOCK);
 		$this->mapSimple(Blocks::BROWN_MUSHROOM(), Ids::BROWN_MUSHROOM);
+		$this->mapSimple(Blocks::BUDDING_AMETHYST(), Ids::BUDDING_AMETHYST);
 		$this->mapSimple(Blocks::CALCITE(), Ids::CALCITE);
 		$this->mapSimple(Blocks::CARTOGRAPHY_TABLE(), Ids::CARTOGRAPHY_TABLE);
 		$this->mapSimple(Blocks::CHEMICAL_HEAT(), Ids::CHEMICAL_HEAT);
@@ -968,6 +970,16 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::ALLIUM(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_ALLIUM));
 		$this->map(Blocks::ALL_SIDED_MUSHROOM_STEM(), fn() => Writer::create(Ids::BROWN_MUSHROOM_BLOCK)
 				->writeInt(StateNames::HUGE_MUSHROOM_BITS, BlockLegacyMetadata::MUSHROOM_BLOCK_ALL_STEM));
+		$this->map(Blocks::AMETHYST_CLUSTER(), fn(AmethystCluster $block) => Writer::create(
+			match($stage = $block->getStage()){
+				AmethystCluster::STAGE_SMALL_BUD => Ids::SMALL_AMETHYST_BUD,
+				AmethystCluster::STAGE_MEDIUM_BUD => Ids::MEDIUM_AMETHYST_BUD,
+				AmethystCluster::STAGE_LARGE_BUD => Ids::LARGE_AMETHYST_BUD,
+				AmethystCluster::STAGE_CLUSTER => Ids::AMETHYST_CLUSTER,
+				default => throw new BlockStateSerializeException("Invalid Amethyst Cluster stage $stage"),
+			})
+			->writeBlockFace($block->getFacing())
+		);
 		$this->map(Blocks::ANDESITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_ANDESITE));
 		$this->map(Blocks::ANDESITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_ANDESITE));
 		$this->map(Blocks::ANDESITE_STAIRS(), fn(Stair $block) => Helper::encodeStairs($block, new Writer(Ids::ANDESITE_STAIRS)));

src/data/bedrock/block/convert/BlockStateReader.php

@@ -135,6 +135,19 @@ final class BlockStateReader{
 		]);
 	}
 
+	/** @throws BlockStateDeserializeException */
+	public function readBlockFace() : int{
+		return match($raw = $this->readString(BlockStateNames::MC_BLOCK_FACE)){
+			StringValues::MC_BLOCK_FACE_DOWN => Facing::DOWN,
+			StringValues::MC_BLOCK_FACE_UP => Facing::UP,
+			StringValues::MC_BLOCK_FACE_NORTH => Facing::NORTH,
+			StringValues::MC_BLOCK_FACE_SOUTH => Facing::SOUTH,
+			StringValues::MC_BLOCK_FACE_WEST => Facing::WEST,
+			StringValues::MC_BLOCK_FACE_EAST => Facing::EAST,
+			default => throw $this->badValueException(BlockStateNames::MC_BLOCK_FACE, $raw)
+		};
+	}
+
 	/**
 	 * @return int[]
 	 * @phpstan-return array<int, int>

src/data/bedrock/block/convert/BlockStateToObjectDeserializer.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\data\bedrock\block\convert;
 
+use pocketmine\block\AmethystCluster;
 use pocketmine\block\Bamboo;
 use pocketmine\block\Block;
 use pocketmine\block\CaveVines;
@@ -611,6 +612,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::BOOKSHELF, fn() => Blocks::BOOKSHELF());
 		$this->mapSimple(Ids::BRICK_BLOCK, fn() => Blocks::BRICKS());
 		$this->mapSimple(Ids::BROWN_MUSHROOM, fn() => Blocks::BROWN_MUSHROOM());
+		$this->mapSimple(Ids::BUDDING_AMETHYST, fn() => Blocks::BUDDING_AMETHYST());
 		$this->mapSimple(Ids::CALCITE, fn() => Blocks::CALCITE());
 		$this->mapSimple(Ids::CARTOGRAPHY_TABLE, fn() => Blocks::CARTOGRAPHY_TABLE());
 		$this->mapSimple(Ids::CHEMICAL_HEAT, fn() => Blocks::CHEMICAL_HEAT());
@@ -857,6 +859,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setPowered($in->readBool(StateNames::RAIL_DATA_BIT))
 				->setShape($in->readBoundedInt(StateNames::RAIL_DIRECTION, 0, 5));
 		});
+		$this->map(Ids::AMETHYST_CLUSTER, function(Reader $in) : Block{
+			return Blocks::AMETHYST_CLUSTER()
+				->setStage(AmethystCluster::STAGE_CLUSTER)
+				->setFacing($in->readBlockFace());
+		});
 		$this->mapStairs(Ids::ANDESITE_STAIRS, fn() => Blocks::ANDESITE_STAIRS());
 		$this->map(Ids::ANVIL, function(Reader $in) : Block{
 			return Blocks::ANVIL()
@@ -1163,6 +1170,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::LANTERN()
 				->setHanging($in->readBool(StateNames::HANGING));
 		});
+		$this->map(Ids::LARGE_AMETHYST_BUD, function(Reader $in) : Block{
+			return Blocks::AMETHYST_CLUSTER()
+				->setStage(AmethystCluster::STAGE_LARGE_BUD)
+				->setFacing($in->readBlockFace());
+		});
 		$this->map(Ids::LAVA, fn(Reader $in) => Helper::decodeStillLiquid(Blocks::LAVA(), $in));
 		$this->map(Ids::LECTERN, function(Reader $in) : Block{
 			return Blocks::LECTERN()
@@ -1225,6 +1237,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::LOOM()
 				->setFacing($in->readLegacyHorizontalFacing());
 		});
+		$this->map(Ids::MEDIUM_AMETHYST_BUD, function(Reader $in) : Block{
+			return Blocks::AMETHYST_CLUSTER()
+				->setStage(AmethystCluster::STAGE_MEDIUM_BUD)
+				->setFacing($in->readBlockFace());
+		});
 		$this->map(Ids::MELON_STEM, fn(Reader $in) => Helper::decodeStem(Blocks::MELON_STEM(), $in));
 		$this->map(Ids::MONSTER_EGG, function(Reader $in) : Block{
 			return match($type = $in->readString(StateNames::MONSTER_EGG_STONE_TYPE)){
@@ -1439,6 +1456,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setFacing($in->readCardinalHorizontalFacing())
 				->setLit(false);
 		});
+		$this->map(Ids::SMALL_AMETHYST_BUD, function(Reader $in) : Block{
+			return Blocks::AMETHYST_CLUSTER()
+				->setStage(AmethystCluster::STAGE_SMALL_BUD)
+				->setFacing($in->readBlockFace());
+		});
 		$this->map(Ids::SMALL_DRIPLEAF_BLOCK, function(Reader $in) : Block{
 			return Blocks::SMALL_DRIPLEAF()
 				->setFacing($in->readCardinalHorizontalFacing())

src/data/bedrock/block/convert/BlockStateWriter.php

@@ -90,6 +90,20 @@ final class BlockStateWriter{
 		return $this;
 	}
 
+	/** @return $this */
+	public function writeBlockFace(int $value) : self{
+		$this->writeString(BlockStateNames::MC_BLOCK_FACE, match($value){
+			Facing::DOWN => StringValues::MC_BLOCK_FACE_DOWN,
+			Facing::UP => StringValues::MC_BLOCK_FACE_UP,
+			Facing::NORTH => StringValues::MC_BLOCK_FACE_NORTH,
+			Facing::SOUTH => StringValues::MC_BLOCK_FACE_SOUTH,
+			Facing::WEST => StringValues::MC_BLOCK_FACE_WEST,
+			Facing::EAST => StringValues::MC_BLOCK_FACE_EAST,
+			default => throw new BlockStateSerializeException("Invalid Facing $value")
+		});
+		return $this;
+	}
+
 	/**
 	 * @param int[] $faces
 	 * @phpstan-param array<int, int> $faces

src/item/StringToItemParser.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\item;
 
+use pocketmine\block\AmethystCluster;
 use pocketmine\block\Block;
 use pocketmine\block\Light;
 use pocketmine\block\utils\CopperOxidation;
@@ -134,6 +135,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("all_sided_mushroom_stem", fn() => Blocks::ALL_SIDED_MUSHROOM_STEM());
 		$result->registerBlock("allium", fn() => Blocks::ALLIUM());
 		$result->registerBlock("amethyst_block", fn() => Blocks::AMETHYST());
+		$result->registerBlock("amethyst_cluster", fn() => Blocks::AMETHYST_CLUSTER());
 		$result->registerBlock("ancient_debris", fn() => Blocks::ANCIENT_DEBRIS());
 		$result->registerBlock("andesite", fn() => Blocks::ANDESITE());
 		$result->registerBlock("andesite_slab", fn() => Blocks::ANDESITE_SLAB());
@@ -196,6 +198,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("bricks_block", fn() => Blocks::BRICKS());
 		$result->registerBlock("brown_mushroom", fn() => Blocks::BROWN_MUSHROOM());
 		$result->registerBlock("brown_mushroom_block", fn() => Blocks::BROWN_MUSHROOM_BLOCK());
+		$result->registerBlock("budding_amethyst", fn() => Blocks::BUDDING_AMETHYST());
 		$result->registerBlock("burning_furnace", fn() => Blocks::FURNACE());
 		$result->registerBlock("bush", fn() => Blocks::DEAD_BUSH());
 		$result->registerBlock("cactus", fn() => Blocks::CACTUS());
@@ -744,6 +747,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("lapis_lazuli_block", fn() => Blocks::LAPIS_LAZULI());
 		$result->registerBlock("lapis_lazuli_ore", fn() => Blocks::LAPIS_LAZULI_ORE());
 		$result->registerBlock("lapis_ore", fn() => Blocks::LAPIS_LAZULI_ORE());
+		$result->registerBlock("large_amethyst_bud", fn() => Blocks::AMETHYST_CLUSTER()->setStage(AmethystCluster::STAGE_LARGE_BUD));
 		$result->registerBlock("large_fern", fn() => Blocks::LARGE_FERN());
 		$result->registerBlock("lava", fn() => Blocks::LAVA());
 		$result->registerBlock("leave", fn() => Blocks::OAK_LEAVES());
@@ -786,6 +790,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("mangrove_trapdoor", fn() => Blocks::MANGROVE_TRAPDOOR());
 		$result->registerBlock("mangrove_wood", fn() => Blocks::MANGROVE_WOOD()->setStripped(false));
 		$result->registerBlock("material_reducer", fn() => Blocks::MATERIAL_REDUCER());
+		$result->registerBlock("medium_amethyst_bud", fn() => Blocks::AMETHYST_CLUSTER()->setStage(AmethystCluster::STAGE_MEDIUM_BUD));
 		$result->registerBlock("melon_block", fn() => Blocks::MELON());
 		$result->registerBlock("melon_stem", fn() => Blocks::MELON_STEM());
 		$result->registerBlock("mob_head", fn() => Blocks::MOB_HEAD());
@@ -976,6 +981,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("slabs", fn() => Blocks::SMOOTH_STONE_SLAB());
 		$result->registerBlock("slime", fn() => Blocks::SLIME());
 		$result->registerBlock("slime_block", fn() => Blocks::SLIME());
+		$result->registerBlock("small_amethyst_bud", fn() => Blocks::AMETHYST_CLUSTER()->setStage(AmethystCluster::STAGE_SMALL_BUD));
 		$result->registerBlock("small_dripleaf", fn() => Blocks::SMALL_DRIPLEAF());
 		$result->registerBlock("smoker", fn() => Blocks::SMOKER());
 		$result->registerBlock("smooth_basalt", fn() => Blocks::SMOOTH_BASALT());