Implement enchanting system

src/block/Block.php

@@ -36,6 +36,7 @@
 use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\entity\Entity;
 use pocketmine\entity\projectile\Projectile;
+use pocketmine\item\enchantment\ItemFlags;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\item\Item;
 use pocketmine\item\ItemBlock;
@@ -67,6 +68,7 @@ class Block{
 	protected BlockIdentifier $idInfo;
 	protected string $fallbackName;
 	protected BlockTypeInfo $typeInfo;
+	protected int $itemEnchantmentFlag;
 	protected Position $position;
 
 	/** @var AxisAlignedBB[]|null */
@@ -80,10 +82,11 @@ class Block{
 	/**
 	 * @param string $name English name of the block type (TODO: implement translations)
 	 */
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo, int $itemEnchantmentFlag = ItemFlags::NONE){
 		$this->idInfo = $idInfo;
 		$this->fallbackName = $name;
 		$this->typeInfo = $typeInfo;
+		$this->itemEnchantmentFlag = $itemEnchantmentFlag;
 		$this->position = new Position(0, 0, 0, null);
 
 		$calculator = new RuntimeDataSizeCalculator();

src/block/VanillaBlocks.php

@@ -59,6 +59,7 @@
 use pocketmine\block\utils\WoodType;
 use pocketmine\crafting\FurnaceType;
 use pocketmine\entity\projectile\Projectile;
+use pocketmine\item\enchantment\ItemFlags;
 use pocketmine\item\Item;
 use pocketmine\item\ToolTier;
 use pocketmine\math\Facing;
@@ -964,7 +965,7 @@ public function getBreakTime(Item $item) : float{
 
 		$pumpkinBreakInfo = new Info(BreakInfo::axe(1.0));
 		self::register("pumpkin", new Pumpkin(new BID(Ids::PUMPKIN), "Pumpkin", $pumpkinBreakInfo));
-		self::register("carved_pumpkin", new CarvedPumpkin(new BID(Ids::CARVED_PUMPKIN), "Carved Pumpkin", $pumpkinBreakInfo));
+		self::register("carved_pumpkin", new CarvedPumpkin(new BID(Ids::CARVED_PUMPKIN), "Carved Pumpkin", $pumpkinBreakInfo, ItemFlags::HEAD));
 		self::register("lit_pumpkin", new LitPumpkin(new BID(Ids::LIT_PUMPKIN), "Jack o'Lantern", $pumpkinBreakInfo));
 
 		self::register("pumpkin_stem", new PumpkinStem(new BID(Ids::PUMPKIN_STEM), "Pumpkin Stem", new Info(BreakInfo::instant())));

src/block/inventory/EnchantInventory.php

@@ -23,18 +23,101 @@
 
 namespace pocketmine\block\inventory;
 
+use pocketmine\data\bedrock\EnchantmentIdMap;
 use pocketmine\inventory\SimpleInventory;
 use pocketmine\inventory\TemporaryInventory;
+use pocketmine\item\enchantment\EnchantmentHelper as Helper;
+use pocketmine\item\enchantment\EnchantmentInstance;
+use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
+use pocketmine\item\VanillaItems;
+use pocketmine\network\mcpe\protocol\PlayerEnchantOptionsPacket;
+use pocketmine\network\mcpe\protocol\types\Enchant;
+use pocketmine\network\mcpe\protocol\types\EnchantOption;
 use pocketmine\world\Position;
+use function array_map;
+use function array_merge;
+use function count;
+use function is_null;
 
 class EnchantInventory extends SimpleInventory implements BlockInventory, TemporaryInventory{
 	use BlockInventoryTrait;
 
 	public const SLOT_INPUT = 0;
 	public const SLOT_LAPIS = 1;
 
+	/** @var EnchantOption[] $options */
+	private array $options = [];
+
+	/** @var Item[] $outputs */
+	private array $outputs = [];
+
 	public function __construct(Position $holder){
 		$this->holder = $holder;
 		parent::__construct(2);
 	}
+
+	protected function onSlotChange(int $index, Item $before) : void{
+		if($index == self::SLOT_INPUT){
+			foreach($this->viewers as $viewer){
+				$this->options = Helper::getEnchantOptions($this->holder, $this->getItem(self::SLOT_INPUT), $viewer->getEnchantmentSeed());
+				$this->outputs = [];
+
+				if(count($this->options) !== 0){
+					$viewer->getNetworkSession()->sendDataPacket(PlayerEnchantOptionsPacket::create($this->options));
+				}
+			}
+		}
+
+		parent::onSlotChange($index, $before);
+	}
+
+	public function getInput() : Item{
+		return $this->getItem(self::SLOT_INPUT);
+	}
+
+	public function getLapis() : Item{
+		return $this->getItem(self::SLOT_LAPIS);
+	}
+
+	public function getOutput(int $optionId) : Item{
+		$this->prepareOutput($optionId);
+		return $this->outputs[$optionId];
+	}
+
+	private function prepareOutput(int $optionId) : void{
+		if(isset($this->outputs[$optionId])){
+			return;
+		}
+
+		$option = $this->options[$optionId] ?? null;
+		if(is_null($option)){
+			throw new \RuntimeException("Failed to find enchantment option with network id $optionId");
+		}
+
+		$enchantments = array_map(
+			function(Enchant $e){
+				$enchantment = EnchantmentIdMap::getInstance()->fromId($e->getId());
+				if(is_null($enchantment)){
+					throw new \RuntimeException("Failed to get enchantment with id {$e->getId()}");
+				}
+				return new EnchantmentInstance($enchantment, $e->getLevel());
+			},
+			array_merge(
+				$option->getEquipActivatedEnchantments(),
+				$option->getHeldActivatedEnchantments(),
+				$option->getSelfActivatedEnchantments()
+			)
+		);
+
+		$outputItem = $this->getItem(self::SLOT_INPUT);
+		if($outputItem->getTypeId() === ItemTypeIds::BOOK){
+			$outputItem = VanillaItems::ENCHANTED_BOOK();
+		}
+		foreach($enchantments as $enchantment){
+			$outputItem->addEnchantment($enchantment);
+		}
+
+		$this->outputs[$optionId] = $outputItem;
+	}
 }

src/data/bedrock/item/ItemSerializerDeserializerRegistrar.php

@@ -223,6 +223,7 @@ private function register1to1ItemMappings() : void{
 		$this->map1to1Item(Ids::ECHO_SHARD, Items::ECHO_SHARD());
 		$this->map1to1Item(Ids::EGG, Items::EGG());
 		$this->map1to1Item(Ids::EMERALD, Items::EMERALD());
+		$this->map1to1Item(Ids::ENCHANTED_BOOK, Items::ENCHANTED_BOOK());
 		$this->map1to1Item(Ids::ENCHANTED_GOLDEN_APPLE, Items::ENCHANTED_GOLDEN_APPLE());
 		$this->map1to1Item(Ids::ENDER_PEARL, Items::ENDER_PEARL());
 		$this->map1to1Item(Ids::EXPERIENCE_BOTTLE, Items::EXPERIENCE_BOTTLE());

src/entity/Human.php

@@ -112,7 +112,7 @@ public static function getNetworkTypeId() : string{ return EntityIds::PLAYER; }
 	protected HungerManager $hungerManager;
 	protected ExperienceManager $xpManager;
 
-	protected int $xpSeed;
+	protected int $enchantmentSeed;
 
 	public function __construct(Location $location, Skin $skin, ?CompoundTag $nbt = null){
 		$this->skin = $skin;
@@ -211,6 +211,14 @@ public function getXpManager() : ExperienceManager{
 		return $this->xpManager;
 	}
 
+	public function getEnchantmentSeed() : int{
+		return $this->enchantmentSeed;
+	}
+
+	protected function generateEnchantmentSeed() : void{
+		$this->enchantmentSeed = mt_rand(Limits::INT32_MIN, Limits::INT32_MAX);
+	}
+
 	public function getXpDropAmount() : int{
 		//this causes some XP to be lost on death when above level 1 (by design), dropping at most enough points for
 		//about 7.5 levels of XP.
@@ -332,9 +340,9 @@ function(Inventory $unused, array $oldItems) use ($syncHeldItem) : void{
 		$this->xpManager->setLifetimeTotalXp($nbt->getInt(self::TAG_LIFETIME_XP_TOTAL, 0));
 
 		if(($xpSeedTag = $nbt->getTag(self::TAG_XP_SEED)) instanceof IntTag){
-			$this->xpSeed = $xpSeedTag->getValue();
+			$this->enchantmentSeed = $xpSeedTag->getValue();
 		}else{
-			$this->xpSeed = random_int(Limits::INT32_MIN, Limits::INT32_MAX);
+			$this->generateEnchantmentSeed();
 		}
 	}
 
@@ -408,7 +416,7 @@ public function saveNBT() : CompoundTag{
 		$nbt->setInt(self::TAG_XP_LEVEL, $this->xpManager->getXpLevel());
 		$nbt->setFloat(self::TAG_XP_PROGRESS, $this->xpManager->getXpProgress());
 		$nbt->setInt(self::TAG_LIFETIME_XP_TOTAL, $this->xpManager->getLifetimeTotalXp());
-		$nbt->setInt(self::TAG_XP_SEED, $this->xpSeed);
+		$nbt->setInt(self::TAG_XP_SEED, $this->enchantmentSeed);
 
 		$inventoryTag = new ListTag([], NBT::TAG_Compound);
 		$nbt->setTag(self::TAG_INVENTORY, $inventoryTag);

src/inventory/transaction/EnchantTransaction.php

@@ -0,0 +1,90 @@
+<?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\inventory\transaction;
+
+use pocketmine\block\inventory\EnchantInventory;
+use pocketmine\inventory\transaction\action\InventoryAction;
+use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
+use pocketmine\player\Player;
+use function count;
+use function is_null;
+
+class EnchantTransaction extends InventoryTransaction{
+
+	private int $optionId;
+	private ?Item $inputItem = null;
+	private int $lapisCost = 0;
+
+	public function __construct(Player $source, int $optionId){
+		$this->optionId = $optionId;
+		parent::__construct($source);
+	}
+
+	public function validate() : void{
+		if(count($this->actions) < 1){
+			throw new TransactionValidationException("Transaction must have at least one action to be executable");
+		}
+
+		/** @var EnchantInventory $enchantWindow */
+		$enchantWindow = $this->source->getCurrentWindow();
+		if(is_null($this->inputItem) || !$this->inputItem->equalsExact($enchantWindow->getInput())){
+			throw new TransactionValidationException("Incorrect input item");
+		}
+
+		if($this->source->hasFiniteResources()){
+			$enchantLevel = $this->getEnchantLevel();
+			if($this->lapisCost !== $enchantLevel){
+				throw new TransactionValidationException("Expected the amount of lapis lazuli spent to be {$this->getEnchantLevel()}, but received $this->lapisCost");
+			}
+
+			$xpLevel = $this->source->getXpManager()->getXpLevel();
+			if($xpLevel < $enchantLevel){
+				throw new TransactionValidationException("Expected player to have xp level at least of $enchantLevel, but received $xpLevel");
+			}
+		}
+	}
+
+	public function addAction(InventoryAction $action) : void{
+		parent::addAction($action);
+
+		$sourceItem = $action->getSourceItem();
+		$targetItem = $action->getTargetItem();
+
+		if($sourceItem->getTypeId() === ItemTypeIds::LAPIS_LAZULI){
+			$this->lapisCost = $sourceItem->getCount() - $targetItem->getCount();
+		}else{
+			$this->inputItem = $sourceItem;
+		}
+	}
+
+	public function execute() : void{
+		parent::execute();
+		$this->source->onEnchant($this->getEnchantLevel());
+	}
+
+	public function getEnchantLevel() : int{
+		return $this->optionId + 1;
+	}
+}

src/item/Armor.php

@@ -26,6 +26,7 @@
 use pocketmine\color\Color;
 use pocketmine\event\entity\EntityDamageEvent;
 use pocketmine\inventory\ArmorInventory;
+use pocketmine\item\enchantment\ItemFlags;
 use pocketmine\item\enchantment\ProtectionEnchantment;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\math\Vector3;
@@ -44,8 +45,8 @@ class Armor extends Durable{
 
 	protected ?Color $customColor = null;
 
-	public function __construct(ItemIdentifier $identifier, string $name, ArmorTypeInfo $info){
-		parent::__construct($identifier, $name);
+	public function __construct(ItemIdentifier $identifier, string $name, ArmorTypeInfo $info, int $enchantmentFlag = ItemFlags::NONE){
+		parent::__construct($identifier, $name, $enchantmentFlag);
 		$this->armorInfo = $info;
 	}
 
@@ -72,6 +73,10 @@ public function isFireProof() : bool{
 		return $this->armorInfo->isFireProof();
 	}
 
+	public function getMaterial() : ArmorMaterial{
+		return $this->armorInfo->getMaterial();
+	}
+
 	/**
 	 * Returns the dyed colour of this armour piece. This generally only applies to leather armour.
 	 */

src/item/ArmorMaterial.php

@@ -0,0 +1,69 @@
+<?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\item;
+
+use pocketmine\utils\EnumTrait;
+
+/**
+ * This doc-block is generated automatically, do not modify it manually.
+ * This must be regenerated whenever registry members are added, removed or changed.
+ * @see build/generate-registry-annotations.php
+ * @generate-registry-docblock
+ *
+ * @method static ArmorMaterial CHAINMAIL()
+ * @method static ArmorMaterial DIAMOND()
+ * @method static ArmorMaterial GOLD()
+ * @method static ArmorMaterial IRON()
+ * @method static ArmorMaterial LEATHER()
+ * @method static ArmorMaterial NETHERITE()
+ * @method static ArmorMaterial TURTLE()
+ */
+final class ArmorMaterial{
+	use EnumTrait {
+		__construct as Enum___construct;
+	}
+
+	protected static function setup() : void{
+		self::registerAll(
+			new self("leather", 15),
+			new self("chainmail", 12),
+			new self("iron", 9),
+			new self("turtle", 9),
+			new self("gold", 25),
+			new self("diamond", 10),
+			new self("netherite", 15)
+		);
+	}
+
+	private function __construct(
+		string $name,
+		private int $enchantability
+	){
+		$this->Enum___construct($name);
+	}
+
+	public function getEnchantability() : int{
+		return $this->enchantability;
+	}
+}