BlockBreakInfo.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\block;
 
use pocketmine\item\Item;
use pocketmine\item\ToolTier;
use function get_class;
 
class BlockBreakInfo{
    public const COMPATIBLE_TOOL_MULTIPLIER = 1.5;
    public const INCOMPATIBLE_TOOL_MULTIPLIER = 5.0;
 
    private float $blastResistance;
    private bool $explosionHarvestable;
 
    public function __construct(
        private float $hardness,
        private int $toolType = BlockToolType::NONE,
        private int $toolHarvestLevel = 0,
        ?float $blastResistance = null,
        ?bool $explosionHarvestable = null,
    ){
        $this->blastResistance = $blastResistance ?? $hardness * 5;
        $this->explosionHarvestable = $explosionHarvestable ?? ($this->toolType & BlockToolType::PICKAXE) !== 0;
    }
 
    public static function tier(float $hardness, int $toolType, ToolTier $toolTier, ?float $blastResistance = null) : self{
        return new self($hardness, $toolType, $toolTier->getHarvestLevel(), $blastResistance);
    }
 
    public static function pickaxe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
        return new self($hardness, BlockToolType::PICKAXE, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
    }
 
    public static function shovel(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
        return new self($hardness, BlockToolType::SHOVEL, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
    }
 
    public static function axe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
        return new self($hardness, BlockToolType::AXE, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
    }
 
    public static function instant(int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0) : self{
        return new self(0.0, $toolType, $toolHarvestLevel, 0.0);
    }
 
    public static function indestructible(float $blastResistance = 18000003.75) : self{
        return new self(-1.0, BlockToolType::NONE, 0, $blastResistance);
    }
 
    public function getHardness() : float{
        return $this->hardness;
    }
 
    public function isBreakable() : bool{
        return $this->hardness >= 0;
    }
 
    public function breaksInstantly() : bool{
        return $this->hardness === 0.0;
    }
 
    public function getBlastResistance() : float{
        return $this->blastResistance;
    }
 
    public function getToolType() : int{
        return $this->toolType;
    }
 
    public function getToolHarvestLevel() : int{
        return $this->toolHarvestLevel;
    }
 
    public function isToolCompatible(Item $tool) : bool{
        if($this->hardness < 0){
            return false;
        }
 
        return $this->toolType === BlockToolType::NONE || $this->toolHarvestLevel === 0 || (
                ($this->toolType & $tool->getBlockToolType()) !== 0 && $tool->getBlockToolHarvestLevel() >= $this->toolHarvestLevel);
    }
 
    public function getBreakTime(Item $item) : float{
        $base = $this->hardness;
        if($this->isToolCompatible($item)){
            $base *= self::COMPATIBLE_TOOL_MULTIPLIER;
        }else{
            $base *= self::INCOMPATIBLE_TOOL_MULTIPLIER;
        }
 
        $efficiency = $item->getMiningEfficiency(($this->toolType & $item->getBlockToolType()) !== 0);
        if($efficiency <= 0){
            throw new \InvalidArgumentException(get_class($item) . " must have a positive mining efficiency, but got $efficiency");
        }
 
        $base /= $efficiency;
 
        return $base;
    }
 
    public function isExplosionHarvestable() : bool{ return $this->explosionHarvestable; }
}