Item.php

<?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\block\Block;
use pocketmine\block\BlockBreakInfo;
use pocketmine\block\BlockToolType;
use pocketmine\block\VanillaBlocks;
use pocketmine\data\bedrock\EnchantmentIdMap;
use pocketmine\data\bedrock\item\ItemTypeDeserializeException;
use pocketmine\data\runtime\RuntimeDataDescriber;
use pocketmine\data\runtime\RuntimeDataWriter;
use pocketmine\data\SavedDataLoadingException;
use pocketmine\entity\Entity;
use pocketmine\entity\Living;
use pocketmine\item\enchantment\EnchantmentInstance;
use pocketmine\math\Vector3;
use pocketmine\nbt\LittleEndianNbtSerializer;
use pocketmine\nbt\NBT;
use pocketmine\nbt\NbtException;
use pocketmine\nbt\tag\CompoundTag;
use pocketmine\nbt\tag\ListTag;
use pocketmine\nbt\tag\StringTag;
use pocketmine\nbt\TreeRoot;
use pocketmine\player\Player;
use pocketmine\utils\Utils;
use pocketmine\world\BlockTransaction;
use pocketmine\world\format\io\GlobalItemDataHandlers;
use function base64_decode;
use function base64_encode;
use function count;
use function gettype;
use function hex2bin;
use function is_string;
use function morton2d_encode;
 
class Item implements \JsonSerializable{
    use ItemEnchantmentHandlingTrait;
 
    public const TAG_ENCH = "ench";
    private const TAG_ENCH_ID = "id"; //TAG_Short
    private const TAG_ENCH_LVL = "lvl"; //TAG_Short
 
    public const TAG_DISPLAY = "display";
    public const TAG_BLOCK_ENTITY_TAG = "BlockEntityTag";
 
    public const TAG_DISPLAY_NAME = "Name";
    public const TAG_DISPLAY_LORE = "Lore";
 
    public const TAG_KEEP_ON_DEATH = "minecraft:keep_on_death";
 
    private const TAG_CAN_PLACE_ON = "CanPlaceOn"; //TAG_List<TAG_String>
    private const TAG_CAN_DESTROY = "CanDestroy"; //TAG_List<TAG_String>
 
    private CompoundTag $nbt;
 
    protected int $count = 1;
 
    //TODO: this stuff should be moved to itemstack properties, not mushed in with type properties
 
    protected string $customName = "";
    protected array $lore = [];
    protected ?CompoundTag $blockEntityTag = null;
 
    protected array $canPlaceOn = [];
    protected array $canDestroy = [];
 
    protected bool $keepOnDeath = false;
 
    public function __construct(
        private ItemIdentifier $identifier,
        protected string $name = "Unknown",
        private array $enchantmentTags = []
    ){
        $this->nbt = new CompoundTag();
    }
 
    public function hasCustomBlockData() : bool{
        return $this->blockEntityTag !== null;
    }
 
    public function clearCustomBlockData(){
        $this->blockEntityTag = null;
        return $this;
    }
 
    public function setCustomBlockData(CompoundTag $compound) : Item{
        $this->blockEntityTag = clone $compound;
 
        return $this;
    }
 
    public function getCustomBlockData() : ?CompoundTag{
        return $this->blockEntityTag;
    }
 
    public function hasCustomName() : bool{
        return $this->customName !== "";
    }
 
    public function getCustomName() : string{
        return $this->customName;
    }
 
    public function setCustomName(string $name) : Item{
        Utils::checkUTF8($name);
        $this->customName = $name;
        return $this;
    }
 
    public function clearCustomName() : Item{
        $this->setCustomName("");
        return $this;
    }
 
    public function getLore() : array{
        return $this->lore;
    }
 
    public function setLore(array $lines) : Item{
        foreach($lines as $line){
            if(!is_string($line)){
                throw new \TypeError("Expected string[], but found " . gettype($line) . " in given array");
            }
            Utils::checkUTF8($line);
        }
        $this->lore = $lines;
        return $this;
    }
 
    public function getCanPlaceOn() : array{
        return $this->canPlaceOn;
    }
 
    public function setCanPlaceOn(array $canPlaceOn) : void{
        $this->canPlaceOn = [];
        foreach($canPlaceOn as $value){
            $this->canPlaceOn[$value] = $value;
        }
    }
 
    public function getCanDestroy() : array{
        return $this->canDestroy;
    }
 
