RS multikill support

still experimental

src/main/java/lol/hyper/toolstats/ToolStats.java

@@ -132,7 +132,7 @@ public final class ToolStats extends JavaPlugin {
         playerDrop = new PlayerDrop(this);
         if (Bukkit.getPluginManager().isPluginEnabled("RoseStacker")) {
             logger.info("RoseStacker has been detected, adding support!");
-            roseStacker = new RoseStacker();
+            roseStacker = new RoseStacker(this);
         }
 
         Bukkit.getServer().getPluginManager().registerEvents(blockBreak, this);

src/main/java/lol/hyper/toolstats/commands/CommandToolStats.java

@@ -423,6 +423,14 @@ public class CommandToolStats implements BasicCommand {
                 }
             }
         }
+        if (toolStats.config.getBoolean("enabled.logs-stripped")) {
+            if (container.has(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER)) {
+                Integer logsStripped = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+                if (logsStripped != null) {
+                    lore.add(toolStats.configTools.formatLore("logs-stripped", "{logs}", toolStats.numberFormat.formatInt(logsStripped)));
+                }
+            }
+        }
         finalMeta.lore(lore);
         finalItem.setItemMeta(finalMeta);
         int slot = player.getInventory().getHeldItemSlot();
@@ -878,6 +886,36 @@ public class CommandToolStats implements BasicCommand {
                 }
                 break;
             }
+            case "logs-stripped": {
+                if (!toolStats.config.getBoolean("enabled.logs-stripped")) {
+                    player.sendMessage(Component.text("This stat is disabled.", NamedTextColor.RED));
+                    return;
+                }
+                if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+                    int value;
+                    try {
+                        value = Integer.parseInt((String) userValue);
+                    } catch (NumberFormatException exception) {
+                        player.sendMessage(Component.text("That is not a valid number.", NamedTextColor.RED));
+                        return;
+                    }
+                    if (value < 0) {
+                        player.sendMessage(Component.text("Number must be positive.", NamedTextColor.RED));
+                        return;
+                    }
+                    Integer statValue = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+                    if (statValue == null) {
+                        player.sendMessage(Component.text("Unable to get stat from item.", NamedTextColor.RED));
+                        return;
+                    }
+                    int difference = value - statValue;
+                    editedItemMeta = toolStats.itemLore.updateLogsStripped(editedItem, difference);
+                    updated = true;
+                } else {
+                    player.sendMessage(Component.text("This item does not have that stat.", NamedTextColor.RED));
+                }
+                break;
+            }
             default: {
                 player.sendMessage(Component.text("That is not a valid stat to update.", NamedTextColor.RED));
                 return;
@@ -1271,6 +1309,34 @@ public class CommandToolStats implements BasicCommand {
                 }
                 break;
             }
+            case "logs-stripped": {
+                if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+                    Integer statValue = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+                    if (statValue == null) {
+                        player.sendMessage(Component.text("Unable to get stat from item.", NamedTextColor.RED));
+                        return;
+                    }
+                    String tokens = container.get(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING);
+                    if (tokens == null) {
+                        player.sendMessage(Component.text("Unable to get tokens from item.", NamedTextColor.RED));
+                        return;
+                    }
+                    container.remove(toolStats.toolStatsKeys.getLogsStripped());
+                    List<String> newTokens = toolStats.itemChecker.removeToken(tokens, "logs-stripped");
+                    if (newTokens.isEmpty()) {
+                        container.remove(toolStats.toolStatsKeys.getTokenApplied());
+                    } else {
+                        container.set(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING, String.join(",", newTokens));
+                    }
+
+                    Component oldLine = toolStats.configTools.formatLore("logs-stripped", "{logs}", toolStats.numberFormat.formatInt(statValue));
+                    List<Component> newLore = toolStats.itemLore.removeLore(editedItemMeta.lore(), oldLine);
+                    editedItemMeta.lore(newLore);
+                } else {
+                    player.sendMessage(Component.text("This item does not have that stat.", NamedTextColor.RED));
+                }
+                break;
+            }
             default: {
                 player.sendMessage(Component.text("That is not a valid stat to update.", NamedTextColor.RED));
                 return;

src/main/java/lol/hyper/toolstats/events/AnvilEvent.java

@@ -39,7 +39,7 @@ public class AnvilEvent implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onAnvilEvent(PrepareAnvilEvent event) {
         // only listen if the token system is enabled
         if (!toolStats.config.getBoolean("tokens.enabled")) {
@@ -139,6 +139,10 @@ public class AnvilEvent implements Listener {
                     addToken(event, tokenType, "critical-strikes", clone);
                     return;
                 }
+                if (tokenType.equalsIgnoreCase("logs-stripped")) {
+                    addToken(event, tokenType, "logs-stripped", clone);
+                    return;
+                }
             }
             return;
         }
@@ -363,6 +367,15 @@ public class AnvilEvent implements Listener {
                 }
                 break;
             }
