first working version of tunnelling

.github/workflows/push.yml

@@ -10,13 +10,13 @@ jobs:
   build-commit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Set up JDK
-        uses: actions/setup-java@v6
+        uses: actions/setup-java@v3
         with:
-          java-version: '21'
+          java-version: 21
           distribution: 'temurin'
       - name: Set short commit hash
         run: fullCommit=${{ github.sha }} && echo "SHORT_SHA=${fullCommit:0:8}" >> $GITHUB_ENV

.github/workflows/wiki.yml

@@ -16,12 +16,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v7
+        uses: actions/checkout@v4
       - name: Build Astro page
-        uses: withastro/action@v6
+        uses: withastro/action@v4
         with:
           path: ./docs
-          node-version: '24'
+          node-version: '22'
   deploy:
     needs: build
     runs-on: ubuntu-latest
@@ -31,4 +31,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

docs/astro.config.mjs

@@ -11,7 +11,7 @@ export default defineConfig({
 			sidebar: [
 				{
 					label: 'Documentation',
-					items: [{ autogenerate: { "directory": "documentation" } }]
+					autogenerate: { directory: 'documentation' },
 				},
 				{
 					label: 'Configuration',

docs/package.json

@@ -10,7 +10,8 @@
     "astro": "astro"
   },
   "dependencies": {
-    "@astrojs/starlight": "^0.42.4",
-    "astro": "^7.2.10"
+    "@astrojs/starlight": "^0.34.3",
+    "astro": "^5.6.1",
+    "sharp": "^0.32.5"
   }
 }

docs/src/content/docs/configuration/input-types.md

@@ -4,41 +4,11 @@ description: How to specify common input types in configuration
 ---
 
 ## Tags
-
-### Items
-
-#### Item reference
-Example: `minecraft:stick`
-
-For specific items, use namespaced vanilla item id. If namespace is not provided, `minecraft` is assumed.
-
-#### Item tag
-Example: `#minecraft:axes`
-
-For <a href="https://minecraft.wiki/w/Item_tag_(Java_Edition)" target="_blank">item tags</a>, use namespaced tag id. If
-namespace is not provided, `minecraft` is assumed. Custom tags from other plugins and datapacks are also supported.
-
-### Blocks
-
-#### Block reference
-Example: `minecraft:dirt`
-
-For specific items, use namespaced vanilla item id. If namespace is not provided, `minecraft` is assumed.
-
-#### Block tag
-Example: `#minecraft:planks`
-
-For <a href="https://minecraft.wiki/w/Block_tag_(Java_Edition)" target="_blank">block tags</a>, use namespaced tag id. If
-namespace is not provided, `minecraft` is assumed. Custom tags from other plugins and datapacks are also supported.
-
-
-### Enchantments
-
-#### Enchantment tag
-Example: `#minecraft:in_enchanting_table`
-
-For <a href="https://minecraft.wiki/w/Enchantment_tag_(Java_Edition)" target="_blank">enchantment tags</a>, use namespaced tag id. If
-namespace is not provided, `minecraft` is assumed. Custom tags from other plugins and datapacks are also supported.
+There are 2 types of tags that can be used in the configuration:
+- `minecraft:item_name` - For specific items, use namespaced vanilla item id. If namespace is not provided, `minecraft` is assumed.
+- `#minecraft:item_tag_name` - For <a href="https://minecraft.wiki/w/Item_tag_(Java_Edition)" target="_blank">item tags</a>,
+  use namespaced tag id. If namespace is not provided, `minecraft` is assumed. Custom tags from other plugins and
+  datapacks are also supported.
 
 ## Slot types
 - `ANY` - Any slot.

docs/src/content/docs/configuration/reference.md

@@ -18,8 +18,8 @@ Cost that will be added to the item when adding the enchantment to it in anvil.
 
 - **Type**: `int`
 
-Weight of the enchantment. Higher numbers mean it will come up more frequently in the enchanting table. Used if
-`#minecraft:in_enchanting_table` is present in enchantment tags.
+Weight of the enchantment. Used if `canGetFromEnchantingTable` is set to true. Higher numbers mean it will come up more
+frequently in the enchanting table.
 
 ### minimumCost
 
@@ -29,7 +29,7 @@ Minimum cost that will be required for the enchantment to show up in the enchant
 
 - **Type**: `int`
 
-Base cost of the enchantment.
+Base cost of the enchant.
 
 #### perLevel
 
@@ -45,7 +45,7 @@ Maximum cost that will be required for the enchantment to show up in the enchant
 
 - **Type**: `int`
 
-Base cost of the enchantment.
+Base cost of the enchant.
 
 #### perLevel
 
@@ -55,22 +55,23 @@ Cost to add per level of the enchantment.
 
 ### enchantmentTags
 
-- **Type**: [`Enchantment Tags`](/configuration/input-types/#enchantment-tag)
+- **Type**: `key[]`
 
-This is list of tags that the enchantment will be tagged with. This can be used to put the enchantment in enchanting table,
-mark it as a curse, etc.
+This is list of [tags](/configuration/input-types#tags) that the enchantment will be tagged with. This can be used to put the enchantment in enchanting table,
+mark it as a curse, etc. <a href="https://minecraft.wiki/w/Enchantment_tag_(Java_Edition)" target="_blank">All vanilla</a>
+and custom tags are supported.
 
 ### supportedItemTags
 
-- **Type**: [`Item Tags`](/configuration/input-types/#items)
+- **Type**: `key[]`
 
-Items and/or item tags that the enchantment can be applied to.
+[Items and/or item tags](/configuration/input-types#tags) that the enchantment can be applied to.
 
 ### activeSlots
 
-- **Type**: [`Slot types`](/configuration/input-types/#slot-types)
+- **Type**: `string[]`
 
-Inventory slots that the enchantment will be active in.
+[Slots](/configuration/input-types#slot-types) that the enchantment will be active in.
 
 
 ### enabled
@@ -95,11 +96,9 @@ of the enchantment does not support multiple levels.
 
 ## Telepathy
 
-### onlyUserCanPickupItems
-
 - **Type**: `boolean`
 
-If set to true, items teleported by the enchantment will only be able to be picked up by the player that broke the block.
+If set to true, items teleported by the enchant will only be able to be picked up by the player that broke the block.
 
 ## Executioner
 
@@ -156,26 +155,6 @@ Cooldown in ticks that will be applied to the activating items cooldown group.
 
 Namespaced key of the sound that will play when enchantment blocks a hit.
 
-## Tunnelling
-
-### affectedBlockTags
-
-- **Type**: [`Block Tags`](/configuration/input-types/#blocks)
-
-List of blocks and block tags that will be affected by the enchantment's mining effect.
-
-### blocksPerLevel
-
-- **Type**: `int`
-
-How many blocks in each direction enchantment should mine per enchantment level.
-
-### visualizeBreaking
-
-- **Type**: `boolean`
-
-Display visualisation of blocks being broken by the enchantment along with breaking the base block.
-
 ## Panic
 
 ### panicChancePerLevel

docs/src/content/docs/documentation/enchant-list.md

@@ -73,14 +73,6 @@ Automatically blocks hits, but triggers a configurable cooldown every time it do
 the enchanted items cooldown group, so if you make this enchantment support more than just 1 item, you're going to have
 to handle applying the cooldown group to them yourself.
 
-### Tunnelling
-**Translation key**: `enchantio.enchantment.tunnelling`
-
-**Description**:
-Mines multiple blocks around initially destroyed block. Activates when mining affected block and breaks all the affected
-blocks in a `range x range x 1` pattern.
-
-
 ## Curses
 
 ### Curse of Panic

pom.xml

@@ -15,7 +15,7 @@
     <properties>
         <java.version>21</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <revision>1.16.1</revision>
+        <revision>1.15.2</revision>
     </properties>
     <url>https://youhavetrouble.me</url>
 

src/main/java/me/youhavetrouble/enchantio/enchants/TunnellingEnchant.java

@@ -25,7 +25,7 @@ public class TunnellingEnchant implements EnchantioEnchant {
     public static final Key AFFECTED_BLOCKS_KEY = Key.key("enchantio", "affected_by_tunnelling");
 
     private final int anvilCost, weight, maxLevel, blocksPerLevel;
-    private final boolean visualizeBreaking;
+    private final boolean canBreakToolIncompatibleBlocks;
     private final EnchantmentRegistryEntry.EnchantmentCost minimumCost;
     private final EnchantmentRegistryEntry.EnchantmentCost maximumCost;
     private final Set<TagEntry<ItemType>> supportedItemTags = new HashSet<>();
@@ -42,7 +42,7 @@ public class TunnellingEnchant implements EnchantioEnchant {
             Map<Key, Set<TagEntry<BlockType>>> affectedBlockTags,
             int maxLevel,
             int blocksPerLevel,
-            boolean visualizeBreaking
+            boolean canBreakToolIncompatibleBlocks
     ) {
         this.anvilCost = anvilCost;
         this.weight = weight;
@@ -50,7 +50,7 @@ public class TunnellingEnchant implements EnchantioEnchant {
         this.maximumCost = maximumCost;
         this.maxLevel = maxLevel;
         this.blocksPerLevel = blocksPerLevel;
-        this.visualizeBreaking = visualizeBreaking;
+        this.canBreakToolIncompatibleBlocks = canBreakToolIncompatibleBlocks;
         this.supportedItemTags.addAll(supportedItemTags);
         this.enchantTagKeys.addAll(enchantTagKeys);
         this.affectedBlockTags.putAll(affectedBlockTags);
@@ -115,8 +115,8 @@ public class TunnellingEnchant implements EnchantioEnchant {
         return blocksPerLevel;
     }
 
-    public boolean shouldVisualizeBreaking() {
-        return visualizeBreaking;
+    public boolean canBreakToolIncompatibleBlocks() {
+        return canBreakToolIncompatibleBlocks;
     }
 
     public static TunnellingEnchant create(ConfigurationSection configurationSection) {
@@ -152,19 +152,13 @@ public class TunnellingEnchant implements EnchantioEnchant {
                                         "#minecraft:base_stone_overworld",
                                         "#minecraft:base_stone_nether",
                                         "#minecraft:ores",
-                                        "#minecraft:terracotta",
-                                        "#minecraft:glazed_terracotta",
-                                        "#minecraft:concrete",
-                                        "#minecraft:stone_bricks",
-                                        "minecraft:end_stone",
-                                        "minecraft:cobblestone",
-                                        "minecraft:cobbled_deepslate"
+                                        "minecraft:end_stone"
                                 )
                         ))
                 ),
                 EnchantioConfig.getInt(configurationSection, "maxLevel", 1),
                 EnchantioConfig.getInt(configurationSection, "blocksPerLevel", 1),
-                EnchantioConfig.getBoolean(configurationSection, "visualizeBreaking", true)
+                EnchantioConfig.getBoolean(configurationSection, "canBreakToolIncompatibleBlocks", false)
         );
 
         if (EnchantioConfig.getBoolean(configurationSection, "enabled", true)) {

src/main/java/me/youhavetrouble/enchantio/listeners/TunnellingListener.java

@@ -5,6 +5,7 @@ import io.papermc.paper.registry.RegistryKey;
 import io.papermc.paper.registry.keys.tags.BlockTypeTagKeys;
 import me.youhavetrouble.enchantio.Enchantio;
 import me.youhavetrouble.enchantio.EnchantioConfig;
+import me.youhavetrouble.enchantio.enchants.EnchantioEnchant;
 import me.youhavetrouble.enchantio.enchants.TunnellingEnchant;
 import org.bukkit.*;
 import org.bukkit.block.Block;
@@ -15,144 +16,91 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
 import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockDamageAbortEvent;
-import org.bukkit.event.block.BlockDamageEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.ItemStack;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+import org.bukkit.persistence.PersistentDataType;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 @SuppressWarnings("UnstableApiUsage")
 public class TunnellingListener implements Listener {
 
     private final static Set<Block> blockBreakSkips = new HashSet<>();
-    private final static Map<UUID, BlockBreakData> blockBreakData = new ConcurrentHashMap<>();
     private final Enchantment tunnelling = RegistryAccess.registryAccess().getRegistry(RegistryKey.ENCHANTMENT).get(TunnellingEnchant.KEY);
-    private final TunnellingEnchant tunnellingEnchant;
+    private final NamespacedKey tunnellingBlockFaceKey = new NamespacedKey("enchantio", "tunellingblockface");
 
-    public TunnellingListener() {
-        if (EnchantioConfig.ENCHANTS.get(TunnellingEnchant.KEY) instanceof TunnellingEnchant enchant) {
-            this.tunnellingEnchant = enchant;
-        } else {
-            throw new RuntimeException("Tunnelling enchantment is not registered, but something tried to create a listener for it. Don't do that.");
-        }
-    }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        UUID uuid = event.getPlayer().getUniqueId();
-        if (!tunnellingEnchant.shouldVisualizeBreaking()) return;
-        event.getPlayer().getScheduler().runAtFixedRate(Enchantio.getPlugin(Enchantio.class), (task) -> {
-            Player player = Bukkit.getPlayer(uuid);
-            if (player == null || !player.isOnline()) {
-                task.cancel();
-                return;
-            }
-            BlockBreakData data = blockBreakData.get(uuid);
-            if (data == null) return;
-            if (player.isSneaking()) {
-                updateBlockBreakProgress(player, data, 0);
-                return;
-            }
-            long elapsed = System.currentTimeMillis() - data.startedBreakingAt();
-            long elapsedTicks = elapsed / 50;
-            float breakSpeed = data.block.getBreakSpeed(player);
-            float ticksNeeded = 1.0f / breakSpeed;
-            float progress = Math.min(elapsedTicks / ticksNeeded, 1.0f);
-            if (progress >= 1.0f) return;
-            updateBlockBreakProgress(player, data, progress);
-        }, null, 1, 1);
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onTunnelBlockStartBreak(BlockDamageEvent event) {
+    public void onTunnelBlockSideCheck(PlayerInteractEvent event) {
         if (tunnelling == null) return;
+        if (event.getHand() != EquipmentSlot.HAND) return;
+        if (event.getAction() != Action.LEFT_CLICK_BLOCK) return;
         Player player = event.getPlayer();
-        if (GameMode.CREATIVE.equals(player.getGameMode())) return;
-        ItemStack item = player.getInventory().getItemInMainHand();
-        if (item.isEmpty()) return;
-        int enchantLevel = item.getEnchantmentLevel(tunnelling);
-        if (enchantLevel == -1) return;
-        if (blockBreakData.containsKey(player.getUniqueId())) return;
-        Block block = event.getBlock();
-        Set<Block> blocksToBreak = getSquare(block, event.getBlockFace(), tunnellingEnchant.getBlocksPerLevel() * enchantLevel);
-        blockBreakData.put(player.getUniqueId(), new BlockBreakData(block, System.currentTimeMillis(), event.getBlockFace(), blocksToBreak));
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onTunnelBlockStopBreak(BlockDamageAbortEvent event) {
-        BlockBreakData data = blockBreakData.remove(event.getPlayer().getUniqueId());
-        if (data == null) return;
-        updateBlockBreakProgress(event.getPlayer(), data, 0f);
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        blockBreakData.remove(event.getPlayer().getUniqueId());
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerTpToAnotherWorld(PlayerTeleportEvent event) {
-        Player player = event.getPlayer();
-        BlockBreakData data = blockBreakData.get(player.getUniqueId());
-        if (data == null) return;
-        if (data.block.getWorld().getUID().equals(player.getWorld().getUID())) return;
-        blockBreakData.remove(player.getUniqueId());
+        if (player.isSneaking() || GameMode.CREATIVE.equals(player.getGameMode())) return;
+        ItemStack item = event.getItem();
+        if (item == null) return;
+        if (!item.containsEnchantment(tunnelling)) return;
+        event.getPlayer().getPersistentDataContainer().set(tunnellingBlockFaceKey, PersistentDataType.STRING, event.getBlockFace().toString());
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onTunnelBlockBreak(BlockBreakEvent event) {
         if (tunnelling == null) return;
         Player player = event.getPlayer();
-        Block block = event.getBlock();
-        BlockBreakData data = blockBreakData.remove(player.getUniqueId());
-        if (blockBreakSkips.contains(block)) return;
-        if (data != null) updateBlockBreakProgress(player, data, 0f);
         if (GameMode.CREATIVE.equals(player.getGameMode())) return;
         if (player.isSneaking()) return;
+        String rawFace = player.getPersistentDataContainer().get(tunnellingBlockFaceKey, PersistentDataType.STRING);
+        if (rawFace == null) return;
+        EnchantioEnchant enchant = EnchantioConfig.ENCHANTS.get(TunnellingEnchant.KEY);
+        if (!(enchant instanceof TunnellingEnchant tunnellingEnchant)) return;
         ItemStack item = event.getPlayer().getInventory().getItemInMainHand();
         int enchantLevel = item.getEnchantmentLevel(tunnelling);
         if (enchantLevel <= 0) return;
+        Block block = event.getBlock();
         BlockType blockType = block.getType().asBlockType();
         if (!Registry.BLOCK.getTagValues(BlockTypeTagKeys.create(TunnellingEnchant.AFFECTED_BLOCKS_KEY)).contains(blockType)) return;
-        if (data == null) return;
-        Set<Block> blocksToBreak = getSquare(block, data.blockFace, tunnellingEnchant.getBlocksPerLevel() * enchantLevel);
+        if (blockBreakSkips.contains(block)) return;
+        BlockFace blockFace;
+        try {
+            blockFace = BlockFace.valueOf(rawFace);
+        } catch (IllegalArgumentException e) {
+            return;
+        }
+        Set<Block> blocksToBreak = getSquare(block, blockFace, tunnellingEnchant.getBlocksPerLevel() * enchantLevel);
         blockBreakSkips.addAll(blocksToBreak);
         for (Block b : blocksToBreak) {
-            if (player.getInventory().getItemInMainHand().isEmpty()) {
-                event.setCancelled(true);
-                blockBreakSkips.removeAll(blocksToBreak);
-                break;
-            }
-            event.getPlayer().breakBlock(b);
+            BlockBreakEvent breakEvent = new BlockBreakEvent(b, player);
+            Enchantio.getPlugin(Enchantio.class).getServer().getPluginManager().callEvent(breakEvent);
             blockBreakSkips.remove(b);
-        }
+            breakBlock(breakEvent, tunnellingEnchant);
         }
 
-    private void updateBlockBreakProgress(Player player, BlockBreakData data, float progress) {
-        if (!tunnellingEnchant.shouldVisualizeBreaking()) return;
-        int id = Integer.MIN_VALUE;
-        for (Block block : data.blocksToSyncDamage) {
-            player.sendBlockDamage(block.getLocation(), progress, id++);
-        }
     }
 
     private Set<Block> getSquare(Block block, BlockFace face, int range) {
+        Set<Block> blocks = new  HashSet<>();
         switch (face) {
-            case DOWN, UP -> {
-                return getBlocksToTunnel(block.getLocation(), range, 0, range);
+            case DOWN:
+            case UP:
+                blocks.addAll(getBlocksToTunnel(block.getLocation(), range, 0, range));
+                break;
+            case EAST:
+            case WEST:
+                blocks.addAll(getBlocksToTunnel(block.getLocation(), 0, range, range));
+                break;
+            case NORTH:
+            case SOUTH:
+                blocks.addAll(getBlocksToTunnel(block.getLocation(), range, range, 0));
+                break;
+            default:
+                break;
         }
-            case EAST, WEST -> {
-                return getBlocksToTunnel(block.getLocation(), 0, range, range);
-            }
-            case NORTH, SOUTH -> {
-                return getBlocksToTunnel(block.getLocation(), range, range, 0);
-            }
-        }
-        return new HashSet<>();
+        return blocks;
     }
 
     /**
@@ -160,8 +108,8 @@ public class TunnellingListener implements Listener {
      * @param base location at the centre of selection
      * @return All blocks that will get broken
      */
-    private Set<Block> getBlocksToTunnel(Location base, int changeX, int changeY, int changeZ) {
-        Set<Block> blocks = new HashSet<>();
+    private List<Block> getBlocksToTunnel(Location base, int changeX, int changeY, int changeZ) {
+        List<Block> blocks = new ArrayList<>();
         for (int x = (base.getBlockX() - changeX); x <= (base.getBlockX() + changeX); x++) {
             for (int y = (base.getBlockY() - changeY); y <= (base.getBlockY() + changeY); y++) {
                 for (int z = (base.getBlockZ() - changeZ); z <= (base.getBlockZ() + changeZ); z++) {
@@ -178,6 +126,15 @@ public class TunnellingListener implements Listener {
         return blocks;
     }
 
-    private record BlockBreakData(Block block, long startedBreakingAt, BlockFace blockFace, Set<Block> blocksToSyncDamage) {}
+    private void breakBlock(BlockBreakEvent event, TunnellingEnchant enchant) {
+        if (tunnelling == null) return;
+        if (event.isCancelled()) return;
+        Block block = event.getBlock();
+        ItemStack item = event.getPlayer().getInventory().getItemInMainHand();
+        int enchantLevel = item.getEnchantmentLevel(tunnelling);
+        if (enchantLevel <= 0) return;
+        block.breakNaturally(item, true, event.getExpToDrop() > 0, enchant.canBreakToolIncompatibleBlocks());
+        item.damage(1, event.getPlayer());
+    }
 
 }