    public function setCanDestroy(array $canDestroy) : void{
        $this->canDestroy = [];
        foreach($canDestroy as $value){
            $this->canDestroy[$value] = $value;
        }
    }
 
    public function keepOnDeath() : bool{
        return $this->keepOnDeath;
    }
 
    public function setKeepOnDeath(bool $keepOnDeath) : void{
        $this->keepOnDeath = $keepOnDeath;
    }
 
    public function hasNamedTag() : bool{
        return $this->getNamedTag()->count() > 0;
    }
 
    public function getNamedTag() : CompoundTag{
        $this->serializeCompoundTag($this->nbt);
        return $this->nbt;
    }
 
    public function setNamedTag(CompoundTag $tag) : Item{
        if($tag->getCount() === 0){
            return $this->clearNamedTag();
        }
 
        $this->nbt = clone $tag;
        $this->deserializeCompoundTag($this->nbt);
 
        return $this;
    }
 
    public function clearNamedTag() : Item{
        $this->nbt = new CompoundTag();
        $this->deserializeCompoundTag($this->nbt);
        return $this;
    }
 
    protected function deserializeCompoundTag(CompoundTag $tag) : void{
        $this->customName = "";
        $this->lore = [];
 
        $display = $tag->getCompoundTag(self::TAG_DISPLAY);
        if($display !== null){
            $this->customName = $display->getString(self::TAG_DISPLAY_NAME, $this->customName);
            $lore = $display->getListTag(self::TAG_DISPLAY_LORE, StringTag::class);
            if($lore !== null){
                foreach($lore as $t){
                    $this->lore[] = $t->getValue();
                }
            }
        }
 
        $this->removeEnchantments();
        $enchantments = $tag->getListTag(self::TAG_ENCH, CompoundTag::class);
        if($enchantments !== null){
            foreach($enchantments as $enchantment){
                $magicNumber = $enchantment->getShort(self::TAG_ENCH_ID, -1);
                $level = $enchantment->getShort(self::TAG_ENCH_LVL, 0);
                if($level <= 0){
                    continue;
                }
                $type = EnchantmentIdMap::getInstance()->fromId($magicNumber);
                if($type !== null){
                    $this->addEnchantment(new EnchantmentInstance($type, $level));
                }
            }
        }
 
        $this->blockEntityTag = $tag->getCompoundTag(self::TAG_BLOCK_ENTITY_TAG);
 
        $this->canPlaceOn = [];
        $canPlaceOn = $tag->getListTag(self::TAG_CAN_PLACE_ON, StringTag::class);
        if($canPlaceOn !== null){
            foreach($canPlaceOn as $entry){
                $this->canPlaceOn[$entry->getValue()] = $entry->getValue();
            }
        }
        $this->canDestroy = [];
        $canDestroy = $tag->getListTag(self::TAG_CAN_DESTROY, StringTag::class);
        if($canDestroy !== null){
            foreach($canDestroy as $entry){
                $this->canDestroy[$entry->getValue()] = $entry->getValue();
            }
        }
 
        $this->keepOnDeath = $tag->getByte(self::TAG_KEEP_ON_DEATH, 0) !== 0;
    }
 