+            case "logs-stripped": {
+                if (toolStats.config.getBoolean("enabled.logs-stripped")) {
+                    newItem.setItemMeta(toolStats.itemLore.updateLogsStripped(newItem, 0));
+                } else {
+                    event.setResult(null);
+                    return;
+                }
+                break;
+            }
         }
         event.setResult(newItem);
         event.getView().setRepairCost(toolStats.itemChecker.getCost(targetToken));
@@ -496,6 +509,14 @@ public class AnvilEvent implements Listener {
             meta = toolStats.itemLore.updateTridentThrows(finalItem, -tridentThrows);
             finalItem.setItemMeta(meta);
         }
+        if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+            Integer logsStripped = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+            if (logsStripped == null) {
+                return;
+            }
+            meta = toolStats.itemLore.updateLogsStripped(finalItem, -logsStripped);
+            finalItem.setItemMeta(meta);
+        }
         event.setResult(finalItem);
         event.getView().setRepairCost(toolStats.itemChecker.getCost("reset"));
     }

src/main/java/lol/hyper/toolstats/events/BlockBreak.java

@@ -39,17 +39,14 @@ import java.util.Locale;
 public class BlockBreak implements Listener {
 
     private final ToolStats toolStats;
-    public List<Block> brokenContainers = new ArrayList<>();
+    public final List<Block> brokenContainers = new ArrayList<>();
 
     public BlockBreak(ToolStats toolStats) {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onBreak(BlockBreakEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
         Player player = event.getPlayer();
         if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {
             return;

src/main/java/lol/hyper/toolstats/events/BlockDispenseEvent.java

@@ -45,7 +45,7 @@ public class BlockDispenseEvent implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onDispense(BlockDispenseLootEvent event) {
         Player player = event.getPlayer();
         if (player == null) {

src/main/java/lol/hyper/toolstats/events/ChunkPopulate.java

@@ -44,7 +44,7 @@ public class ChunkPopulate implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPopulate(ChunkPopulateEvent event) {
         if (event.getChunk().getWorld().getEnvironment() != World.Environment.THE_END) {
             return;
@@ -56,7 +56,7 @@ public class ChunkPopulate implements Listener {
         // this is delayed because entities are not loaded instantly
         // we just check 1 second later
         Chunk chunk = event.getChunk();
-        Bukkit.getRegionScheduler().runDelayed(toolStats, world, chunk.getX(), chunk.getZ(), scheduledTask -> {
+        Bukkit.getRegionScheduler().runDelayed(toolStats, world, chunk.getX(), chunk.getZ(), _ -> {
             for (Entity entity : chunk.getEntities()) {
                 // if there is a new item frame
                 if (!(entity instanceof ItemFrame itemFrame)) {

src/main/java/lol/hyper/toolstats/events/CraftItem.java

@@ -44,11 +44,8 @@ public class CraftItem implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onCraft(CraftItemEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
         Player player = (Player) event.getWhoClicked();
         if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {
             return;

src/main/java/lol/hyper/toolstats/events/CreativeEvent.java

@@ -23,6 +23,7 @@ import net.kyori.adventure.text.Component;
 import org.bukkit.GameMode;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.inventory.InventoryCreativeEvent;
 import org.bukkit.inventory.ItemStack;
@@ -42,7 +43,7 @@ public class CreativeEvent implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onCreativeEvent(InventoryCreativeEvent event) {
         Player player = (Player) event.getWhoClicked();
         if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {

src/main/java/lol/hyper/toolstats/events/EntityDamage.java

@@ -34,7 +34,6 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.projectiles.ProjectileSource;
 
 import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public class EntityDamage implements Listener {
 
@@ -47,12 +46,8 @@ public class EntityDamage implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onDamage(EntityDamageByEntityEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
         if (!(event.getEntity() instanceof LivingEntity mobBeingAttacked)) {
             return;
         }
@@ -264,12 +259,22 @@ public class EntityDamage implements Listener {
 
         if (type.equalsIgnoreCase("mob")) {
             // player is shooting a mob
-            ItemMeta newBow;
-            int count = 1;
             if (toolStats.roseStacker != null) {
-                count = toolStats.roseStacker.countMobs(entity);
+                toolStats.roseStacker.countMobs(entity, count -> {
+                    ItemMeta newBow = toolStats.itemLore.updateMobKills(heldBow, count);
+                    if (newBow != null) {
+                        if (isMain && isOffHand) {
+                            playerInventory.getItemInMainHand().setItemMeta(newBow);
+                        } else if (isMain) {
+                            playerInventory.getItemInMainHand().setItemMeta(newBow);
+                        } else if (isOffHand) {
+                            playerInventory.getItemInOffHand().setItemMeta(newBow);
                         }
-            newBow = toolStats.itemLore.updateMobKills(heldBow, count);
+                    }
+                });
+                return;
+            }
+            ItemMeta newBow = toolStats.itemLore.updateMobKills(heldBow, 1);
             if (newBow != null) {
                 if (isMain && isOffHand) {
                     playerInventory.getItemInMainHand().setItemMeta(newBow);
@@ -297,20 +302,31 @@ public class EntityDamage implements Listener {
 
     private void updateTridentKills(Trident trident, String type, LivingEntity entity) {
         ItemStack newTrident = trident.getItemStack();
-        ItemMeta newTridentMeta;
         if (type.equalsIgnoreCase("player")) {
-            newTridentMeta = toolStats.itemLore.updatePlayerKills(trident.getItemStack(), 1);
+            ItemMeta newTridentMeta = toolStats.itemLore.updatePlayerKills(trident.getItemStack(), 1);
-        } else {
-            int count = 1;
-            if (toolStats.roseStacker != null) {
-                count = toolStats.roseStacker.countMobs(entity);
-            }
-            newTridentMeta = toolStats.itemLore.updateMobKills(newTrident, count);
-        }
             if (newTridentMeta != null) {
                 newTrident.setItemMeta(newTridentMeta);
                 trident.setItemStack(newTrident);
             }
+            return;
+        }
+        if (type.equalsIgnoreCase("mob")) {
+            if (toolStats.roseStacker != null) {
+                toolStats.roseStacker.countMobs(entity, count -> {
+                    ItemMeta newTridentMeta = toolStats.itemLore.updateMobKills(newTrident, count);
+                    if (newTridentMeta != null) {
+                        newTrident.setItemMeta(newTridentMeta);
+                        trident.setItemStack(newTrident);
+                    }
+                });
+                return;
+            }
+            ItemMeta newTridentMeta = toolStats.itemLore.updateMobKills(trident.getItemStack(), 1);
+            if (newTridentMeta != null) {
+                newTrident.setItemMeta(newTridentMeta);
+                trident.setItemStack(newTrident);
+            }
+        }
     }
 
     private void updateTridentDamage(Trident trident, double damage) {
@@ -332,27 +348,36 @@ public class EntityDamage implements Listener {
 
     private void updateWeaponKills(PlayerInventory playerInventory, String type, LivingEntity entity) {
         ItemStack heldWeapon = playerInventory.getItemInMainHand();
-        ItemMeta newHeldWeaponMeta = null;
         if (type.equalsIgnoreCase("player")) {
-            newHeldWeaponMeta = toolStats.itemLore.updatePlayerKills(heldWeapon, 1);
+            ItemMeta newHeldWeaponMeta = toolStats.itemLore.updatePlayerKills(heldWeapon, 1);
-        }
-        if (type.equalsIgnoreCase("mob")) {
-            int count = 1;
-            if (toolStats.roseStacker != null) {
-                count = toolStats.roseStacker.countMobs(entity);
-            }
-            newHeldWeaponMeta = toolStats.itemLore.updateMobKills(heldWeapon, count);
-        }
             if (newHeldWeaponMeta != null) {
                 playerInventory.getItemInMainHand().setItemMeta(newHeldWeaponMeta);
             }
+            return;
+        }
+        if (type.equalsIgnoreCase("mob")) {
+            if (toolStats.roseStacker != null) {
+                toolStats.roseStacker.countMobs(entity, count -> {
+                    ItemStack currentHeldWeapon = playerInventory.getItemInMainHand();
+                    ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateMobKills(currentHeldWeapon, count);
+                    if (newHeldWeaponMeta != null) {
+                        currentHeldWeapon.setItemMeta(newHeldWeaponMeta);
+                    }
+                });
+            } else {
+                ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateMobKills(heldWeapon, 1);
+                if (newHeldWeaponMeta != null) {
+                    playerInventory.getItemInMainHand().setItemMeta(newHeldWeaponMeta);
+                }
+            }
+        }
     }
 
     private void updateBossesKilled(PlayerInventory playerInventory, String boss, LivingEntity entity) {
         ItemStack heldWeapon = playerInventory.getItemInMainHand();
         int count = 1;
         if (toolStats.roseStacker != null) {
-            count = toolStats.roseStacker.countMobs(entity);
+            //count = toolStats.roseStacker.countMobs(entity);
         }
         ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateBossesKilled(heldWeapon, count, boss);
         if (newHeldWeaponMeta != null) {
@@ -369,12 +394,23 @@ public class EntityDamage implements Listener {
         boolean isMain = playerInventory.getItemInMainHand().getType() == Material.BOW || playerInventory.getItemInMainHand().getType() == Material.CROSSBOW;
         boolean isOffHand = playerInventory.getItemInOffHand().getType() == Material.BOW || playerInventory.getItemInOffHand().getType() == Material.CROSSBOW;
 
-        int count = 1;
         if (toolStats.roseStacker != null) {
-            count = toolStats.roseStacker.countMobs(entity);
+            toolStats.roseStacker.countMobs(entity, count -> {
+                ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateBossesKilled(heldBow, count, boss);
+                if (newHeldWeaponMeta != null) {
+                    if (isMain && isOffHand) {
+                        playerInventory.getItemInMainHand().setItemMeta(newHeldWeaponMeta);
+                    } else if (isMain) {
+                        playerInventory.getItemInMainHand().setItemMeta(newHeldWeaponMeta);
+                    } else if (isOffHand) {
+                        playerInventory.getItemInOffHand().setItemMeta(newHeldWeaponMeta);
+                    }
+                }
+            });
+            return;
         }
 
-        ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateBossesKilled(heldBow, count, boss);
+        ItemMeta newHeldWeaponMeta = toolStats.itemLore.updateBossesKilled(heldBow, 1, boss);
         if (newHeldWeaponMeta != null) {
             if (isMain && isOffHand) {
                 playerInventory.getItemInMainHand().setItemMeta(newHeldWeaponMeta);

src/main/java/lol/hyper/toolstats/events/EntityDeath.java

@@ -43,7 +43,7 @@ public class EntityDeath implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onDeath(EntityDeathEvent event) {
         LivingEntity livingEntity = event.getEntity();
         if (livingEntity instanceof Player) {

src/main/java/lol/hyper/toolstats/events/GenerateLoot.java

@@ -39,14 +39,14 @@ import java.util.Map;
 public class GenerateLoot implements Listener {
 
     private final ToolStats toolStats;
-    public Map<Inventory, Location> generatedInventory = new HashMap<>();
+    public final Map<Inventory, Location> generatedInventory = new HashMap<>();
-    public List<Location> droppedLootLocations = new ArrayList<>();
+    public final List<Location> droppedLootLocations = new ArrayList<>();
 
     public GenerateLoot(ToolStats toolStats) {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onGenerateLoot(LootGenerateEvent event) {
         InventoryHolder inventoryHolder = event.getInventoryHolder();
         if (inventoryHolder == null) {

src/main/java/lol/hyper/toolstats/events/InventoryClose.java

@@ -50,7 +50,7 @@ public class InventoryClose implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler
+    @EventHandler(ignoreCancelled = true)
     public void onClose(InventoryCloseEvent event) {
         if (toolStats.generateLoot.generatedInventory.isEmpty()) {
             return;
@@ -106,7 +106,7 @@ public class InventoryClose implements Listener {
                 }, null, 1);
             }
 
-            if (holder instanceof Container container) {
+            if (holder instanceof Container) {
                 Chunk chestChunk = chestLocation.getChunk();
                 Bukkit.getRegionScheduler().runDelayed(toolStats, chestLocation.getWorld(), chestChunk.getX(), chestChunk.getZ(), scheduledTask -> {
                     BlockState blockState = chestLocation.getWorld().getBlockAt(chestLocation).getState();

src/main/java/lol/hyper/toolstats/events/InventoryOpen.java

@@ -42,12 +42,8 @@ public class InventoryOpen implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler
+    @EventHandler(ignoreCancelled = true)
     public void onOpen(InventoryOpenEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
         Inventory inventory = event.getInventory();
         InventoryHolder holder = inventory.getHolder();
         boolean isBlockInventory = holder instanceof BlockInventoryHolder || holder instanceof DoubleChest;

src/main/java/lol/hyper/toolstats/events/PickupItem.java

@@ -47,11 +47,8 @@ public class PickupItem implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPickup(EntityPickupItemEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
         Entity entity = event.getEntity();
         if (entity instanceof Player player) {
             if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {

src/main/java/lol/hyper/toolstats/events/PlayerDrop.java

@@ -34,7 +34,7 @@ public class PlayerDrop implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler
+    @EventHandler(ignoreCancelled = true)
     public void onDrop(PlayerDropItemEvent event) {
         Player player = event.getPlayer();
         if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {

src/main/java/lol/hyper/toolstats/events/PlayerFish.java

@@ -46,11 +46,8 @@ public class PlayerFish implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onFish(PlayerFishEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
         // only listen to when a player catches a fish
         if (event.getState() != PlayerFishEvent.State.CAUGHT_FISH) {
             return;

src/main/java/lol/hyper/toolstats/events/PlayerInteract.java

@@ -33,9 +33,13 @@ import org.bukkit.event.player.PlayerInteractEntityEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.ItemMeta;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
 public class PlayerInteract implements Listener {
 
@@ -50,7 +54,7 @@ public class PlayerInteract implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler
+    @EventHandler(ignoreCancelled = true)
     public void onInteract(PlayerInteractEvent event) {
         if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
             return;
@@ -74,11 +78,35 @@ public class PlayerInteract implements Listener {
             Inventory holderInventory = holder.getInventory();
             openedChests.add(block);
             chestInventories.add(holderInventory);
-            Bukkit.getGlobalRegionScheduler().runDelayed(toolStats, scheduledTask -> openedChests.remove(block), 20);
+            Bukkit.getGlobalRegionScheduler().runDelayed(toolStats, _ -> openedChests.remove(block), 20);
+        }
+        // player right-clicked a log
+        String blockType = block.getType().toString().toLowerCase(Locale.ROOT);
+        if (blockType.endsWith("_log") && !blockType.contains("stripped")) {
+            PlayerInventory playerInventory = player.getInventory();
+            ItemStack axe = toolStats.itemChecker.getAxe(playerInventory);
+
+            // not holding an axe
+            if (axe == null) {
+                return;
+            }
+
+            ItemMeta newAxe = toolStats.itemLore.updateLogsStripped(axe, 1);
+            if (newAxe != null) {
+                boolean isMain = playerInventory.getItemInMainHand().getType().toString().endsWith("_AXE");
+                boolean isOffHand = playerInventory.getItemInOffHand().getType().toString().endsWith("_AXE");
+                if (isMain && isOffHand) {
+                    playerInventory.getItemInMainHand().setItemMeta(newAxe);
+                } else if (isMain) {
+                    playerInventory.getItemInMainHand().setItemMeta(newAxe);
+                } else if (isOffHand) {
+                    playerInventory.getItemInOffHand().setItemMeta(newAxe);
+                }
+            }
         }
     }
 
-    @EventHandler
+    @EventHandler(ignoreCancelled = true)
     public void onInteract(PlayerInteractEntityEvent event) {
         Entity clicked = event.getRightClicked();
         Player player = event.getPlayer();
@@ -91,7 +119,7 @@ public class PlayerInteract implements Listener {
             Inventory mineCartInventory = storageMinecart.getInventory();
             mineCartChestInventories.add(mineCartInventory);
             openedMineCarts.add(storageMinecart);
-            Bukkit.getGlobalRegionScheduler().runDelayed(toolStats, scheduledTask -> openedMineCarts.remove(storageMinecart), 20);
+            Bukkit.getGlobalRegionScheduler().runDelayed(toolStats, _ -> openedMineCarts.remove(storageMinecart), 20);
         }
     }
 }

src/main/java/lol/hyper/toolstats/events/PlayerMove.java

@@ -39,7 +39,7 @@ public class PlayerMove implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onMove(PlayerMoveEvent event) {
         Player player = event.getPlayer();
         if (!toolStats.configTools.checkWorld(player.getWorld().getName())) {

src/main/java/lol/hyper/toolstats/events/SheepShear.java

@@ -39,7 +39,7 @@ public class SheepShear implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onShear(PlayerInteractEntityEvent event) {
         if (event.isCancelled()) {
             return;

src/main/java/lol/hyper/toolstats/events/ShootBow.java

@@ -38,7 +38,7 @@ public class ShootBow implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onShoot(EntityShootBowEvent event) {
         Entity shooter = event.getEntity();
         // only listen for players

src/main/java/lol/hyper/toolstats/events/VillagerTrade.java

@@ -47,9 +47,9 @@ public class VillagerTrade implements Listener {
         this.toolStats = toolStats;
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST)
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onTrade(InventoryClickEvent event) {
-        if (event.isCancelled() || event.getCurrentItem() == null) {
+        if (event.getCurrentItem() == null) {
             return;
         }
         Inventory inventory = event.getClickedInventory();

src/main/java/lol/hyper/toolstats/support/rosestacker/RoseStacker.java

@@ -36,32 +36,61 @@ package lol.hyper.toolstats.support.rosestacker;
 
 import dev.rosewood.rosestacker.api.RoseStackerAPI;
 import dev.rosewood.rosestacker.stack.StackedEntity;
+import lol.hyper.toolstats.ToolStats;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
 import org.bukkit.entity.LivingEntity;
 
+import java.util.function.Consumer;
+
 public class RoseStacker {
 
+    private final ToolStats toolStats;
     private final RoseStackerAPI rsAPI;
 
-    public RoseStacker() {
+    public RoseStacker(ToolStats toolStats) {
+        this.toolStats = toolStats;
         this.rsAPI = RoseStackerAPI.getInstance();
     }
 
-    public int countMobs(LivingEntity entity) {
+    public void countMobs(LivingEntity entity, Consumer<Integer> callback) {
         if (!rsAPI.isEntityStacked(entity)) {
             // if the entity is not stacked, ignore
-            return 1;
+            callback.accept(1);
+            return;
         }
         StackedEntity stackedEntity = rsAPI.getStackedEntity(entity);
         if (stackedEntity == null) {
-            return 1;
+            callback.accept(1);
+            return;
         }
 
+        int before = stackedEntity.getStackSize();
         boolean killAll = stackedEntity.getStackSettings().shouldKillEntireStackOnDeath();
         // if we kill the entire stack, add the entire stack to the count
         if (killAll) {
-            return stackedEntity.getStackSize();
+            callback.accept(before);
+            return;
         }
 
-        return 1;
+        Location stackedLocation = stackedEntity.getLocation();
+        Chunk stackedChunk = stackedEntity.getLocation().getChunk();
+        // check the stack size after a tick to see the difference
+        Bukkit.getRegionScheduler().runDelayed(toolStats, stackedLocation.getWorld(), stackedChunk.getX(), stackedChunk.getZ(), _ -> {
+            int after = stackedEntity.getStackSize();
+            int difference = before - after;
+            // if the diff goes negative, we killed more than the stack
+            // we killed the entire stack, so return the size
+            if (difference <= 0) {
+                difference = before;
+            }
+
+            toolStats.logger.info("before: {}", before);
+            toolStats.logger.info("after: {}", after);
+            toolStats.logger.info("difference: {}", difference);
+
+            callback.accept(difference);
+        }, 1);
     }
 }

src/main/java/lol/hyper/toolstats/tools/ItemChecker.java

@@ -306,6 +306,35 @@ public class ItemChecker {
         return null;
     }
 
+    /**
+     * Get the player's axe.
+     *
+     * @param inventory Their inventory.
+     * @return Their axe, either main or offhand.
+     */
+    public @Nullable ItemStack getAxe(PlayerInventory inventory) {
+        ItemStack main = inventory.getItemInMainHand();
+        ItemStack offHand = inventory.getItemInOffHand();
+
+        boolean isMain = main.getType().toString().endsWith("_AXE");
+        boolean isOffHand = offHand.getType().toString().endsWith("_AXE");
+
+        // if the player is holding an axe in their main hand, use that one
+        // if the axe is in their offhand instead, use that one after checking main hand
+        // Minecraft prioritizes main hand if the player holds in both hands
+        if (isMain && isOffHand) {
+            return main;
+        }
+        if (isMain) {
+            return main;
+        }
+        if (isOffHand) {
+            return offHand;
+        }
+
+        return null;
+    }
+
     /**
      * Checks the keys of the item and returns the tokens we should add.
      * If the server swaps token systems this should allow compatability.
@@ -363,6 +392,9 @@ public class ItemChecker {
         if (container.has(toolStats.toolStatsKeys.getTridentThrows())) {
             tokens.add("trident-throws");
         }
+        if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+            tokens.add("logs-stripped");
+        }
         if (tokens.isEmpty()) {
             return null;
         }

src/main/java/lol/hyper/toolstats/tools/ItemLore.java

@@ -1299,7 +1299,7 @@ public class ItemLore {
 
         if (criticalStrikes == null) {
             criticalStrikes = 0;
-            toolStats.logger.warn("{} does not have valid fish-caught set! Resting to zero. This should NEVER happen.", clone);
+            toolStats.logger.warn("{} does not have valid critical-strikes set! Resting to zero. This should NEVER happen.", clone);
         }
 
         container.set(toolStats.toolStatsKeys.getCriticalStrikes(), PersistentDataType.INTEGER, criticalStrikes + add);
@@ -1397,7 +1397,7 @@ public class ItemLore {
 
         if (tridentThrows == null) {
             tridentThrows = 0;
-            toolStats.logger.warn("{} does not have valid fish-caught set! Resting to zero. This should NEVER happen.", clone);
+            toolStats.logger.warn("{} does not have valid trident-throws set! Resting to zero. This should NEVER happen.", clone);
         }
 
         container.set(toolStats.toolStatsKeys.getTridentThrows(), PersistentDataType.INTEGER, tridentThrows + add);
@@ -1413,6 +1413,104 @@ public class ItemLore {
         return meta;
     }
 
+    /**
+     * Add x to logs stripped.
+     *
+     * @param axe The axe used.
+     */
+    public ItemMeta updateLogsStripped(ItemStack axe, int add) {
+        ItemStack clone = axe.clone();
+        ItemMeta meta = clone.getItemMeta();
+        if (meta == null) {
+            toolStats.logger.warn("{} does NOT have any meta! Unable to update stats.", clone);
+            return null;
+        }
+
+        PersistentDataContainer container = meta.getPersistentDataContainer();
+
+        // if it's disabled, don't update the stats
+        // check to see if the item has the stats, remove them if it does
+        if (!toolStats.config.getBoolean("enabled.logs-stripped")) {
+            if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+                Integer logsStripped = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+                if (logsStripped == null) {
+                    return null;
+                }
+                container.remove(toolStats.toolStatsKeys.getLogsStripped());
+                // remove the applied token if this stat is disabled
+                if (container.has(toolStats.toolStatsKeys.getTokenApplied())) {
+                    String appliedTokens = container.get(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING);
+                    if (appliedTokens != null) {
+                        // remove the token from the list
+                        // if the list is empty, remove the PDC
+                        // otherwise set the PDC back with the new list
+                        List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "logs-stripped");
+                        if (!newTokens.isEmpty()) {
+                            container.set(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING, String.join(",", newTokens));
+                        } else {
+                            container.remove(toolStats.toolStatsKeys.getTokenApplied());
+                        }
+                    }
+                }
+                if (meta.hasLore()) {
+                    String oldLogsStripped = toolStats.numberFormat.formatInt(logsStripped);
+                    Component lineToRemove = toolStats.configTools.formatLore("logs-stripped", "{logs}", oldLogsStripped);
+                    List<Component> newLore = removeLore(meta.lore(), lineToRemove);
+                    meta.lore(newLore);
+                }
+                return meta;
+            }
+            return null;
+        }
+
+        // check for tokens
+        boolean validToken = toolStats.itemChecker.checkTokens(container, "logs-stripped");
+        // check for tokens
+        if (toolStats.config.getBoolean("tokens.enabled")) {
+            // if the item has stats but no token, add the token
+            if (container.has(toolStats.toolStatsKeys.getLogsStripped()) && !validToken) {
+                String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
+                if (newTokens != null) {
+                    container.set(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING, newTokens);
+                }
+            }
+
+            // the item does not have a valid token
+            if (!validToken) {
+                return null;
+            }
+        } else {
+            if (!validToken) {
+                String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
+                if (newTokens != null) {
+                    container.set(toolStats.toolStatsKeys.getTokenApplied(), PersistentDataType.STRING, newTokens);
+                }
+            }
+        }
+
+        Integer logsStripped = 0;
+        if (container.has(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER)) {
+            logsStripped = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+        }
+
+        if (logsStripped == null) {
+            logsStripped = 0;
+            toolStats.logger.warn("{} does not have valid logs-stripped set! Resting to zero. This should NEVER happen.", clone);
+        }
+
+        container.set(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER, logsStripped + add);
+        String oldLogsStrippedFormatted = toolStats.numberFormat.formatInt(logsStripped);
+        String newLogsStrippedFormatted = toolStats.numberFormat.formatInt(logsStripped + add);
+        Component oldLine = toolStats.configTools.formatLore("logs-stripped", "{logs}", oldLogsStrippedFormatted);
+        Component newLine = toolStats.configTools.formatLore("logs-stripped", "{logs}", newLogsStrippedFormatted);
+        if (oldLine == null || newLine == null) {
+            return null;
+        }
+        List<Component> newLore = updateItemLore(meta, oldLine, newLine);
+        meta.lore(newLore);
+        return meta;
+    }
+
     /**
      * Format the item owner lore.
      *
@@ -1667,6 +1765,26 @@ public class ItemLore {
                 finalItem.setItemMeta(meta);
             }
         }
+        if (container.has(toolStats.toolStatsKeys.getTridentThrows())) {
+            Integer tridentThrows = container.get(toolStats.toolStatsKeys.getTridentThrows(), PersistentDataType.INTEGER);
+            if (tridentThrows != null) {
+                container.remove(toolStats.toolStatsKeys.getTridentThrows());
+                String tridentThrowsFormatted = toolStats.numberFormat.formatInt(tridentThrows);
+                Component lineToRemove = toolStats.configTools.formatLore("trident-throws", "{times}", tridentThrowsFormatted);
+                meta.lore(removeLore(meta.lore(), lineToRemove));
+                finalItem.setItemMeta(meta);
+            }
+        }
+        if (container.has(toolStats.toolStatsKeys.getLogsStripped())) {
+            Integer logsStripped = container.get(toolStats.toolStatsKeys.getLogsStripped(), PersistentDataType.INTEGER);
+            if (logsStripped != null) {
+                container.remove(toolStats.toolStatsKeys.getLogsStripped());
+                String logsStrippedFormatted = toolStats.numberFormat.formatInt(logsStripped);
+                Component lineToRemove = toolStats.configTools.formatLore("logs-stripped", "{logs}", logsStrippedFormatted);
+                meta.lore(removeLore(meta.lore(), lineToRemove));
+                finalItem.setItemMeta(meta);
+            }
+        }
         if (removeMeta) {
             Integer origin = null;
             if (container.has(toolStats.toolStatsKeys.getOriginType())) {

src/main/java/lol/hyper/toolstats/tools/TokenData.java

@@ -153,6 +153,13 @@ public class TokenData {
         tridentThrowsRecipe.setIngredient('S', Material.PRISMARINE_SHARD);
         recipes.add(tridentThrowsRecipe);
 
+        NamespacedKey logsStrippedKey = new NamespacedKey(toolStats, "logs-stripped-token");
+        ShapedRecipe logsStrippedRecipe = new ShapedRecipe(logsStrippedKey, createToken("logs-stripped"));
+        logsStrippedRecipe.shape(" P ", "PSP", " P ");
+        logsStrippedRecipe.setIngredient('P', Material.PAPER);
+        logsStrippedRecipe.setIngredient('S', Material.WOODEN_AXE);
+        recipes.add(logsStrippedRecipe);
+
         tokenTypes.add("crops-mined");
         tokenTypes.add("blocks-mined");
         tokenTypes.add("damage-taken");
@@ -169,6 +176,7 @@ public class TokenData {
         tokenTypes.add("enderdragon-kills");
         tokenTypes.add("critical-strikes");
         tokenTypes.add("trident-throws");
+        tokenTypes.add("logs-stripped");
     }
 
     public Set<ShapedRecipe> getRecipes() {

src/main/java/lol/hyper/toolstats/tools/ToolStatsKeys.java

@@ -37,6 +37,7 @@ public class ToolStatsKeys {
     private NamespacedKey criticalStrikes;
     private NamespacedKey tridentThrows;
     private NamespacedKey originType;
+    private NamespacedKey logsStripped;
 
     public void make() {
         itemOwner = new NamespacedKey(toolStats, "owner");
@@ -61,6 +62,7 @@ public class ToolStatsKeys {
         criticalStrikes = new NamespacedKey(toolStats, "critical-strikes");
         tridentThrows = new NamespacedKey(toolStats, "trident-throws");
         originType = new NamespacedKey(toolStats, "origin");
+        logsStripped = new NamespacedKey(toolStats, "logs-stripped");
 
         // save which stat can be used by a reset token
         tokenKeys.add(blocksMined);
@@ -76,6 +78,7 @@ public class ToolStatsKeys {
         tokenKeys.add(enderDragonKills);
         tokenKeys.add(criticalStrikes);
         tokenKeys.add(tridentThrows);
+        tokenKeys.add(logsStripped);
     }
 
     public NamespacedKey getItemOwner() {
@@ -162,6 +165,10 @@ public class ToolStatsKeys {
         return tridentThrows;
     }
 
+    public NamespacedKey getLogsStripped() {
+        return logsStripped;
+    }
+
     /**
      * Stores how an item was created.
      * 0 = crafted.

src/main/resources/config.yml

@@ -180,6 +180,17 @@ tokens:
         enabled: false
         type: float
         value: 1001
+    logs-stripped:
+      title: "&7ToolStats: &8Logs Stripped Token"
+      lore:
+        - "&8Combine with an axe in an anvil to track logs stripped."
+        - "&8Uses &7{levels} &8level."
+      levels: 1
+      material: PAPER
+      custom-model-data:
+        enabled: false
+        type: float
+        value: 1001
 
 enabled:
   # Will show "Crafted by <player>"
@@ -349,6 +360,7 @@ enabled:
   crops-harvested: true
   critical-strikes: true
   trident-throws: true
+  logs-stripped: true
 
 messages:
   crafted:
@@ -386,6 +398,7 @@ messages:
   damage-done: "&7Damage done: &8{damage}"
   critical-strikes: "&7Critical strikes: &8{strikes}"
   trident-throws: "&7Times thrown: &8{times}"
+  logs-stripped: "&7Logs stripped: &8{logs}"
   # Set display name for mobs. See: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/entity/EntityType.html
   mobs:
     ZOMBIE: "Zombie"
@@ -424,4 +437,4 @@ world-limit:
     - world_1
     - world_2
 
-config-version: 15
+config-version: 16