pocketmine\level\Level::useBreakOn PHP Method

    public function useBreakOn(Vector3 $vector, Item &$item = null, Player $player = null, bool $createParticles = false) : bool
    {
        $target = $this->getBlock($vector);
        if ($item === null) {
            $item = Item::get(Item::AIR, 0, 0);
        }
        if ($player !== null) {
            $ev = new BlockBreakEvent($player, $target, $item, $player->isCreative() ? true : false);
            if ($player->isAdventure() or $player->isSpectator() or $player->isSurvival() and $item instanceof Item and !$target->isBreakable($item)) {
                $ev->setCancelled();
            } elseif (!$player->isOp() and ($distance = $this->server->getSpawnRadius()) > -1) {
                $t = new Vector2($target->x, $target->z);
                $s = new Vector2($this->getSpawnLocation()->x, $this->getSpawnLocation()->z);
                if (count($this->server->getOps()->getAll()) > 0 and $t->distance($s) <= $distance) {
                    //set it to cancelled so plugins can bypass this
                    $ev->setCancelled();
                }
            }
            $this->server->getPluginManager()->callEvent($ev);
            if ($ev->isCancelled()) {
                return false;
            }
            /*$breakTime = $target->getBreakTime($item);
            
            			if($player->isCreative() and $breakTime > 0.15){
            				$breakTime = 0.15;
            			}
            
            			if($player->hasEffect(Effect::SWIFTNESS)){
            				$breakTime *= 1 - (0.2 * ($player->getEffect(Effect::SWIFTNESS)->getAmplifier() + 1));
            			}
            
            			if($player->hasEffect(Effect::MINING_FATIGUE)){
            				$breakTime *= 1 + (0.3 * ($player->getEffect(Effect::MINING_FATIGUE)->getAmplifier() + 1));
            			}
            
            			$breakTime -= 0.05; //1 tick compensation
            
            			if(!$ev->getInstaBreak() and ($player->lastBreak + $breakTime) > microtime(true)){
            				return false;
            			}*/
            $player->lastBreak = microtime(true);
            $drops = $ev->getDrops();
            if ($player->isSurvival() and $this->getServer()->expEnabled) {
                $exp = 0;
                if ($item->getEnchantmentLevel(Enchantment::TYPE_MINING_SILK_TOUCH) === 0) {
                    switch ($target->getId()) {
                        case Block::COAL_ORE:
                            $exp = mt_rand(0, 2);
                            break;
                        case Block::DIAMOND_ORE:
                        case Block::EMERALD_ORE:
                            $exp = mt_rand(3, 7);
                            break;
                        case Block::NETHER_QUARTZ_ORE:
                        case Block::LAPIS_ORE:
                            $exp = mt_rand(2, 5);
                            break;
                        case Block::REDSTONE_ORE:
                        case Block::GLOWING_REDSTONE_ORE:
                            $exp = mt_rand(1, 5);
                            break;
                    }
                }
                switch ($target->getId()) {
                    case Block::MONSTER_SPAWNER:
                        $exp = mt_rand(15, 43);
                        break;
                }
                if ($exp > 0) {
                    $this->spawnXPOrb($vector->add(0, 1, 0), $exp);
                }
            }
        } elseif ($item !== null and !$target->isBreakable($item)) {
            return false;
        } else {
            $drops = $target->getDrops($item);
            //Fixes tile entities being deleted before getting drops
            foreach ($drops as $k => $i) {
                if (isset($i[0]) && isset($i[1]) && isset($i[2])) {
                    $drops[$k] = Item::get($i[0], $i[1], $i[2]);
                }
            }
        }
        $above = $this->getBlock(new Vector3($target->x, $target->y + 1, $target->z));
        if ($above !== null) {
            if ($above->getId() === Item::FIRE) {
                $this->setBlock($above, new Air(), true);
            }
        }
        $tag = $item->getNamedTagEntry("CanDestroy");
        if ($tag instanceof ListTag) {
            $canBreak = false;
            foreach ($tag as $v) {
                if ($v instanceof StringTag) {
                    $entry = Item::fromString($v->getValue());
                    if ($entry->getId() > 0 and $entry->getBlock() !== null and $entry->getBlock()->getId() === $target->getId()) {
                        $canBreak = true;
                        break;
                    }
                }
            }
            if (!$canBreak) {
                return false;
            }
        }
        if ($createParticles) {
            $players = $this->getChunkPlayers($target->x >> 4, $target->z >> 4);
            /*if($player !== null){
            			unset($players[$player->getLoaderId()]);
            		}*/
            $this->addParticle(new DestroyBlockParticle($target->add(0.5), $target), $players);
        }
        $target->onBreak($item);
        $tile = $this->getTile($target);
        if ($tile !== null) {
            if ($tile instanceof InventoryHolder) {
                if ($tile instanceof Chest) {
                    $tile->unpair();
                }
                foreach ($tile->getInventory()->getContents() as $chestItem) {
                    $this->dropItem($target, $chestItem);
                }
            }
            $tile->close();
        }
        if ($item !== null) {
            $item->useOn($target);
            if ($item->isTool() and $item->getDamage() >= $item->getMaxDurability()) {
                $item = Item::get(Item::AIR, 0, 0);
            }
        }
        if ($player === null or $player->isSurvival()) {
            foreach ($drops as $drop) {
                if ($drop->getCount() > 0) {
                    $this->dropItem($vector->add(0.5, 0.5, 0.5), $drop);
                }
            }
        }
        return true;
    }