    protected function serializeCompoundTag(CompoundTag $tag) : void{
        $display = $tag->getCompoundTag(self::TAG_DISPLAY);
 
        if($this->customName !== ""){
            $display ??= new CompoundTag();
            $display->setString(self::TAG_DISPLAY_NAME, $this->customName);
        }else{
            $display?->removeTag(self::TAG_DISPLAY_NAME);
        }
 
        if(count($this->lore) > 0){
            $loreTag = new ListTag();
            foreach($this->lore as $line){
                $loreTag->push(new StringTag($line));
            }
            $display ??= new CompoundTag();
            $display->setTag(self::TAG_DISPLAY_LORE, $loreTag);
        }else{
            $display?->removeTag(self::TAG_DISPLAY_LORE);
        }
        $display !== null && $display->count() > 0 ?
            $tag->setTag(self::TAG_DISPLAY, $display) :
            $tag->removeTag(self::TAG_DISPLAY);
 
        if(count($this->enchantments) > 0){
            $ench = new ListTag();
            $enchantmentIdMap = EnchantmentIdMap::getInstance();
            foreach($this->enchantments as $enchantmentInstance){
                $ench->push(CompoundTag::create()
                    ->setShort(self::TAG_ENCH_ID, $enchantmentIdMap->toId($enchantmentInstance->getType()))
                    ->setShort(self::TAG_ENCH_LVL, $enchantmentInstance->getLevel())
                );
            }
            $tag->setTag(self::TAG_ENCH, $ench);
        }else{
            $tag->removeTag(self::TAG_ENCH);
        }
 
        $this->blockEntityTag !== null ?
            $tag->setTag(self::TAG_BLOCK_ENTITY_TAG, clone $this->blockEntityTag) :
            $tag->removeTag(self::TAG_BLOCK_ENTITY_TAG);
 
        if(count($this->canPlaceOn) > 0){
            $canPlaceOn = new ListTag();
            foreach($this->canPlaceOn as $item){
                $canPlaceOn->push(new StringTag($item));
            }
            $tag->setTag(self::TAG_CAN_PLACE_ON, $canPlaceOn);
        }else{
            $tag->removeTag(self::TAG_CAN_PLACE_ON);
        }
        if(count($this->canDestroy) > 0){
            $canDestroy = new ListTag();
            foreach($this->canDestroy as $item){
                $canDestroy->push(new StringTag($item));
            }
            $tag->setTag(self::TAG_CAN_DESTROY, $canDestroy);
        }else{
            $tag->removeTag(self::TAG_CAN_DESTROY);
        }
 
        if($this->keepOnDeath){
            $tag->setByte(self::TAG_KEEP_ON_DEATH, 1);
        }else{
            $tag->removeTag(self::TAG_KEEP_ON_DEATH);
        }
    }
 
    public function getCount() : int{
        return $this->count;
    }
 
    public function setCount(int $count) : Item{
        $this->count = $count;
 
        return $this;
    }
 
    public function pop(int $count = 1) : Item{
        if($count > $this->count){
            throw new \InvalidArgumentException("Cannot pop $count items from a stack of $this->count");
        }
 
        $item = clone $this;
        $item->count = $count;
 
        $this->count -= $count;
 
        return $item;
    }
 
    public function isNull() : bool{
        return $this->count <= 0;
    }
 
    final public function getName() : string{
        return $this->hasCustomName() ? $this->getCustomName() : $this->getVanillaName();
    }
 
    public function getVanillaName() : string{
        return $this->name;
    }
 
    public function getEnchantmentTags() : array{
        return $this->enchantmentTags;
    }
 
    public function getEnchantability() : int{
        return 1;
    }
 
    final public function canBePlaced() : bool{
        return $this->getBlock()->canBePlaced();
    }
 
    protected final function tryPlacementTransaction(Block $blockPlace, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player) : ?BlockTransaction{
        $position = $blockReplace->getPosition();
        $blockPlace->position($position->getWorld(), $position->getFloorX(), $position->getFloorY(), $position->getFloorZ());
        if(!$blockPlace->canBePlacedAt($blockReplace, $clickVector, $face, $blockReplace->getPosition()->equals($blockClicked->getPosition()))){
            return null;
        }
        $transaction = new BlockTransaction($position->getWorld());
        return $blockPlace->place($transaction, $this, $blockReplace, $blockClicked, $face, $clickVector, $player) ? $transaction : null;
    }
 
