From b1cb59b7e8cbbdda35e863262ae18f81f03d0b09 Mon Sep 17 00:00:00 2001 From: Christian Koop Date: Thu, 29 Jun 2023 14:31:22 +0200 Subject: [PATCH] Heavy code style changes and slight refactoring --- .../ultimatetimber/UltimateTimber.java | 74 ++------ .../animation/TreeAnimation.java | 2 - .../animation/TreeAnimationCrumble.java | 26 +-- .../animation/TreeAnimationDisintegrate.java | 18 +- .../animation/TreeAnimationFancy.java | 20 +- .../animation/TreeAnimationNone.java | 2 - .../animation/TreeAnimationType.java | 12 +- .../commands/CommandGiveAxe.java | 20 +- .../commands/CommandReload.java | 8 +- .../commands/CommandToggle.java | 9 +- .../ultimatetimber/events/TreeEvent.java | 10 +- .../ultimatetimber/events/TreeFallEvent.java | 39 ++-- .../ultimatetimber/events/TreeFellEvent.java | 12 +- .../manager/ChoppingManager.java | 9 +- .../manager/ConfigurationManager.java | 21 ++- .../ultimatetimber/manager/Manager.java | 2 - .../manager/PlacedBlockManager.java | 37 ++-- .../manager/SaplingManager.java | 35 ++-- .../manager/TreeAnimationManager.java | 56 ++++-- .../manager/TreeDefinitionManager.java | 175 +++++++++++------- .../manager/TreeDetectionManager.java | 103 +++++++---- .../manager/TreeFallManager.java | 65 ++++--- .../ultimatetimber/misc/OnlyToppleWhile.java | 14 +- .../ultimatetimber/tree/DetectedTree.java | 6 +- .../ultimatetimber/tree/FallingTreeBlock.java | 2 - .../ultimatetimber/tree/ITreeBlock.java | 2 - .../ultimatetimber/tree/TreeBlock.java | 17 +- .../ultimatetimber/tree/TreeBlockSet.java | 53 +++--- .../ultimatetimber/tree/TreeBlockType.java | 6 +- .../ultimatetimber/tree/TreeDefinition.java | 5 +- .../songoda/ultimatetimber/tree/TreeLoot.java | 9 +- .../ultimatetimber/utils/BlockUtils.java | 6 +- .../ultimatetimber/utils/ParticleUtils.java | 57 +++--- .../ultimatetimber/utils/SoundUtils.java | 12 +- 34 files changed, 504 insertions(+), 440 deletions(-) diff --git a/src/main/java/com/songoda/ultimatetimber/UltimateTimber.java b/src/main/java/com/songoda/ultimatetimber/UltimateTimber.java index 355c1a9..04abf32 100644 --- a/src/main/java/com/songoda/ultimatetimber/UltimateTimber.java +++ b/src/main/java/com/songoda/ultimatetimber/UltimateTimber.java @@ -2,6 +2,7 @@ package com.songoda.ultimatetimber; import com.songoda.core.SongodaCore; import com.songoda.core.SongodaPlugin; +import com.songoda.core.commands.CommandManager; import com.songoda.core.compatibility.CompatibleMaterial; import com.songoda.core.configuration.Config; import com.songoda.core.hooks.LogManager; @@ -18,19 +19,16 @@ import com.songoda.ultimatetimber.manager.TreeDefinitionManager; import com.songoda.ultimatetimber.manager.TreeDetectionManager; import com.songoda.ultimatetimber.manager.TreeFallManager; +import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; public class UltimateTimber extends SongodaPlugin { - - private static UltimateTimber INSTANCE; - - private Set managers; + private final Set managers = new HashSet<>(); private ChoppingManager choppingManager; private ConfigurationManager configurationManager; - private com.songoda.core.commands.CommandManager commandManager; private PlacedBlockManager placedBlockManager; private SaplingManager saplingManager; private TreeAnimationManager treeAnimationManager; @@ -38,13 +36,16 @@ public class UltimateTimber extends SongodaPlugin { private TreeDetectionManager treeDetectionManager; private TreeFallManager treeFallManager; + /** + * @deprecated Use {@link #getPlugin(Class)} instead + */ + @Deprecated public static UltimateTimber getInstance() { - return INSTANCE; + return getPlugin(UltimateTimber.class); } @Override public void onPluginLoad() { - INSTANCE = this; } @Override @@ -56,8 +57,8 @@ public class UltimateTimber extends SongodaPlugin { LogManager.load(); // Setup plugin commands - this.commandManager = new com.songoda.core.commands.CommandManager(this); - this.commandManager.addMainCommand("ut") + CommandManager commandManager = new CommandManager(this); + commandManager.addMainCommand("ut") .addSubCommands( new CommandReload(this), new CommandToggle(this), @@ -65,7 +66,6 @@ public class UltimateTimber extends SongodaPlugin { ); // Register managers - this.managers = new HashSet<>(); this.choppingManager = this.registerManager(ChoppingManager.class); this.configurationManager = new ConfigurationManager(this); this.placedBlockManager = this.registerManager(PlacedBlockManager.class); @@ -80,7 +80,8 @@ public class UltimateTimber extends SongodaPlugin { @Override public void onPluginDisable() { - this.disable(); + this.configurationManager.disable(); + this.managers.forEach(Manager::disable); } @Override @@ -96,15 +97,7 @@ public class UltimateTimber extends SongodaPlugin { @Override public List getExtraConfig() { - return null; - } - - /** - * Disables most of the plugin - */ - public void disable() { - this.configurationManager.disable(); - this.managers.forEach(Manager::disable); + return Collections.emptyList(); } /** @@ -125,76 +118,35 @@ public class UltimateTimber extends SongodaPlugin { } } - /** - * Gets the chopping manager - * - * @return The ChoppingManager instance - */ public ChoppingManager getChoppingManager() { return this.choppingManager; } - /** - * Gets the configuration manager - * - * @return The ConfigurationManager instance - */ public ConfigurationManager getConfigurationManager() { return this.configurationManager; } - /** - * Gets the placed block manager - * - * @return The PlacedBlockManager instance - */ public PlacedBlockManager getPlacedBlockManager() { return this.placedBlockManager; } - /** - * Gets the sapling manager - * - * @return The SaplingManager instance - */ public SaplingManager getSaplingManager() { return this.saplingManager; } - /** - * Gets the tree animation manager - * - * @return The TreeAnimationManager instance - */ public TreeAnimationManager getTreeAnimationManager() { return this.treeAnimationManager; } - /** - * Gets the tree definition manager - * - * @return The TreeDefinitionManager instance - */ public TreeDefinitionManager getTreeDefinitionManager() { return this.treeDefinitionManager; } - /** - * Gets the tree detection manager - * - * @return The TreeDetectionManager instance - */ public TreeDetectionManager getTreeDetectionManager() { return this.treeDetectionManager; } - /** - * Gets the tree fall manager - * - * @return The TreeFallManager instance - */ public TreeFallManager getTreeFallManager() { return this.treeFallManager; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimation.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimation.java index 9f7636e..83d52ed 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimation.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimation.java @@ -9,7 +9,6 @@ import com.songoda.ultimatetimber.tree.ITreeBlock; import com.songoda.ultimatetimber.tree.TreeBlock; import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.utils.BlockUtils; -import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; @@ -19,7 +18,6 @@ import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; public abstract class TreeAnimation { - protected final TreeAnimationType treeAnimationType; protected final DetectedTree detectedTree; protected final Player player; diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationCrumble.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationCrumble.java index 6bd2a56..b40a2b1 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationCrumble.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationCrumble.java @@ -24,7 +24,6 @@ import java.util.Comparator; import java.util.List; public class TreeAnimationCrumble extends TreeAnimation { - public TreeAnimationCrumble(DetectedTree detectedTree, Player player) { super(TreeAnimationType.CRUMBLE, detectedTree, player); } @@ -64,29 +63,35 @@ public class TreeAnimationCrumble extends TreeAnimation { List> partition = treeBlocks.get(0); for (int i = 0; i < 3 && !partition.isEmpty(); i++) { ITreeBlock treeBlock = partition.remove(0); - if (treeBlock.getTreeBlockType().equals(TreeBlockType.LOG)) { - if (td.getLogMaterial().stream().noneMatch(x -> x.equals(CompatibleMaterial.getMaterial(treeBlock.getBlock())))) + if (treeBlock.getTreeBlockType() == TreeBlockType.LOG) { + if (td.getLogMaterial().stream().noneMatch(x -> x == CompatibleMaterial.getMaterial(treeBlock.getBlock()))) { continue; - } else if (treeBlock.getTreeBlockType().equals(TreeBlockType.LEAF)) { - if (td.getLeafMaterial().stream().noneMatch(x -> x.equals(CompatibleMaterial.getMaterial(treeBlock.getBlock())))) + } + } else if (treeBlock.getTreeBlockType() == TreeBlockType.LEAF) { + if (td.getLeafMaterial().stream().noneMatch(x -> x == CompatibleMaterial.getMaterial(treeBlock.getBlock()))) { continue; + } } - FallingTreeBlock fallingTreeBlock = TreeAnimationCrumble.this.convertToFallingBlock((TreeBlock)treeBlock); - if (fallingTreeBlock == null) + FallingTreeBlock fallingTreeBlock = TreeAnimationCrumble.this.convertToFallingBlock((TreeBlock) treeBlock); + if (fallingTreeBlock == null) { continue; + } BlockUtils.toggleGravityFallingBlock(fallingTreeBlock.getBlock(), true); fallingTreeBlock.getBlock().setVelocity(Vector.getRandom().setY(0).subtract(new Vector(0.5, 0, 0.5)).multiply(0.15)); TreeAnimationCrumble.this.fallingTreeBlocks.add(fallingTreeBlock); - if (TreeAnimationCrumble.this.fallingTreeBlocks == null) + if (TreeAnimationCrumble.this.fallingTreeBlocks == null) { TreeAnimationCrumble.this.fallingTreeBlocks = new TreeBlockSet<>(fallingTreeBlock); + } - if (useCustomSound) + if (useCustomSound) { SoundUtils.playLandingSound(treeBlock); - if (useCustomParticles) + } + if (useCustomParticles) { ParticleUtils.playFallingParticles(treeBlock); + } } if (partition.isEmpty()) { @@ -102,4 +107,3 @@ public class TreeAnimationCrumble extends TreeAnimation { }.runTaskTimer(ultimateTimber, 0, 1); } } - diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationDisintegrate.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationDisintegrate.java index f7b50e8..d196094 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationDisintegrate.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationDisintegrate.java @@ -23,7 +23,6 @@ import java.util.Comparator; import java.util.List; public class TreeAnimationDisintegrate extends TreeAnimation { - public TreeAnimationDisintegrate(DetectedTree detectedTree, Player player) { super(TreeAnimationType.DISINTEGRATE, detectedTree, player); } @@ -71,20 +70,24 @@ public class TreeAnimationDisintegrate extends TreeAnimation { if (!toDestroy.isEmpty()) { ITreeBlock first = toDestroy.get(0); - if (useCustomSound) + if (useCustomSound) { SoundUtils.playLandingSound(first); + } for (ITreeBlock treeBlock : toDestroy) { - if (treeBlock.getTreeBlockType().equals(TreeBlockType.LOG)) { - if (td.getLogMaterial().stream().noneMatch(x -> x.equals(CompatibleMaterial.getMaterial(treeBlock.getBlock())))) + if (treeBlock.getTreeBlockType() == TreeBlockType.LOG) { + if (td.getLogMaterial().stream().noneMatch(x -> x == CompatibleMaterial.getMaterial(treeBlock.getBlock()))) { continue; - } else if (treeBlock.getTreeBlockType().equals(TreeBlockType.LEAF)) { - if (td.getLeafMaterial().stream().noneMatch(x -> x.equals(CompatibleMaterial.getMaterial(treeBlock.getBlock())))) + } + } else if (treeBlock.getTreeBlockType() == TreeBlockType.LEAF) { + if (td.getLeafMaterial().stream().noneMatch(x -> x == CompatibleMaterial.getMaterial(treeBlock.getBlock()))) { continue; + } } - if (useCustomParticles) + if (useCustomParticles) { ParticleUtils.playFallingParticles(treeBlock); + } treeDefinitionManager.dropTreeLoot(td, treeBlock, p, hst, false); TreeAnimationDisintegrate.this.replaceBlock((TreeBlock) treeBlock); } @@ -95,5 +98,4 @@ public class TreeAnimationDisintegrate extends TreeAnimation { } }.runTaskTimer(ultimateTimber, 0, 1); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationFancy.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationFancy.java index b11b688..b96dfc0 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationFancy.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationFancy.java @@ -18,7 +18,6 @@ import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.util.Vector; public class TreeAnimationFancy extends TreeAnimation { - public TreeAnimationFancy(DetectedTree detectedTree, Player player) { super(TreeAnimationType.FANCY, detectedTree, player); } @@ -31,24 +30,27 @@ public class TreeAnimationFancy extends TreeAnimation { boolean useCustomParticles = ConfigurationManager.Setting.USE_CUSTOM_PARTICLES.getBoolean(); ITreeBlock initialTreeBlock = this.detectedTree.getDetectedTreeBlocks().getInitialLogBlock(); - FallingTreeBlock initialFallingBlock = this.convertToFallingBlock((TreeBlock)this.detectedTree.getDetectedTreeBlocks().getInitialLogBlock()); + FallingTreeBlock initialFallingBlock = this.convertToFallingBlock((TreeBlock) this.detectedTree.getDetectedTreeBlocks().getInitialLogBlock()); - if (useCustomSound) + if (useCustomSound) { SoundUtils.playFallingSound(initialTreeBlock); + } Vector velocityVector = initialTreeBlock.getLocation().clone().subtract(this.player.getLocation().clone()).toVector().normalize().setY(0); this.fallingTreeBlocks = new TreeBlockSet<>(initialFallingBlock); for (ITreeBlock treeBlock : this.detectedTree.getDetectedTreeBlocks().getAllTreeBlocks()) { - FallingTreeBlock fallingTreeBlock = this.convertToFallingBlock((TreeBlock)treeBlock); - if (fallingTreeBlock == null) + FallingTreeBlock fallingTreeBlock = this.convertToFallingBlock((TreeBlock) treeBlock); + if (fallingTreeBlock == null) { continue; + } FallingBlock fallingBlock = fallingTreeBlock.getBlock(); this.fallingTreeBlocks.add(fallingTreeBlock); - if (useCustomParticles) - ParticleUtils.playFallingParticles(treeBlock); + if (useCustomParticles) { + ParticleUtils.playFallingParticles(treeBlock); + } double multiplier = (treeBlock.getLocation().getY() - this.player.getLocation().getY()) * 0.05; fallingBlock.setVelocity(velocityVector.clone().multiply(multiplier)); @@ -83,13 +85,13 @@ public class TreeAnimationFancy extends TreeAnimation { if (this.timer > 4 * 20) { TreeAnimationManager treeAnimationManager = ultimateTimber.getTreeAnimationManager(); - for (ITreeBlock fallingTreeBlock : TreeAnimationFancy.this.fallingTreeBlocks.getAllTreeBlocks()) + for (ITreeBlock fallingTreeBlock : TreeAnimationFancy.this.fallingTreeBlocks.getAllTreeBlocks()) { treeAnimationManager.runFallingBlockImpact(TreeAnimationFancy.this, fallingTreeBlock); + } whenFinished.run(); this.cancel(); } } }.runTaskTimer(ultimateTimber, 20L, 1L); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationNone.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationNone.java index 9e45d7b..6584765 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationNone.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationNone.java @@ -12,7 +12,6 @@ import org.bukkit.block.Block; import org.bukkit.entity.Player; public class TreeAnimationNone extends TreeAnimation { - public TreeAnimationNone(DetectedTree detectedTree, Player player) { super(TreeAnimationType.NONE, detectedTree, player); } @@ -35,5 +34,4 @@ public class TreeAnimationNone extends TreeAnimation { whenFinished.run(); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationType.java b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationType.java index d0d8b19..937c26f 100644 --- a/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationType.java +++ b/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationType.java @@ -4,10 +4,7 @@ package com.songoda.ultimatetimber.animation; * The types of tree animations that are available */ public enum TreeAnimationType { - FANCY, - DISINTEGRATE, - CRUMBLE, - NONE; + FANCY, DISINTEGRATE, CRUMBLE, NONE; /** * Gets a TreeAnimationType from a given string @@ -16,9 +13,12 @@ public enum TreeAnimationType { * @return The TreeAnimationType, returns FANCY if the string is an invalid type */ public static TreeAnimationType fromString(String string) { - for (TreeAnimationType value : values()) - if (value.name().equalsIgnoreCase(string)) + for (TreeAnimationType value : values()) { + if (value.name().equalsIgnoreCase(string)) { return value; + } + } + return TreeAnimationType.FANCY; } } diff --git a/src/main/java/com/songoda/ultimatetimber/commands/CommandGiveAxe.java b/src/main/java/com/songoda/ultimatetimber/commands/CommandGiveAxe.java index d446e1a..1169faf 100644 --- a/src/main/java/com/songoda/ultimatetimber/commands/CommandGiveAxe.java +++ b/src/main/java/com/songoda/ultimatetimber/commands/CommandGiveAxe.java @@ -11,7 +11,6 @@ import org.bukkit.inventory.ItemStack; import java.util.List; public class CommandGiveAxe extends AbstractCommand { - private final UltimateTimber plugin; public CommandGiveAxe(UltimateTimber plugin) { @@ -21,43 +20,44 @@ public class CommandGiveAxe extends AbstractCommand { @Override protected ReturnType runCommand(CommandSender sender, String... args) { - - if (args.length < 1) + if (args.length < 1) { return ReturnType.SYNTAX_ERROR; + } Player player = Bukkit.getPlayer(args[0]); if (player == null) { if (args[0].trim().equalsIgnoreCase("me")) { - if (!(sender instanceof Player)) + if (!(sender instanceof Player)) { return ReturnType.NEEDS_PLAYER; + } player = (Player) sender; } else { - plugin.getLocale().getMessageOrDefault("command.give.not-a-player", "&cNot a player.") + this.plugin.getLocale().getMessageOrDefault("command.give.not-a-player", "&cNot a player.") .sendPrefixedMessage(sender); return ReturnType.FAILURE; } } - ItemStack axe = plugin.getTreeDefinitionManager().getRequiredAxe(); + ItemStack axe = this.plugin.getTreeDefinitionManager().getRequiredAxe(); if (axe == null) { - plugin.getLocale().getMessageOrDefault("command.give.no-axe", "&cThe axe could not be loaded.") + this.plugin.getLocale().getMessageOrDefault("command.give.no-axe", "&cThe axe could not be loaded.") .sendPrefixedMessage(sender); return ReturnType.FAILURE; } player.getInventory().addItem(axe); - plugin.getLocale().getMessageOrDefault("command.give.given", "&fAxe given to &a%player%") + this.plugin.getLocale().getMessageOrDefault("command.give.given", "&fAxe given to &a%player%") .processPlaceholder("player", player.getName()) .sendPrefixedMessage(sender); return ReturnType.SUCCESS; } @Override - protected List onTab(CommandSender commandSender, String... args) { + protected List onTab(CommandSender sender, String... args) { List suggestions = null; if (args.length == 1) { - suggestions = PlayerUtils.getVisiblePlayerNames(commandSender, args[0]); + suggestions = PlayerUtils.getVisiblePlayerNames(sender, args[0]); suggestions.add("me"); } return suggestions; diff --git a/src/main/java/com/songoda/ultimatetimber/commands/CommandReload.java b/src/main/java/com/songoda/ultimatetimber/commands/CommandReload.java index 95f3d1d..cda4971 100644 --- a/src/main/java/com/songoda/ultimatetimber/commands/CommandReload.java +++ b/src/main/java/com/songoda/ultimatetimber/commands/CommandReload.java @@ -7,7 +7,6 @@ import org.bukkit.command.CommandSender; import java.util.List; public class CommandReload extends AbstractCommand { - private final UltimateTimber plugin; public CommandReload(UltimateTimber plugin) { @@ -17,8 +16,8 @@ public class CommandReload extends AbstractCommand { @Override protected ReturnType runCommand(CommandSender sender, String... args) { - plugin.reloadConfig(); - plugin.getLocale().getMessage("command.reload.reloaded").sendPrefixedMessage(sender); + this.plugin.reloadConfig(); + this.plugin.getLocale().getMessage("command.reload.reloaded").sendPrefixedMessage(sender); return ReturnType.SUCCESS; } @@ -39,7 +38,6 @@ public class CommandReload extends AbstractCommand { @Override public String getDescription() { - return plugin.getLocale().getMessage("command.reload.description").getMessage(); + return this.plugin.getLocale().getMessage("command.reload.description").getMessage(); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/commands/CommandToggle.java b/src/main/java/com/songoda/ultimatetimber/commands/CommandToggle.java index aa1cdfd..db98209 100644 --- a/src/main/java/com/songoda/ultimatetimber/commands/CommandToggle.java +++ b/src/main/java/com/songoda/ultimatetimber/commands/CommandToggle.java @@ -8,7 +8,6 @@ import org.bukkit.entity.Player; import java.util.List; public class CommandToggle extends AbstractCommand { - private final UltimateTimber plugin; public CommandToggle(UltimateTimber plugin) { @@ -18,10 +17,10 @@ public class CommandToggle extends AbstractCommand { @Override protected ReturnType runCommand(CommandSender sender, String... args) { - if (UltimateTimber.getInstance().getChoppingManager().togglePlayer((Player) sender)) { - plugin.getLocale().getMessage("command.toggle.enabled").sendPrefixedMessage(sender); + if (this.plugin.getChoppingManager().togglePlayer((Player) sender)) { + this.plugin.getLocale().getMessage("command.toggle.enabled").sendPrefixedMessage(sender); } else { - plugin.getLocale().getMessage("command.toggle.disabled").sendPrefixedMessage(sender); + this.plugin.getLocale().getMessage("command.toggle.disabled").sendPrefixedMessage(sender); } return ReturnType.SUCCESS; } @@ -43,7 +42,7 @@ public class CommandToggle extends AbstractCommand { @Override public String getDescription() { - return plugin.getLocale().getMessage("command.toggle.description").getMessage(); + return this.plugin.getLocale().getMessage("command.toggle.description").getMessage(); } } diff --git a/src/main/java/com/songoda/ultimatetimber/events/TreeEvent.java b/src/main/java/com/songoda/ultimatetimber/events/TreeEvent.java index 46fd387..411586c 100644 --- a/src/main/java/com/songoda/ultimatetimber/events/TreeEvent.java +++ b/src/main/java/com/songoda/ultimatetimber/events/TreeEvent.java @@ -8,21 +8,19 @@ import org.bukkit.event.player.PlayerEvent; * Abstract tree event containing tree's blocks and broke block */ public abstract class TreeEvent extends PlayerEvent { + protected final DetectedTree detectedTree; - protected final DetectedTree detectedTree; - - public TreeEvent(Player player, DetectedTree detectedTree) { - super(player); + public TreeEvent(Player who, DetectedTree detectedTree) { + super(who); this.detectedTree = detectedTree; } /** * Get the tree blocks - * + * * @return The blocks that are part of the tree */ public DetectedTree getDetectedTree() { return this.detectedTree; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/events/TreeFallEvent.java b/src/main/java/com/songoda/ultimatetimber/events/TreeFallEvent.java index 0cebee6..e714471 100644 --- a/src/main/java/com/songoda/ultimatetimber/events/TreeFallEvent.java +++ b/src/main/java/com/songoda/ultimatetimber/events/TreeFallEvent.java @@ -9,32 +9,31 @@ import org.bukkit.event.HandlerList; * Called when a tree will fall */ public class TreeFallEvent extends TreeEvent implements Cancellable { - - private boolean cancelled = false; - - public TreeFallEvent(Player player, DetectedTree detectedTree) { - super(player, detectedTree); + private static final HandlerList HANDLERS = new HandlerList(); + + private boolean cancelled = false; + + public TreeFallEvent(Player who, DetectedTree detectedTree) { + super(who, detectedTree); } - private static final HandlerList handlers = new HandlerList(); - + @Override public HandlerList getHandlers() { - return handlers; + return HANDLERS; + } + + @Override + public boolean isCancelled() { + return this.cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancelled = cancel; } public static HandlerList getHandlerList() { - return handlers; + return HANDLERS; } - - @Override - public boolean isCancelled() { - return this.cancelled; - } - - @Override - public void setCancelled(boolean cancelled) { - this.cancelled = cancelled; - } - } diff --git a/src/main/java/com/songoda/ultimatetimber/events/TreeFellEvent.java b/src/main/java/com/songoda/ultimatetimber/events/TreeFellEvent.java index cfe94d5..10f32bf 100644 --- a/src/main/java/com/songoda/ultimatetimber/events/TreeFellEvent.java +++ b/src/main/java/com/songoda/ultimatetimber/events/TreeFellEvent.java @@ -8,20 +8,18 @@ import org.bukkit.event.HandlerList; * Called when a tree fell */ public class TreeFellEvent extends TreeEvent { + private static final HandlerList HANDLERS = new HandlerList(); - public TreeFellEvent(Player player, DetectedTree detectedTree) { - super(player, detectedTree); + public TreeFellEvent(Player who, DetectedTree detectedTree) { + super(who, detectedTree); } - private static final HandlerList handlers = new HandlerList(); - @Override public HandlerList getHandlers() { - return handlers; + return HANDLERS; } public static HandlerList getHandlerList() { - return handlers; + return HANDLERS; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/ChoppingManager.java b/src/main/java/com/songoda/ultimatetimber/manager/ChoppingManager.java index 685f131..72415cd 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/ChoppingManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/ChoppingManager.java @@ -11,14 +11,13 @@ import java.util.Set; import java.util.UUID; public class ChoppingManager extends Manager { - private final Set disabledPlayers; private final Map cooldownedPlayers; private boolean useCooldown; private int cooldownAmount; - public ChoppingManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public ChoppingManager(UltimateTimber plugin) { + super(plugin); this.disabledPlayers = new HashSet<>(); this.cooldownedPlayers = new HashMap<>(); } @@ -72,8 +71,7 @@ public class ChoppingManager extends Manager { this.cooldownedPlayers.put(player.getUniqueId(), false); - Bukkit.getScheduler().scheduleSyncDelayedTask(UltimateTimber.getInstance(), () -> - this.cooldownedPlayers.remove(player.getUniqueId()), this.cooldownAmount * 20L); + Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> this.cooldownedPlayers.remove(player.getUniqueId()), this.cooldownAmount * 20L); } /** @@ -90,5 +88,4 @@ public class ChoppingManager extends Manager { } return cooldowned; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/ConfigurationManager.java b/src/main/java/com/songoda/ultimatetimber/manager/ConfigurationManager.java index ce74be8..3acd5a3 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/ConfigurationManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/ConfigurationManager.java @@ -8,7 +8,6 @@ import java.io.File; import java.util.List; public class ConfigurationManager extends Manager { - public enum Setting { SERVER_TYPE(SettingType.STRING), LOCALE(SettingType.STRING), @@ -49,7 +48,7 @@ public class ConfigurationManager extends Manager { SCATTER_TREE_BLOCKS_ON_GROUND(SettingType.BOOLEAN), FRAGILE_BLOCKS(SettingType.STRING_LIST); - private SettingType settingType; + private final SettingType settingType; private Object value = null; Setting(SettingType settingType) { @@ -118,10 +117,11 @@ public class ConfigurationManager extends Manager { * Loads the value from the config and caches it if it isn't set yet */ private void loadValue() { - if (this.value != null) + if (this.value != null) { return; + } - FileConfiguration config = UltimateTimber.getInstance().getConfigurationManager().getConfig(); + FileConfiguration config = UltimateTimber.getPlugin(UltimateTimber.class).getConfigurationManager().getConfig(); switch (this.settingType) { case BOOLEAN: this.value = config.getBoolean(this.getNameAsKey()); @@ -161,8 +161,8 @@ public class ConfigurationManager extends Manager { private YamlConfiguration configuration; - public ConfigurationManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public ConfigurationManager(UltimateTimber plugin) { + super(plugin); } @Override @@ -171,7 +171,7 @@ public class ConfigurationManager extends Manager { File configFile = new File(this.plugin.getDataFolder() + "/config.yml"); - // If an old config still exists, rename it so it doesn't interfere + // If an old config still exists, rename it, so it doesn't interfere if (configFile.exists() && this.plugin.getConfig().get("server-type") == null) { File renameConfigTo = new File(this.plugin.getDataFolder() + "/config-old.yml"); configFile.renameTo(renameConfigTo); @@ -188,14 +188,16 @@ public class ConfigurationManager extends Manager { this.configuration = YamlConfiguration.loadConfiguration(configFile); - for (Setting setting : Setting.values()) + for (Setting setting : Setting.values()) { setting.reset(); + } } @Override public void disable() { - for (Setting setting : Setting.values()) + for (Setting setting : Setting.values()) { setting.reset(); + } } /** @@ -206,5 +208,4 @@ public class ConfigurationManager extends Manager { public YamlConfiguration getConfig() { return this.configuration; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/Manager.java b/src/main/java/com/songoda/ultimatetimber/manager/Manager.java index 1d8db10..26fc57a 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/Manager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/Manager.java @@ -3,7 +3,6 @@ package com.songoda.ultimatetimber.manager; import com.songoda.ultimatetimber.UltimateTimber; public abstract class Manager { - protected UltimateTimber plugin; Manager(UltimateTimber plugin) { @@ -19,5 +18,4 @@ public abstract class Manager { * Cleans up the Manager's resources */ public abstract void disable(); - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/PlacedBlockManager.java b/src/main/java/com/songoda/ultimatetimber/manager/PlacedBlockManager.java index fe19fd1..bf12c02 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/PlacedBlockManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/PlacedBlockManager.java @@ -1,11 +1,11 @@ package com.songoda.ultimatetimber.manager; +import com.songoda.core.compatibility.CompatibleMaterial; import com.songoda.ultimatetimber.UltimateTimber; import com.songoda.ultimatetimber.events.TreeFellEvent; import com.songoda.ultimatetimber.tree.ITreeBlock; import org.bukkit.Bukkit; import org.bukkit.Location; -import org.bukkit.Material; import org.bukkit.block.Block; import org.bukkit.block.BlockState; import org.bukkit.event.EventHandler; @@ -22,14 +22,13 @@ import java.util.Map; import java.util.Set; public class PlacedBlockManager extends Manager implements Listener { - private Set placedBlocks; private boolean ignorePlacedBlocks; private int maxPlacedBlockMemorySize; - public PlacedBlockManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); - Bukkit.getPluginManager().registerEvents(this, ultimateTimber); + public PlacedBlockManager(UltimateTimber plugin) { + super(plugin); + Bukkit.getPluginManager().registerEvents(this, plugin); } @Override @@ -53,48 +52,56 @@ public class PlacedBlockManager extends Manager implements Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onBlockPlaced(BlockPlaceEvent event) { - if (!this.ignorePlacedBlocks) + if (!this.ignorePlacedBlocks) { return; + } // Ignore stripping logs - if (event.getBlockPlaced().getType().name().contains("STRIPPED") && !event.getBlockReplacedState().getType().equals(Material.AIR)) + if (event.getBlockPlaced().getType().name().contains("STRIPPED") && !CompatibleMaterial.getMaterial(event.getBlockReplacedState().getType()).isAir()) { return; + } this.internalProtect(event.getBlock(), true); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onBlockBreak(BlockBreakEvent event) { - if (!this.ignorePlacedBlocks) + if (!this.ignorePlacedBlocks) { return; + } this.internalProtect(event.getBlock(), false); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onLeafDecay(LeavesDecayEvent event) { - if (!this.ignorePlacedBlocks) + if (!this.ignorePlacedBlocks) { return; + } this.internalProtect(event.getBlock(), false); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onStructureGrow(StructureGrowEvent event) { - if (!this.ignorePlacedBlocks) + if (!this.ignorePlacedBlocks) { return; + } - for (BlockState blockState : event.getBlocks()) + for (BlockState blockState : event.getBlocks()) { this.internalProtect(blockState.getBlock(), false); + } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onTreeFell(TreeFellEvent event) { - if (!this.ignorePlacedBlocks) + if (!this.ignorePlacedBlocks) { return; + } - for (ITreeBlock treeBlock : event.getDetectedTree().getDetectedTreeBlocks().getAllTreeBlocks()) + for (ITreeBlock treeBlock : event.getDetectedTree().getDetectedTreeBlocks().getAllTreeBlocks()) { this.internalProtect(treeBlock.getBlock(), false); + } } /** @@ -102,8 +109,9 @@ public class PlacedBlockManager extends Manager implements Listener { */ private void internalProtect(Block block, boolean isPlaced) { if (isPlaced) { - if (this.isBlockPlaced(block)) + if (this.isBlockPlaced(block)) { return; + } this.placedBlocks.add(block.getLocation()); } else { @@ -120,5 +128,4 @@ public class PlacedBlockManager extends Manager implements Listener { public boolean isBlockPlaced(Block block) { return this.placedBlocks.contains(block.getLocation()); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/SaplingManager.java b/src/main/java/com/songoda/ultimatetimber/manager/SaplingManager.java index fd032c6..7d264e7 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/SaplingManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/SaplingManager.java @@ -16,24 +16,21 @@ import java.util.Random; import java.util.Set; public class SaplingManager extends Manager { + private final Random random; + private final Set protectedSaplings; - private Random random; - private Set protectedSaplings; - - public SaplingManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public SaplingManager(UltimateTimber plugin) { + super(plugin); this.random = new Random(); this.protectedSaplings = new HashSet<>(); } @Override public void reload() { - } @Override public void disable() { - } /** @@ -41,15 +38,17 @@ public class SaplingManager extends Manager { * Takes into account config settings * * @param treeDefinition The TreeDefinition of the sapling - * @param treeBlock The ITreeBlock to replant for + * @param treeBlock The ITreeBlock to replant for */ public void replantSapling(TreeDefinition treeDefinition, ITreeBlock treeBlock) { - if (!ConfigurationManager.Setting.REPLANT_SAPLINGS.getBoolean()) + if (!ConfigurationManager.Setting.REPLANT_SAPLINGS.getBoolean()) { return; + } Block block = treeBlock.getLocation().getBlock(); - if (!block.getType().equals(Material.AIR) || treeBlock.getTreeBlockType().equals(TreeBlockType.LEAF)) + if (block.getType() != Material.AIR || treeBlock.getTreeBlockType() == TreeBlockType.LEAF) { return; + } Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> this.internalReplant(treeDefinition, treeBlock), 1L); } @@ -59,15 +58,17 @@ public class SaplingManager extends Manager { * Takes into account config settings * * @param treeDefinition The TreeDefinition of the sapling - * @param treeBlock The ITreeBlock to replant for + * @param treeBlock The ITreeBlock to replant for */ public void replantSaplingWithChance(TreeDefinition treeDefinition, ITreeBlock treeBlock) { - if (!ConfigurationManager.Setting.FALLING_BLOCKS_REPLANT_SAPLINGS.getBoolean() || !treeBlock.getLocation().getBlock().getType().equals(Material.AIR)) + if (!ConfigurationManager.Setting.FALLING_BLOCKS_REPLANT_SAPLINGS.getBoolean() || !CompatibleMaterial.getMaterial(treeBlock.getLocation().getBlock()).isAir()) { return; + } double chance = ConfigurationManager.Setting.FALLING_BLOCKS_REPLANT_SAPLINGS_CHANCE.getDouble(); - if (this.random.nextDouble() > chance / 100) + if (this.random.nextDouble() > chance / 100) { return; + } Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> this.internalReplant(treeDefinition, treeBlock), 1L); } @@ -76,7 +77,7 @@ public class SaplingManager extends Manager { * Replants a sapling given a TreeDefinition and Location * * @param treeDefinition The TreeDefinition of the sapling - * @param treeBlock The ITreeBlock to replant for + * @param treeBlock The ITreeBlock to replant for */ private void internalReplant(TreeDefinition treeDefinition, ITreeBlock treeBlock) { TreeDefinitionManager treeDefinitionManager = this.plugin.getTreeDefinitionManager(); @@ -85,14 +86,15 @@ public class SaplingManager extends Manager { Block blockBelow = block.getRelative(BlockFace.DOWN); boolean isValidSoil = false; for (CompatibleMaterial soilMaterial : treeDefinitionManager.getPlantableSoilMaterial(treeDefinition)) { - if (soilMaterial.equals(CompatibleMaterial.getMaterial(blockBelow))) { + if (soilMaterial == CompatibleMaterial.getMaterial(blockBelow)) { isValidSoil = true; break; } } - if (!isValidSoil) + if (!isValidSoil) { return; + } CompatibleMaterial material = treeDefinition.getSaplingMaterial(); material.applyToBlock(block); @@ -113,5 +115,4 @@ public class SaplingManager extends Manager { public boolean isSaplingProtected(Block block) { return this.protectedSaplings.contains(block.getLocation()); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/TreeAnimationManager.java b/src/main/java/com/songoda/ultimatetimber/manager/TreeAnimationManager.java index 10a6f4f..e92906f 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/TreeAnimationManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/TreeAnimationManager.java @@ -30,15 +30,14 @@ import java.util.HashSet; import java.util.Set; public class TreeAnimationManager extends Manager implements Listener, Runnable { - private final Set activeAnimations; private final int taskId; - public TreeAnimationManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public TreeAnimationManager(UltimateTimber plugin) { + super(plugin); this.activeAnimations = new HashSet<>(); this.taskId = -1; - Bukkit.getPluginManager().registerEvents(this, ultimateTimber); + Bukkit.getPluginManager().registerEvents(this, plugin); Bukkit.getScheduler().runTaskTimer(this.plugin, this, 0, 1L); } @@ -59,14 +58,16 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable Set> groundedBlocks = new HashSet<>(); for (ITreeBlock fallingTreeBlock : treeAnimation.getFallingTreeBlocks().getAllTreeBlocks()) { FallingBlock fallingBlock = fallingTreeBlock.getBlock(); - if (fallingBlock.isDead() || ServerVersion.isServerVersionAtLeast(ServerVersion.V1_17) && fallingBlock.isOnGround()) + if (fallingBlock.isDead() || ServerVersion.isServerVersionAtLeast(ServerVersion.V1_17) && fallingBlock.isOnGround()) { groundedBlocks.add(fallingTreeBlock); + } } for (ITreeBlock fallingBlock : groundedBlocks) { this.runFallingBlockImpact(treeAnimation, fallingBlock); - if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_17)) + if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_17)) { fallingBlock.getBlock().remove(); + } treeAnimation.getFallingTreeBlocks().remove(fallingBlock); } } @@ -101,10 +102,13 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable * @param block The block to check */ public boolean isBlockInAnimation(Block block) { - for (TreeAnimation treeAnimation : this.activeAnimations) - for (ITreeBlock treeBlock : treeAnimation.getDetectedTree().getDetectedTreeBlocks().getAllTreeBlocks()) - if (treeBlock.getBlock().equals(block)) + for (TreeAnimation treeAnimation : this.activeAnimations) { + for (ITreeBlock treeBlock : treeAnimation.getDetectedTree().getDetectedTreeBlocks().getAllTreeBlocks()) { + if (treeBlock.getBlock().equals(block)) { return true; + } + } + } return false; } @@ -114,10 +118,13 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable * @param fallingBlock The falling block to check */ public boolean isBlockInAnimation(FallingBlock fallingBlock) { - for (TreeAnimation treeAnimation : this.activeAnimations) - for (ITreeBlock treeBlock : treeAnimation.getFallingTreeBlocks().getAllTreeBlocks()) - if (treeBlock.getBlock().equals(fallingBlock)) + for (TreeAnimation treeAnimation : this.activeAnimations) { + for (ITreeBlock treeBlock : treeAnimation.getFallingTreeBlocks().getAllTreeBlocks()) { + if (treeBlock.getBlock().equals(fallingBlock)) { return true; + } + } + } return false; } @@ -127,10 +134,13 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable * @return A TreeAnimation */ private TreeAnimation getAnimationForBlock(FallingBlock fallingBlock) { - for (TreeAnimation treeAnimation : this.activeAnimations) - for (ITreeBlock treeBlock : treeAnimation.getFallingTreeBlocks().getAllTreeBlocks()) - if (treeBlock.getBlock().equals(fallingBlock)) + for (TreeAnimation treeAnimation : this.activeAnimations) { + for (ITreeBlock treeBlock : treeAnimation.getFallingTreeBlocks().getAllTreeBlocks()) { + if (treeBlock.getBlock().equals(fallingBlock)) { return treeAnimation; + } + } + } return null; } @@ -154,10 +164,12 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable boolean useCustomParticles = ConfigurationManager.Setting.USE_CUSTOM_PARTICLES.getBoolean(); TreeDefinition treeDefinition = treeAnimation.getDetectedTree().getTreeDefinition(); - if (useCustomParticles) + if (useCustomParticles) { ParticleUtils.playLandingParticles(treeBlock); - if (useCustomSound) + } + if (useCustomSound) { SoundUtils.playLandingSound(treeBlock); + } Block block = treeBlock.getLocation().subtract(0, 1, 0).getBlock(); if (ConfigurationManager.Setting.FRAGILE_BLOCKS.getStringList().contains(block.getType().toString())) { @@ -172,17 +184,21 @@ public class TreeAnimationManager extends Manager implements Listener, Runnable @EventHandler(priority = EventPriority.HIGH) public void onFallingBlockLand(EntityChangeBlockEvent event) { - if (!event.getEntityType().equals(EntityType.FALLING_BLOCK)) + if (event.getEntityType() != EntityType.FALLING_BLOCK) { return; + } FallingBlock fallingBlock = (FallingBlock) event.getEntity(); - if (!this.isBlockInAnimation(fallingBlock)) + if (!this.isBlockInAnimation(fallingBlock)) { return; + } if (ConfigurationManager.Setting.FALLING_BLOCKS_DEAL_DAMAGE.getBoolean()) { int damage = ConfigurationManager.Setting.FALLING_BLOCK_DAMAGE.getInt(); for (Entity entity : fallingBlock.getNearbyEntities(0.5, 0.5, 0.5)) { - if (!(entity instanceof LivingEntity)) continue; + if (!(entity instanceof LivingEntity)) { + continue; + } ((LivingEntity) entity).damage(damage, fallingBlock); } } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java b/src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java index df4a2ee..66a60fe 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java @@ -31,7 +31,6 @@ import java.util.Set; import java.util.stream.Collectors; public class TreeDefinitionManager extends Manager { - private final Random random; private final Set treeDefinitions; private final Set globalPlantableSoil; @@ -42,8 +41,8 @@ public class TreeDefinitionManager extends Manager { private ItemStack requiredAxe; private String requiredAxeKey; - public TreeDefinitionManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public TreeDefinitionManager(UltimateTimber plugin) { + super(plugin); this.random = new Random(); this.treeDefinitions = new HashSet<>(); this.globalPlantableSoil = new HashSet<>(); @@ -88,13 +87,17 @@ public class TreeDefinitionManager extends Manager { for (String materialString : tree.getStringList("logs")) { CompatibleMaterial material = CompatibleMaterial.getMaterial(materialString); - if (material == null || material.getMaterial() == null) continue top; + if (material == null || material.getMaterial() == null) { + continue top; + } logMaterials.add(material); } for (String materialString : tree.getStringList("leaves")) { CompatibleMaterial material = CompatibleMaterial.getMaterial(materialString); - if (material == null || material.getMaterial() == null) continue top; + if (material == null || material.getMaterial() == null) { + continue top; + } leafMaterials.add(material); } @@ -102,7 +105,9 @@ public class TreeDefinitionManager extends Manager { for (String materialString : tree.getStringList("plantable-soil")) { CompatibleMaterial material = CompatibleMaterial.getMaterial(materialString); - if (material == null || material.getMaterial() == null) continue top; + if (material == null || material.getMaterial() == null) { + continue top; + } plantableSoilMaterial.add(material); } @@ -113,23 +118,31 @@ public class TreeDefinitionManager extends Manager { dropOriginalLeaf = tree.getBoolean("drop-original-leaf"); ConfigurationSection logLootSection = tree.getConfigurationSection("log-loot"); - if (logLootSection != null) - for (String lootKey : logLootSection.getKeys(false)) + if (logLootSection != null) { + for (String lootKey : logLootSection.getKeys(false)) { logLoot.add(this.getTreeLootEntry(TreeBlockType.LOG, logLootSection.getConfigurationSection(lootKey))); + } + } ConfigurationSection leafLootSection = tree.getConfigurationSection("leaf-loot"); - if (leafLootSection != null) - for (String lootKey : leafLootSection.getKeys(false)) + if (leafLootSection != null) { + for (String lootKey : leafLootSection.getKeys(false)) { leafLoot.add(this.getTreeLootEntry(TreeBlockType.LEAF, leafLootSection.getConfigurationSection(lootKey))); + } + } ConfigurationSection entireTreeLootSection = tree.getConfigurationSection("entire-tree-loot"); - if (entireTreeLootSection != null) - for (String lootKey : entireTreeLootSection.getKeys(false)) + if (entireTreeLootSection != null) { + for (String lootKey : entireTreeLootSection.getKeys(false)) { entireTreeLoot.add(this.getTreeLootEntry(TreeBlockType.LEAF, entireTreeLootSection.getConfigurationSection(lootKey))); + } + } for (String itemStackString : tree.getStringList("required-tools")) { CompatibleMaterial material = CompatibleMaterial.getMaterial(itemStackString); - if (material == null) continue top; + if (material == null) { + continue top; + } requiredTools.add(material.getItem()); } @@ -140,43 +153,52 @@ public class TreeDefinitionManager extends Manager { } // Load global plantable soil - for (String material : config.getStringList("global-plantable-soil")) + for (String material : config.getStringList("global-plantable-soil")) { this.globalPlantableSoil.add(CompatibleMaterial.getMaterial(material)); + } // Load global log drops ConfigurationSection logSection = config.getConfigurationSection("global-log-loot"); - if (logSection != null) - for (String lootKey : logSection.getKeys(false)) + if (logSection != null) { + for (String lootKey : logSection.getKeys(false)) { this.globalLogLoot.add(this.getTreeLootEntry(TreeBlockType.LOG, logSection.getConfigurationSection(lootKey))); + } + } // Load global leaf drops ConfigurationSection leafSection = config.getConfigurationSection("global-leaf-loot"); - if (leafSection != null) - for (String lootKey : leafSection.getKeys(false)) + if (leafSection != null) { + for (String lootKey : leafSection.getKeys(false)) { this.globalLeafLoot.add(this.getTreeLootEntry(TreeBlockType.LEAF, leafSection.getConfigurationSection(lootKey))); + } + } // Load global entire tree drops ConfigurationSection entireTreeSection = config.getConfigurationSection("global-entire-tree-loot"); - if (entireTreeSection != null) - for (String lootKey : entireTreeSection.getKeys(false)) + if (entireTreeSection != null) { + for (String lootKey : entireTreeSection.getKeys(false)) { this.globalEntireTreeLoot.add(this.getTreeLootEntry(TreeBlockType.LOG, entireTreeSection.getConfigurationSection(lootKey))); + } + } // Load global tools for (String itemStackString : config.getStringList("global-required-tools")) { ItemStack tool = CompatibleMaterial.getMaterial(itemStackString).getItem(); - if (tool == null) continue; + if (tool == null) { + continue; + } this.globalRequiredTools.add(tool); } this.globalAxeRequired = config.getBoolean("global-required-axe", false); // Load required axe - if (config.contains("required-axe")) + if (config.contains("required-axe")) { loadAxe(config); + } } private void loadAxe(YamlConfiguration config) { - // Reset the axe loaded, but load the NBT anyway in case someone wanted to use another plugin to give it. this.requiredAxeKey = config.getString("required-axe.nbt"); this.requiredAxe = null; @@ -184,14 +206,14 @@ public class TreeDefinitionManager extends Manager { String typeString = config.getString("required-axe.type"); if (Strings.isNullOrEmpty(typeString)) { - plugin.getLogger().warning("Required-axe has to have a material set."); + this.plugin.getLogger().warning("Required-axe has to have a material set."); return; } CompatibleMaterial material = CompatibleMaterial.getMaterial(typeString); if (material == null) { - plugin.getLogger().warning("Material " + typeString + " is invalid."); + this.plugin.getLogger().warning("Material " + typeString + " is invalid."); return; } @@ -219,13 +241,15 @@ public class TreeDefinitionManager extends Manager { enchantment = Enchantment.getByKey(key); // Try to fall back to #getByName() if someone uses the old names. - if (enchantment == null) + if (enchantment == null) { enchantment = Enchantment.getByName(arr[0].trim()); - } else + } + } else { enchantment = Enchantment.getByName(arr[0].trim()); + } if (enchantment == null) { - plugin.getLogger().warning("Enchantment " + arr[0].trim() + " is invalid."); + this.plugin.getLogger().warning("Enchantment " + arr[0].trim() + " is invalid."); continue; } @@ -236,7 +260,7 @@ public class TreeDefinitionManager extends Manager { // Apply NBT NBTItem nbtItem = new NBTItem(item); - nbtItem.setBoolean(requiredAxeKey, true); + nbtItem.setBoolean(this.requiredAxeKey, true); item = nbtItem.getItem(); this.requiredAxe = item; @@ -255,7 +279,7 @@ public class TreeDefinitionManager extends Manager { } public boolean isGlobalAxeRequired() { - return globalAxeRequired; + return this.globalAxeRequired; } @Override @@ -267,7 +291,6 @@ public class TreeDefinitionManager extends Manager { * Gets a Set of possible TreeDefinitions that match the given Block * * @param block The Block to check - * * @return A Set of TreeDefinitions for the given Block */ public Set getTreeDefinitionsForLog(Block block) { @@ -280,7 +303,6 @@ public class TreeDefinitionManager extends Manager { * @param possibleTreeDefinitions The possible TreeDefinitions * @param block The Block to narrow to * @param treeBlockType The TreeBlockType of the given Block - * * @return A Set of TreeDefinitions narrowed down */ public Set narrowTreeDefinition(Set possibleTreeDefinitions, Block block, TreeBlockType treeBlockType) { @@ -289,7 +311,7 @@ public class TreeDefinitionManager extends Manager { case LOG: for (TreeDefinition treeDefinition : possibleTreeDefinitions) { for (CompatibleMaterial material : treeDefinition.getLogMaterial()) { - if (material.equals(CompatibleMaterial.getMaterial(block))) { + if (material == CompatibleMaterial.getMaterial(block)) { matchingTreeDefinitions.add(treeDefinition); break; } @@ -299,7 +321,7 @@ public class TreeDefinitionManager extends Manager { case LEAF: for (TreeDefinition treeDefinition : possibleTreeDefinitions) { for (CompatibleMaterial material : treeDefinition.getLeafMaterial()) { - if (material.equals(CompatibleMaterial.getMaterial(block))) { + if (material == CompatibleMaterial.getMaterial(block)) { matchingTreeDefinitions.add(treeDefinition); break; } @@ -315,28 +337,34 @@ public class TreeDefinitionManager extends Manager { * Checks if a given tool is valid for any tree definitions, also takes into account global tools * * @param tool The tool to check - * * @return True if the tool is allowed for toppling any trees */ public boolean isToolValidForAnyTreeDefinition(ItemStack tool) { - if (ConfigurationManager.Setting.IGNORE_REQUIRED_TOOLS.getBoolean()) + if (ConfigurationManager.Setting.IGNORE_REQUIRED_TOOLS.getBoolean()) { return true; + } for (TreeDefinition treeDefinition : this.treeDefinitions) { if (treeDefinition.isRequiredAxe() || isGlobalAxeRequired()) { - if (tool != null && !tool.getType().isAir() && new NBTItem(tool).hasKey(requiredAxeKey)) + if (tool != null && !tool.getType().isAir() && new NBTItem(tool).hasTag(this.requiredAxeKey)) { return true; + } } } - for (TreeDefinition treeDefinition : this.treeDefinitions) - for (ItemStack requiredTool : treeDefinition.getRequiredTools()) - if (requiredTool.getType().equals(tool.getType())) + for (TreeDefinition treeDefinition : this.treeDefinitions) { + for (ItemStack requiredTool : treeDefinition.getRequiredTools()) { + if (requiredTool.getType() == tool.getType()) { return true; + } + } + } - for (ItemStack requiredTool : this.globalRequiredTools) - if (requiredTool.getType().equals(tool.getType())) + for (ItemStack requiredTool : this.globalRequiredTools) { + if (requiredTool.getType() == tool.getType()) { return true; + } + } return false; } @@ -346,26 +374,29 @@ public class TreeDefinitionManager extends Manager { * * @param treeDefinition The TreeDefinition to use * @param tool The tool to check - * * @return True if the tool is allowed for toppling the given TreeDefinition */ public boolean isToolValidForTreeDefinition(TreeDefinition treeDefinition, ItemStack tool) { - - if (ConfigurationManager.Setting.IGNORE_REQUIRED_TOOLS.getBoolean()) + if (ConfigurationManager.Setting.IGNORE_REQUIRED_TOOLS.getBoolean()) { return true; + } // If the tree definition requires the custom axe, don't allow any other checks to pass. if (treeDefinition.isRequiredAxe() || isGlobalAxeRequired()) { - return tool != null && !tool.getType().isAir() && new NBTItem(tool).hasKey(requiredAxeKey); + return tool != null && !tool.getType().isAir() && new NBTItem(tool).hasTag(this.requiredAxeKey); } - for (ItemStack requiredTool : treeDefinition.getRequiredTools()) - if (requiredTool.getType().equals(tool.getType())) + for (ItemStack requiredTool : treeDefinition.getRequiredTools()) { + if (requiredTool.getType() == tool.getType()) { return true; + } + } - for (ItemStack requiredTool : this.globalRequiredTools) - if (requiredTool.getType().equals(tool.getType())) + for (ItemStack requiredTool : this.globalRequiredTools) { + if (requiredTool.getType() == tool.getType()) { return true; + } + } return false; } @@ -391,8 +422,9 @@ public class TreeDefinitionManager extends Manager { } else { if (ConfigurationManager.Setting.APPLY_SILK_TOUCH.getBoolean() && hasSilkTouch) { if (ConfigurationManager.Setting.HOOKS_APPLY_EXTRA_DROPS.getBoolean() - && McMMOHook.hasWoodcuttingDoubleDrops(player)) + && McMMOHook.hasWoodcuttingDoubleDrops(player)) { lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); + } lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); } else { switch (treeBlock.getTreeBlockType()) { @@ -401,8 +433,9 @@ public class TreeDefinitionManager extends Manager { toTry.addAll(this.globalLogLoot); if (treeDefinition.shouldDropOriginalLog()) { if (ConfigurationManager.Setting.HOOKS_APPLY_EXTRA_DROPS.getBoolean() - && McMMOHook.hasWoodcuttingDoubleDrops(player)) + && McMMOHook.hasWoodcuttingDoubleDrops(player)) { lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); + } lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); } break; @@ -411,8 +444,9 @@ public class TreeDefinitionManager extends Manager { toTry.addAll(this.globalLeafLoot); if (treeDefinition.shouldDropOriginalLeaf()) { if (ConfigurationManager.Setting.HOOKS_APPLY_EXTRA_DROPS.getBoolean() - && McMMOHook.hasWoodcuttingDoubleDrops(player)) + && McMMOHook.hasWoodcuttingDoubleDrops(player)) { lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); + } lootedItems.addAll(BlockUtils.getBlockDrops(treeBlock)); } break; @@ -423,22 +457,27 @@ public class TreeDefinitionManager extends Manager { // Roll the dice double bonusLootMultiplier = ConfigurationManager.Setting.BONUS_LOOT_MULTIPLIER.getDouble(); for (TreeLoot treeLoot : toTry) { - if (treeLoot == null) continue; - double chance = hasBonusChance ? treeLoot.getChance() * bonusLootMultiplier : treeLoot.getChance(); - if (this.random.nextDouble() > chance / 100) + if (treeLoot == null) { continue; + } + double chance = hasBonusChance ? treeLoot.getChance() * bonusLootMultiplier : treeLoot.getChance(); + if (this.random.nextDouble() > chance / 100) { + continue; + } if (treeLoot.hasItem()) { if (ConfigurationManager.Setting.HOOKS_APPLY_EXTRA_DROPS.getBoolean() - && McMMOHook.hasWoodcuttingDoubleDrops(player)) + && McMMOHook.hasWoodcuttingDoubleDrops(player)) { lootedItems.add(treeLoot.getItem()); + } lootedItems.add(treeLoot.getItem()); } if (treeLoot.hasCommand()) { if (ConfigurationManager.Setting.HOOKS_APPLY_EXTRA_DROPS.getBoolean() - && McMMOHook.hasWoodcuttingDoubleDrops(player)) + && McMMOHook.hasWoodcuttingDoubleDrops(player)) { lootedCommands.add(treeLoot.getCommand()); + } lootedCommands.add(treeLoot.getCommand()); } } @@ -446,32 +485,35 @@ public class TreeDefinitionManager extends Manager { // Add to inventory or drop on ground if (addToInventory && player.getWorld().equals(treeBlock.getLocation().getWorld())) { List extraItems = new ArrayList<>(); - for (ItemStack lootedItem : lootedItems) + for (ItemStack lootedItem : lootedItems) { extraItems.addAll(player.getInventory().addItem(lootedItem).values()); + } Location location = player.getLocation().clone().subtract(0.5, 0, 0.5); - for (ItemStack extraItem : extraItems) + for (ItemStack extraItem : extraItems) { location.getWorld().dropItemNaturally(location, extraItem); + } } else { Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); - for (ItemStack lootedItem : lootedItems) + for (ItemStack lootedItem : lootedItems) { location.getWorld().dropItemNaturally(location, lootedItem); + } } // Run looted commands - for (String lootedCommand : lootedCommands) + for (String lootedCommand : lootedCommands) { Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), lootedCommand.replace("%player%", player.getName()) .replace("%type%", treeDefinition.getKey()) - .replace("%xPos%", treeBlock.getLocation().getBlockX() + "") - .replace("%yPos%", treeBlock.getLocation().getBlockY() + "") - .replace("%zPos%", treeBlock.getLocation().getBlockZ() + "")); + .replace("%xPos%", String.valueOf(treeBlock.getLocation().getBlockX())) + .replace("%yPos%", String.valueOf(treeBlock.getLocation().getBlockY())) + .replace("%zPos%", String.valueOf(treeBlock.getLocation().getBlockZ()))); + } } /** * Gets all possible plantable soil blocks for the given tree definition * * @param treeDefinition The TreeDefinition - * * @return A Set of IBlockData of plantable soil */ public Set getPlantableSoilMaterial(TreeDefinition treeDefinition) { @@ -486,7 +528,6 @@ public class TreeDefinitionManager extends Manager { * * @param treeBlockType The TreeBlockType to use * @param configurationSection The ConfigurationSection - * * @return A TreeLoot entry from the section */ private TreeLoot getTreeLootEntry(TreeBlockType treeBlockType, ConfigurationSection configurationSection) { diff --git a/src/main/java/com/songoda/ultimatetimber/manager/TreeDetectionManager.java b/src/main/java/com/songoda/ultimatetimber/manager/TreeDetectionManager.java index 00bb59e..6aa4221 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/TreeDetectionManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/TreeDetectionManager.java @@ -2,16 +2,24 @@ package com.songoda.ultimatetimber.manager; import com.songoda.core.compatibility.CompatibleMaterial; import com.songoda.ultimatetimber.UltimateTimber; -import com.songoda.ultimatetimber.tree.*; +import com.songoda.ultimatetimber.tree.DetectedTree; +import com.songoda.ultimatetimber.tree.ITreeBlock; +import com.songoda.ultimatetimber.tree.TreeBlock; +import com.songoda.ultimatetimber.tree.TreeBlockSet; +import com.songoda.ultimatetimber.tree.TreeBlockType; +import com.songoda.ultimatetimber.tree.TreeDefinition; import org.bukkit.Location; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.util.Vector; -import java.util.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; public class TreeDetectionManager extends Manager { - private final Set VALID_TRUNK_OFFSETS, VALID_BRANCH_OFFSETS, VALID_LEAF_OFFSETS; private TreeDefinitionManager treeDefinitionManager; @@ -19,24 +27,30 @@ public class TreeDetectionManager extends Manager { private int numLeavesRequiredForTree; private boolean onlyBreakLogsUpwards, entireTreeBase, destroyLeaves; - public TreeDetectionManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); + public TreeDetectionManager(UltimateTimber plugin) { + super(plugin); this.VALID_BRANCH_OFFSETS = new HashSet<>(); this.VALID_TRUNK_OFFSETS = new HashSet<>(); this.VALID_LEAF_OFFSETS = new HashSet<>(); // 3x2x3 centered around log, excluding -y axis - for (int y = 0; y <= 1; y++) - for (int x = -1; x <= 1; x++) - for (int z = -1; z <= 1; z++) + for (int y = 0; y <= 1; y++) { + for (int x = -1; x <= 1; x++) { + for (int z = -1; z <= 1; z++) { this.VALID_BRANCH_OFFSETS.add(new Vector(x, y, z)); + } + } + } // 3x3x3 centered around log - for (int y = -1; y <= 1; y++) - for (int x = -1; x <= 1; x++) - for (int z = -1; z <= 1; z++) + for (int y = -1; y <= 1; y++) { + for (int x = -1; x <= 1; x++) { + for (int z = -1; z <= 1; z++) { this.VALID_TRUNK_OFFSETS.add(new Vector(x, y, z)); + } + } + } // Adjacent blocks to log for (int i = -1; i <= 1; i += 2) { @@ -58,7 +72,6 @@ public class TreeDetectionManager extends Manager { @Override public void disable() { - } /** @@ -74,8 +87,9 @@ public class TreeDetectionManager extends Manager { TreeBlockSet detectedTreeBlocks = new TreeBlockSet<>(initialTreeBlock); Set possibleTreeDefinitions = this.treeDefinitionManager.getTreeDefinitionsForLog(initialBlock); - if (possibleTreeDefinitions.isEmpty()) + if (possibleTreeDefinitions.isEmpty()) { return null; + } // Detect tree trunk List trunkBlocks = new ArrayList<>(); @@ -98,45 +112,52 @@ public class TreeDetectionManager extends Manager { Collections.reverse(trunkBlocks); // Detect branches off the main trunk - for (Block trunkBlock : trunkBlocks) + for (Block trunkBlock : trunkBlocks) { this.recursiveBranchSearch(possibleTreeDefinitions, trunkBlocks, detectedTreeBlocks, trunkBlock, initialBlock.getLocation().getBlockY()); + } // Detect leaves off the trunk/branches Set> branchBlocks = new HashSet<>(detectedTreeBlocks.getLogBlocks()); - for (ITreeBlock branchBlock : branchBlocks) + for (ITreeBlock branchBlock : branchBlocks) { this.recursiveLeafSearch(possibleTreeDefinitions, detectedTreeBlocks, branchBlock.getBlock(), new HashSet<>()); + } // Use the first tree definition in the set TreeDefinition actualTreeDefinition = possibleTreeDefinitions.iterator().next(); // Trees need at least a certain number of leaves - if (detectedTreeBlocks.getLeafBlocks().size() < this.numLeavesRequiredForTree) + if (detectedTreeBlocks.getLeafBlocks().size() < this.numLeavesRequiredForTree) { return null; + } // Remove leaves if we don't care about the leaves - if (!this.destroyLeaves) + if (!this.destroyLeaves) { detectedTreeBlocks.removeAll(TreeBlockType.LEAF); + } // Check that the tree isn't on the ground if enabled if (this.entireTreeBase) { Set groundBlocks = new HashSet<>(); - for (ITreeBlock treeBlock : detectedTreeBlocks.getLogBlocks()) - if (treeBlock != detectedTreeBlocks.getInitialLogBlock() && treeBlock.getLocation().getBlockY() == initialBlock.getLocation().getBlockY()) + for (ITreeBlock treeBlock : detectedTreeBlocks.getLogBlocks()) { + if (treeBlock != detectedTreeBlocks.getInitialLogBlock() && treeBlock.getLocation().getBlockY() == initialBlock.getLocation().getBlockY()) { groundBlocks.add(treeBlock.getBlock()); + } + } for (Block block : groundBlocks) { Block blockBelow = block.getRelative(BlockFace.DOWN); boolean blockBelowIsLog = this.isValidLogType(possibleTreeDefinitions, null, blockBelow); boolean blockBelowIsSoil = false; for (CompatibleMaterial material : treeDefinitionManager.getPlantableSoilMaterial(actualTreeDefinition)) { - if (material.equals(CompatibleMaterial.getMaterial(blockBelow))) { + if (material == CompatibleMaterial.getMaterial(blockBelow)) { blockBelowIsSoil = true; break; } } - if (blockBelowIsLog || blockBelowIsSoil) + if (blockBelowIsLog || blockBelowIsSoil) { return null; + } } } @@ -159,8 +180,9 @@ public class TreeDetectionManager extends Manager { if (this.isValidLogType(treeDefinitions, trunkBlocks, targetBlock) && !treeBlocks.contains(treeBlock)) { treeBlocks.add(treeBlock); treeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(treeDefinitions, targetBlock, TreeBlockType.LOG)); - if (!this.onlyBreakLogsUpwards || targetBlock.getLocation().getBlockY() > startingBlockY) + if (!this.onlyBreakLogsUpwards || targetBlock.getLocation().getBlockY() > startingBlockY) { this.recursiveBranchSearch(treeDefinitions, trunkBlocks, treeBlocks, targetBlock, startingBlockY); + } } } } @@ -177,8 +199,9 @@ public class TreeDetectionManager extends Manager { for (Vector offset : !detectLeavesDiagonally ? this.VALID_LEAF_OFFSETS : this.VALID_TRUNK_OFFSETS) { Block targetBlock = block.getRelative(offset.getBlockX(), offset.getBlockY(), offset.getBlockZ()); - if (visitedBlocks.contains(targetBlock)) + if (visitedBlocks.contains(targetBlock)) { continue; + } visitedBlocks.add(targetBlock); TreeBlock treeBlock = new TreeBlock(targetBlock, TreeBlockType.LEAF); @@ -201,8 +224,9 @@ public class TreeDetectionManager extends Manager { private boolean doesLeafBorderInvalidLog(Set treeDefinitions, TreeBlockSet treeBlocks, Block block) { for (Vector offset : this.VALID_TRUNK_OFFSETS) { Block targetBlock = block.getRelative(offset.getBlockX(), offset.getBlockY(), offset.getBlockZ()); - if (this.isValidLogType(treeDefinitions, null, targetBlock) && !treeBlocks.contains(new TreeBlock(targetBlock, TreeBlockType.LOG))) + if (this.isValidLogType(treeDefinitions, null, targetBlock) && !treeBlocks.contains(new TreeBlock(targetBlock, TreeBlockType.LOG))) { return true; + } } return false; } @@ -217,35 +241,42 @@ public class TreeDetectionManager extends Manager { */ private boolean isValidLogType(Set treeDefinitions, List trunkBlocks, Block block) { // Check if block is placed - if (this.placedBlockManager.isBlockPlaced(block)) + if (this.placedBlockManager.isBlockPlaced(block)) { return false; + } // Check if it matches the tree definition boolean isCorrectType = false; for (TreeDefinition treeDefinition : treeDefinitions) { for (CompatibleMaterial material : treeDefinition.getLogMaterial()) { - if (material.equals(CompatibleMaterial.getMaterial(block))) { + if (material == CompatibleMaterial.getMaterial(block)) { isCorrectType = true; break; } } } - if (!isCorrectType) + if (!isCorrectType) { return false; + } // Check that it is close enough to the trunk - if (trunkBlocks == null || trunkBlocks.isEmpty()) + if (trunkBlocks == null || trunkBlocks.isEmpty()) { return true; + } Location location = block.getLocation(); for (TreeDefinition treeDefinition : treeDefinitions) { double maxDistance = treeDefinition.getMaxLogDistanceFromTrunk() * treeDefinition.getMaxLogDistanceFromTrunk(); if (!this.onlyBreakLogsUpwards) // Help detect logs more often if the tree isn't broken at the base + { maxDistance *= 1.5; - for (Block trunkBlock : trunkBlocks) - if (location.distanceSquared(trunkBlock.getLocation()) < maxDistance) + } + for (Block trunkBlock : trunkBlocks) { + if (location.distanceSquared(trunkBlock.getLocation()) < maxDistance) { return true; + } + } } return false; @@ -261,29 +292,31 @@ public class TreeDetectionManager extends Manager { */ private boolean isValidLeafType(Set treeDefinitions, TreeBlockSet treeBlocks, Block block) { // Check if block is placed - if (this.placedBlockManager.isBlockPlaced(block)) + if (this.placedBlockManager.isBlockPlaced(block)) { return false; + } // Check if it matches the tree definition boolean isCorrectType = false; for (TreeDefinition treeDefinition : treeDefinitions) { for (CompatibleMaterial material : treeDefinition.getLeafMaterial()) { - if (material.equals(CompatibleMaterial.getMaterial(block))) { + if (material == CompatibleMaterial.getMaterial(block)) { isCorrectType = true; break; } } } - if (!isCorrectType) + if (!isCorrectType) { return false; + } // Check that it is close enough to a log - if (treeBlocks == null || treeBlocks.isEmpty()) + if (treeBlocks == null || treeBlocks.isEmpty()) { return true; + } int maxDistanceFromLog = treeDefinitions.stream().map(TreeDefinition::getMaxLeafDistanceFromLog).max(Integer::compareTo).orElse(0); return treeBlocks.getLogBlocks().stream().anyMatch(x -> x.getLocation().distanceSquared(block.getLocation()) < maxDistanceFromLog * maxDistanceFromLog); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/manager/TreeFallManager.java b/src/main/java/com/songoda/ultimatetimber/manager/TreeFallManager.java index 97511d2..f38ea3b 100644 --- a/src/main/java/com/songoda/ultimatetimber/manager/TreeFallManager.java +++ b/src/main/java/com/songoda/ultimatetimber/manager/TreeFallManager.java @@ -28,12 +28,11 @@ import org.bukkit.inventory.ItemStack; import java.util.stream.Collectors; public class TreeFallManager extends Manager implements Listener { - private int maxLogBlocksAllowed; - public TreeFallManager(UltimateTimber ultimateTimber) { - super(ultimateTimber); - Bukkit.getPluginManager().registerEvents(this, ultimateTimber); + public TreeFallManager(UltimateTimber plugin) { + super(plugin); + Bukkit.getPluginManager().registerEvents(this, plugin); } @Override @@ -43,7 +42,6 @@ public class TreeFallManager extends Manager implements Listener { @Override public void disable() { - } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) @@ -67,54 +65,65 @@ public class TreeFallManager extends Manager implements Listener { // Condition checks boolean isValid = true; - if (ConfigurationManager.Setting.DISABLED_WORLDS.getStringList().contains(player.getWorld().getName())) + if (ConfigurationManager.Setting.DISABLED_WORLDS.getStringList().contains(player.getWorld().getName())) { isValid = false; + } - if (!ConfigurationManager.Setting.ALLOW_CREATIVE_MODE.getBoolean() && player.getGameMode().equals(GameMode.CREATIVE)) + if (!ConfigurationManager.Setting.ALLOW_CREATIVE_MODE.getBoolean() && player.getGameMode().equals(GameMode.CREATIVE)) { isValid = false; + } - if (!this.checkToppleWhile(player)) + if (!this.checkToppleWhile(player)) { isValid = false; + } - if (ConfigurationManager.Setting.REQUIRE_CHOP_PERMISSION.getBoolean() && !player.hasPermission("ultimatetimber.chop")) + if (ConfigurationManager.Setting.REQUIRE_CHOP_PERMISSION.getBoolean() && !player.hasPermission("ultimatetimber.chop")) { isValid = false; + } - if (!choppingManager.isChopping(player)) + if (!choppingManager.isChopping(player)) { isValid = false; + } - if (choppingManager.isInCooldown(player)) + if (choppingManager.isInCooldown(player)) { isValid = false; + } if (treeAnimationManager.isBlockInAnimation(block)) { isValid = false; event.setCancelled(true); } - if (!treeDefinitionManager.isToolValidForAnyTreeDefinition(tool)) + if (!treeDefinitionManager.isToolValidForAnyTreeDefinition(tool)) { isValid = false; + } - if (ConfigurationManager.Setting.HOOKS_REQUIRE_ABILITY_ACTIVE.getBoolean() - && !McMMOHook.isUsingTreeFeller(player)) + if (ConfigurationManager.Setting.HOOKS_REQUIRE_ABILITY_ACTIVE.getBoolean() && !McMMOHook.isUsingTreeFeller(player)) { isValid = false; + } boolean alwaysReplantSapling = ConfigurationManager.Setting.ALWAYS_REPLANT_SAPLING.getBoolean(); - if (!isValid && !alwaysReplantSapling) + if (!isValid && !alwaysReplantSapling) { return; + } DetectedTree detectedTree = treeDetectionManager.detectTree(block); - if (detectedTree == null) + if (detectedTree == null) { return; + } if (alwaysReplantSapling) { Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> saplingManager.replantSapling(detectedTree.getTreeDefinition(), detectedTree.getDetectedTreeBlocks().getInitialLogBlock())); - if (!isValid) + if (!isValid) { return; + } } - if (!treeDefinitionManager.isToolValidForTreeDefinition(detectedTree.getTreeDefinition(), tool)) + if (!treeDefinitionManager.isToolValidForTreeDefinition(detectedTree.getTreeDefinition(), tool)) { return; + } short toolDamage = this.getToolDamage(detectedTree.getDetectedTreeBlocks(), tool.containsEnchantment(Enchantment.SILK_TOUCH)); if (ConfigurationManager.Setting.PROTECT_TOOL.getBoolean() && !ItemUtils.hasEnoughDurability(tool, toolDamage)) { @@ -124,13 +133,14 @@ public class TreeFallManager extends Manager implements Listener { // Trigger fall event TreeFallEvent treeFallEvent = new TreeFallEvent(player, detectedTree); Bukkit.getPluginManager().callEvent(treeFallEvent); - if (treeFallEvent.isCancelled()) + if (treeFallEvent.isCancelled()) { return; + } // Valid tree and meets all conditions past this point event.setCancelled(true); - detectedTree.getDetectedTreeBlocks().sortAndLimit(maxLogBlocksAllowed); + detectedTree.getDetectedTreeBlocks().sortAndLimit(this.maxLogBlocksAllowed); choppingManager.cooldownPlayer(player); @@ -140,7 +150,7 @@ public class TreeFallManager extends Manager implements Listener { detectedTree.getDetectedTreeBlocks().remove(detectedTree.getDetectedTreeBlocks().getInitialLogBlock()); } - boolean isCreative = player.getGameMode().equals(GameMode.CREATIVE); + boolean isCreative = player.getGameMode() == GameMode.CREATIVE; if (!isCreative) { new SItemStack(tool).addDamage(player, toolDamage, true); @@ -150,13 +160,16 @@ public class TreeFallManager extends Manager implements Listener { McMMOHook.addWoodcutting(player, detectedTree.getDetectedTreeBlocks().getAllTreeBlocks().stream() .map(ITreeBlock::getBlock).collect(Collectors.toList())); - if (!isCreative && JobsHook.isEnabled()) - for (ITreeBlock treeBlock : detectedTree.getDetectedTreeBlocks().getLogBlocks()) + if (!isCreative && JobsHook.isEnabled()) { + for (ITreeBlock treeBlock : detectedTree.getDetectedTreeBlocks().getLogBlocks()) { JobsHook.breakBlock(player, treeBlock.getBlock()); + } + } } - for (ITreeBlock treeBlock : detectedTree.getDetectedTreeBlocks().getAllTreeBlocks()) + for (ITreeBlock treeBlock : detectedTree.getDetectedTreeBlocks().getAllTreeBlocks()) { LogManager.logRemoval(player, treeBlock.getBlock()); + } treeAnimationManager.runAnimation(detectedTree, player); treeDefinitionManager.dropTreeLoot(detectedTree.getTreeDefinition(), detectedTree.getDetectedTreeBlocks().getInitialLogBlock(), player, false, true); @@ -170,7 +183,6 @@ public class TreeFallManager extends Manager implements Listener { * Checks if a player is doing a certain action required to topple a tree * * @param player The player to check - * * @return True if the check passes, otherwise false */ private boolean checkToppleWhile(Player player) { @@ -185,8 +197,9 @@ public class TreeFallManager extends Manager implements Listener { } private short getToolDamage(TreeBlockSet treeBlocks, boolean hasSilkTouch) { - if (!ConfigurationManager.Setting.REALISTIC_TOOL_DAMAGE.getBoolean()) + if (!ConfigurationManager.Setting.REALISTIC_TOOL_DAMAGE.getBoolean()) { return 1; + } if (ConfigurationManager.Setting.APPLY_SILK_TOUCH_TOOL_DAMAGE.getBoolean() && hasSilkTouch) { return (short) treeBlocks.size(); diff --git a/src/main/java/com/songoda/ultimatetimber/misc/OnlyToppleWhile.java b/src/main/java/com/songoda/ultimatetimber/misc/OnlyToppleWhile.java index bcdd7f3..b51787b 100644 --- a/src/main/java/com/songoda/ultimatetimber/misc/OnlyToppleWhile.java +++ b/src/main/java/com/songoda/ultimatetimber/misc/OnlyToppleWhile.java @@ -1,20 +1,20 @@ package com.songoda.ultimatetimber.misc; public enum OnlyToppleWhile { - SNEAKING, - NOT_SNEAKING, - ALWAYS; + SNEAKING, NOT_SNEAKING, ALWAYS; /** * Gets an OnlyToppleWhile from a given string * - * @param string The string - * @return The TreeAnimationType, returns FANCY if the string is an invalid type + * @return The TreeAnimationType, returns {@link #ALWAYS} if the string is an invalid type */ public static OnlyToppleWhile fromString(String string) { - for (OnlyToppleWhile value : values()) - if (value.name().equalsIgnoreCase(string)) + for (OnlyToppleWhile value : values()) { + if (value.name().equalsIgnoreCase(string)) { return value; + } + } + return OnlyToppleWhile.ALWAYS; } } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/DetectedTree.java b/src/main/java/com/songoda/ultimatetimber/tree/DetectedTree.java index fd7f6ce..c65bc57 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/DetectedTree.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/DetectedTree.java @@ -3,9 +3,8 @@ package com.songoda.ultimatetimber.tree; import org.bukkit.block.Block; public class DetectedTree { - - private TreeDefinition treeDefinition; - private TreeBlockSet detectedTreeBlocks; + private final TreeDefinition treeDefinition; + private final TreeBlockSet detectedTreeBlocks; public DetectedTree(TreeDefinition treeDefinition, TreeBlockSet detectedTreeBlocks) { this.treeDefinition = treeDefinition; @@ -29,5 +28,4 @@ public class DetectedTree { public TreeBlockSet getDetectedTreeBlocks() { return this.detectedTreeBlocks; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/FallingTreeBlock.java b/src/main/java/com/songoda/ultimatetimber/tree/FallingTreeBlock.java index 843565b..71243d9 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/FallingTreeBlock.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/FallingTreeBlock.java @@ -4,7 +4,6 @@ import org.bukkit.Location; import org.bukkit.entity.FallingBlock; public class FallingTreeBlock implements ITreeBlock { - private final FallingBlock fallingBlock; private final TreeBlockType treeBlockType; @@ -27,5 +26,4 @@ public class FallingTreeBlock implements ITreeBlock { public TreeBlockType getTreeBlockType() { return this.treeBlockType; } - } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/ITreeBlock.java b/src/main/java/com/songoda/ultimatetimber/tree/ITreeBlock.java index 1d2cb1d..47ae099 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/ITreeBlock.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/ITreeBlock.java @@ -3,7 +3,6 @@ package com.songoda.ultimatetimber.tree; import org.bukkit.Location; public interface ITreeBlock { - /** * Gets the block this TreeBlock represents * @@ -24,5 +23,4 @@ public interface ITreeBlock { * @return The TreeBlockType */ TreeBlockType getTreeBlockType(); - } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlock.java b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlock.java index 2f6f45c..98c540c 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlock.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlock.java @@ -6,7 +6,6 @@ import org.bukkit.block.Block; import java.util.Objects; public class TreeBlock implements ITreeBlock { - private final Block block; private final TreeBlockType treeBlockType; @@ -36,11 +35,15 @@ public class TreeBlock implements ITreeBlock { } @Override - public boolean equals(Object o) { - if (!(o instanceof TreeBlock)) return false; - if (o == this) return true; - TreeBlock oTreeBlock = (TreeBlock)o; - return oTreeBlock.block.equals(this.block) && oTreeBlock.treeBlockType.equals(this.treeBlockType); - } + public boolean equals(Object obj) { + if (!(obj instanceof TreeBlock)) { + return false; + } + if (obj == this) { + return true; + } + TreeBlock oTreeBlock = (TreeBlock) obj; + return oTreeBlock.block.equals(this.block) && oTreeBlock.treeBlockType == this.treeBlockType; + } } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockSet.java b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockSet.java index 1255522..8c9008e 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockSet.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockSet.java @@ -1,7 +1,5 @@ package com.songoda.ultimatetimber.tree; -import org.bukkit.block.Block; - import java.util.Collection; import java.util.Collections; import java.util.Comparator; @@ -13,7 +11,6 @@ import java.util.Set; import java.util.stream.Collectors; public class TreeBlockSet implements Collection { - private final ITreeBlock initialLogBlock; private List> logBlocks; private final List> leafBlocks; @@ -29,8 +26,9 @@ public class TreeBlockSet implements Collection { this.logBlocks = new LinkedList<>(); this.leafBlocks = new LinkedList<>(); - if (initialLogBlock != null) + if (initialLogBlock != null) { this.logBlocks.add(initialLogBlock); + } } /** @@ -100,7 +98,9 @@ public class TreeBlockSet implements Collection { @Override @SuppressWarnings("unchecked") public boolean add(Object o) { - if (!(o instanceof ITreeBlock)) return false; + if (!(o instanceof ITreeBlock)) { + return false; + } ITreeBlock treeBlock = (ITreeBlock) o; switch (treeBlock.getTreeBlockType()) { case LOG: @@ -113,7 +113,9 @@ public class TreeBlockSet implements Collection { @Override public boolean remove(Object o) { - if (!(o instanceof ITreeBlock)) return false; + if (!(o instanceof ITreeBlock)) { + return false; + } ITreeBlock treeBlock = (ITreeBlock) o; switch (treeBlock.getTreeBlockType()) { case LOG: @@ -168,18 +170,22 @@ public class TreeBlockSet implements Collection { } public void sortAndLimit(int max) { - if (logBlocks.size() < max) + if (this.logBlocks.size() < max) { return; + } - logBlocks = logBlocks.stream().sorted(Comparator.comparingInt(b -> b.getLocation().getBlockY())) + this.logBlocks = this.logBlocks.stream().sorted(Comparator.comparingInt(b -> b.getLocation().getBlockY())) .limit(max).collect(Collectors.toList()); - int highest = logBlocks.get(logBlocks.size() - 1).getLocation().getBlockY(); + int highest = this.logBlocks.get(this.logBlocks.size() - 1).getLocation().getBlockY(); - if (logBlocks.size() >= max) - for (ITreeBlock leafBlock : new LinkedList<>(leafBlocks)) - if (leafBlock.getLocation().getY() > highest) - leafBlocks.remove(leafBlock); + if (this.logBlocks.size() >= max) { + for (ITreeBlock leafBlock : new LinkedList<>(this.leafBlocks)) { + if (leafBlock.getLocation().getY() > highest) { + this.leafBlocks.remove(leafBlock); + } + } + } } /** @@ -189,11 +195,12 @@ public class TreeBlockSet implements Collection { * @return If any blocks were removed */ public boolean removeAll(TreeBlockType treeBlockType) { - if (treeBlockType.equals(TreeBlockType.LOG)) { + if (treeBlockType == TreeBlockType.LOG) { boolean removedAny = !this.logBlocks.isEmpty(); this.logBlocks.clear(); return removedAny; - } else if (treeBlockType.equals(TreeBlockType.LEAF)) { + } + if (treeBlockType == TreeBlockType.LEAF) { boolean removedAny = !this.leafBlocks.isEmpty(); this.leafBlocks.clear(); return removedAny; @@ -203,9 +210,11 @@ public class TreeBlockSet implements Collection { @Override public boolean containsAll(Collection c) { - for (Object o : c) - if (!this.contains(o)) + for (Object o : c) { + if (!this.contains(o)) { return false; + } + } return true; } @@ -213,10 +222,12 @@ public class TreeBlockSet implements Collection { @SuppressWarnings("unchecked") public Object[] toArray(Object[] a) { Set> treeBlocks = new HashSet<>(); - for (Object o : a) - if (o instanceof ITreeBlock) - treeBlocks.add((ITreeBlock)o); + for (Object o : a) { + if (o instanceof ITreeBlock) { + treeBlocks.add((ITreeBlock) o); + } + } + return treeBlocks.toArray(); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockType.java b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockType.java index 1122618..e351de1 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockType.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/TreeBlockType.java @@ -1,9 +1,5 @@ package com.songoda.ultimatetimber.tree; -/** - * Represents a tree block type and whether it is a log or a leaf block - */ public enum TreeBlockType { - LOG, - LEAF + LOG, LEAF } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/TreeDefinition.java b/src/main/java/com/songoda/ultimatetimber/tree/TreeDefinition.java index b8c5755..7938df0 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/TreeDefinition.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/TreeDefinition.java @@ -7,7 +7,6 @@ import java.util.Collections; import java.util.Set; public class TreeDefinition { - private final String key; private final Set logMaterial, leafMaterial, plantableSoilMaterial; private final CompatibleMaterial saplingMaterial; @@ -167,11 +166,11 @@ public class TreeDefinition { } /** - * Returns whether or not does this TreeDefinition require a custom axe. + * Returns whether this TreeDefinition requires a custom axe. * * @return True if the TreeDefinition requires a custom axe */ public boolean isRequiredAxe() { - return requiredAxe; + return this.requiredAxe; } } diff --git a/src/main/java/com/songoda/ultimatetimber/tree/TreeLoot.java b/src/main/java/com/songoda/ultimatetimber/tree/TreeLoot.java index 81cb4a2..f0563e2 100644 --- a/src/main/java/com/songoda/ultimatetimber/tree/TreeLoot.java +++ b/src/main/java/com/songoda/ultimatetimber/tree/TreeLoot.java @@ -3,7 +3,6 @@ package com.songoda.ultimatetimber.tree; import org.bukkit.inventory.ItemStack; public class TreeLoot { - private final TreeBlockType treeBlockType; private final ItemStack item; private final String command; @@ -73,10 +72,10 @@ public class TreeLoot { @Override public String toString() { return "TreeLoot{" + - "treeBlockType=" + treeBlockType + - ", item=" + item + - ", command='" + command + '\'' + - ", chance=" + chance + + "treeBlockType=" + this.treeBlockType + + ", item=" + this.item + + ", command='" + this.command + '\'' + + ", chance=" + this.chance + '}'; } } diff --git a/src/main/java/com/songoda/ultimatetimber/utils/BlockUtils.java b/src/main/java/com/songoda/ultimatetimber/utils/BlockUtils.java index 1813076..22d2aab 100644 --- a/src/main/java/com/songoda/ultimatetimber/utils/BlockUtils.java +++ b/src/main/java/com/songoda/ultimatetimber/utils/BlockUtils.java @@ -13,17 +13,16 @@ import java.util.HashSet; import java.util.Set; public class BlockUtils { - public static Collection getBlockDrops(ITreeBlock treeBlock) { Set drops = new HashSet<>(); if (treeBlock.getBlock() instanceof Block) { - Block block = (Block)treeBlock.getBlock(); + Block block = (Block) treeBlock.getBlock(); CompatibleMaterial material = CompatibleMaterial.getMaterial(block); if (material.isAir()) return drops; drops.add(CompatibleMaterial.getMaterial(block).getItem()); } else if (treeBlock.getBlock() instanceof FallingBlock) { - CompatibleMaterial material = CompatibleMaterial.getMaterial((FallingBlock)treeBlock.getBlock()); + CompatibleMaterial material = CompatibleMaterial.getMaterial((FallingBlock) treeBlock.getBlock()); if (material == null) return drops; drops.add(material.getItem()); @@ -45,5 +44,4 @@ public class BlockUtils { fallingBlock.setDropItem(false); fallingBlock.setHurtEntities(false); } - } diff --git a/src/main/java/com/songoda/ultimatetimber/utils/ParticleUtils.java b/src/main/java/com/songoda/ultimatetimber/utils/ParticleUtils.java index 791a568..87ae3ae 100644 --- a/src/main/java/com/songoda/ultimatetimber/utils/ParticleUtils.java +++ b/src/main/java/com/songoda/ultimatetimber/utils/ParticleUtils.java @@ -2,7 +2,6 @@ package com.songoda.ultimatetimber.utils; import com.songoda.core.compatibility.ServerVersion; import com.songoda.ultimatetimber.tree.ITreeBlock; -import com.songoda.ultimatetimber.tree.TreeDefinition; import org.bukkit.Effect; import org.bukkit.Location; import org.bukkit.Particle; @@ -14,7 +13,6 @@ import org.bukkit.inventory.ItemStack; import java.util.Collection; public class ParticleUtils { - public static void playFallingParticles(ITreeBlock treeBlock) { if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)) { BlockData blockData; @@ -22,22 +20,26 @@ public class ParticleUtils { blockData = ((Block) treeBlock.getBlock()).getBlockData(); } else if (treeBlock.getBlock() instanceof FallingBlock) { blockData = ((FallingBlock) treeBlock.getBlock()).getBlockData(); - } else return; + } else { + return; + } Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); location.getWorld().spawnParticle(Particle.BLOCK_DUST, location, 10, blockData); + + return; + } + + Collection blockDrops = BlockUtils.getBlockDrops(treeBlock); + if (!blockDrops.iterator().hasNext()) { + return; + } + + Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); + if (ServerVersion.isServerVersion(ServerVersion.V1_8)) { + location.getWorld().playEffect(location, Effect.SMOKE, 4); } else { - - Collection blockDrops = BlockUtils.getBlockDrops(treeBlock); - if (!blockDrops.iterator().hasNext()) - return; - - Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); - if (ServerVersion.isServerVersion(ServerVersion.V1_8)) { - location.getWorld().playEffect(location, Effect.SMOKE, 4); - } else { - location.getWorld().spawnParticle(Particle.BLOCK_DUST, location, 10, blockDrops.iterator().next().getData()); - } + location.getWorld().spawnParticle(Particle.BLOCK_DUST, location, 10, blockDrops.iterator().next().getData()); } } @@ -48,21 +50,26 @@ public class ParticleUtils { blockData = ((Block) treeBlock.getBlock()).getBlockData(); } else if (treeBlock.getBlock() instanceof FallingBlock) { blockData = ((FallingBlock) treeBlock.getBlock()).getBlockData(); - } else return; + } else { + return; + } Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); location.getWorld().spawnParticle(Particle.BLOCK_CRACK, location, 10, blockData); - } else { - Collection blockDrops = BlockUtils.getBlockDrops(treeBlock); - if (!blockDrops.iterator().hasNext()) - return; - Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); - if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_9)) { - location.getWorld().spawnParticle(Particle.BLOCK_CRACK, location, 10, blockDrops.iterator().next().getData()); - } else { - location.getWorld().playEffect(location, Effect.SMOKE, 4); - } + return; + } + + Collection blockDrops = BlockUtils.getBlockDrops(treeBlock); + if (!blockDrops.iterator().hasNext()) { + return; + } + + Location location = treeBlock.getLocation().clone().add(0.5, 0.5, 0.5); + if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_9)) { + location.getWorld().spawnParticle(Particle.BLOCK_CRACK, location, 10, blockDrops.iterator().next().getData()); + } else { + location.getWorld().playEffect(location, Effect.SMOKE, 4); } } } diff --git a/src/main/java/com/songoda/ultimatetimber/utils/SoundUtils.java b/src/main/java/com/songoda/ultimatetimber/utils/SoundUtils.java index 0e6bed9..a0d2293 100644 --- a/src/main/java/com/songoda/ultimatetimber/utils/SoundUtils.java +++ b/src/main/java/com/songoda/ultimatetimber/utils/SoundUtils.java @@ -6,22 +6,24 @@ import com.songoda.ultimatetimber.tree.TreeBlockType; import org.bukkit.Location; public class SoundUtils { - public static void playFallingSound(ITreeBlock block) { Location location = block.getLocation(); - if (location.getWorld() == null) return; + if (location.getWorld() == null) { + return; + } CompatibleSound.BLOCK_CHEST_OPEN.play(location.getWorld(), location, 2F, 0.1F); } public static void playLandingSound(ITreeBlock block) { Location location = block.getLocation(); - if (location.getWorld() == null) return; + if (location.getWorld() == null) { + return; + } - if (block.getTreeBlockType().equals(TreeBlockType.LOG)) { + if (block.getTreeBlockType() == TreeBlockType.LOG) { CompatibleSound.BLOCK_WOOD_FALL.play(location.getWorld(), location, 2F, 0.1F); } else { CompatibleSound.BLOCK_GRASS_BREAK.play(location.getWorld(), location, 0.5F, 0.75F); } } - }