Introduce the multi block events

core/common/src/main/kotlin/com/willfp/libreforge/Utils.kt

@@ -64,18 +64,38 @@ fun Collection<ItemStack?>.filterNotEmpty() =
 internal val ItemStack?.isEcoEmpty: Boolean
     get() = Items.isEmpty(this)
 
+@Suppress("DEPRECATION")
+@Deprecated("Use applyDamage with the removeItem function")
 fun ItemStack.applyDamage(damage: Int, player: Player?): Boolean {
+    return this.applyDamage(damage, player) { this.type = Material.AIR }
+}
+
+fun ItemStack.applyDamage(damage: Int, player: Player?, removeItem: Runnable): Boolean {
     val meta = this.itemMeta as? Damageable ?: return false
-    meta.damage += damage
+    val unbreaking = meta.getEnchantLevel(Enchantment.UNBREAKING)
+
+    // Calculate actual damage considering unbreaking
+    // Each damage point has a chance to be negated
+    var actualDamage = damage
+    if (unbreaking > 0) {
+        var damageNegated = 0
+        repeat(damage) {
+            // Chance to negate this damage point: (unbreakingLevel) / (unbreakingLevel + 1)
+            if (Math.random() < (unbreaking.toDouble() / (unbreaking + 1)))
+                damageNegated++
+        }
+        actualDamage = damage - damageNegated
+    }
+
+    meta.damage += actualDamage
     if (meta.damage >= this.type.maxDurability) {
         meta.damage = this.type.maxDurability.toInt()
         this.itemMeta = meta
         if (player != null) {
             Bukkit.getPluginManager().callEvent(PlayerItemBreakEvent(player, this))
             player.playSound(player.location, Sound.ENTITY_ITEM_BREAK, SoundCategory.BLOCKS, 1f, 1f)
         }
-        @Suppress("DEPRECATION")
-        this.type = Material.AIR
+        removeItem.run()
     } else {
         this.itemMeta = meta
     }

core/common/src/main/kotlin/com/willfp/libreforge/effects/impl/EffectDamageArmor.kt

@@ -2,6 +2,7 @@ package com.willfp.libreforge.effects.impl
 
 import com.willfp.eco.core.config.interfaces.Config
 import com.willfp.libreforge.NoCompileData
+import com.willfp.libreforge.applyDamage
 import com.willfp.libreforge.arguments
 import com.willfp.libreforge.effects.Effect
 import com.willfp.libreforge.enumValueOfOrNull
@@ -10,13 +11,9 @@ import com.willfp.libreforge.triggers.TriggerData
 import com.willfp.libreforge.triggers.TriggerParameter
 import org.bukkit.Bukkit
 import org.bukkit.Material
-import org.bukkit.Sound
-import org.bukkit.SoundCategory
 import org.bukkit.entity.Player
-import org.bukkit.event.player.PlayerItemBreakEvent
 import org.bukkit.event.player.PlayerItemDamageEvent
 import org.bukkit.inventory.EquipmentSlot
-import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.Damageable
 
 
@@ -67,10 +64,10 @@ object EffectDamageArmor : Effect<NoCompileData>("damage_armor") {
                     val event = PlayerItemDamageEvent(victim, item, damage)
                     Bukkit.getPluginManager().callEvent(event)
                     if (!event.isCancelled) {
-                        applyDamage(item, event.damage, victim)
+                        item.applyDamage(event.damage, victim)
                     }
                 } else {
-                    applyDamage(item, damage, null)
+                    item.applyDamage(damage, null)
                 }
             }
         } else {
@@ -83,37 +80,15 @@ object EffectDamageArmor : Effect<NoCompileData>("damage_armor") {
                         val event = PlayerItemDamageEvent(victim, item, damage)
                         Bukkit.getPluginManager().callEvent(event)
                         if (!event.isCancelled) {
-                            applyDamage(item, event.damage, victim)
+                            item.applyDamage(event.damage, victim)
                         }
                     } else {
-                        applyDamage(item, damage, null)
+                        item.applyDamage(damage, null)
                     }
                 }
             }
         }
 
         return true
     }