    public function getPlacementTransaction(Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : ?BlockTransaction{
        return $this->tryPlacementTransaction($this->getBlock($face), $blockReplace, $blockClicked, $face, $clickVector, $player);
    }
 
    public function getBlock(?int $clickedFace = null) : Block{
        return VanillaBlocks::AIR();
    }
 
    final public function getTypeId() : int{
        return $this->identifier->getTypeId();
    }
 
    final public function getStateId() : int{
        return morton2d_encode($this->identifier->getTypeId(), $this->computeStateData());
    }
 
    private function computeStateData() : int{
        $writer = new RuntimeDataWriter(16); //TODO: max bits should be a constant instead of being hardcoded all over the place
        $this->describeState($writer);
        return $writer->getValue();
    }
 
    protected function describeState(RuntimeDataDescriber $w) : void{
        //NOOP
    }
 
    public function getMaxStackSize() : int{
        return 64;
    }
 
    public function getFuelTime() : int{
        return 0;
    }
 
    public function getFuelResidue() : Item{
        $item = clone $this;
        $item->pop();
 
        return $item;
    }
 
    public function isFireProof() : bool{
        return false;
    }
 
    public function getAttackPoints() : int{
        return 1;
    }
 
    public function getDefensePoints() : int{
        return 0;
    }
 
    public function getBlockToolType() : int{
        return BlockToolType::NONE;
    }
 
    public function getBlockToolHarvestLevel() : int{
        return 0;
    }
 
    public function getMiningEfficiency(bool $isCorrectTool) : float{
        return 1;
    }
 
    public function onInteractBlock(Player $player, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, array &$returnedItems) : ItemUseResult{
        return ItemUseResult::NONE;
    }
 
    public function onClickAir(Player $player, Vector3 $directionVector, array &$returnedItems) : ItemUseResult{
        return ItemUseResult::NONE;
    }
 
    public function onReleaseUsing(Player $player, array &$returnedItems) : ItemUseResult{
        return ItemUseResult::NONE;
    }
 
    public function onDestroyBlock(Block $block, array &$returnedItems) : bool{
        return false;
    }
 
    public function onAttackEntity(Entity $victim, array &$returnedItems) : bool{
        return false;
    }
 
    public function onTickWorn(Living $entity) : bool{
        return false;
    }
 
    public function onInteractEntity(Player $player, Entity $entity, Vector3 $clickVector) : bool{
        return false;
    }
 
    public function getCooldownTicks() : int{
        return 0;
    }
 
    public function getCooldownTag() : ?string{
        return null;
    }
 
    final public function equals(Item $item, bool $checkDamage = true, bool $checkCompound = true) : bool{
        return $this->getStateId() === $item->getStateId() &&
            (!$checkCompound || $this->getNamedTag()->equals($item->getNamedTag()));
    }
 
    final public function canStackWith(Item $other) : bool{
        return $this->equals($other, true, true);
    }
 
    final public function equalsExact(Item $other) : bool{
        return $this->canStackWith($other) && $this->count === $other->count;
    }
 
    final public function __toString() : string{
        return "Item " . $this->name . " (" . $this->getTypeId() . ":" . $this->computeStateData() . ")x" . $this->count . ($this->hasNamedTag() ? " tags:0x" . base64_encode((new LittleEndianNbtSerializer())->write(new TreeRoot($this->getNamedTag()))) : "");
    }
 
    public function jsonSerialize() : array{
        throw new \LogicException("json_encode()ing Item instances is no longer supported. Make your own method to convert the item to an array or stdClass.");
    }
 
    final public static function legacyJsonDeserialize(array $data) : Item{
        $nbt = "";
 
        //Backwards compatibility
        if(isset($data["nbt"])){
            $nbt = $data["nbt"];
        }elseif(isset($data["nbt_hex"])){
            $nbt = hex2bin($data["nbt_hex"]);
        }elseif(isset($data["nbt_b64"])){
            $nbt = base64_decode($data["nbt_b64"], true);
        }
 
        $itemStackData = GlobalItemDataHandlers::getUpgrader()->upgradeItemTypeDataInt(
            (int) $data["id"],
            (int) ($data["damage"] ?? 0),
            (int) ($data["count"] ?? 1),
            $nbt !== "" ? (new LittleEndianNbtSerializer())->read($nbt)->mustGetCompoundTag() : null
        );
 
        try{
            return GlobalItemDataHandlers::getDeserializer()->deserializeStack($itemStackData);
        }catch(ItemTypeDeserializeException $e){
            throw new SavedDataLoadingException($e->getMessage(), 0, $e);
        }
    }
 
    public function nbtSerialize(int $slot = -1) : CompoundTag{
        return GlobalItemDataHandlers::getSerializer()->serializeStack($this, $slot !== -1 ? $slot : null)->toNbt();
    }
 
    public static function nbtDeserialize(CompoundTag $tag) : Item{
        $itemData = GlobalItemDataHandlers::getUpgrader()->upgradeItemStackNbt($tag);
        if($itemData === null){
            return VanillaItems::AIR();
        }
 
        try{
            return GlobalItemDataHandlers::getDeserializer()->deserializeStack($itemData);
        }catch(ItemTypeDeserializeException $e){
            throw new SavedDataLoadingException($e->getMessage(), 0, $e);
        }
    }
 
    public function __clone(){
        $this->nbt = clone $this->nbt;
        if($this->blockEntityTag !== null){
            $this->blockEntityTag = clone $this->blockEntityTag;
        }
    }
}