Merge branch 'Norbit4:master' into ver/1.0

Author: Biquaternions

build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 group = 'pl.norbit'
-version = 'v2.0.0'
+version = 'v2.0.3'
 
 repositories {
     mavenCentral()

src/main/java/pl/norbit/treecuter/TreeCuter.java

@@ -46,10 +46,7 @@ public void onEnable() {
     }
 
     private void registerCommand(){
-        var command = getCommand("treecuter");
-        var treeCuterCommand = new TreeCuterCommand();
-
-        command.setExecutor(treeCuterCommand);
+        getCommand("treecuter").setExecutor(new TreeCuterCommand());
     }
 
     private void registerPapi(){
@@ -90,7 +87,9 @@ private boolean checkPlugin(String pluginName) {
 
         if(plugin != null && plugin.isEnabled()){
             var logger = getServer().getLogger();
-            logger.info("Hooked to: " + pluginName);
+            String message = "Hooked to: " + pluginName;
+
+            logger.info(message);
             return true;
         }
         return false;

src/main/java/pl/norbit/treecuter/api/listeners/TreeCutEvent.java

@@ -9,13 +9,12 @@
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
-import java.util.Set;
 
 public class TreeCutEvent extends Event implements Cancellable {
     private static final HandlerList handlers = new HandlerList();
     /**
      * -- GETTER --
-     *  Get set of wood blocks.
+     *  Get list of wood blocks.
      */
     @Getter
     private final List<Block> blocks;

src/main/java/pl/norbit/treecuter/api/listeners/TreeGlowEvent.java

@@ -9,14 +9,12 @@
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
-import java.util.Set;
-
 
 public class TreeGlowEvent extends Event implements Cancellable {
     private static final HandlerList handlers = new HandlerList();
     /**
      * -- GETTER --
-     *  Get set of wood blocks.
+     *  Get list of wood blocks.
      */
     @Getter
     private final List<Block> blocks;

src/main/java/pl/norbit/treecuter/config/Settings.java

@@ -14,6 +14,7 @@
 import pl.norbit.treecuter.service.TreePlanterService;
 
 import java.util.*;
+import java.util.logging.Logger;
 
 public class Settings {
 
@@ -68,6 +69,9 @@ public class Settings {
     @Getter
     private static List<Material> autoPlantSapling;
 
+    @Getter
+    private static Map<Material, List<String>> actionsTypeMap;
+
     //block worlds
     private static List<String> blockWorlds;
 
@@ -117,10 +121,20 @@ public class Settings {
 
     private static List<CutShape> woodBlocks;
 
+    @Getter
+    private static boolean actionsEnabled;
+    @Getter
+    private static List<String> actions;
+
     private Settings() {
         throw new IllegalStateException("This class cannot be instantiated");
     }
 
+
+    public static List<String> getActions(Material material){
+        return actionsTypeMap.get(material);
+    }
+
     public static Optional<ItemStack> getCustomToolForKey(String key){
         return woodBlocks.stream()
                 .filter(shape -> shape.getId().equalsIgnoreCase(key))
@@ -199,6 +213,9 @@ public static void loadConfig(boolean reload) {
         placeholderToggleOn = config.getString("placeholder.toggle-on");
         placeholderToggleOff = config.getString("placeholder.toggle-off");
 
+        actions = config.getStringList("actions.action-list.global");
+        actionsEnabled = config.getBoolean("actions.enable");
+
         acceptTools = new ArrayList<>();
         acceptWoodBlocks = new ArrayList<>();
         acceptLeavesBlocks = new ArrayList<>();
@@ -266,6 +283,7 @@ public static void loadConfig(boolean reload) {
 
         ConfigurationSection section = config.getConfigurationSection("wood-blocks");
 
+
         if (section == null) {
             javaPlugin.getLogger().warning("No wood blocks found in config");
         }else {
@@ -282,10 +300,35 @@ public static void loadConfig(boolean reload) {
             }
         }
 
+        loadActionsTypes(config.getConfigurationSection("actions.action-list.types"));
+
         if(autoPlant) TreePlanterService.start();
         else TreePlanterService.stop();
     }
 
+    public static void loadActionsTypes(ConfigurationSection section) {
+        actionsTypeMap = new EnumMap<>(Material.class);
+
+        if (section == null) {
+            return;
+        }
+
+        Logger logger = TreeCuter.getInstance().getLogger();
+
+        for (String key : section.getKeys(false)) {
+            Material material = Material.getMaterial(key.toUpperCase());
+
+            if (material == null) {
+                logger.warning("Wrong action material: " + key);
+                continue;
+            }
+
+            List<String> commands = section.getStringList(key);
+            actionsTypeMap.put(material, commands);
+        }
+    }
+
+
     private static CutShape getCutShape(ConfigurationSection section, String key) {
         CutShape cutShape = new CutShape();
         cutShape.setId(key);

src/main/java/pl/norbit/treecuter/listeners/BlockBreakListener.java

@@ -30,12 +30,12 @@ public void onBlockBreak(BlockBreakEvent e) {
 
         var item = p.getInventory().getItemInMainHand();
 
-        CutShape woodBlocks = Settings.getCutShape(b, item);
+        CutShape shape = Settings.getCutShape(b, item);
 
-        if (woodBlocks == null){
+        if (shape == null){
             return;
         }
 
-        TreeCutService.cutTree(p);
+        TreeCutService.cutTree(p, shape);
     }
 }

src/main/java/pl/norbit/treecuter/listeners/BlockInteractListener.java

@@ -46,16 +46,16 @@ public void onBlockInteract(PlayerInteractEvent e) {
             return;
         }
 
-        if (Settings.isWorldGuardEnabled() && (!WorldGuardUtils.canBreak(b.getLocation(), p))){
-            return;
-        }
-
         String worldName = p.getWorld().getName();
 
         if(Settings.isBlockedWorld(worldName)){
             return;
         }
 
+        if(Settings.isShiftMining() && (!p.isSneaking())){
+            return;
+        }
+
         if(Settings.isUsePermissions() && (!PermissionsUtils.hasPermission(p, Settings.getPermission()))){
             return;
         }
@@ -68,7 +68,7 @@ public void onBlockInteract(PlayerInteractEvent e) {
             return;
         }
 
-        if(Settings.isShiftMining() && (!p.isSneaking())){
+        if (Settings.isWorldGuardEnabled() && (!WorldGuardUtils.canBreak(b.getLocation(), p))){
             return;
         }
 

src/main/java/pl/norbit/treecuter/service/ActionsService.java

@@ -0,0 +1,65 @@
+package pl.norbit.treecuter.service;
+
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.block.Block;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import pl.norbit.treecuter.config.Settings;
+import pl.norbit.treecuter.config.model.CutShape;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class ActionsService {
+    private record MaterialCount(Material material, long count) { }
+
+    private ActionsService() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    public static void triggerActions(Player p, CutShape shape, List<Block> blocks){
+        if(!Settings.isActionsEnabled()){
+            return;
+        }
+
+        String playerName = p.getName();
+        Server server = p.getServer();
+        ConsoleCommandSender consoleSender = server.getConsoleSender();
+        String id = shape.getId();
+
+        //global actions
+        Settings.getActions().forEach(action ->{
+            String command = action
+                    .replace("{player}", playerName)
+                    .replace("{shape}", id)
+                    .replace("{count}", String.valueOf(blocks.size()));
+
+            server.dispatchCommand(consoleSender, command);
+        });
+
+        //material specific actions
+        countMaterials(blocks).forEach(mCount -> Settings.getActions(mCount.material)
+                .forEach(action -> {
+            String command = action
+                    .replace("{player}", playerName)
+                    .replace("{shape}", id)
+                    .replace("{count}", String.valueOf(mCount.count()));
+
+            server.dispatchCommand(consoleSender, command);
+        }));
+    }
+
+    private static List<MaterialCount> countMaterials(List<Block> blocks) {
+        Map<Material, Long> counts = blocks.stream()
+                .collect(Collectors.groupingBy(
+                        Block::getType,
+                        Collectors.counting()
+                ));
+
+        return counts.entrySet().stream()
+                .map(e -> new MaterialCount(e.getKey(), e.getValue()))
+                .toList();
+    }
+}

src/main/java/pl/norbit/treecuter/service/TreeCutService.java

@@ -1,8 +1,11 @@
 package pl.norbit.treecuter.service;
 
+import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.Server;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.plugin.PluginManager;
@@ -24,8 +27,6 @@
 
 public class TreeCutService {
 
-//    private static final Map<UUID, List<Block>> selectedBlocks = new HashMap<>();
-//    private static final Map<UUID, Block> mainBlocks = new HashMap<>();
     private static final Map<UUID, SelectedBreak> selectedMap = new HashMap<>();
     private static final PluginManager pluginManager = TreeCuter.getInstance().getServer().getPluginManager();
     private static final List<BreakTask> breakTasks = new CopyOnWriteArrayList<>();
@@ -152,7 +153,7 @@ private static boolean lastBlocksIsSame(UUID playerUUID, Block mainBlock, List<B
      * When player has no selected blocks, do nothing.
      * @param p Player
      */
-    public static void cutTree(Player p) {
+    public static void cutTree(Player p, CutShape shape) {
         if(p == null){
             return;
         }
@@ -190,6 +191,8 @@ public static void cutTree(Player p) {
         updateItem(p, size - 1);
 
         selectedMap.remove(p.getUniqueId());
+
+        ActionsService.triggerActions(p, shape, blocks);
     }
 
     private static void breakBlock(Player p, Block b){
@@ -206,6 +209,10 @@ private static void breakBlock(Player p, Block b){
         if(mat == Material.AIR){
             return;
         }
+
+        //simulate event for plugins compatibility
+//        simulateBlockBreakEvent(p, b);
+
         //log block break to CoreProtect
         CoreProtectService.logBreak(p.getName(), b.getState());
 
@@ -215,6 +222,14 @@ private static void breakBlock(Player p, Block b){
         } else b.breakNaturally();
     }
 
+    private static void simulateBlockBreakEvent(Player p, Block b){
+        BlockBreakEvent e = new BlockBreakEvent(b, p);
+        TreeCuter.getInstance().getServer().getPluginManager().callEvent(e);
+
+        e.setDropItems(false);
+        e.setExpToDrop(0);
+    }
+
     private static void updateItem(Player p, int durabilityDamage){
         PlayerInventory inventory = p.getInventory();
 

src/main/java/pl/norbit/treecuter/utils/WorldGuardUtils.java

@@ -10,25 +10,41 @@
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class WorldGuardUtils {
+    private static final Map<String, RegionManager> REGION_CACHE = new HashMap<>();
 
     private WorldGuardUtils() {
         throw new IllegalStateException("This class cannot be instantiated");
     }
 
-    public static boolean canBreak(Location loc, Player p) {
+    public static RegionManager getRegionManager(World world) {
+        var cached = REGION_CACHE.get(world.getName());
+
+        if(cached != null){
+            return cached;
+        }
+
         var container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        var current = container.get(BukkitAdapter.adapt(world));
+        REGION_CACHE.put(world.getName(), current);
+
+        return current;
+    }
 
+    public static boolean canBreak(Location loc, Player p) {
         if(p.isOp()){
             return true;
         }
 
-        var regionManager = container.get(BukkitAdapter.adapt(loc.getWorld()));
+        var regionManager = getRegionManager(loc.getWorld());
 
         if (regionManager == null){
             return true;
@@ -52,6 +68,10 @@ private static boolean canBreakInRegion(Player p, ProtectedRegion region) {
         LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(p);
         StateFlag.State flag = region.getFlag(Flags.BLOCK_BREAK);
 
+        if(region.isOwner(localPlayer)){
+            return true;
+        }
+
         if(region.isMember(localPlayer) && flag != StateFlag.State.DENY){
             return true;
         }