-
-    private fun applyDamage(itemStack: ItemStack, amount: Int, player: Player?) {
-        val meta = itemStack.itemMeta as? Damageable ?: return
-
-        meta.damage += amount
-
-        if (meta.damage >= itemStack.type.maxDurability) {
-            meta.damage = itemStack.type.maxDurability.toInt()
-
-            itemStack.itemMeta = meta
-
-            if (player != null) {
-                Bukkit.getPluginManager().callEvent(PlayerItemBreakEvent(player, itemStack))
-                player.playSound(player.location, Sound.ENTITY_ITEM_BREAK, SoundCategory.BLOCKS, 1f, 1f)
-            }
-
-            @Suppress("DEPRECATION")
-            itemStack.type = Material.AIR
-        } else {
-            itemStack.itemMeta = meta
-        }
-    }
 }

core/common/src/main/kotlin/com/willfp/libreforge/effects/impl/EffectDrill.kt

@@ -3,13 +3,13 @@ package com.willfp.libreforge.effects.impl
 import com.willfp.eco.core.config.interfaces.Config
 import com.willfp.eco.core.integrations.antigrief.AntigriefManager
 import com.willfp.eco.util.VectorUtils
-import com.willfp.eco.util.containsIgnoreCase
 import com.willfp.libreforge.NoCompileData
 import com.willfp.libreforge.arguments
 import com.willfp.libreforge.effects.templates.MineBlockEffect
 import com.willfp.libreforge.getIntFromExpression
 import com.willfp.libreforge.triggers.TriggerData
 import com.willfp.libreforge.triggers.TriggerParameter
+import org.bukkit.Material
 import org.bukkit.block.Block
 
 
@@ -25,46 +25,47 @@ object EffectDrill : MineBlockEffect<NoCompileData>("drill") {
 
     override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean {
         val block = data.block ?: data.location?.block ?: return false
-
         val player = data.player ?: return false
+        val world = block.world
 
         val amount = config.getIntFromExpression("amount", data)
 
-        if (player.isSneaking && config.getBool("disable_on_sneak")) {
+        if (player.isSneaking && config.getBool("disable_on_sneak"))
             return false
-        }
 
         val whitelist = config.getStringsOrNull("whitelist")
+            ?.mapNotNull { Material.matchMaterial(it.uppercase()) }?.toSet()
+
+        val blacklist = config.getStringsOrNull("blacklisted_blocks")
+            ?.mapNotNull { Material.matchMaterial(it.uppercase()) }?.toSet()
 
         val blocks = mutableSetOf<Block>()
 
+        val checkHardness = config.getBool("check_hardness")
+
         for (i in 1..amount) {
             val simplified = VectorUtils.simplifyVector(player.location.direction.normalize()).multiply(i)
-            val toBreak = block.world.getBlockAt(block.location.clone().add(simplified))
+            val toBreak = world.getBlockAt(block.location.clone().add(simplified))
 
-            if (config.getStrings("blacklisted_blocks").containsIgnoreCase(toBreak.type.name)) {
+            if (toBreak.type == Material.AIR)
                 continue
-            }
 
-            if (whitelist != null) {
-                if (!whitelist.containsIgnoreCase(toBreak.type.name)) {
-                    continue
-                }
-            }
+            if (toBreak.type.hardness < 0)
+                continue
+
+            if (!AntigriefManager.canBreakBlock(player, toBreak))
+                continue
 
-            if (config.getBool("check_hardness")) {
-                if (toBreak.type.hardness > block.type.hardness) {
+            if (blacklist != null)
+                if (toBreak.type in blacklist)
                     continue
-                }
-            }
 
-            if (!AntigriefManager.canBreakBlock(player, toBreak)) {
-                continue
-            }
+            if (whitelist != null)
+                if (toBreak.type !in whitelist)
+                    continue
 
-            if (toBreak.type.hardness < 0) {
+            if (checkHardness && toBreak.type.hardness > block.type.hardness)
                 continue
-            }
 
             blocks.add(toBreak)
         }

core/common/src/main/kotlin/com/willfp/libreforge/effects/impl/EffectGlowNearbyBlocks.kt

@@ -3,6 +3,7 @@
 package com.willfp.libreforge.effects.impl
 
 import com.willfp.eco.core.config.interfaces.Config
+import com.willfp.eco.core.events.MultiBlockBreakEvent
 import com.willfp.eco.util.TeamUtils
 import com.willfp.libreforge.NoCompileData
 import com.willfp.libreforge.arguments
@@ -133,4 +134,28 @@ object EffectGlowNearbyBlocks : Effect<NoCompileData>("glow_nearby_blocks") {
             shulker.remove()
         }
     }
+
+    @EventHandler
+    fun onBreak(event: MultiBlockBreakEvent) {
+        for (block in event.blocks) {
+            if (!block.hasMetadata("gnb-uuid")) {
+                return
+            }
+
+            val uuid = block.getMetadata("gnb-uuid").firstOrNull {
+                it.value() is UUID
+            }?.value() as? UUID ?: return
+
+            Bukkit.getServer().getEntity(uuid)?.remove()
+
+            for (shulker in block.location.world.getNearbyEntities(
+                block.location,
+                2.0,
+                2.0,
+                2.0
+            ) { it.hasMetadata("gnb-shulker") }) {
+                shulker.remove()
+            }
+        }
+    }
 }

