From 58f38489a6c8200478b69ac2787c3904f2ae7942 Mon Sep 17 00:00:00 2001 From: okx-code Date: Fri, 12 Jul 2019 16:01:58 +0100 Subject: [PATCH 1/5] refactoring --- build.gradle | 2 +- src/main/java/sh/okx/rankup/AutoRankup.java | 9 +- src/main/java/sh/okx/rankup/Rankup.java | 225 +++--------------- src/main/java/sh/okx/rankup/RankupHelper.java | 188 +++++++++++++++ .../sh/okx/rankup/RankupRegisterEvent.java | 4 +- .../okx/rankup/commands/PrestigeCommand.java | 6 +- .../sh/okx/rankup/commands/RankupCommand.java | 6 +- .../java/sh/okx/rankup/gui/GuiListener.java | 6 +- .../okx/rankup/messages/MessageBuilder.java | 5 +- ...geBuilder.java => NullMessageBuilder.java} | 6 +- .../rankup/placeholders/RankupExpansion.java | 5 + .../java/sh/okx/rankup/prestige/Prestige.java | 2 +- src/main/java/sh/okx/rankup/ranks/Rank.java | 10 +- .../requirement/MobKillsRequirement.java | 1 + src/main/resources/plugin.yml | 4 +- .../rankup/messages/MessageBuilderTest.java | 2 +- 16 files changed, 261 insertions(+), 220 deletions(-) create mode 100644 src/main/java/sh/okx/rankup/RankupHelper.java rename src/main/java/sh/okx/rankup/messages/{EmptyMessageBuilder.java => NullMessageBuilder.java} (75%) diff --git a/build.gradle b/build.gradle index fe919be..e971046 100644 --- a/build.gradle +++ b/build.gradle @@ -3,7 +3,7 @@ plugins { } group 'sh.okx' -version '3.5.4' +version '3.5.6' repositories { mavenCentral() diff --git a/src/main/java/sh/okx/rankup/AutoRankup.java b/src/main/java/sh/okx/rankup/AutoRankup.java index 160ac0c..9d5749d 100644 --- a/src/main/java/sh/okx/rankup/AutoRankup.java +++ b/src/main/java/sh/okx/rankup/AutoRankup.java @@ -11,12 +11,13 @@ public class AutoRankup extends BukkitRunnable { @Override public void run() { + RankupHelper helper = rankup.getHelper(); for (Player player : Bukkit.getOnlinePlayers()) { if (player.hasPermission("rankup.auto")) { - if (rankup.checkRankup(player, false)) { - rankup.rankup(player); - } else if (rankup.getPrestiges() != null && rankup.checkPrestige(player, false)) { - rankup.prestige(player); + if (helper.checkRankup(player, false)) { + helper.rankup(player); + } else if (rankup.getPrestiges() != null && helper.checkPrestige(player, false)) { + helper.prestige(player); } } } diff --git a/src/main/java/sh/okx/rankup/Rankup.java b/src/main/java/sh/okx/rankup/Rankup.java index b57a7a6..c87f5e1 100644 --- a/src/main/java/sh/okx/rankup/Rankup.java +++ b/src/main/java/sh/okx/rankup/Rankup.java @@ -4,6 +4,7 @@ import lombok.Getter; import net.milkbowl.vault.economy.Economy; import net.milkbowl.vault.permission.Permission; import org.bukkit.Bukkit; +import org.bukkit.ChatColor; import org.bukkit.command.CommandSender; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.FileConfiguration; @@ -11,6 +12,7 @@ import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; import org.bukkit.event.inventory.InventoryType; import org.bukkit.inventory.InventoryView; +import org.bukkit.plugin.PluginManager; import org.bukkit.plugin.RegisteredServiceProvider; import org.bukkit.plugin.java.JavaPlugin; import sh.okx.rankup.commands.InfoCommand; @@ -20,7 +22,7 @@ import sh.okx.rankup.commands.RanksCommand; import sh.okx.rankup.commands.RankupCommand; import sh.okx.rankup.gui.Gui; import sh.okx.rankup.gui.GuiListener; -import sh.okx.rankup.messages.EmptyMessageBuilder; +import sh.okx.rankup.messages.NullMessageBuilder; import sh.okx.rankup.messages.Message; import sh.okx.rankup.messages.MessageBuilder; import sh.okx.rankup.messages.Variable; @@ -44,7 +46,6 @@ import java.text.DecimalFormat; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.WeakHashMap; import java.util.function.Supplier; public class Rankup extends JavaPlugin { @@ -56,7 +57,7 @@ public class Rankup extends JavaPlugin { * The registry for listing the requirements to /rankup. */ @Getter - private RequirementRegistry requirementRegistry; + private RequirementRegistry requirements; @Getter private FileConfiguration messages; @Getter @@ -67,10 +68,8 @@ public class Rankup extends JavaPlugin { private Prestiges prestiges; @Getter private Placeholders placeholders; - /** - * Players who cannot rankup/prestige for a certain amount of time. - */ - private Map cooldowns; + @Getter + private RankupHelper helper; private AutoRankup autoRankup; @Override @@ -117,7 +116,6 @@ public class Rankup extends JavaPlugin { } public void reload() { - cooldowns = new WeakHashMap<>(); closeInventories(); loadConfigs(); @@ -139,6 +137,8 @@ public class Rankup extends JavaPlugin { getLogger().severe("You may then copy in your config values from the old config."); getLogger().severe("Check the changelog on the Rankup spigot page to see the changes."); } + + helper = new RankupHelper(this); } private void addAll(Map map, RankList ranks) { @@ -191,6 +191,7 @@ public class Rankup extends JavaPlugin { e.printStackTrace(); Bukkit.getPluginManager().disablePlugin(this); getLogger().severe("Could not finish enabling Rankup"); + Bukkit.broadcast(ChatColor.RED + "Could not reload rankup successfully, please check console for more information.", "rankup.reload"); } } @@ -217,34 +218,36 @@ public class Rankup extends JavaPlugin { } private void registerRequirements() { - requirementRegistry = new RequirementRegistry(); + requirements = new RequirementRegistry(); + requirements.addRequirement(new XpLevelRequirement(this)); + requirements.addRequirement(new PlaytimeMinutesRequirement(this)); + requirements.addRequirement(new GroupRequirement(this)); + requirements.addRequirement(new PermissionRequirement(this)); + requirements.addRequirement(new PlaceholderRequirement(this)); + requirements.addRequirement(new WorldRequirement(this)); + requirements.addRequirement(new BlockBreakRequirement(this)); + requirements.addRequirement(new PlayerKillsRequirement(this)); + requirements.addRequirement(new MobKillsRequirement(this)); + requirements.addRequirement(new ItemRequirement(this)); + requirements.addRequirement(new UseItemRequirement(this)); + requirements.addRequirement(new TotalMobKillsRequirement(this)); + requirements.addRequirement(new CraftItemRequirement(this)); if (economy != null) { - requirementRegistry.addRequirement(new MoneyRequirement(this)); + requirements.addRequirement(new MoneyRequirement(this)); } - requirementRegistry.addRequirement(new XpLevelRequirement(this)); - requirementRegistry.addRequirement(new PlaytimeMinutesRequirement(this)); - requirementRegistry.addRequirement(new GroupRequirement(this)); - requirementRegistry.addRequirement(new PermissionRequirement(this)); - requirementRegistry.addRequirement(new PlaceholderRequirement(this)); - requirementRegistry.addRequirement(new WorldRequirement(this)); - requirementRegistry.addRequirement(new BlockBreakRequirement(this)); - requirementRegistry.addRequirement(new PlayerKillsRequirement(this)); - requirementRegistry.addRequirement(new MobKillsRequirement(this)); - if (Bukkit.getPluginManager().isPluginEnabled("mcMMO")) { - requirementRegistry.addRequirement(new McMMOSkillRequirement(this)); - requirementRegistry.addRequirement(new McMMOPowerLevelRequirement(this)); + + PluginManager pluginManager = Bukkit.getPluginManager(); + if (pluginManager.isPluginEnabled("mcMMO")) { + requirements.addRequirement(new McMMOSkillRequirement(this)); + requirements.addRequirement(new McMMOPowerLevelRequirement(this)); } - if (Bukkit.getPluginManager().isPluginEnabled("AdvancedAchievements")) { - requirementRegistry.addRequirement(new AdvancedAchievementsAchievementRequirement(this)); - requirementRegistry.addRequirement(new AdvancedAchievementsTotalRequirement(this)); + if (pluginManager.isPluginEnabled("AdvancedAchievements")) { + requirements.addRequirement(new AdvancedAchievementsAchievementRequirement(this)); + requirements.addRequirement(new AdvancedAchievementsTotalRequirement(this)); } - if (Bukkit.getPluginManager().isPluginEnabled("VotingPlugin")) { - requirementRegistry.addRequirement(new VotingPluginVotesRequirement(this)); + if (pluginManager.isPluginEnabled("VotingPlugin")) { + requirements.addRequirement(new VotingPluginVotesRequirement(this)); } - requirementRegistry.addRequirement(new ItemRequirement(this)); - requirementRegistry.addRequirement(new UseItemRequirement(this)); - requirementRegistry.addRequirement(new TotalMobKillsRequirement(this)); - requirementRegistry.addRequirement(new CraftItemRequirement(this)); } private void setupPermissions() { @@ -289,166 +292,8 @@ public class Rankup extends JavaPlugin { return MessageBuilder.of(messages, message); } - private boolean checkCooldown(Player player, Rank rank) { - if (cooldowns.containsKey(player)) { - long time = System.currentTimeMillis() - cooldowns.get(player); - // if time passed is less than the cooldown - long cooldownSeconds = config.getInt("cooldown"); - long timeLeft = (cooldownSeconds * 1000) - time; - if (timeLeft > 0) { - long secondsLeft = (long) Math.ceil(timeLeft / 1000f); - getMessage(rank, secondsLeft > 1 ? Message.COOLDOWN_PLURAL : Message.COOLDOWN_SINGULAR) - .failIfEmpty() - .replaceRanks(player, rank.getRank()) - .replaceFromTo(rank) - .replace(Variable.SECONDS, cooldownSeconds) - .replace(Variable.SECONDS_LEFT, secondsLeft) - .send(player); - return true; - } - // cooldown has expired so remove it - cooldowns.remove(player); - } - return false; - } - - private void applyCooldown(Player player) { - if (config.getInt("cooldown") > 0) { - cooldowns.put(player, System.currentTimeMillis()); - } - } - - public void rankup(Player player) { - if (!checkRankup(player)) { - return; - } - - Rank oldRank = rankups.getByPlayer(player); - String next = oldRank.getNext(); - - oldRank.applyRequirements(player); - - permissions.playerRemoveGroup(null, player, oldRank.getRank()); - permissions.playerAddGroup(null, player, next); - - getMessage(oldRank, Message.SUCCESS_PUBLIC) - .failIfEmpty() - .replaceRanks(player, oldRank, next) - .broadcast(); - getMessage(oldRank, Message.SUCCESS_PRIVATE) - .failIfEmpty() - .replaceRanks(player, oldRank, next) - .send(player); - - oldRank.runCommands(player, next); - applyCooldown(player); - } - - public boolean checkRankup(Player player) { - return checkRankup(player, true); - } - - /** - * Checks if a player can rankup, - * and if they can't, sends the player a message and returns false - * - * @param player the player to check if they can rankup - * @return true if the player can rankup, false otherwise - */ - public boolean checkRankup(Player player, boolean message) { - Rank rank = rankups.getByPlayer(player); - if (rankups.isLast(permissions, player)) { - getMessage(prestiges == null ? Message.NO_RANKUP : prestiges.isLast(permissions, player) ? Message.NO_RANKUP : Message.MUST_PRESTIGE) - .failIf(!message) - .replaceRanks(player, rankups.getLast()) - .send(player); - return false; - } else if (rank == null) { // check if in ladder - getMessage(Message.NOT_IN_LADDER) - .failIf(!message) - .replace(Variable.PLAYER, player.getName()) - .send(player); - return false; - } else if (!rank.hasRequirements(player)) { // check if they can afford it - if (message) { - replaceMoneyRequirements(getMessage(rank, Message.REQUIREMENTS_NOT_MET) - .replaceRanks(player, rank, rank.getNext()), player, rank) - .send(player); - } - return false; - } else if (message && checkCooldown(player, rank)) { - return false; - } - - return true; - } - - public void prestige(Player player) { - if (!checkPrestige(player)) { - return; - } - - Prestige oldPrestige = prestiges.getByPlayer(player); - - oldPrestige.applyRequirements(player); - - permissions.playerRemoveGroup(null, player, oldPrestige.getFrom()); - permissions.playerAddGroup(null, player, oldPrestige.getTo()); - if (oldPrestige.getRank() != null) { - permissions.playerRemoveGroup(null, player, oldPrestige.getRank()); - } - permissions.playerAddGroup(null, player, oldPrestige.getNext()); - - getMessage(oldPrestige, Message.PRESTIGE_SUCCESS_PUBLIC) - .failIfEmpty() - .replaceRanks(player, oldPrestige,oldPrestige.getNext()) - .replaceFromTo(oldPrestige) - .broadcast(); - getMessage(oldPrestige, Message.PRESTIGE_SUCCESS_PRIVATE) - .failIfEmpty() - .replaceRanks(player, oldPrestige, oldPrestige.getNext()) - .replaceFromTo(oldPrestige) - .send(player); - - oldPrestige.runCommands(player, oldPrestige.getNext()); - applyCooldown(player); - } - - public boolean checkPrestige(Player player) { - return checkPrestige(player, true); - } - - public boolean checkPrestige(Player player, boolean message) { - Prestige prestige = prestiges.getByPlayer(player); - if (prestige == null || !prestige.isEligable(player)) { // check if in ladder - getMessage(Message.NOT_HIGH_ENOUGH) - .failIf(!message) - .replace(Variable.PLAYER, player.getName()) - .send(player); - return false; - } else if (prestiges.isLast(permissions, player)) { // check if they are at the highest rank - getMessage(prestige, Message.PRESTIGE_NO_PRESTIGE) - .failIf(!message) - .replaceRanks(player, prestige.getRank()) - .replaceFromTo(prestige) - .send(player); - return false; - } else if (!prestige.hasRequirements(player)) { // check if they can afford it - replaceMoneyRequirements(getMessage(prestige, Message.PRESTIGE_REQUIREMENTS_NOT_MET) - .failIf(!message) - .replaceRanks(player, prestige, prestiges.next(prestige).getRank()), player, prestige) - .replaceFromTo(prestige) - .send(player); - return false; - } else if (checkCooldown(player, prestige)) { - return false; - } - - return true; - } - public MessageBuilder replaceMoneyRequirements(MessageBuilder builder, CommandSender sender, Rank rank) { - if (builder instanceof EmptyMessageBuilder) { + if (builder instanceof NullMessageBuilder) { return builder; } diff --git a/src/main/java/sh/okx/rankup/RankupHelper.java b/src/main/java/sh/okx/rankup/RankupHelper.java new file mode 100644 index 0000000..0d1b425 --- /dev/null +++ b/src/main/java/sh/okx/rankup/RankupHelper.java @@ -0,0 +1,188 @@ +package sh.okx.rankup; + +import lombok.RequiredArgsConstructor; +import net.milkbowl.vault.permission.Permission; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; +import sh.okx.rankup.messages.Message; +import sh.okx.rankup.messages.Variable; +import sh.okx.rankup.prestige.Prestige; +import sh.okx.rankup.prestige.Prestiges; +import sh.okx.rankup.ranks.Rank; +import sh.okx.rankup.ranks.Rankups; + +import java.util.HashMap; +import java.util.Map; + +public class RankupHelper { + private final Rankup plugin; + private final ConfigurationSection config; + private final Permission permissions; + /** + * Players who cannot rankup/prestige for a certain amount of time. + */ + private Map cooldowns = new HashMap<>(); + + public RankupHelper(Rankup plugin) { + this.plugin = plugin; + this.config = plugin.getConfig(); + this.permissions = plugin.getPermissions(); + } + + private void doRankup(Player player, Rank rank) { + rank.runCommands(player); + applyCooldown(player); + + permissions.playerRemoveGroup(null, player, rank.getRank()); + permissions.playerAddGroup(null, player, rank.getNext()); + } + + private boolean checkCooldown(Player player, Rank rank) { + if (cooldowns.containsKey(player)) { + long time = System.currentTimeMillis() - cooldowns.get(player); + // if time passed is less than the cooldown + long cooldownSeconds = config.getInt("cooldown"); + long timeLeft = (cooldownSeconds * 1000) - time; + if (timeLeft > 0) { + long secondsLeft = (long) Math.ceil(timeLeft / 1000f); + plugin.getMessage(rank, secondsLeft > 1 ? Message.COOLDOWN_PLURAL : Message.COOLDOWN_SINGULAR) + .failIfEmpty() + .replaceRanks(player, rank.getRank()) + .replaceFromTo(rank) + .replace(Variable.SECONDS, cooldownSeconds) + .replace(Variable.SECONDS_LEFT, secondsLeft) + .send(player); + return true; + } + // cooldown has expired so remove it + cooldowns.remove(player); + } + return false; + } + + private void applyCooldown(Player player) { + if (config.getInt("cooldown") > 0) { + cooldowns.put(player, System.currentTimeMillis()); + } + } + + public void rankup(Player player) { + if (!checkRankup(player)) { + return; + } + + Rank rank = plugin.getRankups().getByPlayer(player); + rank.applyRequirements(player); + doRankup(player, rank); + + plugin.getMessage(rank, Message.SUCCESS_PUBLIC) + .failIfEmpty() + .replaceRanks(player, rank, rank.getNext()) + .broadcast(); + plugin.getMessage(rank, Message.SUCCESS_PRIVATE) + .failIfEmpty() + .replaceRanks(player, rank, rank.getNext()) + .send(player); + } + + public boolean checkRankup(Player player) { + return checkRankup(player, true); + } + + /** + * Checks if a player can rankup, + * and if they can't, sends the player a message and returns false + * + * @param player the player to check if they can rankup + * @return true if the player can rankup, false otherwise + */ + public boolean checkRankup(Player player, boolean message) { + Rankups rankups = plugin.getRankups(); + Rank rank = rankups.getByPlayer(player); + if (rankups.isLast(permissions, player)) { + Prestiges prestiges = plugin.getPrestiges(); + plugin.getMessage(prestiges == null ? Message.NO_RANKUP : prestiges.isLast(permissions, player) ? Message.NO_RANKUP : Message.MUST_PRESTIGE) + .failIf(!message) + .replaceRanks(player, rankups.getLast()) + .send(player); + return false; + } else if (rank == null) { // check if in ladder + plugin.getMessage(Message.NOT_IN_LADDER) + .failIf(!message) + .replace(Variable.PLAYER, player.getName()) + .send(player); + return false; + } else if (!rank.hasRequirements(player)) { // check if they can afford it + if (message) { + plugin.replaceMoneyRequirements(plugin.getMessage(rank, Message.REQUIREMENTS_NOT_MET) + .replaceRanks(player, rank, rank.getNext()), player, rank) + .send(player); + } + return false; + } else if (message && checkCooldown(player, rank)) { + return false; + } + + return true; + } + + public void prestige(Player player) { + if (!checkPrestige(player)) { + return; + } + + Prestige prestige = plugin.getPrestiges().getByPlayer(player); + prestige.applyRequirements(player); + doRankup(player, prestige); + + if (prestige.getRank() != null) { + permissions.playerRemoveGroup(null, player, prestige.getRank()); + } + permissions.playerAddGroup(null, player, prestige.getNext()); + + plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PUBLIC) + .failIfEmpty() + .replaceRanks(player, prestige,prestige.getNext()) + .replaceFromTo(prestige) + .broadcast(); + plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PRIVATE) + .failIfEmpty() + .replaceRanks(player, prestige, prestige.getNext()) + .replaceFromTo(prestige) + .send(player); + } + + public boolean checkPrestige(Player player) { + return checkPrestige(player, true); + } + + public boolean checkPrestige(Player player, boolean message) { + Prestiges prestiges = plugin.getPrestiges(); + Prestige prestige = prestiges.getByPlayer(player); + if (prestige == null || !prestige.isEligable(player)) { // check if in ladder + plugin.getMessage(Message.NOT_HIGH_ENOUGH) + .failIf(!message) + .replace(Variable.PLAYER, player.getName()) + .send(player); + return false; + } else if (prestiges.isLast(plugin.getPermissions(), player)) { // check if they are at the highest rank + plugin.getMessage(prestige, Message.PRESTIGE_NO_PRESTIGE) + .failIf(!message) + .replaceRanks(player, prestige.getRank()) + .replaceFromTo(prestige) + .send(player); + return false; + } else if (!prestige.hasRequirements(player)) { // check if they can afford it + plugin.replaceMoneyRequirements(plugin.getMessage(prestige, Message.PRESTIGE_REQUIREMENTS_NOT_MET) + .failIf(!message) + .replaceRanks(player, prestige, prestiges.next(prestige).getRank()), player, prestige) + .replaceFromTo(prestige) + .send(player); + return false; + } else if (checkCooldown(player, prestige)) { + return false; + } + + return true; + } +} diff --git a/src/main/java/sh/okx/rankup/RankupRegisterEvent.java b/src/main/java/sh/okx/rankup/RankupRegisterEvent.java index 444331e..b19151a 100644 --- a/src/main/java/sh/okx/rankup/RankupRegisterEvent.java +++ b/src/main/java/sh/okx/rankup/RankupRegisterEvent.java @@ -24,11 +24,11 @@ public class RankupRegisterEvent extends Event { } public RequirementRegistry getRequirementRegistry() { - return plugin.getRequirementRegistry(); + return plugin.getRequirements(); } public void addRequirement(Requirement requirement) { - plugin.getRequirementRegistry().addRequirement(requirement); + plugin.getRequirements().addRequirement(requirement); } @Override diff --git a/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java b/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java index b6f8d65..303b91a 100644 --- a/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java +++ b/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java @@ -30,7 +30,7 @@ public class PrestigeCommand implements CommandExecutor { Prestiges prestiges = plugin.getPrestiges(); Prestige prestige = prestiges.getByPlayer(player); - if (!plugin.checkPrestige(player)) { + if (!plugin.getHelper().checkPrestige(player)) { return true; } @@ -39,7 +39,7 @@ public class PrestigeCommand implements CommandExecutor { if (confirmationType.equals("text") && confirming.containsKey(player)) { long time = System.currentTimeMillis() - confirming.remove(player); if (time < config.getInt("text.timeout") * 1000) { - plugin.prestige(player); + plugin.getHelper().prestige(player); return true; } } @@ -59,7 +59,7 @@ public class PrestigeCommand implements CommandExecutor { Gui.of(player, prestige, prestige.getNext(), plugin).open(player); break; case "none": - plugin.prestige(player); + plugin.getHelper().prestige(player); break; default: throw new IllegalArgumentException("Invalid confirmation type " + confirmationType); diff --git a/src/main/java/sh/okx/rankup/commands/RankupCommand.java b/src/main/java/sh/okx/rankup/commands/RankupCommand.java index 0103e63..1e4a3d7 100644 --- a/src/main/java/sh/okx/rankup/commands/RankupCommand.java +++ b/src/main/java/sh/okx/rankup/commands/RankupCommand.java @@ -32,7 +32,7 @@ public class RankupCommand implements CommandExecutor { Rankups rankups = plugin.getRankups(); Rank rank = rankups.getByPlayer(player); - if (!plugin.checkRankup(player)) { + if (!plugin.getHelper().checkRankup(player)) { return true; } /*Rank next = rankups.next(rank); @@ -51,7 +51,7 @@ public class RankupCommand implements CommandExecutor { if (confirmationType.equals("text") && confirming.containsKey(player)) { long time = System.currentTimeMillis() - confirming.remove(player); if (time < config.getInt("text.timeout") * 1000) { - plugin.rankup(player); + plugin.getHelper().rankup(player); return true; } } @@ -67,7 +67,7 @@ public class RankupCommand implements CommandExecutor { Gui.of(player, rank, next, plugin).open(player); break; case "none": - plugin.rankup(player); + plugin.getHelper().rankup(player); break; default: throw new IllegalArgumentException("Invalid confirmation type " + confirmationType); diff --git a/src/main/java/sh/okx/rankup/gui/GuiListener.java b/src/main/java/sh/okx/rankup/gui/GuiListener.java index 692c102..550b9d4 100644 --- a/src/main/java/sh/okx/rankup/gui/GuiListener.java +++ b/src/main/java/sh/okx/rankup/gui/GuiListener.java @@ -18,7 +18,7 @@ public class GuiListener implements Listener { Inventory inventory = e.getInventory(); if (inventory == null || !(inventory.getHolder() instanceof Gui) - || !e.getInventory().equals(e.getClickedInventory())) { + || !inventory.equals(e.getClickedInventory())) { return; } e.setCancelled(true); @@ -29,9 +29,9 @@ public class GuiListener implements Listener { if (gui.getRankup().isSimilar(e.getCurrentItem())) { Bukkit.getScheduler().runTask(plugin, player::closeInventory); if (gui.isPrestige()) { - plugin.prestige(player); + plugin.getHelper().prestige(player); } else { - plugin.rankup(player); + plugin.getHelper().rankup(player); } } else if (gui.getCancel().isSimilar(e.getCurrentItem())) { Bukkit.getScheduler().runTask(plugin, player::closeInventory); diff --git a/src/main/java/sh/okx/rankup/messages/MessageBuilder.java b/src/main/java/sh/okx/rankup/messages/MessageBuilder.java index 54bd8bf..8444a00 100644 --- a/src/main/java/sh/okx/rankup/messages/MessageBuilder.java +++ b/src/main/java/sh/okx/rankup/messages/MessageBuilder.java @@ -84,8 +84,7 @@ public class MessageBuilder { /** * Fails the MessageBuilder if the message is empty. * if this fails, all subsequent calls to that MessageBuilder will do nothing - * - * @return an EmptyMessageBuilder if the message is empty, itself otherwise + * @return a NullMessageBuilder if the message is empty, itself otherwise */ public MessageBuilder failIfEmpty() { return failIf(message.isEmpty()); @@ -93,7 +92,7 @@ public class MessageBuilder { public MessageBuilder failIf(boolean value) { if (value) { - return new EmptyMessageBuilder(); + return new NullMessageBuilder(); } else { return this; } diff --git a/src/main/java/sh/okx/rankup/messages/EmptyMessageBuilder.java b/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java similarity index 75% rename from src/main/java/sh/okx/rankup/messages/EmptyMessageBuilder.java rename to src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java index 376d6b6..216a20f 100644 --- a/src/main/java/sh/okx/rankup/messages/EmptyMessageBuilder.java +++ b/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java @@ -2,13 +2,13 @@ package sh.okx.rankup.messages; import org.bukkit.command.CommandSender; -public class EmptyMessageBuilder extends MessageBuilder { - EmptyMessageBuilder() { +public class NullMessageBuilder extends MessageBuilder { + NullMessageBuilder() { super(null); } @Override - public MessageBuilder failIfEmpty() { + public MessageBuilder failIf(boolean value) { return this; } diff --git a/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java b/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java index 08f2a4f..9b9b6c3 100644 --- a/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java +++ b/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java @@ -185,4 +185,9 @@ public class RankupExpansion extends PlaceholderExpansion { public String getVersion() { return plugin.getDescription().getVersion(); } + + @Override + public boolean persist() { + return true; + } } diff --git a/src/main/java/sh/okx/rankup/prestige/Prestige.java b/src/main/java/sh/okx/rankup/prestige/Prestige.java index ca4998b..aa969ad 100644 --- a/src/main/java/sh/okx/rankup/prestige/Prestige.java +++ b/src/main/java/sh/okx/rankup/prestige/Prestige.java @@ -28,7 +28,7 @@ public class Prestige extends Rank { public static Prestige deserialize(Rankup plugin, ConfigurationSection section) { List requirementsList = section.getStringList("requirements"); - Set requirements = plugin.getRequirementRegistry().getRequirements(requirementsList); + Set requirements = plugin.getRequirements().getRequirements(requirementsList); return new Prestige(section, plugin, section.getString("next"), diff --git a/src/main/java/sh/okx/rankup/ranks/Rank.java b/src/main/java/sh/okx/rankup/ranks/Rank.java index a3b5b89..83e2056 100644 --- a/src/main/java/sh/okx/rankup/ranks/Rank.java +++ b/src/main/java/sh/okx/rankup/ranks/Rank.java @@ -34,7 +34,7 @@ public class Rank { public static Rank deserialize(Rankup plugin, ConfigurationSection section) { List requirementsList = section.getStringList("requirements"); - Set requirements = plugin.getRequirementRegistry().getRequirements(requirementsList); + Set requirements = plugin.getRequirements().getRequirements(requirementsList); return new Rank(section, plugin, section.getString("next"), @@ -87,11 +87,13 @@ public class Rank { } } - public void runCommands(Player player, String next) { + public void runCommands(Player player) { for (String command : commands) { String string = new MessageBuilder(command).replaceRanks(player, this, next).toString(); - Bukkit.dispatchCommand(Bukkit.getConsoleSender(), - PlaceholderAPI.setPlaceholders(player, string)); + if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { + string = PlaceholderAPI.setPlaceholders(player, string); + } + Bukkit.dispatchCommand(Bukkit.getConsoleSender(), string); } } } diff --git a/src/main/java/sh/okx/rankup/requirements/requirement/MobKillsRequirement.java b/src/main/java/sh/okx/rankup/requirements/requirement/MobKillsRequirement.java index 856dad5..3115068 100644 --- a/src/main/java/sh/okx/rankup/requirements/requirement/MobKillsRequirement.java +++ b/src/main/java/sh/okx/rankup/requirements/requirement/MobKillsRequirement.java @@ -18,6 +18,7 @@ public class MobKillsRequirement extends ProgressiveRequirement { super(clone); } + @SuppressWarnings("deprecation") @Override public double getProgress(Player player) { EntityType entity = Objects.requireNonNull(EntityType.fromName(getSub()), "Invalid entity type '" + getSub() + "' in mob-kills requirement."); diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 82f72ab..2b01c13 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -1,10 +1,10 @@ name: Rankup -version: 3.5.4 +version: 3.5.6 main: sh.okx.rankup.Rankup author: Okx depend: [Vault] softdepend: [PlaceholderAPI, mcMMO, AdvancedAchievements] -api-version: 1.13 +api-version: '1.13' commands: rankup: diff --git a/src/test/java/sh/okx/rankup/messages/MessageBuilderTest.java b/src/test/java/sh/okx/rankup/messages/MessageBuilderTest.java index f6c4226..8ac0837 100644 --- a/src/test/java/sh/okx/rankup/messages/MessageBuilderTest.java +++ b/src/test/java/sh/okx/rankup/messages/MessageBuilderTest.java @@ -9,6 +9,6 @@ import static org.junit.Assert.assertThat; public class MessageBuilderTest { @Test public void testFailIfEmpty() { - assertThat(new MessageBuilder("").failIfEmpty(), instanceOf(EmptyMessageBuilder.class)); + assertThat(new MessageBuilder("").failIfEmpty(), instanceOf(NullMessageBuilder.class)); } } \ No newline at end of file From 11200862cd80350c3bf6d9f186e5166787824c6a Mon Sep 17 00:00:00 2001 From: okx-code Date: Sat, 3 Aug 2019 15:29:44 +0100 Subject: [PATCH 2/5] 3.5.7-alpha - better reporting of configuration errors (instead of disabling the plugin, send the error on startup and whenever a command is executed) - don't check for updates if on a pre-release version - add infinite rankup loop detection - add itemh requirement (like the item requirement, but not deductible) - make it so i only have to change the plugin version in one place --- build.gradle | 20 ++++-- src/main/java/sh/okx/rankup/AutoRankup.java | 4 ++ src/main/java/sh/okx/rankup/RankList.java | 10 ++- src/main/java/sh/okx/rankup/Rankup.java | 69 +++++++++++++++---- src/main/java/sh/okx/rankup/RankupHelper.java | 1 - .../sh/okx/rankup/commands/InfoCommand.java | 17 +++-- .../okx/rankup/commands/PrestigeCommand.java | 4 ++ .../okx/rankup/commands/PrestigesCommand.java | 4 ++ .../sh/okx/rankup/commands/RanksCommand.java | 4 ++ .../sh/okx/rankup/commands/RankupCommand.java | 4 ++ .../requirements/RequirementRegistry.java | 2 +- .../requirement/ItemRequirement.java | 28 ++++---- .../requirement/ItemhRequirement.java | 33 +++++++++ src/main/resources/plugin.yml | 2 +- 14 files changed, 164 insertions(+), 38 deletions(-) create mode 100644 src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java diff --git a/build.gradle b/build.gradle index e971046..7a5846e 100644 --- a/build.gradle +++ b/build.gradle @@ -1,9 +1,10 @@ plugins { id 'java' + id "io.freefair.lombok" version "3.8.0" } group 'sh.okx' -version '3.5.6' +version '3.5.7-alpha' repositories { mavenCentral() @@ -26,9 +27,6 @@ repositories { } dependencies { - compileOnly 'org.projectlombok:lombok:1.18.6' - annotationProcessor 'org.projectlombok:lombok:1.18.6' - testCompile group: 'junit', name: 'junit', version: '4.12' compile 'org.spigotmc:spigot-api:1.13.2-R0.1-SNAPSHOT' @@ -42,3 +40,17 @@ dependencies { } compile 'com.github.Ben12345rocks:VotingPlugin:5.18.2' } + +// automatically copy the version to plugin.yml +processResources { + inputs.property 'version', project.version + + from(sourceSets.main.resources.srcDirs) { + include 'plugin.yml' + expand 'version':project.version + } + + from(sourceSets.main.resources.srcDirs) { + exclude 'plugin.yml' + } +} \ No newline at end of file diff --git a/src/main/java/sh/okx/rankup/AutoRankup.java b/src/main/java/sh/okx/rankup/AutoRankup.java index 9d5749d..ab48433 100644 --- a/src/main/java/sh/okx/rankup/AutoRankup.java +++ b/src/main/java/sh/okx/rankup/AutoRankup.java @@ -11,6 +11,10 @@ public class AutoRankup extends BukkitRunnable { @Override public void run() { + if (rankup.error()) { + return; + } + RankupHelper helper = rankup.getHelper(); for (Player player : Bukkit.getOnlinePlayers()) { if (player.hasPermission("rankup.auto")) { diff --git a/src/main/java/sh/okx/rankup/RankList.java b/src/main/java/sh/okx/rankup/RankList.java index 2533037..995cf48 100644 --- a/src/main/java/sh/okx/rankup/RankList.java +++ b/src/main/java/sh/okx/rankup/RankList.java @@ -41,7 +41,7 @@ public class RankList { if (keys.size() == 1 && keys.iterator().next().equalsIgnoreCase("rank")) { throw new IllegalArgumentException( "Having a final rank (for example: \"Z: rank: 'Z'\") from 3.4.2 or earlier should no longer be used.\n" + - "It is safe to just delete the final rank " + name + ""); + "It is safe to just delete the final rank " + name + ""); } else if (section.getStringList("requirements").isEmpty()) { throw new IllegalArgumentException("Rank " + name + " does not have any requirements."); } @@ -59,13 +59,19 @@ public class RankList { // nothing ranks up to this return rank; } - return null; + throw new IllegalArgumentException("Could not find a first rank. First ranks must not have anything that ranks up to them."); } public List getOrderedList() { List list = new ArrayList<>(); T t = getFirst(); while (t != null) { + for (T existing : list) { + if (existing.equals(t)) { + throw new IllegalArgumentException("Infinite rankup loop detected at rank " + t.getRank() + " to " + t.getNext() + + "\nMake sure no there are no rankups to previous ranks or to the same rank"); + } + } list.add(t); t = next(t); } diff --git a/src/main/java/sh/okx/rankup/Rankup.java b/src/main/java/sh/okx/rankup/Rankup.java index c87f5e1..e780fff 100644 --- a/src/main/java/sh/okx/rankup/Rankup.java +++ b/src/main/java/sh/okx/rankup/Rankup.java @@ -71,12 +71,11 @@ public class Rankup extends JavaPlugin { @Getter private RankupHelper helper; private AutoRankup autoRankup; + private String errorMessage; @Override public void onEnable() { - setupPermissions(); - setupEconomy(); - reload(); + reload(true); Metrics metrics = new Metrics(this); metrics.addCustomChart(new Metrics.SimplePie("confirmation", @@ -112,12 +111,20 @@ public class Rankup extends JavaPlugin { @Override public void onDisable() { closeInventories(); - placeholders.unregister(); + if (placeholders != null) { + placeholders.unregister(); + } } - public void reload() { + public void reload(boolean init) { + errorMessage = null; + if(!setupPermissions()) { + errorMessage = "No permission plugin found"; + } + setupEconomy(); + closeInventories(); - loadConfigs(); + loadConfigs(init); if (autoRankup != null) { autoRankup.cancel(); @@ -141,6 +148,30 @@ public class Rankup extends JavaPlugin { helper = new RankupHelper(this); } + public boolean error() { + return error(null); + } + + /** + * Notify the player of an error if there is one + * @return true if there was an error and action was taken + */ + public boolean error(CommandSender sender) { + if (errorMessage == null) { + return false; + } + + if (!(sender instanceof Player)) { + getLogger().severe("Failed to load Rankup"); + } else { + sender.sendMessage(ChatColor.RED + "Could not load Rankup, check console for more information."); + } + for (String line : errorMessage.split("\n")) { + getLogger().severe(line); + } + return true; + } + private void addAll(Map map, RankList ranks) { for (Rank rank : ranks.ranks) { for (Requirement requirement : rank.getRequirements()) { @@ -165,7 +196,7 @@ public class Rankup extends JavaPlugin { } } - private void loadConfigs() { + private void loadConfigs(boolean init) { saveLocales(); config = loadConfig("config.yml"); @@ -173,7 +204,14 @@ public class Rankup extends JavaPlugin { File localeFile = new File(new File(getDataFolder(), "locale"), locale + ".yml"); messages = YamlConfiguration.loadConfiguration(localeFile); - Bukkit.getScheduler().scheduleSyncDelayedTask(this, this::refreshRanks); + if (init) { + Bukkit.getScheduler().scheduleSyncDelayedTask(this, () -> { + refreshRanks(); + error(); + }); + } else { + refreshRanks(); + } } public void refreshRanks() { @@ -187,11 +225,13 @@ public class Rankup extends JavaPlugin { } else { prestiges = null; } + + // check rankups are not in an infinite loop + rankups.getOrderedList(); + prestiges.getOrderedList(); } catch (Exception e) { + this.errorMessage = e.getMessage(); e.printStackTrace(); - Bukkit.getPluginManager().disablePlugin(this); - getLogger().severe("Could not finish enabling Rankup"); - Bukkit.broadcast(ChatColor.RED + "Could not reload rankup successfully, please check console for more information.", "rankup.reload"); } } @@ -229,6 +269,7 @@ public class Rankup extends JavaPlugin { requirements.addRequirement(new PlayerKillsRequirement(this)); requirements.addRequirement(new MobKillsRequirement(this)); requirements.addRequirement(new ItemRequirement(this)); + requirements.addRequirement(new ItemhRequirement(this)); requirements.addRequirement(new UseItemRequirement(this)); requirements.addRequirement(new TotalMobKillsRequirement(this)); requirements.addRequirement(new CraftItemRequirement(this)); @@ -250,9 +291,13 @@ public class Rankup extends JavaPlugin { } } - private void setupPermissions() { + private boolean setupPermissions() { RegisteredServiceProvider rsp = getServer().getServicesManager().getRegistration(Permission.class); + if (rsp == null) { + return false; + } permissions = rsp.getProvider(); + return permissions.hasGroupSupport(); } private void setupEconomy() { diff --git a/src/main/java/sh/okx/rankup/RankupHelper.java b/src/main/java/sh/okx/rankup/RankupHelper.java index 0d1b425..5f627b0 100644 --- a/src/main/java/sh/okx/rankup/RankupHelper.java +++ b/src/main/java/sh/okx/rankup/RankupHelper.java @@ -1,6 +1,5 @@ package sh.okx.rankup; -import lombok.RequiredArgsConstructor; import net.milkbowl.vault.permission.Permission; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.Player; diff --git a/src/main/java/sh/okx/rankup/commands/InfoCommand.java b/src/main/java/sh/okx/rankup/commands/InfoCommand.java index fa66e88..f901c3d 100644 --- a/src/main/java/sh/okx/rankup/commands/InfoCommand.java +++ b/src/main/java/sh/okx/rankup/commands/InfoCommand.java @@ -24,27 +24,36 @@ public class InfoCommand implements CommandExecutor { public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (args.length > 0) { if (args[0].equalsIgnoreCase("reload") && sender.hasPermission("rankup.reload")) { - plugin.reload(); - sender.sendMessage(ChatColor.GREEN + "" + ChatColor.BOLD + "Rankup " + ChatColor.YELLOW + "Reloaded configuration files."); + plugin.reload(false); + if (!plugin.error(sender)) { + sender.sendMessage(ChatColor.GREEN + "" + ChatColor.BOLD + "Rankup " + ChatColor.YELLOW + "Reloaded configuration files."); + } return true; } } + PluginDescriptionFile description = plugin.getDescription(); + String version = description.getVersion(); sender.sendMessage( - ChatColor.GREEN + "" + ChatColor.BOLD + description.getName() + " " + description.getVersion() + + ChatColor.GREEN + "" + ChatColor.BOLD + description.getName() + " " + version + ChatColor.YELLOW + " by " + ChatColor.BLUE + ChatColor.BOLD + String.join(", ", description.getAuthors())); if (sender.hasPermission("rankup.reload")) { sender.sendMessage(ChatColor.GREEN + "/" + label + " reload " + ChatColor.YELLOW + "Reloads configuration files."); } if (sender.hasPermission("rankup.checkversion")) { if (versionMessage == null) { + if (version.contains("alpha") || version.contains("beta") || version.contains("rc")) { + versionMessage = ChatColor.YELLOW + "You are on a pre-release version."; + sender.sendMessage(versionMessage); + return true; + } sender.sendMessage(ChatColor.YELLOW + "Checking version..."); Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> { String message; try { String latest = getLatestVersion(); - if (description.getVersion().equals(latest)) { + if (version.equals(latest)) { message = ChatColor.GREEN + "You are on the latest version."; } else { message = ChatColor.YELLOW + "A new version is available: " + ChatColor.GOLD + latest diff --git a/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java b/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java index 303b91a..5bbd9a6 100644 --- a/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java +++ b/src/main/java/sh/okx/rankup/commands/PrestigeCommand.java @@ -22,6 +22,10 @@ public class PrestigeCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (plugin.error(sender)) { + return true; + } + // check if player if (!(sender instanceof Player)) { return false; diff --git a/src/main/java/sh/okx/rankup/commands/PrestigesCommand.java b/src/main/java/sh/okx/rankup/commands/PrestigesCommand.java index df57c51..7bc12f4 100644 --- a/src/main/java/sh/okx/rankup/commands/PrestigesCommand.java +++ b/src/main/java/sh/okx/rankup/commands/PrestigesCommand.java @@ -16,6 +16,10 @@ public class PrestigesCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (plugin.error(sender)) { + return true; + } + Prestiges prestiges = plugin.getPrestiges(); Prestige playerRank = null; if (sender instanceof Player) { diff --git a/src/main/java/sh/okx/rankup/commands/RanksCommand.java b/src/main/java/sh/okx/rankup/commands/RanksCommand.java index ca7c5ea..6104ff9 100644 --- a/src/main/java/sh/okx/rankup/commands/RanksCommand.java +++ b/src/main/java/sh/okx/rankup/commands/RanksCommand.java @@ -16,6 +16,10 @@ public class RanksCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (plugin.error(sender)) { + return true; + } + Rankups rankups = plugin.getRankups(); Rank playerRank = null; if (sender instanceof Player) { diff --git a/src/main/java/sh/okx/rankup/commands/RankupCommand.java b/src/main/java/sh/okx/rankup/commands/RankupCommand.java index 1e4a3d7..16483c2 100644 --- a/src/main/java/sh/okx/rankup/commands/RankupCommand.java +++ b/src/main/java/sh/okx/rankup/commands/RankupCommand.java @@ -24,6 +24,10 @@ public class RankupCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (plugin.error(sender)) { + return true; + } + // check if player if (!(sender instanceof Player)) { return false; diff --git a/src/main/java/sh/okx/rankup/requirements/RequirementRegistry.java b/src/main/java/sh/okx/rankup/requirements/RequirementRegistry.java index 33d5eb1..5279289 100644 --- a/src/main/java/sh/okx/rankup/requirements/RequirementRegistry.java +++ b/src/main/java/sh/okx/rankup/requirements/RequirementRegistry.java @@ -31,7 +31,7 @@ public class RequirementRegistry { String name = parts[0]; String value = parts[1]; Requirement requirement = newRequirement(name, value); - Objects.requireNonNull(requirement, name.equalsIgnoreCase("money") ? "Money requirement disabled because no economy was found." : "Unknown requirement: " + name); + Objects.requireNonNull(requirement, name.equalsIgnoreCase("money") ? "The 'money' requirement is being used but no economy is found" : "Unknown requirement: " + name); requirements.add(requirement); } return requirements; diff --git a/src/main/java/sh/okx/rankup/requirements/requirement/ItemRequirement.java b/src/main/java/sh/okx/rankup/requirements/requirement/ItemRequirement.java index c28b17a..78450f4 100644 --- a/src/main/java/sh/okx/rankup/requirements/requirement/ItemRequirement.java +++ b/src/main/java/sh/okx/rankup/requirements/requirement/ItemRequirement.java @@ -9,6 +9,8 @@ import sh.okx.rankup.requirements.DeductibleRequirement; import sh.okx.rankup.requirements.ProgressiveRequirement; import sh.okx.rankup.requirements.Requirement; +import java.util.Arrays; + public class ItemRequirement extends DeductibleRequirement { public ItemRequirement(Rankup plugin) { super(plugin, "item", true); @@ -18,25 +20,25 @@ public class ItemRequirement extends DeductibleRequirement { super(clone); } - @Override - public double getProgress(Player player) { - Material material = Material.matchMaterial(getSub()); - int count = 0; - for (ItemStack item : player.getInventory().getStorageContents()) { - if (item != null && item.getType() == material) { - count += item.getAmount(); - } - } - return count; - } - @Override public void apply(Player player, double multiplier) { - player.getInventory().removeItem(new ItemStack(Material.matchMaterial(getSub()), (int) (getValueInt() * multiplier))); + Material type = Material.matchMaterial(getSub()); + if (type == null) { + throw new IllegalArgumentException("Invalid item " + getSub()); + } + player.getInventory().removeItem(new ItemStack(type, (int) (getValueInt() * multiplier))); } @Override public Requirement clone() { return new ItemRequirement(this); } + + @Override + public double getProgress(Player player) { + Material material = Material.matchMaterial(getSub()); + return Arrays.stream(player.getInventory().getStorageContents()) + .filter(item -> item != null && item.getType() == material) + .mapToInt(ItemStack::getAmount).sum(); + } } diff --git a/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java b/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java new file mode 100644 index 0000000..35ca8d3 --- /dev/null +++ b/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java @@ -0,0 +1,33 @@ +package sh.okx.rankup.requirements.requirement; + +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; +import sh.okx.rankup.Rankup; +import sh.okx.rankup.requirements.ProgressiveRequirement; +import sh.okx.rankup.requirements.Requirement; + +import java.util.Arrays; + +public class ItemhRequirement extends ProgressiveRequirement { + public ItemhRequirement(Rankup plugin) { + super(plugin, "itemh", true); + } + + protected ItemhRequirement(ItemRequirement clone) { + super(clone); + } + + @Override + public double getProgress(Player player) { + Material material = Material.matchMaterial(getSub()); + return Arrays.stream(player.getInventory().getStorageContents()) + .filter(item -> item != null && item.getType() == material) + .mapToInt(ItemStack::getAmount).sum(); + } + + @Override + public Requirement clone() { + return new ItemhRequirement(plugin); + } +} diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 2b01c13..7fc475b 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -1,5 +1,5 @@ name: Rankup -version: 3.5.6 +version: ${version} main: sh.okx.rankup.Rankup author: Okx depend: [Vault] From 2cfa96cbb564896d95dbd0b6d3abd6b466106e87 Mon Sep 17 00:00:00 2001 From: okx-code Date: Sat, 3 Aug 2019 21:52:19 +0100 Subject: [PATCH 3/5] prestige bugfix --- build.gradle | 2 +- lombok.config | 2 ++ src/main/java/sh/okx/rankup/RankupHelper.java | 4 +++- src/main/resources/prestiges.yml | 2 +- 4 files changed, 7 insertions(+), 3 deletions(-) create mode 100644 lombok.config diff --git a/build.gradle b/build.gradle index 7a5846e..d3a73c2 100644 --- a/build.gradle +++ b/build.gradle @@ -4,7 +4,7 @@ plugins { } group 'sh.okx' -version '3.5.7-alpha' +version '3.5.7-alpha.1' repositories { mavenCentral() diff --git a/lombok.config b/lombok.config new file mode 100644 index 0000000..6aa51d7 --- /dev/null +++ b/lombok.config @@ -0,0 +1,2 @@ +# This file is generated by the 'io.freefair.lombok' Gradle plugin +config.stopBubbling = true diff --git a/src/main/java/sh/okx/rankup/RankupHelper.java b/src/main/java/sh/okx/rankup/RankupHelper.java index 5f627b0..d4dce5d 100644 --- a/src/main/java/sh/okx/rankup/RankupHelper.java +++ b/src/main/java/sh/okx/rankup/RankupHelper.java @@ -32,7 +32,9 @@ public class RankupHelper { rank.runCommands(player); applyCooldown(player); - permissions.playerRemoveGroup(null, player, rank.getRank()); + if (rank.getRank() != null) { + permissions.playerRemoveGroup(null, player, rank.getRank()); + } permissions.playerAddGroup(null, player, rank.getNext()); } diff --git a/src/main/resources/prestiges.yml b/src/main/resources/prestiges.yml index c85036b..355d49e 100644 --- a/src/main/resources/prestiges.yml +++ b/src/main/resources/prestiges.yml @@ -4,7 +4,7 @@ first: # the rank to change it to to: 'A' next: 'P1' - # see rankups.yml for more information on requirements, operations, commands and messages + # see rankups.yml for more information on requirements, commands, and messages requirements: - 'money 10000' P1example: From ce6aa9430d72f68226896d8ea0dc554eccf9dc13 Mon Sep 17 00:00:00 2001 From: okx-code Date: Fri, 9 Aug 2019 02:17:18 +0100 Subject: [PATCH 4/5] 3.5.7-alpha.2 - add %prestige_percent_left/done_formatted% - fix prestige bug - show ranks as completed if at last rank --- build.gradle | 11 ++++++++++- src/main/java/sh/okx/rankup/Rankup.java | 5 +++-- src/main/java/sh/okx/rankup/RankupHelper.java | 9 +++++++-- .../java/sh/okx/rankup/commands/RanksCommand.java | 3 ++- .../sh/okx/rankup/messages/NullMessageBuilder.java | 3 +++ .../sh/okx/rankup/placeholders/Placeholders.java | 5 ++++- .../sh/okx/rankup/placeholders/RankupExpansion.java | 12 ++++++++++-- 7 files changed, 39 insertions(+), 9 deletions(-) diff --git a/build.gradle b/build.gradle index d3a73c2..9c4488e 100644 --- a/build.gradle +++ b/build.gradle @@ -1,10 +1,11 @@ plugins { id 'java' id "io.freefair.lombok" version "3.8.0" + id 'maven-publish' } group 'sh.okx' -version '3.5.7-alpha.1' +version '3.5.7-alpha.2' repositories { mavenCentral() @@ -53,4 +54,12 @@ processResources { from(sourceSets.main.resources.srcDirs) { exclude 'plugin.yml' } +} + +publishing { + publications { + maven(MavenPublication) { + from components.java + } + } } \ No newline at end of file diff --git a/src/main/java/sh/okx/rankup/Rankup.java b/src/main/java/sh/okx/rankup/Rankup.java index e780fff..8dbc0e2 100644 --- a/src/main/java/sh/okx/rankup/Rankup.java +++ b/src/main/java/sh/okx/rankup/Rankup.java @@ -375,7 +375,8 @@ public class Rankup extends JavaPlugin { () -> percentFormat.format(Math.max(0, (requirement.getRemaining(player) / requirement.getValueDouble()) * 100))); replaceRequirements(builder, Variable.PERCENT_DONE, requirement, () -> percentFormat.format(Math.min(100, (1 - (requirement.getRemaining(player) / requirement.getValueDouble())) * 100))); - replaceRequirements(builder, Variable.AMOUNT_DONE, requirement, () -> simpleFormat.format(requirement.getValueDouble() - requirement.getRemaining(player))); + replaceRequirements(builder, Variable.AMOUNT_DONE, requirement, + () -> simpleFormat.format(requirement.getValueDouble() - requirement.getRemaining(player))); } } catch (NumberFormatException ignored) { } @@ -418,6 +419,6 @@ public class Rankup extends JavaPlugin { public boolean isLegacy() { String version = Bukkit.getVersion(); - return !(version.contains("1.13") || version.contains("1.14")); + return !(version.contains("1.13") || version.contains("1.14") || version.contains("1.15")); } } diff --git a/src/main/java/sh/okx/rankup/RankupHelper.java b/src/main/java/sh/okx/rankup/RankupHelper.java index d4dce5d..9f81ce8 100644 --- a/src/main/java/sh/okx/rankup/RankupHelper.java +++ b/src/main/java/sh/okx/rankup/RankupHelper.java @@ -134,7 +134,12 @@ public class RankupHelper { Prestige prestige = plugin.getPrestiges().getByPlayer(player); prestige.applyRequirements(player); - doRankup(player, prestige); + + prestige.runCommands(player); + applyCooldown(player); + + permissions.playerRemoveGroup(null, player, prestige.getFrom()); + permissions.playerAddGroup(null, player, prestige.getTo()); if (prestige.getRank() != null) { permissions.playerRemoveGroup(null, player, prestige.getRank()); @@ -143,7 +148,7 @@ public class RankupHelper { plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PUBLIC) .failIfEmpty() - .replaceRanks(player, prestige,prestige.getNext()) + .replaceRanks(player, prestige, prestige.getNext()) .replaceFromTo(prestige) .broadcast(); plugin.getMessage(prestige, Message.PRESTIGE_SUCCESS_PRIVATE) diff --git a/src/main/java/sh/okx/rankup/commands/RanksCommand.java b/src/main/java/sh/okx/rankup/commands/RanksCommand.java index 6104ff9..12a7938 100644 --- a/src/main/java/sh/okx/rankup/commands/RanksCommand.java +++ b/src/main/java/sh/okx/rankup/commands/RanksCommand.java @@ -28,7 +28,8 @@ public class RanksCommand implements CommandExecutor { plugin.sendHeaderFooter(sender, playerRank, Message.RANKS_HEADER); - Message message = playerRank == null ? Message.RANKS_INCOMPLETE : Message.RANKS_COMPLETE; + Message message = !(sender instanceof Player && rankups.isLast(plugin.getPermissions(), (Player) sender)) + && playerRank == null ? Message.RANKS_INCOMPLETE : Message.RANKS_COMPLETE; Rank rank = rankups.getFirst(); while (rank != null) { String name = rank.getNext(); diff --git a/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java b/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java index 216a20f..1c1668c 100644 --- a/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java +++ b/src/main/java/sh/okx/rankup/messages/NullMessageBuilder.java @@ -2,6 +2,9 @@ package sh.okx.rankup.messages; import org.bukkit.command.CommandSender; +/** + * A no-op implementation of MessageBuilder + */ public class NullMessageBuilder extends MessageBuilder { NullMessageBuilder() { super(null); diff --git a/src/main/java/sh/okx/rankup/placeholders/Placeholders.java b/src/main/java/sh/okx/rankup/placeholders/Placeholders.java index 31f04be..aefa433 100644 --- a/src/main/java/sh/okx/rankup/placeholders/Placeholders.java +++ b/src/main/java/sh/okx/rankup/placeholders/Placeholders.java @@ -16,6 +16,8 @@ public class Placeholders { private final DecimalFormat percentFormat; @Getter private final DecimalFormat simpleFormat; + @Getter + private RankupExpansion expansion; private boolean registered; public Placeholders(Rankup plugin) { @@ -27,7 +29,8 @@ public class Placeholders { public void register() { if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) { - new RankupExpansion(plugin, this).register(); + expansion = new RankupExpansion(plugin, this); + expansion.register(); registered = true; } else { registered = false; diff --git a/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java b/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java index 9b9b6c3..c3b485c 100644 --- a/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java +++ b/src/main/java/sh/okx/rankup/placeholders/RankupExpansion.java @@ -88,9 +88,9 @@ public class RankupExpansion extends PlaceholderExpansion { } return orElsePlaceholder(rank, r -> orElsePlaceholder(rank, Rank::getNext, "highest-rank"), "not-in-ladder"); case "money": - return String.valueOf(orElse(rank, r -> simplify(r.getRequirement("money").getValueDouble()), 0)); + return String.valueOf(getMoney(rank)); case "money_formatted": - return plugin.formatMoney(orElse(rank, r -> r.getRequirement("money").getValueDouble(), 0D)); + return plugin.formatMoney(getMoney(rank).doubleValue()); case "money_left": return String.valueOf(Math.max(0, orElse(rank, r -> simplify(plugin.getEconomy().getBalance(player) - r.getRequirement("money").getValueDouble()), 0).doubleValue())); case "money_left_formatted": @@ -103,11 +103,19 @@ public class RankupExpansion extends PlaceholderExpansion { return String.valueOf(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement("money").getValueDouble()) * 100, 0).doubleValue())); case "percent_done_formatted": return placeholders.getPercentFormat().format(Math.min(100D, orElse(rank, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement("money").getValueDouble()) * 100, 0).doubleValue())); + case "prestige_percent_left_formatted": + return placeholders.getPercentFormat().format(Math.max(0D, orElse(prestige, r -> (1 - (plugin.getEconomy().getBalance(player) / r.getRequirement("money").getValueDouble())) * 100, 0).doubleValue())); + case "prestige_percent_done_formatted": + return placeholders.getPercentFormat().format(Math.min(100D, orElse(prestige, r -> (plugin.getEconomy().getBalance(player) / r.getRequirement("money").getValueDouble()) * 100, 0).doubleValue())); default: return null; } } + private Number getMoney(Rank rank) { + return orElse(rank, r -> simplify(r.getRequirement("money").getValueDouble()), 0); + } + private void requirePrestiging(Prestiges prestiges, String params) { Objects.requireNonNull(prestiges, "Using %rankup_" + params + "% prestige placeholder but prestiging is disabled."); } From 645e7a5931489c186a708203a2d869b995863d66 Mon Sep 17 00:00:00 2001 From: okx-code Date: Sat, 17 Aug 2019 09:55:13 +0100 Subject: [PATCH 5/5] add xp-levelh and moneyh requirements --- build.gradle | 2 +- src/main/java/sh/okx/rankup/Rankup.java | 14 +++++--- .../NonDeductibleRequirement.java | 30 +++++++++++++++++ .../requirement/ItemhRequirement.java | 33 ------------------- .../requirement/TotalMobKillsRequirement.java | 2 +- 5 files changed, 42 insertions(+), 39 deletions(-) create mode 100644 src/main/java/sh/okx/rankup/requirements/NonDeductibleRequirement.java delete mode 100644 src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java diff --git a/build.gradle b/build.gradle index 9c4488e..cae7d52 100644 --- a/build.gradle +++ b/build.gradle @@ -5,7 +5,7 @@ plugins { } group 'sh.okx' -version '3.5.7-alpha.2' +version '3.5.6' repositories { mavenCentral() diff --git a/src/main/java/sh/okx/rankup/Rankup.java b/src/main/java/sh/okx/rankup/Rankup.java index 8dbc0e2..c0a4dbe 100644 --- a/src/main/java/sh/okx/rankup/Rankup.java +++ b/src/main/java/sh/okx/rankup/Rankup.java @@ -31,6 +31,8 @@ import sh.okx.rankup.prestige.Prestige; import sh.okx.rankup.prestige.Prestiges; import sh.okx.rankup.ranks.Rank; import sh.okx.rankup.ranks.Rankups; +import sh.okx.rankup.requirements.DeductibleRequirement; +import sh.okx.rankup.requirements.NonDeductibleRequirement; import sh.okx.rankup.requirements.Requirement; import sh.okx.rankup.requirements.RequirementRegistry; import sh.okx.rankup.requirements.requirement.*; @@ -259,7 +261,7 @@ public class Rankup extends JavaPlugin { private void registerRequirements() { requirements = new RequirementRegistry(); - requirements.addRequirement(new XpLevelRequirement(this)); + registerDeductible(new XpLevelRequirement(this)); requirements.addRequirement(new PlaytimeMinutesRequirement(this)); requirements.addRequirement(new GroupRequirement(this)); requirements.addRequirement(new PermissionRequirement(this)); @@ -268,13 +270,12 @@ public class Rankup extends JavaPlugin { requirements.addRequirement(new BlockBreakRequirement(this)); requirements.addRequirement(new PlayerKillsRequirement(this)); requirements.addRequirement(new MobKillsRequirement(this)); - requirements.addRequirement(new ItemRequirement(this)); - requirements.addRequirement(new ItemhRequirement(this)); + registerDeductible(new ItemRequirement(this)); requirements.addRequirement(new UseItemRequirement(this)); requirements.addRequirement(new TotalMobKillsRequirement(this)); requirements.addRequirement(new CraftItemRequirement(this)); if (economy != null) { - requirements.addRequirement(new MoneyRequirement(this)); + registerDeductible(new MoneyRequirement(this)); } PluginManager pluginManager = Bukkit.getPluginManager(); @@ -291,6 +292,11 @@ public class Rankup extends JavaPlugin { } } + private void registerDeductible(DeductibleRequirement requirement) { + requirements.addRequirement(requirement); + requirements.addRequirement(new NonDeductibleRequirement(requirement, requirement.getName() + "h")); + } + private boolean setupPermissions() { RegisteredServiceProvider rsp = getServer().getServicesManager().getRegistration(Permission.class); if (rsp == null) { diff --git a/src/main/java/sh/okx/rankup/requirements/NonDeductibleRequirement.java b/src/main/java/sh/okx/rankup/requirements/NonDeductibleRequirement.java new file mode 100644 index 0000000..a17df0e --- /dev/null +++ b/src/main/java/sh/okx/rankup/requirements/NonDeductibleRequirement.java @@ -0,0 +1,30 @@ +package sh.okx.rankup.requirements; + +import org.bukkit.entity.Player; + +/** + * Proxy requirement for a deductible requirement that is exactly the same but is not deductible + */ +public class NonDeductibleRequirement extends ProgressiveRequirement { + private final DeductibleRequirement requirement; + + public NonDeductibleRequirement(DeductibleRequirement requirement, String name) { + super(requirement.plugin, name, requirement.hasSubRequirement()); + this.requirement = requirement; + } + + protected NonDeductibleRequirement(NonDeductibleRequirement clone) { + super(clone); + this.requirement = clone.requirement; + } + + @Override + public double getProgress(Player player) { + return requirement.getProgress(player); + } + + @Override + public Requirement clone() { + return new NonDeductibleRequirement(this); + } +} diff --git a/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java b/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java deleted file mode 100644 index 35ca8d3..0000000 --- a/src/main/java/sh/okx/rankup/requirements/requirement/ItemhRequirement.java +++ /dev/null @@ -1,33 +0,0 @@ -package sh.okx.rankup.requirements.requirement; - -import org.bukkit.Material; -import org.bukkit.entity.Player; -import org.bukkit.inventory.ItemStack; -import sh.okx.rankup.Rankup; -import sh.okx.rankup.requirements.ProgressiveRequirement; -import sh.okx.rankup.requirements.Requirement; - -import java.util.Arrays; - -public class ItemhRequirement extends ProgressiveRequirement { - public ItemhRequirement(Rankup plugin) { - super(plugin, "itemh", true); - } - - protected ItemhRequirement(ItemRequirement clone) { - super(clone); - } - - @Override - public double getProgress(Player player) { - Material material = Material.matchMaterial(getSub()); - return Arrays.stream(player.getInventory().getStorageContents()) - .filter(item -> item != null && item.getType() == material) - .mapToInt(ItemStack::getAmount).sum(); - } - - @Override - public Requirement clone() { - return new ItemhRequirement(plugin); - } -} diff --git a/src/main/java/sh/okx/rankup/requirements/requirement/TotalMobKillsRequirement.java b/src/main/java/sh/okx/rankup/requirements/requirement/TotalMobKillsRequirement.java index 6baea68..2e0142b 100644 --- a/src/main/java/sh/okx/rankup/requirements/requirement/TotalMobKillsRequirement.java +++ b/src/main/java/sh/okx/rankup/requirements/requirement/TotalMobKillsRequirement.java @@ -11,7 +11,7 @@ public class TotalMobKillsRequirement extends ProgressiveRequirement { super(plugin, "total-mob-kills"); } - protected TotalMobKillsRequirement(Requirement clone) { + private TotalMobKillsRequirement(Requirement clone) { super(clone); }