ExperienceManager.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\entity;
 
use pocketmine\entity\utils\ExperienceUtils;
use pocketmine\event\player\PlayerExperienceChangeEvent;
use pocketmine\item\Durable;
use pocketmine\item\enchantment\VanillaEnchantments;
use pocketmine\utils\Limits;
use pocketmine\world\sound\XpCollectSound;
use pocketmine\world\sound\XpLevelUpSound;
use function array_rand;
use function ceil;
use function count;
use function max;
use function min;
 
class ExperienceManager{
 
    private Attribute $levelAttr;
    private Attribute $progressAttr;
 
    private int $totalXp = 0;
 
    private bool $canAttractXpOrbs = true;
 
    private int $xpCooldown = 0;
 
    public function __construct(
        private Human $entity
    ){
        $this->levelAttr = self::fetchAttribute($entity, Attribute::EXPERIENCE_LEVEL);
        $this->progressAttr = self::fetchAttribute($entity, Attribute::EXPERIENCE);
    }
 
    private static function fetchAttribute(Entity $entity, string $attributeId) : Attribute{
        $attribute = AttributeFactory::getInstance()->mustGet($attributeId);
        $entity->getAttributeMap()->add($attribute);
        return $attribute;
    }
 
    public function getXpLevel() : int{
        return (int) $this->levelAttr->getValue();
    }
 
    public function setXpLevel(int $level) : bool{
        return $this->setXpAndProgress($level, null);
    }
 
    public function addXpLevels(int $amount, bool $playSound = true) : bool{
        $oldLevel = $this->getXpLevel();
        if($this->setXpLevel($oldLevel + $amount)){
            if($playSound){
                $newLevel = $this->getXpLevel();
                if((int) ($newLevel / 5) > (int) ($oldLevel / 5)){
                    $this->entity->broadcastSound(new XpLevelUpSound($newLevel));
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    public function subtractXpLevels(int $amount) : bool{
        return $this->addXpLevels(-$amount);
    }
 
    public function getXpProgress() : float{
        return $this->progressAttr->getValue();
    }
 
    public function setXpProgress(float $progress) : bool{
        return $this->setXpAndProgress(null, $progress);
    }
 
    public function getRemainderXp() : int{
        return (int) (ExperienceUtils::getXpToCompleteLevel($this->getXpLevel()) * $this->getXpProgress());
    }
 
    public function getCurrentTotalXp() : int{
        return ExperienceUtils::getXpToReachLevel($this->getXpLevel()) + $this->getRemainderXp();
    }
 
    public function setCurrentTotalXp(int $amount) : bool{
        $newLevel = ExperienceUtils::getLevelFromXp($amount);
 
        $xpLevel = (int) $newLevel;
        $xpProgress = $newLevel - (int) $newLevel;
        return $this->setXpAndProgress($xpLevel, $xpProgress);
    }
 
    public function addXp(int $amount, bool $playSound = true) : bool{
        $amount = min($amount, Limits::INT32_MAX - $this->totalXp);
        $oldLevel = $this->getXpLevel();
        $oldTotal = $this->getCurrentTotalXp();
 
        if($this->setCurrentTotalXp($oldTotal + $amount)){
            if($amount > 0){
                $this->totalXp += $amount;
            }
            if($playSound){
                $newLevel = $this->getXpLevel();
                if((int) ($newLevel / 5) > (int) ($oldLevel / 5)){
                    $this->entity->broadcastSound(new XpLevelUpSound($newLevel));
                }elseif($this->getCurrentTotalXp() > $oldTotal){
                    $this->entity->broadcastSound(new XpCollectSound());
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    public function subtractXp(int $amount) : bool{
        return $this->addXp(-$amount);
    }
 
    public function setXpAndProgress(?int $level, ?float $progress) : bool{
        $ev = new PlayerExperienceChangeEvent($this->entity, $this->getXpLevel(), $this->getXpProgress(), $level, $progress);
        $ev->call();
 
        if($ev->isCancelled()){
            return false;
        }
 
        $level = $ev->getNewLevel();
        $progress = $ev->getNewProgress();
 
        if($level !== null){
            $this->levelAttr->setValue($level);
        }
 
        if($progress !== null){
            $this->progressAttr->setValue($progress);
        }
 
        return true;
    }
 
    public function setXpAndProgressNoEvent(int $level, float $progress) : void{
        $this->levelAttr->setValue($level);
        $this->progressAttr->setValue($progress);
    }
 
    public function getLifetimeTotalXp() : int{
        return $this->totalXp;
    }
 
    public function setLifetimeTotalXp(int $amount) : void{
        if($amount < 0 || $amount > Limits::INT32_MAX){
            throw new \InvalidArgumentException("XP must be greater than 0 and less than " . Limits::INT32_MAX);
        }
 
        $this->totalXp = $amount;
    }
 
    public function canPickupXp() : bool{
        return $this->xpCooldown === 0;
    }
 
    public function onPickupXp(int $xpValue) : void{
        $mainHandIndex = -1;
        $offHandIndex = -2;
 
        //TODO: replace this with a more generic equipment getting/setting interface
        $equipment = [];
 
        if(($item = $this->entity->getInventory()->getItemInHand()) instanceof Durable && $item->hasEnchantment(VanillaEnchantments::MENDING())){
            $equipment[$mainHandIndex] = $item;
        }
        if(($item = $this->entity->getOffHandInventory()->getItem(0)) instanceof Durable && $item->hasEnchantment(VanillaEnchantments::MENDING())){
            $equipment[$offHandIndex] = $item;
        }
        foreach($this->entity->getArmorInventory()->getContents() as $k => $armorItem){
            if($armorItem instanceof Durable && $armorItem->hasEnchantment(VanillaEnchantments::MENDING())){
                $equipment[$k] = $armorItem;
            }
        }
 
        if(count($equipment) > 0){
            $repairItem = $equipment[$k = array_rand($equipment)];
            if($repairItem->getDamage() > 0){
                $repairAmount = min($repairItem->getDamage(), $xpValue * 2);
                $repairItem->setDamage($repairItem->getDamage() - $repairAmount);
                $xpValue -= (int) ceil($repairAmount / 2);
 
                if($k === $mainHandIndex){
                    $this->entity->getInventory()->setItemInHand($repairItem);
                }elseif($k === $offHandIndex){
                    $this->entity->getOffHandInventory()->setItem(0, $repairItem);
                }else{
                    $this->entity->getArmorInventory()->setItem($k, $repairItem);
                }
            }
        }
 
        $this->addXp($xpValue); //this will still get fired even if the value is 0 due to mending, to play sounds
        $this->resetXpCooldown();
    }
 
    public function resetXpCooldown(int $value = 2) : void{
        $this->xpCooldown = $value;
    }
 
    public function tick(int $tickDiff = 1) : void{
        if($this->xpCooldown > 0){
            $this->xpCooldown = max(0, $this->xpCooldown - $tickDiff);
        }
    }
 
    public function canAttractXpOrbs() : bool{
        return $this->canAttractXpOrbs;
    }
 
    public function setCanAttractXpOrbs(bool $v = true) : void{
        $this->canAttractXpOrbs = $v;
    }
}