core/common/src/main/kotlin/com/willfp/libreforge/effects/impl/EffectMineRadius.kt

@@ -2,7 +2,6 @@ package com.willfp.libreforge.effects.impl
 
 import com.willfp.eco.core.config.interfaces.Config
 import com.willfp.eco.core.integrations.antigrief.AntigriefManager
-import com.willfp.eco.util.containsIgnoreCase
 import com.willfp.libreforge.NoCompileData
 import com.willfp.libreforge.arguments
 import com.willfp.libreforge.effects.templates.MineBlockEffect
@@ -24,59 +23,56 @@ object EffectMineRadius : MineBlockEffect<NoCompileData>("mine_radius") {
     override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean {
         val block = data.block ?: data.location?.block ?: return false
         val player = data.player ?: return false
+        val world = block.world
 
         val radius = config.getIntFromExpression("radius", data)
 
-        if (player.isSneaking && config.getBool("disable_on_sneak")) {
+        if (player.isSneaking && config.getBool("disable_on_sneak"))
             return false
-        }
 
         val whitelist = config.getStringsOrNull("whitelist")
+            ?.mapNotNull { Material.matchMaterial(it.uppercase()) }?.toSet()
+
+        val blacklist = config.getStringsOrNull("blacklisted_blocks")
+            ?.mapNotNull { Material.matchMaterial(it.uppercase()) }?.toSet()
+
+        val blocks = mutableListOf<Block>()
 
-        val blocks = mutableSetOf<Block>()
+        val checkHardness = config.getBool("check_hardness")
+
+        for (y in (-radius..radius)) {
+            val endY = block.y + y
+            if (endY !in world.minHeight..world.maxHeight) {
+                continue
+            }
 
-        for (x in (-radius..radius)) {
-            for (y in (-radius..radius)) {
+            for (x in (-radius..radius)) {
                 for (z in (-radius..radius)) {
                     if (x == 0 && y == 0 && z == 0) {
                         continue
                     }
 
-                    val toBreak = block.world.getBlockAt(
-                        block.location.clone().add(x.toDouble(), y.toDouble(), z.toDouble())
-                    )
+                    val toBreak = world.getBlockAt(block.x + x, block.y + y, block.z + z)
 
-                    if (toBreak.location.blockY !in block.world.minHeight..block.world.maxHeight) {
+                    if (toBreak.type == Material.AIR)
                         continue
-                    }
 
-                    if (config.getStrings("blacklisted_blocks").containsIgnoreCase(toBreak.type.name)) {
+                    if (toBreak.type.hardness < 0)
                         continue
-                    }
 
-                    if (whitelist != null) {
-                        if (!whitelist.containsIgnoreCase(toBreak.type.name)) {
-                            continue
-                        }
-                    }
+                    if (!AntigriefManager.canBreakBlock(player, toBreak))
+                        continue
 
-                    if (config.getBoolOrNull("check_hardness") != false) {
-                        if (toBreak.type.hardness < 0 || toBreak.type.hardness > block.type.hardness) {
+                    if (blacklist != null)
+                        if (toBreak.type in blacklist)
                             continue
-                        }
-                    }
-
-                    if (toBreak.type.hardness < 0) {
-                        continue
-                    }
 
-                    if (toBreak.type == Material.AIR) {
-                        continue
-                    }
+                    if (whitelist != null)
+                        if (toBreak.type !in whitelist)
+                            continue
 
-                    if (!AntigriefManager.canBreakBlock(player, toBreak)) {
+                    if (checkHardness && toBreak.type.hardness > block.type.hardness)
                         continue
-                    }
 
                     blocks.add(toBreak)
                 }