From 400c48300acd22dcbbd422e80bde7765b06e24e7 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:15:42 -0600 Subject: [PATCH 01/20] Extract built-in reward implementations --- .../rewards/builtin/BuiltinRewards.java | 39 ++++ .../rewards/builtin/RewardActionBar.java | 66 ++++++ .../builtin/RewardAdvancedPriority.java | 77 +++++++ .../builtin/RewardAdvancedRandomReward.java | 76 +++++++ .../builtin/RewardAdvancedRewards.java | 73 +++++++ .../rewards/builtin/RewardAdvancedWorld.java | 72 +++++++ .../rewards/builtin/RewardBossBar.java | 52 +++++ .../rewards/builtin/RewardChoices.java | 93 +++++++++ .../rewards/builtin/RewardCommands.java | 192 ++++++++++++++++++ .../rewards/builtin/RewardEffect.java | 51 +++++ .../rewards/builtin/RewardExp.java | 130 ++++++++++++ .../rewards/builtin/RewardFirework.java | 58 ++++++ .../rewards/builtin/RewardItems.java | 172 ++++++++++++++++ .../rewards/builtin/RewardJavascript.java | 103 ++++++++++ .../rewards/builtin/RewardLucky.java | 109 ++++++++++ .../rewards/builtin/RewardMessages.java | 146 +++++++++++++ .../rewards/builtin/RewardMoney.java | 98 +++++++++ .../rewards/builtin/RewardPotions.java | 51 +++++ .../rewards/builtin/RewardPriority.java | 52 +++++ .../rewards/builtin/RewardRandom.java | 64 ++++++ .../rewards/builtin/RewardRandomReward.java | 48 +++++ .../rewards/builtin/RewardSound.java | 55 +++++ .../rewards/builtin/RewardSpecialChance.java | 105 ++++++++++ .../rewards/builtin/RewardSubRewards.java | 55 +++++ .../rewards/builtin/RewardTempPermission.java | 58 ++++++ .../rewards/builtin/RewardTitle.java | 53 +++++ .../requirements/BuiltinRequirements.java | 24 +++ .../requirements/RequirementChance.java | 60 ++++++ .../builtin/requirements/RequirementDate.java | 112 ++++++++++ .../requirements/RequirementDayOfMonth.java | 61 ++++++ .../requirements/RequirementJavascript.java | 53 +++++ .../RequirementLocationDistance.java | 83 ++++++++ .../requirements/RequirementPermission.java | 88 ++++++++ .../RequirementRewardExpiration.java | 51 +++++ .../requirements/RequirementRewardType.java | 49 +++++ .../requirements/RequirementServer.java | 101 +++++++++ .../requirements/RequirementWorld.java | 144 +++++++++++++ 37 files changed, 2974 insertions(+) create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardActionBar.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedPriority.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRandomReward.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRewards.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedWorld.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardBossBar.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardChoices.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardEffect.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardExp.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardFirework.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardJavascript.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardLucky.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMessages.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMoney.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPotions.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPriority.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandom.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomReward.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSound.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSpecialChance.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSubRewards.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTempPermission.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTitle.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/BuiltinRequirements.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementChance.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDate.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDayOfMonth.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementJavascript.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementLocationDistance.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementPermission.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardExpiration.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardType.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementServer.java create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java new file mode 100644 index 000000000..b228f02fc --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java @@ -0,0 +1,39 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.rewards.RewardHandler; + +/** Registers the built-in AdvancedCore reward implementations. */ +public final class BuiltinRewards { + + private BuiltinRewards() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + RewardMoney.register(handler, plugin); + RewardExp.register(handler, plugin); + RewardMessages.register(handler, plugin); + RewardCommands.register(handler, plugin); + RewardActionBar.register(handler, plugin); + RewardJavascript.register(handler, plugin); + RewardLucky.register(handler, plugin); + RewardRandom.register(handler, plugin); + RewardSubRewards.register(handler, plugin); + RewardRandomReward.register(handler, plugin); + RewardTempPermission.register(handler, plugin); + RewardAdvancedRewards.register(handler, plugin); + RewardAdvancedRandomReward.register(handler, plugin); + RewardPriority.register(handler, plugin); + RewardPotions.register(handler, plugin); + RewardTitle.register(handler, plugin); + RewardBossBar.register(handler, plugin); + RewardSound.register(handler, plugin); + RewardEffect.register(handler, plugin); + RewardFirework.register(handler, plugin); + RewardItems.register(handler, plugin); + RewardAdvancedPriority.register(handler, plugin); + RewardAdvancedWorld.register(handler, plugin); + RewardSpecialChance.register(handler, plugin); + RewardChoices.register(handler, plugin); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardActionBar.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardActionBar.java new file mode 100644 index 000000000..65a042810 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardActionBar.java @@ -0,0 +1,66 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditActionBar; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardActionBar { + + private RewardActionBar() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("ActionBar") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + user.sendActionBar(PlaceholderUtils.replacePlaceHolder(section.getString("Message", ""), placeholders), + section.getInt("Delay", 30)); + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("ActionBar") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditActionBar() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Actionbar configuration"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String message = data.getString("ActionBar.Message"); + int delay = data.getInt("ActionBar.Delay", -1); + if (message != null && message.isEmpty()) { + warning(reward, inject, "No actionbar message set"); + } + if (delay == -1) { + warning(reward, inject, "No actionbar delay set"); + } else if (delay == 0) { + warning(reward, inject, "Actionbar delay can not be 0"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedPriority.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedPriority.java new file mode 100644 index 000000000..a43c468c0 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedPriority.java @@ -0,0 +1,77 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedPriority; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardAdvancedPriority { + + private RewardAdvancedPriority() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("AdvancedPriority") { + @Override + public String onRewardRequested(Reward sourceReward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + for (String key : section.getKeys(false)) { + Reward reward = handler.getReward(section, key, new RewardOptions()); + if (reward != null && reward.canGiveReward(user, new RewardOptions().withPlaceHolder(placeholders))) { + plugin.extraDebug("AdvancedPriority: Giving reward " + reward.getName()); + reward.giveReward(user, new RewardOptions().setIgnoreChance(true).setIgnoreRequirements(true) + .setPrefix(sourceReward.getName() + "_AdvancedPriority").withPlaceHolder(placeholders)); + return reward.getName(); + } + plugin.extraDebug("AdvancedPriority: Can't give reward " + key); + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String base = direct.getPath() + direct.needsDot() + "AdvancedPriority"; + if (direct.getFileData().isConfigurationSection(base)) { + for (String key : direct.getFileData().getConfigurationSection(base).getKeys(false)) { + if (direct.getFileData().isConfigurationSection(base + "." + key)) { + subs.add(new SubDirectlyDefinedReward(direct, "AdvancedPriority." + key)); + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedPriority") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditAdvancedPriority() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("AdvancedPriority will run first sub reward that it can, then ignore the rest of the sub rewards") + .addLore("Can be used for permission based rewards or chance based rewards"))) + .priority(10).alwaysValid().postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRandomReward.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRandomReward.java new file mode 100644 index 000000000..e1929935c --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRandomReward.java @@ -0,0 +1,76 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Set; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedRandomReward; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; + +public final class RewardAdvancedRandomReward { + + private RewardAdvancedRandomReward() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("AdvancedRandomReward") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + Set keys = section.getKeys(false); + ArrayList rewards = ArrayUtils.convert(keys); + if (!rewards.isEmpty()) { + String selected = rewards.get(ThreadLocalRandom.current().nextInt(rewards.size())); + handler.giveReward(user, section, selected, new RewardOptions().setPlaceholders(placeholders) + .setPrefix(reward.getRewardName() + "_AdvancedRandomReward")); + return selected; + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String base = direct.getPath() + direct.needsDot() + "AdvancedRandomReward"; + if (direct.getFileData().isConfigurationSection(base)) { + for (String key : direct.getFileData().getConfigurationSection(base).getKeys(false)) { + if (direct.getFileData().isConfigurationSection(base + "." + key)) { + subs.add(new SubDirectlyDefinedReward(direct, "AdvancedRandomReward." + key)); + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedRandomReward") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditAdvancedRandomReward() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Execute random reward"))).asPlaceholder("RandomReward").synchronize().priority(20).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRewards.java new file mode 100644 index 000000000..ff100042c --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedRewards.java @@ -0,0 +1,73 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Set; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedRandomReward; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; + +public final class RewardAdvancedRewards { + + private RewardAdvancedRewards() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("AdvancedRewards") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + Set keys = section.getKeys(false); + ArrayList rewards = ArrayUtils.convert(keys); + for (String rewardName : rewards) { + handler.giveReward(user, section, rewardName, new RewardOptions().setPlaceholders(placeholders) + .setPrefix(reward.getRewardName() + "_AdvancedRewards_" + rewardName)); + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String base = direct.getPath() + direct.needsDot() + "AdvancedRewards"; + if (direct.getFileData().isConfigurationSection(base)) { + for (String key : direct.getFileData().getConfigurationSection(base).getKeys(false)) { + if (direct.getFileData().isConfigurationSection(base + "." + key)) { + subs.add(new SubDirectlyDefinedReward(direct, "AdvancedRewards." + key)); + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedRewards") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditAdvancedRandomReward() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Execute rewards"))).synchronize().priority(20).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedWorld.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedWorld.java new file mode 100644 index 000000000..88f3c54bb --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardAdvancedWorld.java @@ -0,0 +1,72 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedWorld; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; + +public final class RewardAdvancedWorld { + + private RewardAdvancedWorld() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("AdvancedWorld") { + @Override + public String onRewardRequested(Reward sourceReward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + for (String key : section.getKeys(false)) { + plugin.extraDebug("AdvancedWorld: Giving reward " + sourceReward.getName() + "_AdvancedWorld"); + section.set(key + ".Worlds", ArrayUtils.convert(new String[] { key })); + handler.giveReward(user, section, key, new RewardOptions().withPlaceHolder(placeholders) + .setPrefix(sourceReward.getName() + "_AdvancedWorld")); + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String base = direct.getPath() + direct.needsDot() + "AdvancedWorld"; + if (direct.getFileData().isConfigurationSection(base)) { + for (String key : direct.getFileData().getConfigurationSection(base).getKeys(false)) { + if (direct.getFileData().isConfigurationSection(base + "." + key)) { + subs.add(new SubDirectlyDefinedReward(direct, "AdvancedWorld." + key)); + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedWorld") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditAdvancedWorld() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("AdvancedReward will run rewards based worlds specified"))).priority(10).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardBossBar.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardBossBar.java new file mode 100644 index 000000000..313e222c4 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardBossBar.java @@ -0,0 +1,52 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditBossBar; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardBossBar { + + private RewardBossBar() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("BossBar") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + user.sendBossBar(PlaceholderUtils.replacePlaceHolder(section.getString("Message", ""), placeholders), + section.getString("Color", "BLUE"), section.getString("Style", "SOLID"), + section.getDouble("Progress", .5), section.getInt("Delay", 30)); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("DRAGON_HEAD"), new EditGUIValueInventory("BossBar") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditBossBar() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure bossbar")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardChoices.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardChoices.java new file mode 100644 index 000000000..58a90cd26 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardChoices.java @@ -0,0 +1,93 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditChoices; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectBoolean; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardChoices { + + private RewardChoices() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectBoolean("EnableChoices") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, boolean value, + HashMap placeholders) { + if (value) { + debug("Checking choice rewards"); + String choice = user.getChoicePreference(reward.getName()); + if (choice.isEmpty() || choice.equalsIgnoreCase("none")) { + debug("No choice specified"); + user.addUnClaimedChoiceReward(reward.getName()); + } else { + handler.giveChoicesReward(reward, user, choice); + } + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String root = direct.getPath() + direct.needsDot(); + if (direct.getFileData().getBoolean(root + "EnableChoices") + && direct.getFileData().isConfigurationSection(root + "Choices")) { + for (String choice : direct.getFileData().getConfigurationSection(root + "Choices").getKeys(false)) { + String path = "Choices." + choice + ".Rewards"; + if (direct.getFileData().isConfigurationSection(root + path)) { + subs.add(new SubDirectlyDefinedReward(direct, path)); + } + } + } + return subs; + } + }.priority(10).synchronize().validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (data.getBoolean("EnableChoices")) { + ConfigurationSection choices = data.getConfigurationSection("Choices"); + if (choices == null) { + warning(reward, inject, "Choices section is missing while EnableChoices is true"); + return; + } + if (choices.getKeys(false).size() <= 1) { + warning(reward, inject, "Not enough choices for choice rewards, 1 or less is not a choice"); + } + } + } + }.addPath("Choices")).addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Choices") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditChoices() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addCheckKey("EnableChoices").addLore("Give users a choice on the reward")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java new file mode 100644 index 000000000..13c9369df --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java @@ -0,0 +1,192 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardCommands { + + private RewardCommands() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("NumberCommand") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + int min = section.getInt("Min", 0); + int max = section.getInt("Max", 100); + int number = ThreadLocalRandom.current().nextInt(min, max + 1); + String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); + return String.valueOf(number); + } + }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") + || !data.isString("NumberCommand.Command")) { + warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); + return; + } + int min = data.getInt("NumberCommand.Min"); + int max = data.getInt("NumberCommand.Max"); + if (min > max) { + warning(reward, inject, "NumberCommand Min can not be greater than Max"); + } + if (min == max) { + warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); + } + } + })); + + handler.getInjectedRewards().add(new RewardInjectString("Command") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute single console command"))).validator(commandValidator())); + + handler.getInjectedRewards().add(new RewardInjectStringList("Commands") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), list, placeholders, true); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueList("Commands", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("List of console commands"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (data.isList(inject.getPath()) && !data.isConfigurationSection(inject.getPath())) { + List list = data.getStringList(inject.getPath()); + if (list.isEmpty()) { + warning(reward, inject, "No commands listed"); + } + for (String command : list) { + if (command.startsWith("/")) { + warning(reward, inject, "Commands can not start with /"); + } + } + } + } + })); + + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Commands") { + @SuppressWarnings("unchecked") + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + ArrayList consoleCommands = (ArrayList) section.getList("Console", new ArrayList<>()); + ArrayList userCommands = (ArrayList) section.getList("Player", new ArrayList<>()); + if (!consoleCommands.isEmpty()) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), consoleCommands, placeholders, + section.getBoolean("Stagger", true)); + } + if (!userCommands.isEmpty()) { + user.preformCommand(userCommands, placeholders); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Commands.Console", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Old style for console commands"))).addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Commands.Player", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute commands as player")))); + + handler.getInjectedRewards().add(new RewardInjectStringList("RandomCommand") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), + list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute random command"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + List list = data.getStringList(inject.getPath()); + if (list.isEmpty()) { + warning(reward, inject, "No rewards listed for random reward"); + } else if (list.size() == 1) { + warning(reward, inject, "Only one reward listed for random reward"); + } + } + })); + } + + private static RewardInjectValidator commandValidator() { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String command = data.getString(inject.getPath()); + if (command != null && command.startsWith("/")) { + warning(reward, inject, "Can't start command with /"); + } + } + }; + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardEffect.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardEffect.java new file mode 100644 index 000000000..43770b4b1 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardEffect.java @@ -0,0 +1,51 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEffect; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardEffect { + + private RewardEffect() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Effect") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + user.playParticle(section.getString("Effect"), section.getInt("Data", 1), + section.getInt("Particles", 1), section.getInt("Radius", 5)); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.DIAMOND), new EditGUIValueInventory("Effect") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditEffect() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure particle effect")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardExp.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardExp.java new file mode 100644 index 000000000..50f358ea7 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardExp.java @@ -0,0 +1,130 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEXP; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEXPLevels; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectInt; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardExp { + + private RewardExp() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectInt("EXP", 0) { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, int num, + HashMap placeholders) { + user.giveExp(num); + return null; + } + }.asPlaceholder("EXP").priority(100).addEditButton( + new EditGUIButton(new ItemBuilder("EXPERIENCE_BOTTLE"), new EditGUIValueInventory("EXP") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditEXP() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("EXP to give"))).validator(zeroValidator("EXP can not be 0"))); + + handler.getInjectedRewards().add(new RewardInjectInt("EXPLevels", 0) { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, int num, + HashMap placeholders) { + user.giveExpLevels(num); + return null; + } + }.asPlaceholder("EXP").priority(100).addEditButton( + new EditGUIButton(new ItemBuilder("EXPERIENCE_BOTTLE"), new EditGUIValueInventory("EXPLevels") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditEXPLevels() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("EXPLevels to give"))).validator(zeroValidator("EXP can not be 0"))); + + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("EXP") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + int minExp = section.getInt("Min", 0); + int maxExp = section.getInt("Max", 0); + int value = ThreadLocalRandom.current().nextInt(minExp, maxExp); + user.giveExp(value); + return "" + value; + } + }.asPlaceholder("EXP").priority(100).validator(rangeValidator("EXP"))); + + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("EXPLevels") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + int minExp = section.getInt("Min", 0); + int maxExp = section.getInt("Max", 0); + int value = ThreadLocalRandom.current().nextInt(minExp, maxExp); + user.giveExpLevels(value); + return "" + value; + } + }.asPlaceholder("EXP").priority(100).validator(rangeValidator("EXPLevels"))); + } + + private static RewardInjectValidator zeroValidator(String message) { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (data.getDouble(inject.getPath(), -1) == 0) { + warning(reward, inject, message); + } + } + }; + } + + private static RewardInjectValidator rangeValidator(String path) { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + int min = data.getInt(path + ".Min", 0); + int max = data.getInt(path + ".Max", 0); + if (max == 0) { + warning(reward, inject, "Max " + path + " can not be 0"); + } + if (min > max) { + warning(reward, inject, path + ".Min can not be greater than " + path + ".Max"); + } + if (min == max) { + warning(reward, inject, path + ".Min and " + path + ".Max are the same, random range is unnecessary"); + } + } + }; + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardFirework.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardFirework.java new file mode 100644 index 000000000..eb51824f5 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardFirework.java @@ -0,0 +1,58 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.effects.FireworkHandler; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditFirework; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardFirework { + + private RewardFirework() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Firework") { + @SuppressWarnings("unchecked") + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + FireworkHandler.getInstance().launchFirework(user.getPlayer().getLocation(), + section.getInt("Power", 1), + (ArrayList) section.getList("Colors", new ArrayList<>()), + (ArrayList) section.getList("FadeOutColor", new ArrayList<>()), + section.getBoolean("Trail"), section.getBoolean("Flicker"), + (ArrayList) section.getList("Types", new ArrayList<>()), + section.getBoolean("Detonate", false)); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("FIREWORK_ROCKET"), new EditGUIValueInventory("Firework") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditFirework() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure firework effect")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java new file mode 100644 index 000000000..b0c4ee140 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java @@ -0,0 +1,172 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; +import java.util.Set; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditItems; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectKeys; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; + +public final class RewardItems { + + private RewardItems() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Item") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + ItemBuilder builder = new ItemBuilder(section); + builder.setCheckLoreLength(false); + user.giveItem(builder); + return null; + } + }.validator(itemValidator())); + + handler.getInjectedRewards().add(new RewardInjectKeys("RandomItem") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, + ConfigurationSection data, HashMap placeholders) { + if (!section.isEmpty()) { + String item = ArrayUtils.pickRandom(ArrayUtils.convert(section)); + ItemBuilder builder = new ItemBuilder(data.getConfigurationSection(item)); + builder.setCheckLoreLength(false); + user.giveItem(builder); + return item; + } + return null; + } + }.asPlaceholder("RandomItem").priority(90).validator(randomItemValidator())); + + handler.getInjectedRewards().add(new RewardInjectKeys("Items") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, + ConfigurationSection data, HashMap placeholders) { + boolean oneChance = reward.getConfig().getConfigData().getBoolean("OnlyOneItemChance", false); + if (!section.isEmpty()) { + for (String item : section) { + ItemBuilder builder = new ItemBuilder(data.getConfigurationSection(item)); + builder.setCheckLoreLength(false); + user.giveItem(builder.setPlaceholders(placeholders)); + debug("Giving item " + item + ":" + builder); + if (builder.isChancePass() && oneChance) { + return item; + } + } + } + return ""; + } + }.priority(90).asPlaceholder("Item").validator(itemsValidator().addPath("OnlyOneItemChance")) + .addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Items") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditItems(plugin) { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Edit items")))); + } + + private static RewardInjectValidator itemValidator() { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String material = data.getString("Item.Material", ""); + if (material.isEmpty()) { + warning(reward, inject, "No material is set on item"); + return; + } + validateMaterial(this, reward, inject, material, ""); + } + }; + } + + private static RewardInjectValidator randomItemValidator() { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + ConfigurationSection section = data.getConfigurationSection("RandomItem"); + if (section == null) { + warning(reward, inject, "RandomItem section is missing"); + return; + } + for (String item : section.getKeys(false)) { + String material = section.getString(item + ".Material", ""); + if (material.isEmpty()) { + warning(reward, inject, "No material is set on item: " + item); + } else { + validateMaterial(this, reward, inject, material, " on RandomItem." + item); + } + } + } + }; + } + + private static RewardInjectValidator itemsValidator() { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (!data.isConfigurationSection("Items")) { + warning(reward, inject, "Invalid item section"); + return; + } + for (String item : data.getConfigurationSection("Items").getKeys(false)) { + String material = data.getString("Items." + item + ".Material", ""); + if (material.isEmpty()) { + try { + Material.valueOf(item); + } catch (Exception e) { + warning(reward, inject, "No material is set on item: " + item); + } + } else { + validateMaterial(this, reward, inject, material, ""); + } + if (data.getInt("Items." + item + ".Amount", 0) == 0 + && data.getInt("Items." + item + ".MinAmount", 0) == 0 + && data.getInt("Items." + item + ".MaxAmount") == 0) { + warning(reward, inject, "No amount on item: " + item); + } + } + } + }; + } + + private static void validateMaterial(RewardInjectValidator validator, Reward reward, RewardInject inject, + String material, String suffix) { + try { + Material matched = Material.matchMaterial(material.toUpperCase()); + if (matched == null) { + matched = Material.matchMaterial(material, true); + if (matched != null) { + validator.warning(reward, inject, + "Found legacy material: " + material + ", please update material" + suffix); + } else { + validator.warning(reward, inject, "Invalid material set: " + material); + } + } + } catch (NoSuchMethodError ignored) { + } + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardJavascript.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardJavascript.java new file mode 100644 index 000000000..61eab2828 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardJavascript.java @@ -0,0 +1,103 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.javascript.JavascriptEngine; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditJavascript; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardJavascript { + + private RewardJavascript() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectStringList("Javascripts") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + JavascriptEngine engine = new JavascriptEngine().addPlayer(user.getOfflinePlayer()); + for (String script : list) { + String expression = PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), script); + engine.execute(PlaceholderUtils.replacePlaceHolder(expression, placeholders)); + } + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Javascripts", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Javascript expressions to run")))); + + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Javascript") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + String expression = section.getString("Expression"); + expression = PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), expression); + if (new JavascriptEngine().addPlayer(user.getOfflinePlayer()) + .getBooleanValue(PlaceholderUtils.replacePlaceHolder(expression, placeholders))) { + new RewardBuilder(section, "TrueRewards").withPrefix(reward.getName() + ".Javascript").send(user); + } else { + new RewardBuilder(section, "FalseRewards").withPrefix(reward.getName() + ".Javascript").send(user); + } + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + if (direct.getFileData().isConfigurationSection( + direct.getPath() + direct.needsDot() + "Javascript.TrueRewards")) { + subs.add(new SubDirectlyDefinedReward(direct, "Javascript.TrueRewards")); + } + if (direct.getFileData().isConfigurationSection( + direct.getPath() + direct.needsDot() + "Javascript.FalseRewards")) { + subs.add(new SubDirectlyDefinedReward(direct, "Javascript.FalseRewards")); + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Javascript") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditJavascript() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Run javascript to run rewards based on expression return value of true/false")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardLucky.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardLucky.java new file mode 100644 index 000000000..529ef942a --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardLucky.java @@ -0,0 +1,109 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map.Entry; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditLucky; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; +import com.bencodez.simpleapi.messages.MessageAPI; + +public final class RewardLucky { + + private RewardLucky() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Lucky") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + HashMap luckyRewards = new HashMap<>(); + for (String key : section.getKeys(false)) { + if (MessageAPI.isInt(key)) { + int num = Integer.parseInt(key); + if (num > 0) { + luckyRewards.put(num, "Lucky." + num); + } + } + } + HashMap map = new LinkedHashMap<>(); + for (Entry entry : luckyRewards.entrySet()) { + if (MiscUtils.getInstance().checkChance(1, entry.getKey())) { + map.put(entry.getValue(), entry.getKey()); + } + } + map = ArrayUtils.sortByValuesStr(map, false); + if (!map.isEmpty()) { + if (reward.getConfig().getConfigData().getBoolean("OnlyOneLucky", false)) { + for (Entry entry : map.entrySet()) { + new RewardBuilder(reward.getConfig().getConfigData(), entry.getKey()) + .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); + return null; + } + } else { + for (Entry entry : map.entrySet()) { + new RewardBuilder(reward.getConfig().getConfigData(), entry.getKey()) + .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); + } + } + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Lucky")) { + for (String key : direct.getFileData() + .getConfigurationSection(direct.getPath() + direct.needsDot() + "Lucky").getKeys(false)) { + if (MessageAPI.isInt(key) && Integer.parseInt(key) > 0) { + String path = "Lucky." + key; + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + path)) { + subs.add(new SubDirectlyDefinedReward(direct, path)); + } + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Lucky") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditLucky() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + })).priority(10).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + } + }.addPath("OnlyOneLucky"))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMessages.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMessages.java new file mode 100644 index 000000000..c03dc1bde --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMessages.java @@ -0,0 +1,146 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditMessages; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardMessages { + + private RewardMessages() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectString("Message") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + user.sendMessage(value, placeholders); + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("OAK_SIGN"), new EditGUIValueInventory("Messages") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditMessages() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addCheckKey("Message"))).validator(playerMessageValidator())); + + handler.getInjectedRewards().add(new RewardInjectStringList("Messages.Player") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, + HashMap placeholders) { + user.sendMessage(value, placeholders); + return null; + } + }); + + handler.getInjectedRewards().add(new RewardInjectStringList("Message") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, + HashMap placeholders) { + user.sendMessage(value, placeholders); + return null; + } + }); + + handler.getInjectedRewards().add(new RewardInjectStringList("RandomMessage") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, + HashMap placeholders) { + user.sendMessage(value.get(ThreadLocalRandom.current().nextInt(0, value.size())), placeholders); + return null; + } + }); + + handler.getInjectedRewards().add(new RewardInjectString("Messages.Player") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + user.sendMessage(value, placeholders); + return null; + } + }.validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (data.isString(inject.getPath()) && data.getString(inject.getPath()).isEmpty()) { + warning(reward, inject, "No player message set"); + } + } + })); + + handler.getInjectedRewards().add(new RewardInjectStringList("Messages.Broadcast") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, + HashMap placeholders) { + if (plugin.getOptions().getBroadcastBlacklist().contains(user.getPlayerName())) { + debug("Not broadcasting for " + user.getPlayerName() + ", in blacklist"); + return null; + } + for (String message : value) { + MiscUtils.getInstance().broadcast(PlaceholderUtils.replacePlaceHolders(user.getPlayer(), + PlaceholderUtils.replacePlaceHolder(message, placeholders))); + } + return null; + } + }); + + handler.getInjectedRewards().add(new RewardInjectString("Messages.Broadcast") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + if (plugin.getOptions().getBroadcastBlacklist().contains(user.getPlayerName())) { + debug("Not broadcasting for " + user.getPlayerName() + ", in blacklist"); + return null; + } + MiscUtils.getInstance().broadcast(PlaceholderUtils.replacePlaceHolders(user.getPlayer(), + PlaceholderUtils.replacePlaceHolder(value, placeholders))); + return null; + } + }.validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (!data.isList(inject.getPath()) && data.getString(inject.getPath(), "Empty").isEmpty()) { + warning(reward, inject, "No broadcast was set"); + } + } + })); + } + + private static RewardInjectValidator playerMessageValidator() { + return new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String value = data.getString(inject.getPath()); + if (value != null && value.isEmpty()) { + warning(reward, inject, "No player message set"); + } + } + }; + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMoney.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMoney.java new file mode 100644 index 000000000..6dd85470e --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardMoney.java @@ -0,0 +1,98 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.text.DecimalFormat; +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditMoney; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectDouble; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardMoney { + + private RewardMoney() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectDouble("Money", 0) { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, double num, + HashMap placeholders) { + user.giveMoney(num); + return "" + (int) num; + } + }.asPlaceholder("Money").priority(100) + .addEditButton(new EditGUIButton(new ItemBuilder(Material.DIAMOND), new EditGUIValueInventory("Money") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditMoney() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Money to execute, may not work on some economy plugins").addLore("Supports random amounts"))) + .validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (data.getDouble(inject.getPath(), -1) == 0) { + warning(reward, inject, "Money can not be 0"); + } + } + })); + + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Money") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + double minMoney = section.getDouble("Min", 0); + double maxMoney = section.getDouble("Max", 0); + double value = ThreadLocalRandom.current().nextDouble(minMoney, maxMoney); + if (section.getBoolean("Round")) { + value = Math.round(value); + user.giveMoney(value); + return "" + value; + } + DecimalFormat format = new DecimalFormat("##.00"); + user.giveMoney(value); + return "" + format.format(value); + } + }.asPlaceholder("Money").priority(100).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + double min = data.getDouble("Money.Min", 0); + double max = data.getDouble("Money.Max", 0); + if (!data.isConfigurationSection("Money")) { + return; + } + if (max == 0) { + warning(reward, inject, "Maximum money can not be 0"); + } + if (min > max) { + warning(reward, inject, "Money.Min can not be greater than Money.Max"); + } + if (min == max) { + warning(reward, inject, "Money.Min and Money.Max are the same, random range is unnecessary"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPotions.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPotions.java new file mode 100644 index 000000000..78518fbc5 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPotions.java @@ -0,0 +1,51 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditPotions; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardPotions { + + private RewardPotions() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Potions") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + for (String potion : section.getKeys(false)) { + user.givePotionEffect(potion, section.getInt(potion + ".Duration", 1), + section.getInt(potion + ".Amplifier", 1)); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAINTING), new EditGUIValueInventory("Potions") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditPotions() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure Potion Effects")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPriority.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPriority.java new file mode 100644 index 000000000..bb5990f2e --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardPriority.java @@ -0,0 +1,52 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardPriority { + + private RewardPriority() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectStringList("Priority") { + @Override + public String onRewardRequest(Reward source, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + for (String rewardName : list) { + Reward reward = handler.getReward(rewardName); + if (reward.canGiveReward(user, new RewardOptions().withPlaceHolder(placeholders))) { + new RewardBuilder(reward).withPlaceHolder(placeholders).setIgnoreChance(true) + .setIgnoreRequirements(true).send(user); + return reward.getName(); + } + } + return null; + } + }.asPlaceholder("Priority").addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Priority", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute first reward file that can be executed"))).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandom.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandom.java new file mode 100644 index 000000000..e6c17ace6 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandom.java @@ -0,0 +1,64 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardRandom { + + private RewardRandom() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Random") { + @SuppressWarnings("unchecked") + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (MiscUtils.getInstance().checkChance(section.getDouble("Chance", 100), 100)) { + if (section.getBoolean("PickRandom", true)) { + ArrayList rewards = (ArrayList) section.getList("Rewards", new ArrayList<>()); + if (rewards != null && !rewards.isEmpty()) { + String selected = rewards.get(ThreadLocalRandom.current().nextInt(rewards.size())); + if (!selected.equals("")) { + handler.giveReward(user, selected, new RewardOptions().setPlaceholders(placeholders)); + } + } + } else { + new RewardBuilder(reward.getConfig().getConfigData(), "Random.Rewards") + .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); + } + } else { + new RewardBuilder(reward.getConfig().getConfigData(), "Random.FallBack") + .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); + } + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Random.Rewards")) { + subs.add(new SubDirectlyDefinedReward(direct, "Random.Rewards")); + } + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Random.FallBack")) { + subs.add(new SubDirectlyDefinedReward(direct, "Random.FallBack")); + } + return subs; + } + }.priority(10)); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomReward.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomReward.java new file mode 100644 index 000000000..34365f89e --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomReward.java @@ -0,0 +1,48 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardRandomReward { + + private RewardRandomReward() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectStringList("RandomReward") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + String selected = list.get(ThreadLocalRandom.current().nextInt(list.size())); + handler.giveReward(user, selected, new RewardOptions().setPlaceholders(placeholders)); + return selected; + } + return null; + } + }.asPlaceholder("RandomReward").priority(20).addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomReward", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + } + }.addLore("Execute random reward"))).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSound.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSound.java new file mode 100644 index 000000000..fe10f7b96 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSound.java @@ -0,0 +1,55 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditSound; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardSound { + + private RewardSound() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Sound") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + try { + user.playSound(section.getString("Sound"), (float) section.getDouble("Volume", 1.0), + (float) section.getDouble("Pitch", 1.0)); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.NOTE_BLOCK), new EditGUIValueInventory("Sound") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditSound() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure sound")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSpecialChance.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSpecialChance.java new file mode 100644 index 000000000..99a7e288f --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSpecialChance.java @@ -0,0 +1,105 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditSpecialChance; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.messages.MessageAPI; + +public final class RewardSpecialChance { + + private RewardSpecialChance() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("SpecialChance") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + double totalChance = 0; + LinkedHashMap map = new LinkedHashMap<>(); + for (String key : section.getKeys(false)) { + String path = key; + key = key.replaceAll("_", "."); + if (MessageAPI.isDouble(key)) { + double chance = Double.valueOf(key); + totalChance += chance; + map.put(chance, path); + } + } + + Set> copy = new HashSet<>(map.entrySet()); + double currentNum = 0; + map.clear(); + for (Entry entry : copy) { + currentNum += entry.getKey(); + map.put(currentNum, entry.getValue()); + } + + double randomNum = ThreadLocalRandom.current().nextDouble(totalChance); + for (Entry entry : map.entrySet()) { + if (randomNum <= entry.getKey()) { + new RewardBuilder(section, entry.getValue()).withPrefix(reward.getName() + "_SpecialChance") + .withPlaceHolder(placeholders).withPlaceHolder("chance", "" + entry.getKey()).send(user); + plugin.debug("Giving special chance: " + entry.getValue() + ", Random number: " + randomNum + + ", Total chance: " + totalChance); + return null; + } + } + plugin.debug("Failed to give special chance"); + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + String base = direct.getPath() + direct.needsDot() + "SpecialChance"; + if (direct.getFileData().isConfigurationSection(base)) { + for (String key : direct.getFileData().getConfigurationSection(base).getKeys(false)) { + if (MessageAPI.isDouble(key.replaceAll("_", "."))) { + String path = "SpecialChance." + key; + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + path)) { + subs.add(new SubDirectlyDefinedReward(direct, path)); + } + } + } + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("SpecialChance") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditSpecialChance() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Rewards based on chance"))).priority(10).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSubRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSubRewards.java new file mode 100644 index 000000000..e9e08e374 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardSubRewards.java @@ -0,0 +1,55 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.DefinedReward; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.SubDirectlyDefinedReward; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardSubRewards { + + private RewardSubRewards() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Rewards") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + plugin.debug("12345c" + reward.getName()); + new RewardBuilder(reward.getConfig().getConfigData(), "Rewards").withPrefix(reward.getName()) + .withPlaceHolder(placeholders).send(user); + return null; + } + + @Override + public ArrayList subRewards(DefinedReward direct) { + ArrayList subs = new ArrayList<>(); + if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Rewards")) { + subs.add(new SubDirectlyDefinedReward(direct, "Rewards")); + } + return subs; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.DISPENSER), new EditGUIValueInventory("Rewards") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + handler.openSubReward(clickEvent.getPlayer(), "Rewards", reward); + } + }.addLore("Sub rewards"))).priority(5).alwaysForce().postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTempPermission.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTempPermission.java new file mode 100644 index 000000000..5dc04dada --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTempPermission.java @@ -0,0 +1,58 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditTempPermission; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardTempPermission { + + private RewardTempPermission() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("TempPermission") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + String permission = section.getString("Permission", ""); + int time = section.getInt("Expiration"); + if (!permission.isEmpty()) { + if (time > 0) { + user.addPermission(permission, time); + } else { + extraDebug("Time is 0"); + } + } else { + extraDebug("Permission is empty"); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("TempPermission") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditTempPermission() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Give temporary permission"))).priority(90).postReward()); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTitle.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTitle.java new file mode 100644 index 000000000..b252e22cf --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardTitle.java @@ -0,0 +1,53 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditTitle; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RewardTitle { + + private RewardTitle() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Title") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + if (section.getBoolean("Enabled")) { + user.sendTitle(PlaceholderUtils.replacePlaceHolder(section.getString("Title"), placeholders), + PlaceholderUtils.replacePlaceHolder(section.getString("SubTitle"), placeholders), + section.getInt("FadeIn", 10), section.getInt("ShowTime", 50), section.getInt("FadeOut", 10)); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAINTING), new EditGUIValueInventory("Title") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditTitle() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Configure Title & SubTitle")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/BuiltinRequirements.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/BuiltinRequirements.java new file mode 100644 index 000000000..2def18762 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/BuiltinRequirements.java @@ -0,0 +1,24 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.rewards.RewardHandler; + +/** Registers the built-in AdvancedCore reward requirements. */ +public final class BuiltinRequirements { + + private BuiltinRequirements() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + RequirementChance.register(handler, plugin); + RequirementRewardExpiration.register(handler, plugin); + RequirementPermission.register(handler, plugin); + RequirementDayOfMonth.register(handler, plugin); + RequirementServer.register(handler, plugin); + RequirementWorld.register(handler, plugin); + RequirementRewardType.register(handler, plugin); + RequirementJavascript.register(handler, plugin); + RequirementDate.register(handler, plugin); + RequirementLocationDistance.register(handler, plugin); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementChance.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementChance.java new file mode 100644 index 000000000..22c65e8d3 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementChance.java @@ -0,0 +1,60 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectDouble; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementChance { + + private RequirementChance() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectDouble("Chance", 100) { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, double num, + RewardOptions rewardOptions) { + if (rewardOptions.isIgnoreChance()) { + return true; + } + return MiscUtils.getInstance().checkChance(num, 100); + } + }.priority(100).addEditButton( + new EditGUIButton(new ItemBuilder("DROPPER"), new EditGUIValueNumber("Chance", null) { + @Override + public void setValue(Player player, Number value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value.intValue()); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Set chance for reward to execute"))).validator(new RequirementInjectValidator() { + @Override + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + if (data.getDouble(inject.getPath(), 0) == 100) { + warning(reward, inject, + "Chance is 100, if intended then remove the chance option, as it's unneeded"); + } else if (data.getDouble(inject.getPath(), 0) > 100) { + warning(reward, inject, "Chance is greater than 100, this will always give the reward"); + } else if (data.getDouble(inject.getPath(), 1) == 0) { + warning(reward, inject, "Chance can not be 0"); + } else if (data.getDouble(inject.getPath(), 1) < 0) { + warning(reward, inject, "Chance can not be negative"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDate.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDate.java new file mode 100644 index 000000000..e9df827a2 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDate.java @@ -0,0 +1,112 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import java.time.DayOfWeek; +import java.time.LocalDateTime; +import java.time.Month; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditDate; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementDate { + + private RequirementDate() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectConfigurationSection("Date") { + @Override + public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + RewardOptions rewardOptions) { + LocalDateTime now = LocalDateTime.now(); + if (section.isString("WeekDay")) { + String requiredWeekDay = section.getString("WeekDay").toUpperCase(); + if (!now.getDayOfWeek().name().equals(requiredWeekDay)) { + debug("WeekDay does not match: " + requiredWeekDay); + return false; + } + } else if (section.isInt("WeekDay")) { + int requiredWeekDay = section.getInt("WeekDay"); + if (now.getDayOfWeek().getValue() != requiredWeekDay) { + debug("WeekDay does not match: " + requiredWeekDay); + return false; + } + } + if (section.isInt("DayOfMonth")) { + int requiredDayOfMonth = section.getInt("DayOfMonth"); + if (now.getDayOfMonth() != requiredDayOfMonth) { + debug("DayOfMonth does not match: " + requiredDayOfMonth); + return false; + } + } + if (section.isString("Month")) { + String requiredMonth = section.getString("Month").toUpperCase(); + if (!now.getMonth().name().equals(requiredMonth)) { + debug("Month does not match: " + requiredMonth); + return false; + } + } + return true; + } + }.priority(90).validator(new RequirementInjectValidator() { + @Override + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + if (!data.isConfigurationSection("Date")) { + return; + } + ConfigurationSection section = data.getConfigurationSection("Date"); + if (section.isString("WeekDay")) { + try { + DayOfWeek.valueOf(section.getString("WeekDay").toUpperCase()); + } catch (IllegalArgumentException e) { + warning(reward, inject, "Invalid WeekDay: " + section.getString("WeekDay")); + } + } else if (section.isInt("WeekDay")) { + int weekDay = section.getInt("WeekDay"); + if (weekDay < 1 || weekDay > 7) { + warning(reward, inject, "Invalid WeekDay: " + weekDay); + } + } + if (section.isInt("DayOfMonth")) { + int day = section.getInt("DayOfMonth"); + if (day < 1 || day > 31) { + warning(reward, inject, "Invalid DayOfMonth: " + day); + } + } + if (section.isString("Month")) { + try { + Month.valueOf(section.getString("Month").toUpperCase()); + } catch (IllegalArgumentException e) { + warning(reward, inject, "Invalid Month: " + section.getString("Month")); + } + } + } + }).addEditButton(new EditGUIButton(new ItemBuilder("PAPER"), new EditGUIValueInventory("Date") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditDate() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Edit date-based requirements for the reward")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDayOfMonth.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDayOfMonth.java new file mode 100644 index 000000000..4cb3dd463 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementDayOfMonth.java @@ -0,0 +1,61 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementDayOfMonth { + + private RequirementDayOfMonth() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectConfigurationSection("DayOfMonth") { + @Override + public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection data, + RewardOptions rewardOptions) { + if (!data.getBoolean("Enabled", false)) { + return true; + } + List days = data.getIntegerList("Days"); + return days.contains(LocalDateTime.now().getDayOfMonth()); + } + }.priority(100).addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Days", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Set the days of the month for the requirement"))) + .validator(new RequirementInjectValidator() { + @Override + @SuppressWarnings("unchecked") + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + List days = (List) data.getList("Days", null); + if (days != null && days.isEmpty()) { + warning(reward, inject, "No days specified for DayOfMonth requirement"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementJavascript.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementJavascript.java new file mode 100644 index 000000000..4ca7a2cc3 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementJavascript.java @@ -0,0 +1,53 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.javascript.JavascriptEngine; +import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementJavascript { + + private RequirementJavascript() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectString("JavascriptExpression", "") { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String expression, + RewardOptions rewardOptions) { + return expression.equals("") || new JavascriptEngine().addPlayer(user.getOfflinePlayer()) + .getBooleanValue(PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), + PlaceholderUtils.replacePlaceHolder(expression, rewardOptions.getPlaceholders()))); + } + }.priority(90).addEditButton(new EditGUIButton(new ItemBuilder("DETECTOR_RAIL"), + new EditGUIValueString("JavascriptExpression", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + } + }.addLore("Javascript expression required to run reward"))).validator(new RequirementInjectValidator() { + @Override + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + String str = data.getString("JavascriptExpression", null); + if (str != null && str.isEmpty()) { + warning(reward, inject, "No javascript expression set"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementLocationDistance.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementLocationDistance.java new file mode 100644 index 000000000..008b818f5 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementLocationDistance.java @@ -0,0 +1,83 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditLocationDistance; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementLocationDistance { + + private RequirementLocationDistance() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectConfigurationSection("LocationDistance") { + @Override + public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + RewardOptions rewardOptions) { + if (!user.isOnline()) { + plugin.debug("user not online"); + return false; + } + World world = Bukkit.getWorld(section.getString("World")); + if (world == null) { + plugin.debug("Invalid world for LocationDistance"); + return false; + } + Location loc = new Location(world, section.getInt("X"), section.getInt("Y"), section.getInt("Z")); + Location playerLocation = user.getPlayer().getLocation(); + if (!loc.getWorld().getName().equals(playerLocation.getWorld().getName())) { + plugin.debug("Worlds don't match"); + return false; + } + return playerLocation.distance(loc) < section.getInt("Distance"); + } + }.priority(90).validator(new RequirementInjectValidator() { + @Override + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + if (!data.isConfigurationSection("LocationDistance")) { + return; + } + ConfigurationSection section = data.getConfigurationSection("LocationDistance"); + try { + new Location(Bukkit.getWorld(section.getString("World")), section.getInt("X"), section.getInt("Y"), + section.getInt("Z")); + } catch (Exception e) { + warning(reward, inject, "Failed to get location for LocationDistance"); + e.printStackTrace(); + } + if (section.getInt("Distance") < 0) { + warning(reward, inject, "Invalid distance for LocationDistance"); + } + } + }).addEditButton(new EditGUIButton(new ItemBuilder("MAP"), new EditGUIValueInventory("LocationDistance") { + @Override + public void openInventory(ClickEvent clickEvent) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + new RewardEditLocationDistance() { + @Override + public void setVal(String key, Object value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(key, value); + plugin.reloadAdvancedCore(false); + } + }.open(clickEvent.getPlayer(), reward); + } + }.addLore("Require player to be within a certain distance of location to get reward")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementPermission.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementPermission.java new file mode 100644 index 000000000..3783329f1 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementPermission.java @@ -0,0 +1,88 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import java.util.UUID; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueBoolean; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.PlayerManager; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementPermission { + + private RequirementPermission() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectString("Permission", "") { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String str, + RewardOptions rewardOptions) { + if (!reward.getConfig().getRequirePermission()) { + return true; + } + if (str.isEmpty()) { + str = "AdvancedCore.Reward." + reward.getName(); + } + + boolean reverse = false; + if (str.startsWith("!")) { + reverse = true; + str = str.substring(1); + debug("Doing permission check in reverse"); + } + + boolean perm = PlayerManager.getInstance().hasServerPermission(UUID.fromString(user.getUUID()), + user.getPlayerName(), str); + if (reverse) { + perm = !perm; + } + if (!perm) { + debug(user.getPlayerName() + " does not have permission " + str + " to get reward " + + reward.getName() + ", reverse: " + reverse); + return false; + } + return true; + } + }.priority(100).alwaysForce().addEditButton( + new EditGUIButton(new ItemBuilder("IRON_DOOR"), new EditGUIValueString("Permission", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Set permission required to be given, set RequirePermission to true if using this"))) + .addEditButton(new EditGUIButton(new EditGUIValueBoolean("RequirePermission", null) { + @Override + public void setValue(Player player, boolean value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("If true, permission is required to run reward"))) + .validator(new RequirementInjectValidator() { + @Override + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + if (!data.getBoolean("RequirePermission", false) + && !data.getString("Permission", "").isEmpty()) { + warning(reward, inject, "Detected permission set but RequirePermission is false"); + } + } + }.addPath("RequirePermission"))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardExpiration.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardExpiration.java new file mode 100644 index 000000000..2b8612261 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardExpiration.java @@ -0,0 +1,51 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectInt; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementRewardExpiration { + + private RequirementRewardExpiration() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectInt("RewardExpiration", -1) { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, int num, + RewardOptions rewardOptions) { + if (rewardOptions.getOrginalTrigger() > 0) { + long execDate = rewardOptions.getOrginalTrigger(); + debug("OrgTrigger: " + execDate + ", plus time: " + (execDate + num * 60 * 1000) + + ", current time: " + System.currentTimeMillis()); + return execDate + num * 60 * 1000 > System.currentTimeMillis(); + } + if (rewardOptions.getPlaceholders().containsKey("ExecDate") && num > 0) { + long execDate = Long.parseLong(rewardOptions.getPlaceholders().get("ExecDate")); + debug("ExecDate: " + execDate + ", plus time: " + (execDate + num * 60 * 1000) + + ", current time: " + System.currentTimeMillis()); + return execDate + num * 60 * 1000 > System.currentTimeMillis(); + } + return true; + } + }.priority(100).addEditButton( + new EditGUIButton(new ItemBuilder("CLOCK"), new EditGUIValueNumber("RewardExpiration", null) { + @Override + public void setValue(Player player, Number value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value.intValue()); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Time before reward expires, if not executed").addLore("In minutes")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardType.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardType.java new file mode 100644 index 000000000..af72c0195 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementRewardType.java @@ -0,0 +1,49 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementRewardType { + + private RequirementRewardType() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectString("RewardType", "BOTH") { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String type, + RewardOptions rewardOptions) { + if (rewardOptions.isOnline()) { + if (type.equalsIgnoreCase("offline")) { + debug("Reward Type Don't match"); + return false; + } + } else if (type.equalsIgnoreCase("online")) { + debug("Reward Type Don't match"); + return false; + } + return true; + } + }.priority(100).addEditButton( + new EditGUIButton(new ItemBuilder("REDSTONE_TORCH"), new EditGUIValueString("RewardType", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addOptions("ONLINE", "OFFLINE", "BOTH") + .addLore("Define whether should execute if player was offline/online")))); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementServer.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementServer.java new file mode 100644 index 000000000..f608ae66d --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementServer.java @@ -0,0 +1,101 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import java.util.ArrayList; + +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectStringList; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.simpleapi.array.ArrayUtils; + +public final class RequirementServer { + + private RequirementServer() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectString("Server", "") { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String str, + RewardOptions rewardOptions) { + String serverToMatch = str; + boolean hadPlaceholder = false; + if (str.isEmpty()) { + if (rewardOptions.getPlaceholders().containsKey("Server")) { + serverToMatch = rewardOptions.getPlaceholders().get("Server"); + hadPlaceholder = true; + } else if (!rewardOptions.getServer().isEmpty()) { + serverToMatch = rewardOptions.getServer(); + } + } + String currentServer = plugin.getOptions().getServer(); + if (!serverToMatch.isEmpty()) { + debug("Current Server: " + currentServer + ", ServerToMatch: " + serverToMatch); + boolean matched = serverToMatch.equalsIgnoreCase(currentServer); + if (!matched && !hadPlaceholder) { + rewardOptions.addPlaceholder("Server", serverToMatch); + } + return matched; + } + return true; + } + }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueString("Server", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + } + }.addOptions(Bukkit.getServer().getName()).addLore("Server to execute reward on")))); + + handler.getInjectedRequirements().add(new RequirementInjectStringList("BlockedServers", new ArrayList<>()) { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList servers, + RewardOptions rewardOptions) { + if (servers.isEmpty()) { + return true; + } + String currentServer = plugin.getOptions().getServer(); + if (ArrayUtils.containsIgnoreCase(servers, currentServer)) { + debug("Current server is in blocked servers list: " + currentServer + " " + servers); + return false; + } + return true; + } + }.priority(100).allowReattempt().addEditButton( + new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("BlockedServers", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("List of servers for reward not to run on"))).validator(new RequirementInjectValidator() { + @Override + @SuppressWarnings("unchecked") + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + ArrayList list = (ArrayList) data.getList("BlockedServers", null); + if (list != null && list.isEmpty()) { + warning(reward, inject, "No blocked servers were listed"); + } + } + })); + } +} diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java new file mode 100644 index 000000000..014fd04e4 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java @@ -0,0 +1,144 @@ +package com.bencodez.advancedcore.rewards.builtin.requirements; + +import java.util.ArrayList; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectStringList; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +public final class RequirementWorld { + + private RequirementWorld() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRequirements().add(new RequirementInjectStringList("Worlds", new ArrayList<>()) { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList worlds, + RewardOptions rewardOptions) { + if (worlds.isEmpty()) { + if (plugin.getOptions().getDefaultRewardWorlds().isEmpty() || !rewardOptions.isUseDefaultWorlds()) { + debug("No whitelisted worlds specified"); + return true; + } + Player player = user.getPlayer(); + if (player == null) { + debug("No player"); + return false; + } + reward.checkRewardFile(); + String world = player.getWorld().getName(); + if (plugin.getOptions().getDefaultRewardWorlds().contains(world)) { + debug("Player in default whitelisted world: " + world); + return true; + } + user.setCheckWorld(true); + debug("Player not in default whitelisted world: " + world); + return false; + } + + Player player = user.getPlayer(); + if (player == null) { + debug("No player"); + return false; + } + reward.checkRewardFile(); + String world = player.getWorld().getName(); + if (worlds.contains(world)) { + debug("Player in whitelisted world: " + world); + return true; + } + user.setCheckWorld(true); + debug("Player not in whitelisted world: " + world); + return false; + } + }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( + new EditGUIButton(new ItemBuilder("END_PORTAL_FRAME"), new EditGUIValueList("Worlds", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Worlds to execute reward in, only executes into one reward"))) + .validator(listValidator("Worlds")); + + handler.getInjectedRequirements().add(new RequirementInjectStringList("BlackListedWorlds", new ArrayList<>()) { + @Override + public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList worlds, + RewardOptions rewardOptions) { + if (worlds.isEmpty()) { + if (plugin.getOptions().getDefaultRewardBlackListedWorlds().isEmpty() + || !rewardOptions.isUseDefaultWorlds()) { + debug("No blacklisted worlds specified"); + return true; + } + Player player = user.getPlayer(); + if (player == null) { + debug("No player"); + return false; + } + reward.checkRewardFile(); + String world = player.getWorld().getName(); + if (plugin.getOptions().getDefaultRewardBlackListedWorlds().contains(world)) { + user.setCheckWorld(true); + debug("Player in default blacklisted world: " + world); + return false; + } + debug("Player not in default blacklisted worlds"); + return true; + } + + Player player = user.getPlayer(); + if (player == null) { + debug("No player"); + return false; + } + reward.checkRewardFile(); + String world = player.getWorld().getName(); + if (worlds.contains(world)) { + user.setCheckWorld(true); + debug("Player in default blacklisted world: " + world); + return false; + } + debug("Player not in blacklisted worlds"); + return true; + } + }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( + new EditGUIButton(new ItemBuilder("END_PORTAL_FRAME"), new EditGUIValueList("BlackListedWorlds", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Worlds to never execute the reward in"))).validator(listValidator("BlackListedWorlds")); + } + + private static RequirementInjectValidator listValidator(String path) { + return new RequirementInjectValidator() { + @Override + @SuppressWarnings("unchecked") + public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { + ArrayList list = (ArrayList) data.getList(path, null); + if (list != null && list.isEmpty()) { + warning(reward, inject, "No worlds were listed"); + } + } + }; + } +} From d535bbafc49d8a7774c8053a8c06afde81a889dc Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:18:03 -0600 Subject: [PATCH 02/20] Delegate built-in reward registration --- .../api/rewards/RewardHandler.java | 3844 ++++------------- 1 file changed, 760 insertions(+), 3084 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/rewards/RewardHandler.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/rewards/RewardHandler.java index 64e5f5439..ea3533d32 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/rewards/RewardHandler.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/api/rewards/RewardHandler.java @@ -1,596 +1,532 @@ -package com.bencodez.advancedcore.api.rewards; - -import java.io.File; -import java.text.DecimalFormat; -import java.time.DayOfWeek; -import java.time.LocalDateTime; -import java.time.Month; -import java.util.ArrayList; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map.Entry; -import java.util.Set; -import java.util.UUID; -import java.util.concurrent.CopyOnWriteArrayList; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.ThreadLocalRandom; -import java.util.concurrent.TimeUnit; - -import org.bukkit.Bukkit; -import org.bukkit.Location; -import org.bukkit.Material; -import org.bukkit.World; -import org.bukkit.configuration.Configuration; -import org.bukkit.configuration.ConfigurationSection; -import org.bukkit.configuration.file.FileConfiguration; -import org.bukkit.entity.Player; - -import com.bencodez.advancedcore.AdvancedCorePlugin; -import com.bencodez.advancedcore.api.exceptions.FileDirectoryException; -import com.bencodez.advancedcore.api.inventory.BInventory.ClickEvent; -import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueBoolean; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueInventory; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueNumber; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; -import com.bencodez.advancedcore.api.item.ItemBuilder; -import com.bencodez.advancedcore.api.javascript.JavascriptEngine; -import com.bencodez.advancedcore.api.messages.PlaceholderUtils; -import com.bencodez.advancedcore.api.misc.MiscUtils; -import com.bencodez.advancedcore.api.misc.PlayerManager; -import com.bencodez.advancedcore.api.misc.effects.FireworkHandler; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditActionBar; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedPriority; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedRandomReward; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditAdvancedWorld; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditBossBar; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditChoices; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditDate; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEXP; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEXPLevels; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditEffect; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditFirework; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditItems; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditJavascript; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditLocationDistance; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditLucky; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditMessages; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditMoney; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditPotions; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditSound; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditSpecialChance; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditTempPermission; -import com.bencodez.advancedcore.api.rewards.editbuttons.RewardEditTitle; -import com.bencodez.advancedcore.api.rewards.injected.RewardInject; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectBoolean; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectDouble; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectInt; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectKeys; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectConfigurationSection; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectDouble; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectInt; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectStringList; -import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectValidator; -import com.bencodez.advancedcore.api.user.AdvancedCoreUser; -import com.bencodez.advancedcore.api.user.UserStartup; -import com.bencodez.advancedcore.command.gui.RewardEditGUI; -import com.bencodez.simpleapi.array.ArrayUtils; -import com.bencodez.simpleapi.messages.MessageAPI; - -import lombok.Getter; -import lombok.Setter; - -/** - * The Class RewardHandler. - */ -public class RewardHandler { - - /** The default folder. */ - private File defaultFolder; - - @Getter - private CopyOnWriteArrayList directlyDefinedRewards = new CopyOnWriteArrayList(); - - @Getter - private CopyOnWriteArrayList subDirectlyDefinedRewards = new CopyOnWriteArrayList(); - - @Getter - private CopyOnWriteArrayList injectedRequirements = new CopyOnWriteArrayList(); - - @Getter - private CopyOnWriteArrayList injectedRewards = new CopyOnWriteArrayList(); - - @Getter - private CopyOnWriteArrayList placeholders = new CopyOnWriteArrayList(); - - AdvancedCorePlugin plugin; - - /** The reward folders. */ - private ArrayList rewardFolders; - - /** The rewards. */ - private List rewards; - - @Getter - private ScheduledExecutorService delayedTimer = Executors.newSingleThreadScheduledExecutor(); - - @Getter - @Setter - private Set validPaths = new HashSet<>(); - - public RewardHandler(AdvancedCorePlugin plugin) { - this.plugin = plugin; - rewardFolders = new ArrayList<>(); - setDefaultFolder(new File(plugin.getDataFolder(), "Rewards")); - } - - public void addDirectlyDefined(DirectlyDefinedReward directlyDefinedReward) { - if (getDirectlyDefined(directlyDefinedReward.getPath()) != null) { - plugin.extraDebug( - "DirectlyDefinedReward with path already exists, skipping: " + directlyDefinedReward.getPath()); - return; - } - plugin.extraDebug("Adding directlydefined reward handle: " + directlyDefinedReward.getPath() - + ", isdirectlydefined: " + directlyDefinedReward.isDirectlyDefined()); - directlyDefinedRewards.add(directlyDefinedReward); - } - - public void addInjectedRequirements(RequirementInject inject) { - injectedRequirements.add(inject); - sortInjectedRequirements(); - } - - public void addInjectedReward(RewardInject inject) { - injectedRewards.add(inject); - sortInjectedRewards(); - } - - public void addPlaceholder(RewardPlaceholderHandle handle) { - placeholders.add(handle); - } - - public void addRewardFolder(File file) { - addRewardFolder(file, true, true); - } - - public void addRewardFolder(File file, boolean load, boolean create) { - if (create) { - file.mkdirs(); - } - if (!file.exists()) { - return; - } - if (file.isDirectory()) { - if (!rewardFolders.contains(file)) { - rewardFolders.add(file); - if (load) { - loadRewards(); - } - } - } else { - plugin.debug(file.getAbsolutePath()); - try { - throw new FileDirectoryException("File is not a directory"); - } catch (FileDirectoryException e) { - e.printStackTrace(); - } - } - } - - public void addSubDirectlyDefined(SubDirectlyDefinedReward subDirectlyDefinedReward) { - plugin.extraDebug("Adding subdirectlydefined reward handle: " + subDirectlyDefinedReward.getFullPath() - + ", isdirectlydefined: " + subDirectlyDefinedReward.isDirectlyDefined()); - subDirectlyDefinedRewards.add(subDirectlyDefinedReward); - } - - public void addValidPath(String path) { - validPaths.add(path); - } - - public void checkDirectlyDefinedRewardFiles() { - ArrayList directlyDefinedPaths = new ArrayList(); - for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { - directlyDefinedPaths.add(direct.getPath().replace(".", "_")); - } - - for (SubDirectlyDefinedReward direct : getSubDirectlyDefinedRewards()) { - directlyDefinedPaths.add(direct.getFullPath().replace(".", "_")); +package com.bencodez.advancedcore.api.rewards; + +import java.io.File; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.Configuration; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.exceptions.FileDirectoryException; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.advancedcore.api.user.UserStartup; +import com.bencodez.advancedcore.command.gui.RewardEditGUI; +import com.bencodez.simpleapi.array.ArrayUtils; + +import lombok.Getter; +import lombok.Setter; + +/** + * The Class RewardHandler. + */ +public class RewardHandler { + + /** The default folder. */ + private File defaultFolder; + + @Getter + private CopyOnWriteArrayList directlyDefinedRewards = new CopyOnWriteArrayList(); + + @Getter + private CopyOnWriteArrayList subDirectlyDefinedRewards = new CopyOnWriteArrayList(); + + @Getter + private CopyOnWriteArrayList injectedRequirements = new CopyOnWriteArrayList(); + + @Getter + private CopyOnWriteArrayList injectedRewards = new CopyOnWriteArrayList(); + + @Getter + private CopyOnWriteArrayList placeholders = new CopyOnWriteArrayList(); + + AdvancedCorePlugin plugin; + + /** The reward folders. */ + private ArrayList rewardFolders; + + /** The rewards. */ + private List rewards; + + @Getter + private ScheduledExecutorService delayedTimer = Executors.newSingleThreadScheduledExecutor(); + + @Getter + @Setter + private Set validPaths = new HashSet<>(); + + public RewardHandler(AdvancedCorePlugin plugin) { + this.plugin = plugin; + rewardFolders = new ArrayList<>(); + setDefaultFolder(new File(plugin.getDataFolder(), "Rewards")); + } + + public void addDirectlyDefined(DirectlyDefinedReward directlyDefinedReward) { + if (getDirectlyDefined(directlyDefinedReward.getPath()) != null) { + plugin.extraDebug( + "DirectlyDefinedReward with path already exists, skipping: " + directlyDefinedReward.getPath()); + return; + } + plugin.extraDebug("Adding directlydefined reward handle: " + directlyDefinedReward.getPath() + + ", isdirectlydefined: " + directlyDefinedReward.isDirectlyDefined()); + directlyDefinedRewards.add(directlyDefinedReward); + } + + public void addInjectedRequirements(RequirementInject inject) { + injectedRequirements.add(inject); + sortInjectedRequirements(); + } + + public void addInjectedReward(RewardInject inject) { + injectedRewards.add(inject); + sortInjectedRewards(); + } + + public void addPlaceholder(RewardPlaceholderHandle handle) { + placeholders.add(handle); + } + + public void addRewardFolder(File file) { + addRewardFolder(file, true, true); + } + + public void addRewardFolder(File file, boolean load, boolean create) { + if (create) { + file.mkdirs(); + } + if (!file.exists()) { + return; + } + if (file.isDirectory()) { + if (!rewardFolders.contains(file)) { + rewardFolders.add(file); + if (load) { + loadRewards(); + } + } + } else { + plugin.debug(file.getAbsolutePath()); + try { + throw new FileDirectoryException("File is not a directory"); + } catch (FileDirectoryException e) { + e.printStackTrace(); + } + } + } + + public void addSubDirectlyDefined(SubDirectlyDefinedReward subDirectlyDefinedReward) { + plugin.extraDebug("Adding subdirectlydefined reward handle: " + subDirectlyDefinedReward.getFullPath() + + ", isdirectlydefined: " + subDirectlyDefinedReward.isDirectlyDefined()); + subDirectlyDefinedRewards.add(subDirectlyDefinedReward); + } + + public void addValidPath(String path) { + validPaths.add(path); + } + + public void checkDirectlyDefinedRewardFiles() { + ArrayList directlyDefinedPaths = new ArrayList(); + for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { + directlyDefinedPaths.add(direct.getPath().replace(".", "_")); + } + + for (SubDirectlyDefinedReward direct : getSubDirectlyDefinedRewards()) { + directlyDefinedPaths.add(direct.getFullPath().replace(".", "_")); } for (Reward rewardFile : getRewards()) { if (ArrayUtils.containsIgnoreCase(directlyDefinedPaths, rewardFile.getName())) { plugin.getLogger().warning("Found reward file conflict: " + rewardFile.getName() + ", recommend deleting or renaming file to prevent issues"); - } - } - } - - public void checkDirectlyDefined() { - for (Reward rewardFile : getRewards()) { - File folder = rewardFile.getConfig().getRewardFolder(); - if (folder != null && folder.getName().equalsIgnoreCase("DirectlyDefined")) { - if (hasDirectRewardHandle(rewardFile.getName())) { - rewardFile.getFile().delete(); - } - } - } - loadRewards(); - } - - public void checkSubRewards() { - plugin.extraDebug("Checking directlydefined rewards for sub rewards"); - subDirectlyDefinedRewards = new CopyOnWriteArrayList(); - for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { - checkSubRewards(direct); - } - - plugin.extraDebug("Checking reward file for sub rewards"); - for (Reward reward : getRewards()) { - checkSubRewards(new RewardFileDefinedReward(reward)); - } - } - - public void checkSubRewards(DefinedReward direct) { - for (RewardInject inject : getInjectedRewards()) { - for (SubDirectlyDefinedReward sub : inject.subRewards(direct)) { - addSubDirectlyDefined(sub); - checkSubRewards(sub); - } - } - } - - /** - * Copy file. - * - * @param fileName the file name - */ - private void copyFile(String fileName) { - File file = new File(plugin.getDataFolder(), "Rewards" + File.separator + fileName); - if (!file.exists()) { - plugin.saveResource("Rewards" + File.separator + fileName, true); - } - } - - /** - * Gets the default folder. - * - * @return the default folder - */ - public File getDefaultFolder() { - return defaultFolder; - } - - public DirectlyDefinedReward getDirectlyDefined(String path) { - for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { - if (direct.getPath().equalsIgnoreCase(path)) { - return direct; - } - } - return null; - } - - private String getFileExtension(File file) { - String name = file.getName(); - int lastIndexOf = name.lastIndexOf("."); - if (lastIndexOf == -1) { - return ""; // empty extension - } - return name.substring(lastIndexOf); - } - - public Reward getReward(ConfigurationSection data, String path, RewardOptions rewardOptions) { - if (path == null) { - plugin.getLogger().warning("Path is null, failing to give reward"); - return null; - } - if (data == null) { - plugin.getLogger().warning("ConfigurationSection is null, failing to give reward: " + path); - return null; - } - if (data.isConfigurationSection(path)) { - String rewardName = ""; - String prefix = rewardOptions.getPrefix(); - if (prefix != null && !prefix.equals("")) { - rewardName += prefix + "_"; - } - rewardName += path.replace(".", "_"); - - String suffix = rewardOptions.getSuffix(); - if (suffix != null && !suffix.equals("")) { - rewardName += "_" + suffix; - } - ConfigurationSection section = data.getConfigurationSection(path); - return new Reward(rewardName, section); - } - return null; - } - - /** - * Gets the reward. - * - * @param reward the reward - * @return the reward - */ - public Reward getReward(String reward) { - if (reward == null) { - reward = ""; - } - reward = reward.replace(" ", "_"); - - if (reward.equals("")) { - plugin.getLogger().warning("Tried to get any empty reward file name, renaming to EmptyName"); - reward = "EmptyName"; - } - - if (reward.equalsIgnoreCase("examplebasic") || reward.equalsIgnoreCase("exampleadvanced")) { - plugin.getLogger().warning("Using example rewards as a reward, be carefull"); - } - - for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { - if (direct.getPath().replace(".", "_").equals(reward)) { - plugin.debug("Using directlydefined reward for: " + reward); - return direct.getReward(); - } - } + } + } + } + + public void checkDirectlyDefined() { + for (Reward rewardFile : getRewards()) { + File folder = rewardFile.getConfig().getRewardFolder(); + if (folder != null && folder.getName().equalsIgnoreCase("DirectlyDefined")) { + if (hasDirectRewardHandle(rewardFile.getName())) { + rewardFile.getFile().delete(); + } + } + } + loadRewards(); + } + + public void checkSubRewards() { + plugin.extraDebug("Checking directlydefined rewards for sub rewards"); + subDirectlyDefinedRewards = new CopyOnWriteArrayList(); + for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { + checkSubRewards(direct); + } + + plugin.extraDebug("Checking reward file for sub rewards"); + for (Reward reward : getRewards()) { + checkSubRewards(new RewardFileDefinedReward(reward)); + } + } + + public void checkSubRewards(DefinedReward direct) { + for (RewardInject inject : getInjectedRewards()) { + for (SubDirectlyDefinedReward sub : inject.subRewards(direct)) { + addSubDirectlyDefined(sub); + checkSubRewards(sub); + } + } + } + + /** + * Copy file. + * + * @param fileName the file name + */ + private void copyFile(String fileName) { + File file = new File(plugin.getDataFolder(), "Rewards" + File.separator + fileName); + if (!file.exists()) { + plugin.saveResource("Rewards" + File.separator + fileName, true); + } + } + + /** + * Gets the default folder. + * + * @return the default folder + */ + public File getDefaultFolder() { + return defaultFolder; + } + + public DirectlyDefinedReward getDirectlyDefined(String path) { + for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { + if (direct.getPath().equalsIgnoreCase(path)) { + return direct; + } + } + return null; + } + + private String getFileExtension(File file) { + String name = file.getName(); + int lastIndexOf = name.lastIndexOf("."); + if (lastIndexOf == -1) { + return ""; // empty extension + } + return name.substring(lastIndexOf); + } + + public Reward getReward(ConfigurationSection data, String path, RewardOptions rewardOptions) { + if (path == null) { + plugin.getLogger().warning("Path is null, failing to give reward"); + return null; + } + if (data == null) { + plugin.getLogger().warning("ConfigurationSection is null, failing to give reward: " + path); + return null; + } + if (data.isConfigurationSection(path)) { + String rewardName = ""; + String prefix = rewardOptions.getPrefix(); + if (prefix != null && !prefix.equals("")) { + rewardName += prefix + "_"; + } + rewardName += path.replace(".", "_"); + + String suffix = rewardOptions.getSuffix(); + if (suffix != null && !suffix.equals("")) { + rewardName += "_" + suffix; + } + ConfigurationSection section = data.getConfigurationSection(path); + return new Reward(rewardName, section); + } + return null; + } + + /** + * Gets the reward. + * + * @param reward the reward + * @return the reward + */ + public Reward getReward(String reward) { + if (reward == null) { + reward = ""; + } + reward = reward.replace(" ", "_"); + + if (reward.equals("")) { + plugin.getLogger().warning("Tried to get any empty reward file name, renaming to EmptyName"); + reward = "EmptyName"; + } + + if (reward.equalsIgnoreCase("examplebasic") || reward.equalsIgnoreCase("exampleadvanced")) { + plugin.getLogger().warning("Using example rewards as a reward, be carefull"); + } + + for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { + if (direct.getPath().replace(".", "_").equals(reward)) { + plugin.debug("Using directlydefined reward for: " + reward); + return direct.getReward(); + } + } for (SubDirectlyDefinedReward direct : getSubDirectlyDefinedRewards()) { if (matchesSubDirectlyDefined(direct, reward)) { plugin.debug("Using subdirectlydefined reward for: " + reward); return direct.getReward(); } - } - - for (Reward rewardFile : getRewards()) { - if (rewardFile.getName().equalsIgnoreCase(reward)) { - return rewardFile; - } - } - - return new Reward(reward); - } - - public Reward getRewardDirectlyDefined(String reward) { - if (reward == null) { - reward = ""; - } - reward = reward.replace(" ", "_"); - - for (Reward rewardFile : getRewards()) { - File folder = rewardFile.getConfig().getRewardFolder(); - if (folder != null && folder.getName().equalsIgnoreCase("DirectlyDefined")) { - if (rewardFile.getName().equalsIgnoreCase(reward)) { - return rewardFile; - } - } - } - - if (reward.equals("")) { - plugin.getLogger().warning("Tried to get any empty reward file name, renaming to EmptyName"); - reward = "EmptyName"; - } - - if (reward.equalsIgnoreCase("examplebasic") || reward.equalsIgnoreCase("exampleadvanced")) { - plugin.getLogger().warning("Using example rewards as a reward, becarefull"); - } - - File directFolder = new File(getDefaultFolder().getAbsolutePath() + File.separator + "DirectlyDefined"); - directFolder.mkdirs(); - return new Reward(directFolder, reward); - } - - /** - * Gets the reward files. - * - * @param folder the folder - * @return the reward files - */ - public ArrayList getRewardFiles(File folder) { - ArrayList fileNames = new ArrayList(); - if (folder != null && folder.exists()) { - File[] files = folder.listFiles(); - if (files == null) { - return fileNames; - } - for (File file : files) { - if (getFileExtension(file).equals(".yml")) { - fileNames.add(file.getName()); - } - } - } - return fileNames; - } - - /** - * Gets the reward names. - * - * @param file the file - * @return the reward names - */ - public ArrayList getRewardNames(File file) { - ArrayList rewardFiles = getRewardFiles(file); - if (rewardFiles == null) { - return new ArrayList<>(); - } - for (int i = 0; i < rewardFiles.size(); i++) { - if (rewardFiles.get(i).contains(".yml")) { - rewardFiles.set(i, rewardFiles.get(i).replace(".yml", "")); - } else { - plugin.debug("Not a proper reward file: " + rewardFiles.get(i)); - } - - } - - Collections.sort(rewardFiles, String.CASE_INSENSITIVE_ORDER); - - return rewardFiles; - } - - /** - * Gets the rewards. - * - * @return the rewards - */ - public List getRewards() { - if (rewards == null) { - rewards = Collections.synchronizedList(new ArrayList()); - } - return rewards; - } - + } + + for (Reward rewardFile : getRewards()) { + if (rewardFile.getName().equalsIgnoreCase(reward)) { + return rewardFile; + } + } + + return new Reward(reward); + } + + public Reward getRewardDirectlyDefined(String reward) { + if (reward == null) { + reward = ""; + } + reward = reward.replace(" ", "_"); + + for (Reward rewardFile : getRewards()) { + File folder = rewardFile.getConfig().getRewardFolder(); + if (folder != null && folder.getName().equalsIgnoreCase("DirectlyDefined")) { + if (rewardFile.getName().equalsIgnoreCase(reward)) { + return rewardFile; + } + } + } + + if (reward.equals("")) { + plugin.getLogger().warning("Tried to get any empty reward file name, renaming to EmptyName"); + reward = "EmptyName"; + } + + if (reward.equalsIgnoreCase("examplebasic") || reward.equalsIgnoreCase("exampleadvanced")) { + plugin.getLogger().warning("Using example rewards as a reward, becarefull"); + } + + File directFolder = new File(getDefaultFolder().getAbsolutePath() + File.separator + "DirectlyDefined"); + directFolder.mkdirs(); + return new Reward(directFolder, reward); + } + + /** + * Gets the reward files. + * + * @param folder the folder + * @return the reward files + */ + public ArrayList getRewardFiles(File folder) { + ArrayList fileNames = new ArrayList(); + if (folder != null && folder.exists()) { + File[] files = folder.listFiles(); + if (files == null) { + return fileNames; + } + for (File file : files) { + if (getFileExtension(file).equals(".yml")) { + fileNames.add(file.getName()); + } + } + } + return fileNames; + } + + /** + * Gets the reward names. + * + * @param file the file + * @return the reward names + */ + public ArrayList getRewardNames(File file) { + ArrayList rewardFiles = getRewardFiles(file); + if (rewardFiles == null) { + return new ArrayList<>(); + } + for (int i = 0; i < rewardFiles.size(); i++) { + if (rewardFiles.get(i).contains(".yml")) { + rewardFiles.set(i, rewardFiles.get(i).replace(".yml", "")); + } else { + plugin.debug("Not a proper reward file: " + rewardFiles.get(i)); + } + } + + Collections.sort(rewardFiles, String.CASE_INSENSITIVE_ORDER); + return rewardFiles; + } + + /** + * Gets the rewards. + * + * @return the rewards + */ + public List getRewards() { + if (rewards == null) { + rewards = Collections.synchronizedList(new ArrayList()); + } + return rewards; + } + public SubDirectlyDefinedReward getSubDirectlyDefined(String path) { for (SubDirectlyDefinedReward direct : getSubDirectlyDefinedRewards()) { if (matchesSubDirectlyDefined(direct, path)) { return direct; } } - return null; - } - - public void giveChoicesReward(Reward mainReward, AdvancedCoreUser user, String choice) { - RewardBuilder reward = new RewardBuilder(mainReward.getConfig().getConfigData(), - mainReward.getConfig().getChoicesRewardsPath(choice)); - reward.withPrefix(mainReward.getName()); - reward.withPlaceHolder("choice", choice); - reward.send(user); - } - - @SuppressWarnings("unchecked") - public void giveReward(AdvancedCoreUser user, ConfigurationSection data, String path, RewardOptions rewardOptions) { - if (!rewardOptions.isOnlineSet()) { - rewardOptions.setOnline(user.isOnline()); - } - if (path == null) { - plugin.getLogger().warning("Path is null, failing to give reward"); - return; - } - if (data == null) { - plugin.getLogger().warning("ConfigurationSection is null, failing to give reward: " + path); - return; - } - if (plugin == null || !plugin.isEnabled()) { - plugin.getLogger().severe("Not giving reward " + path + ", plugin is not enabled"); - return; - } - if (data.isList(path)) { - ArrayList rewards = (ArrayList) data.getList(path, new ArrayList<>()); - if (rewards.isEmpty()) { - plugin.debug( - "Not giving empty list of rewards from " + path + ", Options: " + rewardOptions.toString()); - } else { - plugin.debug("Giving list of rewards (" + ArrayUtils.makeStringList(rewards) + ") from " + path - + ", Options: " + rewardOptions.toString() + " to " + user.getPlayerName() + "/" - + user.getUUID()); - for (String reward : rewards) { - giveReward(user, reward, rewardOptions); - } - } - } else if (data.isConfigurationSection(path)) { - String rewardName = ""; - String prefix = rewardOptions.getPrefix(); - if (prefix != null && !prefix.equals("")) { - rewardName += prefix + "_"; - } - rewardName += path.replace(".", "_"); - - String suffix = rewardOptions.getSuffix(); - if (suffix != null && !suffix.equals("")) { - rewardName += "_" + suffix; - } - DirectlyDefinedReward direct = getDirectlyDefined(path); - SubDirectlyDefinedReward sub = getSubDirectlyDefined(rewardName); - if (suffix != null && prefix != null && (direct != null || sub != null)) { - if (direct != null) { - Reward reward = direct.getReward(); - if (reward != null) { - plugin.debug("Giving directlydefined reward " + path + ", Options: " + rewardOptions.toString() - + " to " + user.getPlayerName() + "/" + user.getUUID()); - giveReward(user, reward, rewardOptions); - } else { - plugin.debug("Failed to give directlydefined reward " + path + ", Options: " - + rewardOptions.toString() + ", Reward == null"); - } - } else { - Reward reward = sub.getReward(); - if (reward != null) { - plugin.debug("Giving subdirectlydefined reward " + rewardName + ", Options: " - + rewardOptions.toString() + " to " + user.getPlayerName() + "/" + user.getUUID()); - giveReward(user, reward, rewardOptions); - } else { - plugin.debug("Failed to give subdirectlydefined reward " + path + ", Options: " - + rewardOptions.toString() + ", Reward == null"); - } - } - } else { - ConfigurationSection section = data.getConfigurationSection(path); - Reward reward = new Reward(rewardName, section); - reward.checkRewardFile(); - plugin.debug("Giving reward " + path + ", Options: " + rewardOptions.toString() + " to " - + user.getPlayerName() + "/" + user.getUUID()); - giveReward(user, reward, rewardOptions); - } - } else { - String reward = data.getString(path, ""); - if (!reward.isEmpty()) { - plugin.debug("Giving reward " + reward + " from path " + path + ", Options: " + rewardOptions.toString() - + " to " + user.getPlayerName() + "/" + user.getUUID()); - giveReward(user, reward, rewardOptions); - } else { - plugin.debug("Not giving reward " + reward + " from path " + path + ", Options: " - + rewardOptions.toString()); - } - } - } - - public void giveReward(AdvancedCoreUser user, Reward reward, RewardOptions rewardOptions) { - if (reward != null) { - // make sure reward is async to avoid issues - if (Bukkit.isPrimaryThread()) { - plugin.getBukkitScheduler().runTaskAsynchronously(plugin, new Runnable() { - - @Override - public void run() { - reward.giveReward(user, rewardOptions); - } - }); - } else { - reward.giveReward(user, rewardOptions); - } - } else { - plugin.debug("Reward == null"); - } - - } - - public void giveReward(AdvancedCoreUser user, String reward, RewardOptions rewardOptions) { - if (!reward.equals("")) { - if (reward.startsWith("/")) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), reward, - rewardOptions.getPlaceholders()); - return; - } - giveReward(user, getReward(reward), rewardOptions); - } - } - - public boolean hasDirectRewardHandle(String reward) { - for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { - if (direct.getPath().replace(".", "_").equals(reward)) { - return true; - } - } + return null; + } + + public void giveChoicesReward(Reward mainReward, AdvancedCoreUser user, String choice) { + RewardBuilder reward = new RewardBuilder(mainReward.getConfig().getConfigData(), + mainReward.getConfig().getChoicesRewardsPath(choice)); + reward.withPrefix(mainReward.getName()); + reward.withPlaceHolder("choice", choice); + reward.send(user); + } + @SuppressWarnings("unchecked") + public void giveReward(AdvancedCoreUser user, ConfigurationSection data, String path, RewardOptions rewardOptions) { + if (!rewardOptions.isOnlineSet()) { + rewardOptions.setOnline(user.isOnline()); + } + if (path == null) { + plugin.getLogger().warning("Path is null, failing to give reward"); + return; + } + if (data == null) { + plugin.getLogger().warning("ConfigurationSection is null, failing to give reward: " + path); + return; + } + if (plugin == null || !plugin.isEnabled()) { + plugin.getLogger().severe("Not giving reward " + path + ", plugin is not enabled"); + return; + } + if (data.isList(path)) { + ArrayList rewards = (ArrayList) data.getList(path, new ArrayList<>()); + if (rewards.isEmpty()) { + plugin.debug( + "Not giving empty list of rewards from " + path + ", Options: " + rewardOptions.toString()); + } else { + plugin.debug("Giving list of rewards (" + ArrayUtils.makeStringList(rewards) + ") from " + path + + ", Options: " + rewardOptions.toString() + " to " + user.getPlayerName() + "/" + + user.getUUID()); + for (String reward : rewards) { + giveReward(user, reward, rewardOptions); + } + } + } else if (data.isConfigurationSection(path)) { + String rewardName = ""; + String prefix = rewardOptions.getPrefix(); + if (prefix != null && !prefix.equals("")) { + rewardName += prefix + "_"; + } + rewardName += path.replace(".", "_"); + + String suffix = rewardOptions.getSuffix(); + if (suffix != null && !suffix.equals("")) { + rewardName += "_" + suffix; + } + DirectlyDefinedReward direct = getDirectlyDefined(path); + SubDirectlyDefinedReward sub = getSubDirectlyDefined(rewardName); + if (suffix != null && prefix != null && (direct != null || sub != null)) { + if (direct != null) { + Reward reward = direct.getReward(); + if (reward != null) { + plugin.debug("Giving directlydefined reward " + path + ", Options: " + rewardOptions.toString() + + " to " + user.getPlayerName() + "/" + user.getUUID()); + giveReward(user, reward, rewardOptions); + } else { + plugin.debug("Failed to give directlydefined reward " + path + ", Options: " + + rewardOptions.toString() + ", Reward == null"); + } + } else { + Reward reward = sub.getReward(); + if (reward != null) { + plugin.debug("Giving subdirectlydefined reward " + rewardName + ", Options: " + + rewardOptions.toString() + " to " + user.getPlayerName() + "/" + user.getUUID()); + giveReward(user, reward, rewardOptions); + } else { + plugin.debug("Failed to give subdirectlydefined reward " + path + ", Options: " + + rewardOptions.toString() + ", Reward == null"); + } + } + } else { + ConfigurationSection section = data.getConfigurationSection(path); + Reward reward = new Reward(rewardName, section); + reward.checkRewardFile(); + plugin.debug("Giving reward " + path + ", Options: " + rewardOptions.toString() + " to " + + user.getPlayerName() + "/" + user.getUUID()); + giveReward(user, reward, rewardOptions); + } + } else { + String reward = data.getString(path, ""); + if (!reward.isEmpty()) { + plugin.debug("Giving reward " + reward + " from path " + path + ", Options: " + rewardOptions.toString() + + " to " + user.getPlayerName() + "/" + user.getUUID()); + giveReward(user, reward, rewardOptions); + } else { + plugin.debug("Not giving reward " + reward + " from path " + path + ", Options: " + + rewardOptions.toString()); + } + } + } + + public void giveReward(AdvancedCoreUser user, Reward reward, RewardOptions rewardOptions) { + if (reward != null) { + // make sure reward is async to avoid issues + if (Bukkit.isPrimaryThread()) { + plugin.getBukkitScheduler().runTaskAsynchronously(plugin, new Runnable() { + @Override + public void run() { + reward.giveReward(user, rewardOptions); + } + }); + } else { + reward.giveReward(user, rewardOptions); + } + } else { + plugin.debug("Reward == null"); + } + } + + public void giveReward(AdvancedCoreUser user, String reward, RewardOptions rewardOptions) { + if (!reward.equals("")) { + if (reward.startsWith("/")) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), reward, + rewardOptions.getPlaceholders()); + return; + } + giveReward(user, getReward(reward), rewardOptions); + } + } + + public boolean hasDirectRewardHandle(String reward) { + for (DirectlyDefinedReward direct : getDirectlyDefinedRewards()) { + if (direct.getPath().replace(".", "_").equals(reward)) { + return true; + } + } for (SubDirectlyDefinedReward direct : getSubDirectlyDefinedRewards()) { if (matchesSubDirectlyDefined(direct, reward)) { return true; @@ -604,2513 +540,253 @@ private boolean matchesSubDirectlyDefined(SubDirectlyDefinedReward direct, Strin || direct.getFullPath().replace(".", "_").equalsIgnoreCase(reward) || direct.getFullPath().equalsIgnoreCase(reward.replaceAll("_", ".")); } - - public boolean hasRewards(FileConfiguration data, String path) { - if (data.isList(path)) { - if (data.getList(path, new ArrayList<>()).size() != 0) { - return true; - } - } - if (data.isConfigurationSection(path)) { - if (data.getConfigurationSection(path).getKeys(false).size() != 0) { - return true; - } - } - if (data.isString(path)) { - if (!data.getString(path, "").equals("")) { - return true; - } - } - - return false; - - } - - public void loadInjectedRequirements() { - injectedRequirements.clear(); - injectedRequirements.add(new RequirementInjectDouble("Chance", 100) { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, double num, - RewardOptions rewardOptions) { - if (rewardOptions.isIgnoreChance()) { - return true; - } - return MiscUtils.getInstance().checkChance(num, 100); - } - }.priority(100) - .addEditButton(new EditGUIButton(new ItemBuilder("DROPPER"), new EditGUIValueNumber("Chance", null) { - - @Override - public void setValue(Player player, Number value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value.intValue()); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Set chance for reward to execute"))).validator(new RequirementInjectValidator() { - - @Override - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - if (data.getDouble(inject.getPath(), 0) == 100) { - warning(reward, inject, - "Chance is 100, if intended then remove the chance option, as it's unneeded"); - } else if (data.getDouble(inject.getPath(), 0) > 100) { - warning(reward, inject, "Chance is greater than 100, this will always give the reward"); - } else if (data.getDouble(inject.getPath(), 1) == 0) { - warning(reward, inject, "Chance can not be 0"); - } else if (data.getDouble(inject.getPath(), 1) < 0) { - warning(reward, inject, "Chance can not be negative"); - } - } - })); - - injectedRequirements.add(new RequirementInjectInt("RewardExpiration", -1) { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, int num, - RewardOptions rewardOptions) { - if (rewardOptions.getOrginalTrigger() > 0) { - long execDate = rewardOptions.getOrginalTrigger(); - debug("OrgTrigger: " + execDate + ", plus time: " + (execDate + num * 60 * 1000) - + ", current time: " + System.currentTimeMillis()); - if (execDate + num * 60 * 1000 > System.currentTimeMillis()) { - return true; - } else { - return false; - } - } - if (rewardOptions.getPlaceholders().containsKey("ExecDate") && num > 0) { - long execDate = Long.parseLong(rewardOptions.getPlaceholders().get("ExecDate")); - debug("ExecDate: " + execDate + ", plus time: " + (execDate + num * 60 * 1000) + ", current time: " - + System.currentTimeMillis()); - if (execDate + num * 60 * 1000 > System.currentTimeMillis()) { - return true; - } else { - return false; - } - } - return true; - } - }.priority(100).addEditButton( - new EditGUIButton(new ItemBuilder("CLOCK"), new EditGUIValueNumber("RewardExpiration", null) { - - @Override - public void setValue(Player player, Number value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value.intValue()); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Time before reward expires, if not executed").addLore("In minutes")))); - - injectedRequirements.add(new RequirementInjectString("Permission", "") { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String str, - RewardOptions rewardOptions) { - if (!reward.getConfig().getRequirePermission()) { - return true; - } - if (str.isEmpty()) { - str = "AdvancedCore.Reward." + reward.getName(); - } - - boolean reverse = false; - if (str.startsWith("!")) { - reverse = true; - str = str.substring(1); - debug("Doing permission check in reverse"); - } - - boolean perm = PlayerManager.getInstance().hasServerPermission(UUID.fromString(user.getUUID()), - user.getPlayerName(), str); - if (reverse) { - perm = !perm; - } - if (!perm) { - debug(user.getPlayerName() + " does not have permission " + str + " to get reward " - + reward.getName() + ", reverse: " + reverse); - return false; - } - return true; - } - }.priority(100).alwaysForce().addEditButton( - new EditGUIButton(new ItemBuilder("IRON_DOOR"), new EditGUIValueString("Permission", null) { - - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Set permission required to be given, set RequirePermission to true if using this"))) - .addEditButton(new EditGUIButton(new EditGUIValueBoolean("RequirePermission", null) { - - @Override - public void setValue(Player player, boolean value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("If true, permission is required to run reward"))) - .validator(new RequirementInjectValidator() { - - @Override - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - if (!data.getBoolean("RequirePermission", false)) { - if (!data.getString("Permission", "").isEmpty()) { - warning(reward, inject, "Detected permission set but RequirePermission is false"); - } - } - } - }.addPath("RequirePermission"))); - - injectedRequirements.add(new RequirementInjectConfigurationSection("DayOfMonth") { - @Override - public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection data, - RewardOptions rewardOptions) { - if (!data.getBoolean("Enabled", false)) { - return true; - } - - List days = data.getIntegerList("Days"); - int currentDay = LocalDateTime.now().getDayOfMonth(); - - return days.contains(currentDay); - } - }.priority(100) - .addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Days", null) { - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Set the days of the month for the requirement"))) - .validator(new RequirementInjectValidator() { - @Override - @SuppressWarnings("unchecked") - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - List days = (List) data.getList("Days", null); - if (days != null && days.isEmpty()) { - warning(reward, inject, "No days specified for DayOfMonth requirement"); - } - } - })); - - injectedRequirements.add(new RequirementInjectString("Server", "") { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String str, - RewardOptions rewardOptions) { - // set server to match - String serverToMatch = str; - boolean hadPlaceholder = false; - if (str.isEmpty()) { - if (rewardOptions.getPlaceholders().containsKey("Server")) { - serverToMatch = rewardOptions.getPlaceholders().get("Server"); - hadPlaceholder = true; - } else if (!rewardOptions.getServer().isEmpty()) { - serverToMatch = rewardOptions.getServer(); - } - } - String currentServer = AdvancedCorePlugin.getInstance().getOptions().getServer(); - - if (!serverToMatch.isEmpty()) { - debug("Current Server: " + currentServer + ", ServerToMatch: " + serverToMatch); - boolean matched = serverToMatch.equalsIgnoreCase(currentServer); - - if (!matched && !hadPlaceholder) { - // add server for offline reward - rewardOptions.addPlaceholder("Server", serverToMatch); - } - - return matched; - - } - - return true; - } - }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueString("Server", null) { - - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - } - }.addOptions(Bukkit.getServer().getName()).addLore("Server to execute reward on")))); - - injectedRequirements.add(new RequirementInjectStringList("BlockedServers", new ArrayList<>()) { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList servers, - RewardOptions rewardOptions) { - if (servers.isEmpty()) { - return true; - } - - String currentServer = AdvancedCorePlugin.getInstance().getOptions().getServer(); - - if (ArrayUtils.containsIgnoreCase(servers, currentServer)) { - debug("Current server is in blocked servers list: " + currentServer + " " + servers.toString()); - return false; - } - - return true; - } - }.priority(100).allowReattempt().addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("BlockedServers", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("List of servers for reward not to run on"))).validator(new RequirementInjectValidator() { - - @Override - @SuppressWarnings("unchecked") - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - ArrayList list = (ArrayList) data.getList("BlockedServers", null); - if (list != null) { - if (list.isEmpty()) { - warning(reward, inject, "No blocked servers were listed"); - } - } - } - })); - - injectedRequirements.add(new RequirementInjectStringList("Worlds", new ArrayList<>()) { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList worlds, - RewardOptions rewardOptions) { - if (worlds.isEmpty()) { - if (plugin.getOptions().getDefaultRewardWorlds().isEmpty() || !rewardOptions.isUseDefaultWorlds()) { - debug("No whitelisted worlds specified"); - return true; - } - Player player = user.getPlayer(); - if (player == null) { - debug("No player"); - return false; - } - reward.checkRewardFile(); - String world = player.getWorld().getName(); - if (plugin.getOptions().getDefaultRewardWorlds().contains(world)) { - debug("Player in default whitelisted world: " + world); - return true; - } - - user.setCheckWorld(true); - debug("Player not in default whitelisted world: " + world); - return false; - } - - Player player = user.getPlayer(); - if (player == null) { - debug("No player"); - return false; - } - reward.checkRewardFile(); - String world = player.getWorld().getName(); - if (worlds.contains(world)) { - debug("Player in whitelisted world: " + world); - return true; - } - - user.setCheckWorld(true); - debug("Player not in whitelisted world: " + world); - return false; - } - }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( - new EditGUIButton(new ItemBuilder("END_PORTAL_FRAME"), new EditGUIValueList("Worlds", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Worlds to execute reward in, only executes into one reward"))) - .validator(new RequirementInjectValidator() { - - @Override - @SuppressWarnings("unchecked") - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - ArrayList list = (ArrayList) data.getList("Worlds", null); - if (list != null) { - if (list.isEmpty()) { - warning(reward, inject, "No worlds were listed"); - } - } - } - })); - - injectedRequirements.add(new RequirementInjectStringList("BlackListedWorlds", new ArrayList<>()) { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList worlds, - RewardOptions rewardOptions) { - if (worlds.isEmpty()) { - if (plugin.getOptions().getDefaultRewardBlackListedWorlds().isEmpty() - || !rewardOptions.isUseDefaultWorlds()) { - debug("No blacklisted worlds specified"); - return true; - } - Player player = user.getPlayer(); - if (player == null) { - debug("No player"); - return false; - } - reward.checkRewardFile(); - String world = player.getWorld().getName(); - if (plugin.getOptions().getDefaultRewardBlackListedWorlds().contains(world)) { - user.setCheckWorld(true); - debug("Player in default blacklisted world: " + world); - return false; - } - debug("Player not in default blacklisted worlds"); - return true; - } - - Player player = user.getPlayer(); - if (player == null) { - debug("No player"); - return false; - } - reward.checkRewardFile(); - String world = player.getWorld().getName(); - if (worlds.contains(world)) { - user.setCheckWorld(true); - debug("Player in default blacklisted world: " + world); - return false; - } - debug("Player not in blacklisted worlds"); - return true; - } - }.priority(100).allowReattempt().alwaysForceNoData().addEditButton( - new EditGUIButton(new ItemBuilder("END_PORTAL_FRAME"), new EditGUIValueList("BlackListedWorlds", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Worlds to never execute the reward in"))).validator(new RequirementInjectValidator() { - - @Override - @SuppressWarnings("unchecked") - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - ArrayList list = (ArrayList) data.getList("BlackListedWorlds", null); - if (list != null) { - if (list.isEmpty()) { - warning(reward, inject, "No worlds were listed"); - } - } - } - })); - - injectedRequirements.add(new RequirementInjectString("RewardType", "BOTH") { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String type, - RewardOptions rewardOptions) { - if (rewardOptions.isOnline()) { - if (type.equalsIgnoreCase("offline")) { - debug("Reward Type Don't match"); - return false; - } - } else { - if (type.equalsIgnoreCase("online")) { - debug("Reward Type Don't match"); - return false; - } - } - return true; - } - }.priority(100).addEditButton( - new EditGUIButton(new ItemBuilder("REDSTONE_TORCH"), new EditGUIValueString("RewardType", null) { - - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addOptions("ONLINE", "OFFLINE", "BOTH") - .addLore("Define whether should execute if player was offline/online")))); - - injectedRequirements.add(new RequirementInjectString("JavascriptExpression", "") { - - @Override - public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, String expression, - RewardOptions rewardOptions) { - if (expression.equals("") || new JavascriptEngine().addPlayer(user.getOfflinePlayer()) - .getBooleanValue(PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), - PlaceholderUtils.replacePlaceHolder(expression, rewardOptions.getPlaceholders())))) { - return true; - } - return false; - } - }.priority(90).addEditButton(new EditGUIButton(new ItemBuilder("DETECTOR_RAIL"), - new EditGUIValueString("JavascriptExpression", null) { - - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - } - }.addLore("Javascript expression required to run reward"))).validator(new RequirementInjectValidator() { - - @Override - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - String str = data.getString("JavascriptExpression", null); - if (str != null) { - if (str.isEmpty()) { - warning(reward, inject, "No javascript expression set"); - } - } - } - })); - - injectedRequirements.add(new RequirementInjectConfigurationSection("Date") { - @Override - public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - RewardOptions rewardOptions) { - LocalDateTime now = LocalDateTime.now(); - - // Validate WeekDay - if (section.isString("WeekDay")) { - String requiredWeekDay = section.getString("WeekDay").toUpperCase(); - if (!now.getDayOfWeek().name().equals(requiredWeekDay)) { - debug("WeekDay does not match: " + requiredWeekDay); - return false; - } - } else if (section.isInt("WeekDay")) { - int requiredWeekDay = section.getInt("WeekDay"); - if (now.getDayOfWeek().getValue() != requiredWeekDay) { - debug("WeekDay does not match: " + requiredWeekDay); - return false; - } - } - - // Validate DayOfMonth - if (section.isInt("DayOfMonth")) { - int requiredDayOfMonth = section.getInt("DayOfMonth"); - if (now.getDayOfMonth() != requiredDayOfMonth) { - debug("DayOfMonth does not match: " + requiredDayOfMonth); - return false; - } - } - - // Validate Month - if (section.isString("Month")) { - String requiredMonth = section.getString("Month").toUpperCase(); - if (!now.getMonth().name().equals(requiredMonth)) { - debug("Month does not match: " + requiredMonth); - return false; - } - } - - return true; - } - }.priority(90).validator(new RequirementInjectValidator() { - @Override - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - if (!data.isConfigurationSection("Date")) { - return; - } - - ConfigurationSection section = data.getConfigurationSection("Date"); - - // Validate WeekDay - if (section.isString("WeekDay")) { - try { - DayOfWeek.valueOf(section.getString("WeekDay").toUpperCase()); - } catch (IllegalArgumentException e) { - warning(reward, inject, "Invalid WeekDay: " + section.getString("WeekDay")); - } - } else if (section.isInt("WeekDay")) { - int weekDay = section.getInt("WeekDay"); - if (weekDay < 1 || weekDay > 7) { - warning(reward, inject, "Invalid WeekDay: " + weekDay); - } - } - - // Validate DayOfMonth - if (section.isInt("DayOfMonth")) { - int day = section.getInt("DayOfMonth"); - if (day < 1 || day > 31) { - warning(reward, inject, "Invalid DayOfMonth: " + day); - } - } - - // Validate Month - if (section.isString("Month")) { - try { - Month.valueOf(section.getString("Month").toUpperCase()); - } catch (IllegalArgumentException e) { - warning(reward, inject, "Invalid Month: " + section.getString("Month")); - } - } - } - }).addEditButton(new EditGUIButton(new ItemBuilder("PAPER"), new EditGUIValueInventory("Date") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditDate() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Edit date-based requirements for the reward")))); - - injectedRequirements.add(new RequirementInjectConfigurationSection("LocationDistance") { - @Override - public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - RewardOptions rewardOptions) { - if (!user.isOnline()) { - plugin.debug("user not online"); - return false; - } - World world = Bukkit.getWorld(section.getString("World")); - - if (world == null) { - plugin.debug("Invalid world for LocationDistance"); - return false; - } - - Location loc = new Location(world, section.getInt("X"), section.getInt("Y"), section.getInt("Z")); - Location pLoc = user.getPlayer().getLocation(); - if (!loc.getWorld().getName().equals(pLoc.getWorld().getName())) { - plugin.debug("Worlds don't match"); - return false; - } - if (pLoc.distance(loc) < section.getInt("Distance")) { - return true; - } - return false; - } - }.priority(90).validator(new RequirementInjectValidator() { - - @Override - public void onValidate(Reward reward, RequirementInject inject, ConfigurationSection data) { - if (!data.isConfigurationSection("LocationDistance")) { - return; - - } - - ConfigurationSection section = data.getConfigurationSection("LocationDistance"); - - try { - new Location(Bukkit.getWorld(section.getString("World")), section.getInt("X"), section.getInt("Y"), - section.getInt("Z")); - } catch (Exception e) { - warning(reward, inject, "Failed to get location for LocationDistance"); - e.printStackTrace(); - } - - if (section.getInt("Distance") < 0) { - warning(reward, inject, "Invalid distance for LocationDistance"); - } - - } - }).addEditButton(new EditGUIButton(new ItemBuilder("MAP"), new EditGUIValueInventory("LocationDistance") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditLocationDistance() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Require player to be within a certain distance of location to get reward")))); - - for (RequirementInject reward : injectedRequirements) { - reward.setInternalReward(true); - } - - sortInjectedRequirements(); - } - - public void loadInjectedRewards() { - injectedRewards.clear(); - injectedRewards.add(new RewardInjectDouble("Money", 0) { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, double num, - HashMap placeholders) { - user.giveMoney(num); - return "" + (int) num; - } - }.asPlaceholder("Money").priority(100) - .addEditButton(new EditGUIButton(new ItemBuilder(Material.DIAMOND), new EditGUIValueInventory("Money") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditMoney() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Money to execute, may not work on some economy plugins").addLore("Supports random amounts"))) - .validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getDouble(inject.getPath(), -1) == 0) { - warning(reward, inject, "Money can not be 0"); - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("Money") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - double minMoney = section.getDouble("Min", 0); - double maxMoney = section.getDouble("Max", 0); - double value = ThreadLocalRandom.current().nextDouble(minMoney, maxMoney); - - if (section.getBoolean("Round")) { - value = Math.round(value); - user.giveMoney(value); - return "" + value; - } - DecimalFormat f = new DecimalFormat("##.00"); - user.giveMoney(value); - return "" + f.format(value); - } - }.asPlaceholder("Money").priority(100).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - double min = data.getDouble("Money.Min", 0); - double max = data.getDouble("Money.Max", 0); - - if (!data.isConfigurationSection("Money")) { - return; - } - - if (max == 0) { - warning(reward, inject, "Maximum money can not be 0"); - } - - if (min > max) { - warning(reward, inject, "Money.Min can not be greater than Money.Max"); - } - - if (min == max) { - warning(reward, inject, "Money.Min and Money.Max are the same, random range is unnecessary"); - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("NumberCommand") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - int min = section.getInt("Min", 0); - int max = section.getInt("Max", 100); - int number = ThreadLocalRandom.current().nextInt(min, max + 1); - String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); - return String.valueOf(number); - } - }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") - || !data.isString("NumberCommand.Command")) { - warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); - return; - } - - int min = data.getInt("NumberCommand.Min"); - int max = data.getInt("NumberCommand.Max"); - - if (min > max) { - warning(reward, inject, "NumberCommand Min can not be greater than Max"); - } - - if (min == max) { - warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); - } - } - })); - - injectedRewards.add(new RewardInjectInt("EXP", 0) { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, int num, - HashMap placeholders) { - user.giveExp(num); - return null; - } - }.asPlaceholder("EXP").priority(100).addEditButton( - new EditGUIButton(new ItemBuilder("EXPERIENCE_BOTTLE"), new EditGUIValueInventory("EXP") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditEXP() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("EXP to give"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getDouble(inject.getPath(), -1) == 0) { - warning(reward, inject, "EXP can not be 0"); - } - } - })); - - injectedRewards.add(new RewardInjectInt("EXPLevels", 0) { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, int num, - HashMap placeholders) { - user.giveExpLevels(num); - return null; - } - }.asPlaceholder("EXP").priority(100).addEditButton( - new EditGUIButton(new ItemBuilder("EXPERIENCE_BOTTLE"), new EditGUIValueInventory("EXPLevels") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditEXPLevels() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("EXPLevels to give"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getDouble(inject.getPath(), -1) == 0) { - warning(reward, inject, "EXP can not be 0"); - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("EXP") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - int minEXP = section.getInt("Min", 0); - int maxEXP = section.getInt("Max", 0); - int value = ThreadLocalRandom.current().nextInt(minEXP, maxEXP); - user.giveExp(value); - return "" + value; - } - }.asPlaceholder("EXP").priority(100).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - int min = data.getInt("EXP.Min", 0); - int max = data.getInt("EXP.Max", 0); - - if (max == 0) { - warning(reward, inject, "Max EXP can not be 0"); - } - - if (min > max) { - warning(reward, inject, "EXP.Min can not be greater than EXP.Max"); - } - - if (min == max) { - warning(reward, inject, "EXP.Min and EXP.Max are the same, random range is unnecessary"); - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("EXPLevels") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - int minEXP = section.getInt("Min", 0); - int maxEXP = section.getInt("Max", 0); - int value = ThreadLocalRandom.current().nextInt(minEXP, maxEXP); - user.giveExpLevels(value); - return "" + value; - } - }.asPlaceholder("EXP").priority(100).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - int min = data.getInt("EXPLevels.Min", 0); - int max = data.getInt("EXPLevels.Max", 0); - - if (max == 0) { - warning(reward, inject, "Max EXPLevels can not be 0"); - } - - if (min > max) { - warning(reward, inject, "EXPLevels.Min can not be greater than EXPLevels.Max"); - } - - if (min == max) { - warning(reward, inject, - "EXPLevels.Min and EXPLevels.Max are the same, random range is unnecessary"); - } - } - })); - - injectedRewards.add(new RewardInjectString("Message") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - user.sendMessage(value, placeholders); - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder("OAK_SIGN"), new EditGUIValueInventory("Messages") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditMessages() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addCheckKey("Message"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getString(inject.getPath()).isEmpty()) { - warning(reward, inject, "No player message set"); - } - - } - })); - - injectedRewards.add(new RewardInjectStringList("Messages.Player") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, - HashMap placeholders) { - user.sendMessage(value, placeholders); - return null; - } - }); - - injectedRewards.add(new RewardInjectStringList("Message") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, - HashMap placeholders) { - user.sendMessage(value, placeholders); - return null; - } - }); - - injectedRewards.add(new RewardInjectStringList("RandomMessage") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, - HashMap placeholders) { - String msg = value.get(ThreadLocalRandom.current().nextInt(0, value.size())); - user.sendMessage(msg, placeholders); - return null; - } - }); - - injectedRewards.add(new RewardInjectString("Messages.Player") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - user.sendMessage(value, placeholders); - return null; - } - }.validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.isString(inject.getPath()) && data.getString(inject.getPath()).isEmpty()) { - warning(reward, inject, "No player message set"); - } - - } - })); - - injectedRewards.add(new RewardInjectStringList("Messages.Broadcast") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList value, - HashMap placeholders) { - String playerName = user.getPlayerName(); - if (plugin.getOptions().getBroadcastBlacklist().contains(playerName)) { - debug("Not broadcasting for " + playerName + ", in blacklist"); - return null; - } - for (String str : value) { - MiscUtils.getInstance().broadcast(PlaceholderUtils.replacePlaceHolders(user.getPlayer(), - PlaceholderUtils.replacePlaceHolder(str, placeholders))); - } - return null; - } - }.validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - } - })); - - injectedRewards.add(new RewardInjectString("Messages.Broadcast") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - String playerName = user.getPlayerName(); - if (plugin.getOptions().getBroadcastBlacklist().contains(playerName)) { - debug("Not broadcasting for " + playerName + ", in blacklist"); - return null; - } - MiscUtils.getInstance().broadcast(PlaceholderUtils.replacePlaceHolders(user.getPlayer(), - PlaceholderUtils.replacePlaceHolder(value, placeholders))); - return null; - } - }.validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (!data.isList(inject.getPath())) { - if (data.getString(inject.getPath(), "Empty").isEmpty()) { - warning(reward, inject, "No broadcast was set"); - } - } - - } - })); - - injectedRewards.add(new RewardInjectString("Command") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { - - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute single console command"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getString(inject.getPath()).startsWith("/")) { - warning(reward, inject, "Can't start command with /"); - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("ActionBar") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - user.sendActionBar(PlaceholderUtils.replacePlaceHolder(section.getString("Message", ""), placeholders), - section.getInt("Delay", 30)); - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("ActionBar") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditActionBar() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Actionbar configuration"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - String str = data.getString("ActionBar.Message"); - int delay = data.getInt("ActionBar.Delay", -1); - if (str != null && str.isEmpty()) { - warning(reward, inject, "No actionbar message set"); - } - if (delay == -1) { - warning(reward, inject, "No actionbar delay set"); - } else if (delay == 0) { - warning(reward, inject, "Actionbar delay can not be 0"); - } - } - })); - - injectedRewards.add(new RewardInjectStringList("Commands") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (!list.isEmpty()) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), list, placeholders, true); - } - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueList("Commands", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("List of console commands"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.isList(inject.getPath()) && !data.isConfigurationSection(inject.getPath())) { - List list = data.getStringList(inject.getPath()); - if (list != null) { - if (list.isEmpty()) { - warning(reward, inject, "No commands listed"); - } - for (String str : list) { - if (str.startsWith("/")) { - warning(reward, inject, "Commands can not start with /"); - } - } - } - } - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("Commands") { - - @SuppressWarnings("unchecked") - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - ArrayList consoleCommands = (ArrayList) section.getList("Console", new ArrayList<>()); - ArrayList userCommands = (ArrayList) section.getList("Player", new ArrayList<>()); - if (!consoleCommands.isEmpty()) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), consoleCommands, placeholders, - section.getBoolean("Stagger", true)); - } - if (!userCommands.isEmpty()) { - user.preformCommand(userCommands, placeholders); - } - return null; - - } - }.addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Commands.Console", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Old style for console commands"))).addEditButton(new EditGUIButton( - new ItemBuilder(Material.PAPER), new EditGUIValueList("Commands.Player", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute commands as player")))); - - injectedRewards.add(new RewardInjectStringList("Javascripts") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (!list.isEmpty()) { - JavascriptEngine engine = new JavascriptEngine().addPlayer(user.getOfflinePlayer()); - - for (String str : list) { - String expression = PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), str); - engine.execute(PlaceholderUtils.replacePlaceHolder(expression, placeholders)); - } - } - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Javascripts", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Javascript expressions to run")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Javascript") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - if (section.getBoolean("Enabled")) { - String expression = section.getString("Expression"); - expression = PlaceholderUtils.replacePlaceHolders(user.getOfflinePlayer(), expression); - if (new JavascriptEngine().addPlayer(user.getOfflinePlayer()) - .getBooleanValue(PlaceholderUtils.replacePlaceHolder(expression, placeholders))) { - new RewardBuilder(section, "TrueRewards").withPrefix(reward.getName() + ".Javascript") - .send(user); - } else { - new RewardBuilder(section, "FalseRewards").withPrefix(reward.getName() + ".Javascript") - .send(user); - } - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "Javascript.TrueRewards")) { - subs.add(new SubDirectlyDefinedReward(direct, "Javascript.TrueRewards")); - } - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "Javascript.FalseRewards")) { - subs.add(new SubDirectlyDefinedReward(direct, "Javascript.FalseRewards")); - } - return subs; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Javascript") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditJavascript() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Run javascript to run rewards based on expression return value of true/false")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Lucky") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - HashMap luckyRewards = new HashMap<>(); - - for (String str : section.getKeys(false)) { - if (MessageAPI.isInt(str)) { - int num = Integer.parseInt(str); - if (num > 0) { - String path = "Lucky." + num; - luckyRewards.put(num, path); - } - } - } - HashMap map = new LinkedHashMap<>(); - for (Entry entry : luckyRewards.entrySet()) { - if (MiscUtils.getInstance().checkChance(1, entry.getKey())) { - map.put(entry.getValue(), entry.getKey()); - } - } - - map = ArrayUtils.sortByValuesStr(map, false); - if (map.size() > 0) { - if (reward.getConfig().getConfigData().getBoolean("OnlyOneLucky", false)) { - for (Entry entry : map.entrySet()) { - new RewardBuilder(reward.getConfig().getConfigData(), entry.getKey()) - .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); - return null; - } - } else { - for (Entry entry : map.entrySet()) { - new RewardBuilder(reward.getConfig().getConfigData(), entry.getKey()) - .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); - } - } - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Lucky")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "Lucky").getKeys(false)) { - if (MessageAPI.isInt(str)) { - int num = Integer.parseInt(str); - if (num > 0) { - String path = "Lucky." + num; - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + path)) { - subs.add(new SubDirectlyDefinedReward(direct, path)); - } - } - } - } - } - return subs; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Lucky") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditLucky() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - })).priority(10).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - - } - }.addPath("OnlyOneLucky"))); - - injectedRewards.add(new RewardInjectConfigurationSection("Random") { - - @SuppressWarnings("unchecked") - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - if (MiscUtils.getInstance().checkChance(section.getDouble("Chance", 100), 100)) { - if (section.getBoolean("PickRandom", true)) { - ArrayList rewards = (ArrayList) section.getList("Rewards", new ArrayList<>()); - if (rewards != null) { - if (rewards.size() > 0) { - String reward1 = rewards.get(ThreadLocalRandom.current().nextInt(rewards.size())); - if (!reward1.equals("")) { - giveReward(user, reward1, new RewardOptions().setPlaceholders(placeholders)); - } - } - } - } else { - new RewardBuilder(reward.getConfig().getConfigData(), "Random.Rewards") - .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); - } - } else { - new RewardBuilder(reward.getConfig().getConfigData(), "Random.FallBack") - .withPrefix(reward.getName()).withPlaceHolder(placeholders).send(user); - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "Random.Rewards")) { - subs.add(new SubDirectlyDefinedReward(direct, "Random.Rewards")); - } - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "Random.FallBack")) { - subs.add(new SubDirectlyDefinedReward(direct, "Random.FallBack")); - } - return subs; - } - }.priority(10)); - - injectedRewards.add(new RewardInjectConfigurationSection("Rewards") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - plugin.debug("12345c" + reward.getName()); - new RewardBuilder(reward.getConfig().getConfigData(), "Rewards").withPrefix(reward.getName()) - .withPlaceHolder(placeholders).send(user); - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Rewards")) { - subs.add(new SubDirectlyDefinedReward(direct, "Rewards")); - } - return subs; - } - - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.DISPENSER), new EditGUIValueInventory("Rewards") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - openSubReward(clickEvent.getPlayer(), "Rewards", reward); - } - - }.addLore("Sub rewards"))).priority(5).alwaysForce().postReward()); - - injectedRewards.add(new RewardInjectStringList("RandomCommand") { - - @Override - public String onRewardRequest(Reward r, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (list.size() > 0) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), - list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); - } - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute random command"))).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - List list = data.getStringList(inject.getPath()); - if (list.size() == 0) { - warning(reward, inject, "No rewards listed for random reward"); - } else if (list.size() == 1) { - warning(reward, inject, "Only one reward listed for random reward"); - } - } - })); - - injectedRewards.add(new RewardInjectStringList("RandomReward") { - - @Override - public String onRewardRequest(Reward r, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (list.size() > 0) { - String reward = list.get(ThreadLocalRandom.current().nextInt(list.size())); - giveReward(user, reward, new RewardOptions().setPlaceholders(placeholders)); - return reward; - } - return null; - } - }.asPlaceholder("RandomReward").priority(20).addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomReward", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - } - }.addLore("Execute random reward"))).postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("TempPermission") { - - @Override - public String onRewardRequested(Reward r, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - String perm = section.getString("Permission", ""); - int time = section.getInt("Expiration"); - if (!perm.isEmpty()) { - if (time > 0) { - user.addPermission(perm, time); - } else { - extraDebug("Time is 0"); - } - } else { - extraDebug("Permission is empty"); - } - - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("TempPermission") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditTempPermission() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Give temporary permission"))).priority(90).postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("AdvancedRewards") { - - @Override - public String onRewardRequested(Reward r, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - Set keys = section.getKeys(false); - ArrayList rewards = ArrayUtils.convert(keys); - if (rewards.size() > 0) { - for (String reward : rewards) { - giveReward(user, section, reward, new RewardOptions().setPlaceholders(placeholders) - .setPrefix(r.getRewardName() + "_AdvancedRewards_" + reward)); - } - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedRewards")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedRewards") - .getKeys(false)) { - if (direct.getFileData().isConfigurationSection( - direct.getPath() + direct.needsDot() + "AdvancedRewards." + str)) { - subs.add(new SubDirectlyDefinedReward(direct, "AdvancedRewards." + str)); - } - } - } - return subs; - } - }.addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedRewards") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditAdvancedRandomReward() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Execute rewards"))).synchronize().priority(20).postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("AdvancedRandomReward") { - - @Override - public String onRewardRequested(Reward r, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - Set keys = section.getKeys(false); - ArrayList rewards = ArrayUtils.convert(keys); - if (rewards.size() > 0) { - String reward = rewards.get(ThreadLocalRandom.current().nextInt(rewards.size())); - giveReward(user, section, reward, new RewardOptions().setPlaceholders(placeholders) - .setPrefix(r.getRewardName() + "_AdvancedRandomReward")); - return reward; - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedRandomReward")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedRandomReward") - .getKeys(false)) { - if (direct.getFileData().isConfigurationSection( - direct.getPath() + direct.needsDot() + "AdvancedRandomReward." + str)) { - subs.add(new SubDirectlyDefinedReward(direct, "AdvancedRandomReward." + str)); - } - } - } - return subs; - } - }.addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedRandomReward") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditAdvancedRandomReward() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Execute random reward"))).asPlaceholder("RandomReward").synchronize().priority(20) - .postReward()); - - injectedRewards.add(new RewardInjectStringList("Priority") { - - @Override - public String onRewardRequest(Reward r, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - for (String str : list) { - Reward reward = getReward(str); - if (reward.canGiveReward(user, new RewardOptions().withPlaceHolder(placeholders))) { - new RewardBuilder(reward).withPlaceHolder(placeholders).setIgnoreChance(true) - .setIgnoreRequirements(true).send(user); - return reward.getName(); - } - } - return null; - } - }.asPlaceholder("Priority").addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("Priority", null) { - - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute first reward file that can be executed"))).postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("Potions") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - for (String potion : section.getKeys(false)) { - user.givePotionEffect(potion, section.getInt(potion + ".Duration", 1), - section.getInt(potion + ".Amplifier", 1)); - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAINTING), new EditGUIValueInventory("Potions") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditPotions() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure Potion Effects")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Title") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - if (section.getBoolean("Enabled")) { - user.sendTitle(PlaceholderUtils.replacePlaceHolder(section.getString("Title"), placeholders), - - PlaceholderUtils.replacePlaceHolder(section.getString("SubTitle"), placeholders), - - section.getInt("FadeIn", 10), section.getInt("ShowTime", 50), - section.getInt("FadeOut", 10)); - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAINTING), new EditGUIValueInventory("Title") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditTitle() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure Title & SubTitle")))); - - injectedRewards.add(new RewardInjectConfigurationSection("BossBar") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - if (section.getBoolean("Enabled")) { - user.sendBossBar( - PlaceholderUtils.replacePlaceHolder(section.getString("Message", ""), placeholders), - section.getString("Color", "BLUE"), section.getString("Style", "SOLID"), - section.getDouble("Progress", .5), section.getInt("Delay", 30)); - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder("DRAGON_HEAD"), new EditGUIValueInventory("BossBar") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditBossBar() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure bossbar")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Sound") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - - if (section.getBoolean("Enabled")) { - try { - user.playSound(section.getString("Sound"), (float) section.getDouble("Volume", 1.0), - (float) section.getDouble("Pitch", 1.0)); - } catch (Exception ex) { - ex.printStackTrace(); - } - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.NOTE_BLOCK), new EditGUIValueInventory("Sound") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditSound() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure sound")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Effect") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - if (section.getBoolean("Enabled")) { - user.playParticle(section.getString("Effect"), section.getInt("Data", 1), - section.getInt("Particles", 1), section.getInt("Radius", 5)); - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.DIAMOND), new EditGUIValueInventory("Effect") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditEffect() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure particle effect")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Firework") { - - @SuppressWarnings("unchecked") - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - if (section.getBoolean("Enabled")) { - FireworkHandler.getInstance().launchFirework(user.getPlayer().getLocation(), - section.getInt("Power", 1), - (ArrayList) section.getList("Colors", new ArrayList<>()), - (ArrayList) section.getList("FadeOutColor", new ArrayList<>()), - section.getBoolean("Trail"), section.getBoolean("Flicker"), - (ArrayList) section.getList("Types", new ArrayList<>()), - section.getBoolean("Detonate", false)); - } - return null; - - } - }.addEditButton(new EditGUIButton(new ItemBuilder("FIREWORK_ROCKET"), new EditGUIValueInventory("Firework") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditFirework() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - }.addLore("Configure firework effect")))); - - injectedRewards.add(new RewardInjectConfigurationSection("Item") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - ItemBuilder builder = new ItemBuilder(section); - builder.setCheckLoreLength(false); - user.giveItem(builder); - return null; - - } - }.validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - String material = data.getString("Item.Material", ""); - if (material.isEmpty()) { - warning(reward, inject, "No material is set on item"); - } else { - try { - Material m = Material.matchMaterial(material.toUpperCase()); - - // change legacy item - if (m == null) { - m = Material.matchMaterial(material, true); - if (material != null) { - warning(reward, inject, - "Found legacy material: " + material + ", please update material"); - } - } - } catch (NoSuchMethodError e) { - } - } - - } - })); - - injectedRewards.add(new RewardInjectConfigurationSection("AdvancedPriority") { - - @Override - public String onRewardRequested(Reward reward1, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - for (String keys : section.getKeys(false)) { - Reward reward = getReward(section, keys, new RewardOptions()); - if (reward != null - && reward.canGiveReward(user, new RewardOptions().withPlaceHolder(placeholders))) { - plugin.extraDebug("AdvancedPriority: Giving reward " + reward.getName()); - reward.giveReward(user, new RewardOptions().setIgnoreChance(true).setIgnoreRequirements(true) - .setPrefix(reward1.getName() + "_AdvancedPriority").withPlaceHolder(placeholders)); - return reward.getName(); - } - plugin.extraDebug("AdvancedPriority: Can't give reward " + keys); - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedPriority")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedPriority") - .getKeys(false)) { - if (direct.getFileData().isConfigurationSection( - direct.getPath() + direct.needsDot() + "AdvancedPriority." + str)) { - subs.add(new SubDirectlyDefinedReward(direct, "AdvancedPriority." + str)); - } - } - } - return subs; - } - }.addEditButton( - new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedPriority") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditAdvancedPriority() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore( - "AdvancedPriority will run first sub reward that it can, then ignore the rest of the sub rewards") - .addLore("Can be used for permission based rewards or chance based rewards"))) - .priority(10).alwaysValid().postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("AdvancedWorld") { - - @Override - public String onRewardRequested(Reward reward1, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - for (String keys : section.getKeys(false)) { - plugin.extraDebug("AdvancedWorld: Giving reward " + reward1.getName() + "_AdvancedWorld"); - section.set(keys + ".Worlds", ArrayUtils.convert(new String[] { keys })); - giveReward(user, section, keys, new RewardOptions().withPlaceHolder(placeholders) - .setPrefix(reward1.getName() + "_AdvancedWorld")); - } - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedWorld")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "AdvancedWorld") - .getKeys(false)) { - if (direct.getFileData().isConfigurationSection( - direct.getPath() + direct.needsDot() + "AdvancedWorld." + str)) { - subs.add(new SubDirectlyDefinedReward(direct, "AdvancedWorld." + str)); - } - } - } - return subs; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("AdvancedWorld") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - - new RewardEditAdvancedWorld() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - - } - - }.addLore("AdvancedReward will run rewards based worlds specified"))).priority(10).postReward()); - - injectedRewards.add(new RewardInjectConfigurationSection("SpecialChance") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - double totalChance = 0; - LinkedHashMap map = new LinkedHashMap<>(); - for (String key : section.getKeys(false)) { - String path = key; - key = key.replaceAll("_", "."); - if (MessageAPI.isDouble(key)) { - double chance = Double.valueOf(key); - totalChance += chance; - map.put(chance, path); - } - } - - Set> copy = new HashSet<>(map.entrySet()); - double currentNum = 0; - map.clear(); - for (Entry entry : copy) { - currentNum += entry.getKey(); - map.put(currentNum, entry.getValue()); - } - - double randomNum = ThreadLocalRandom.current().nextDouble(totalChance); - - for (Entry entry : map.entrySet()) { - if (randomNum <= entry.getKey()) { - new RewardBuilder(section, entry.getValue()).withPrefix(reward.getName() + "_SpecialChance") - .withPlaceHolder(placeholders).withPlaceHolder("chance", "" + entry.getKey()) - .send(user); - - AdvancedCorePlugin.getInstance().debug("Giving special chance: " + entry.getValue() - + ", Random number: " + randomNum + ", Total chance: " + totalChance); - return null; - } - } - - AdvancedCorePlugin.getInstance().debug("Failed to give special chance"); - - return null; - - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + "SpecialChance")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "SpecialChance") - .getKeys(false)) { - String key = str.replaceAll("_", "."); - if (MessageAPI.isDouble(key)) { - String path = "SpecialChance." + str; - if (direct.getFileData() - .isConfigurationSection(direct.getPath() + direct.needsDot() + path)) { - subs.add(new SubDirectlyDefinedReward(direct, path)); - } - } - } - } - return subs; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("SpecialChance") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditSpecialChance() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Rewards based on chance"))).priority(10).postReward()); - - injectedRewards.add(new RewardInjectKeys("RandomItem") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, - ConfigurationSection data, HashMap placeholders) { - if (section.size() > 0) { - String item = ArrayUtils.pickRandom(ArrayUtils.convert(section)); - ItemBuilder builder = new ItemBuilder(data.getConfigurationSection(item)); - - builder.setCheckLoreLength(false); - user.giveItem(builder); - return item; - } - return null; - } - }.asPlaceholder("RandomItem").priority(90).validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - ConfigurationSection randomItemSection = data.getConfigurationSection("RandomItem"); - if (randomItemSection == null) { - warning(reward, inject, "RandomItem section is missing"); - return; - } - - for (String item : randomItemSection.getKeys(false)) { - String material = randomItemSection.getString(item + ".Material", ""); - if (material.isEmpty()) { - warning(reward, inject, "No material is set on item: " + item); - } else { - try { - Material m = Material.matchMaterial(material.toUpperCase()); - - // change legacy item - if (m == null) { - m = Material.matchMaterial(material.toUpperCase(), true); - if (material != null) { - warning(reward, inject, "Found legacy material: " + material - + ", please update material on RandomItem." + item); - } - } - } catch (NoSuchMethodError e) { - } - } - - } - } - })); - - injectedRewards.add(new RewardInjectBoolean("EnableChoices") { - - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, boolean value, - HashMap placeholders) { - if (value) { - debug("Checking choice rewards"); - // reward.checkRewardFile(); - String choice = user.getChoicePreference(reward.getName()); - if (choice.isEmpty() || choice.equalsIgnoreCase("none")) { - debug("No choice specified"); - user.addUnClaimedChoiceReward(reward.getName()); - } else { - giveChoicesReward(reward, user, choice); - } - } - return null; - } - - @Override - public ArrayList subRewards(DefinedReward direct) { - ArrayList subs = new ArrayList<>(); - if (direct.getFileData().getBoolean(direct.getPath() + direct.needsDot() + "EnableChoices") && direct - .getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + "Choices")) { - for (String str : direct.getFileData() - .getConfigurationSection(direct.getPath() + direct.needsDot() + "Choices").getKeys(false)) { - - String path = "Choices." + str + ".Rewards"; - if (direct.getFileData().isConfigurationSection(direct.getPath() + direct.needsDot() + path)) { - subs.add(new SubDirectlyDefinedReward(direct, path)); - } - - } - } - return subs; - } - }.priority(10).synchronize().validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.getBoolean("EnableChoices")) { - ConfigurationSection choices = data.getConfigurationSection("Choices"); - if (choices == null) { - warning(reward, inject, "Choices section is missing while EnableChoices is true"); - return; - } - if (choices.getKeys(false).size() <= 1) { - warning(reward, inject, "Not enough choices for choice rewards, 1 or less is not a choice"); - } - } - } - }.addPath("Choices")) - .addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Choices") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditChoices() { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addCheckKey("EnableChoices").addLore("Give users a choice on the reward")))); - - injectedRewards.add(new RewardInjectKeys("Items") { - - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, - ConfigurationSection data, HashMap placeholders) { - boolean oneChance = reward.getConfig().getConfigData().getBoolean("OnlyOneItemChance", false); - if (section.size() > 0) { - for (String str : section) { - ItemBuilder builder = new ItemBuilder(data.getConfigurationSection(str)); - builder.setCheckLoreLength(false); - user.giveItem(builder.setPlaceholders(placeholders)); - debug("Giving item " + str + ":" + builder.toString()); - if (builder.isChancePass() && oneChance) { - return str; - } - } - } - return ""; - } - }.priority(90).asPlaceholder("Item").validator(new RewardInjectValidator() { - - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (data.isConfigurationSection("Items")) { - for (String item : data.getConfigurationSection("Items").getKeys(false)) { - String material = data.getString("Items." + item + ".Material", ""); - if (material.isEmpty()) { - try { - Material.valueOf(item); - } catch (Exception e) { - warning(reward, inject, "No material is set on item: " + item); - } - - } else { - try { - Material m = Material.matchMaterial(material.toUpperCase()); - - // check legacy - if (m == null) { - m = Material.matchMaterial(material, true); - if (m != null) { - warning(reward, inject, - "Found legacy material: " + material + ", please update material"); - } else { - warning(reward, inject, "Invalid material set: " + material); - } - } - } catch (NoSuchMethodError e) { - } - } - - if (data.getInt("Items." + item + ".Amount", 0) == 0) { - if (data.getInt("Items." + item + ".MinAmount", 0) == 0 - && data.getInt("Items." + item + ".MaxAmount") == 0) { - warning(reward, inject, "No amount on item: " + item); - } - } - - } - } else { - warning(reward, inject, "Invalid item section"); - } - } - }.addPath("OnlyOneItemChance")) - .addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueInventory("Items") { - - @Override - public void openInventory(ClickEvent clickEvent) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - new RewardEditItems(plugin) { - - @Override - public void setVal(String key, Object value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(key, value); - plugin.reloadAdvancedCore(false); - } - }.open(clickEvent.getPlayer(), reward); - } - - }.addLore("Edit items")))); - - for (RewardInject reward : injectedRewards) { - reward.setInternalReward(true); - } - - sortInjectedRewards(); - } - - /** - * Load rewards. - */ - public void loadRewards() { - rewards = Collections.synchronizedList(new ArrayList()); - setupExample(); - addValidPath("DirectlyDefinedReward"); - addValidPath("Delayed"); - addValidPath("Timed"); - addValidPath("DisplayItem"); - addValidPath("ForceOffline"); - for (File file : rewardFolders) { - loadRewards(file); - } - - sortInjectedRewards(); - sortInjectedRequirements(); - - plugin.debug("Loaded rewards"); - - } - - private void loadRewards(File file) { - for (String reward : getRewardNames(file)) { - if (!reward.equals("")) { - if (!rewardExist(reward)) { - try { - Reward reward1 = new Reward(file, reward); - reward1.validate(); - if (!reward1.getConfig().isDirectlyDefinedReward() - || file.getName().equalsIgnoreCase("DirectlyDefined")) { - rewards.add(reward1); - if (reward1.getConfig().getConfigData().getConfigurationSection("").getKeys(true) - .size() > 0) { - - plugin.extraDebug("Loaded Reward File: " + file.getAbsolutePath() + "/" + reward); - } else { - plugin.debug("Loaded empty reward file" + file.getAbsolutePath() + "/" + reward); - } - } else { - plugin.extraDebug( - "Ignoring directly defined reward file " + file.getAbsolutePath() + "/" + reward); - } - } catch (Exception e) { - plugin.getLogger().severe("Failed to load reward file " + reward + ".yml: " + e.getMessage()); - e.printStackTrace(); - } - } else { - plugin.debug("Detected that a reward file named " + reward - + " already exists, cannot load reward file " + file.getAbsolutePath() + "/" + reward); - } - } else { - plugin.getLogger().warning( - "Detected getting a reward file with an empty name! That means you either didn't type a name or didn't properly make an empty list"); - } - } - } - - public void openSubReward(Player player, String path, RewardEditData reward) { - if (!reward.getData().contains(path)) { - reward.createSection(path); - } - RewardEditGUI.getInstance().openRewardGUI(player, new RewardEditData(new DirectlyDefinedReward(path) { - - @Override - public void createSection(String path) { - reward.createSection(path); - } - - @Override - public ConfigurationSection getFileData() { - return reward.getData(); - } - - @Override - public void save() { - reward.save(); - } - - @Override - public void setData(String path, Object value) { - reward.setValue(path, value); - } - }, reward), reward.getName() + "." + path); - } - - /** - * Reward exist. - * - * @param reward the reward - * @return true, if successful - */ - public boolean rewardExist(String reward) { - if (reward.equals("")) { - return false; - } - for (Reward rewardName : getRewards()) { - if (rewardName.getName().equalsIgnoreCase(reward)) { - return true; - } - } - return false; - } - - /** - * Sets the default folder. - * - * @param defaultFolder the new default folder - */ - public void setDefaultFolder(File defaultFolder) { - this.defaultFolder = defaultFolder; - } - - /** - * Setup example. - */ - public void setupExample() { - if (!plugin.getDataFolder().exists()) { - plugin.getDataFolder().mkdir(); - } - - if (AdvancedCorePlugin.getInstance().getOptions().isLoadDefaultRewards()) { - copyFile("ExampleBasic.yml"); - copyFile("ExampleAdvanced.yml"); - } - } - - public void shutdown() { - delayedTimer.shutdown(); - try { - delayedTimer.awaitTermination(10, TimeUnit.SECONDS); - } catch (InterruptedException e) { - e.printStackTrace(); - } - delayedTimer.shutdownNow(); - } - - public void sortInjectedRequirements() { - Collections.sort(injectedRequirements, new Comparator() { - @Override - public int compare(RequirementInject o1, RequirementInject o2) { - return Integer.compare(o2.getPriority(), o1.getPriority()); - } - }); - } - - public void sortInjectedRewards() { - Collections.sort(injectedRewards, new Comparator() { - @Override - public int compare(RewardInject o1, RewardInject o2) { - return Integer.compare(o2.getPriority(), o1.getPriority()); - } - }); - } - - /* - * private void updateReward(Reward reward) { for (int i = getRewards().size() - - * 1; i >= 0; i--) { if - * (getRewards().get(i).getFile().getName().equals(reward.getFile().getName())) - * { getRewards().set(i, reward); return; } } getRewards().add(reward); } - */ - - public void startup() { - plugin.addUserStartup(new UserStartup() { - - @Override - public void onFinish() { - - } - - @Override - public void onStart() { - plugin.debug("Checking timed/delayed rewards"); - } - - @Override - public void onStartUp(AdvancedCoreUser user) { - try { - HashMap timed = user.getTimedRewards(); - for (Entry entry : timed.entrySet()) { - user.loadTimedDelayedTimer(entry.getValue().longValue()); - } - } catch (Exception ex) { - plugin.debug("Failed to update delayed/timed for: " + user.getUUID()); - plugin.debug(ex); - } - } - }); - - } - - public void updateReward(Configuration data, String path, RewardOptions rewardOptions) { - if (rewardOptions == null) { - rewardOptions = new RewardOptions(); - } - if (data.isConfigurationSection(path)) { - String rewardName = ""; - String prefix = rewardOptions.getPrefix(); - if (prefix != null && !prefix.equals("")) { - rewardName += prefix + "_"; - } - rewardName += path.replace(".", "_"); - - String suffix = rewardOptions.getSuffix(); - if (suffix != null && !suffix.equals("")) { - rewardName += "_" + suffix; - } - ConfigurationSection section = data.getConfigurationSection(path); - Reward reward = new Reward(rewardName, section); - reward.checkRewardFile(); - } - } - - public void updateReward(Reward reward) { - reward.validate(); - for (int i = getRewards().size() - 1; i >= 0; i--) { - if (getRewards().get(i).getFile().getPath().equals(reward.getFile().getPath())) { - getRewards().set(i, reward); - return; - } - } - getRewards().add(reward); - } - -} + + public boolean hasRewards(FileConfiguration data, String path) { + if (data.isList(path)) { + if (data.getList(path, new ArrayList<>()).size() != 0) { + return true; + } + } + if (data.isConfigurationSection(path)) { + if (data.getConfigurationSection(path).getKeys(false).size() != 0) { + return true; + } + } + if (data.isString(path)) { + if (!data.getString(path, "").equals("")) { + return true; + } + } + return false; + } + + public void loadInjectedRequirements() { + injectedRequirements.clear(); + com.bencodez.advancedcore.rewards.builtin.requirements.BuiltinRequirements.register(this, plugin); + for (RequirementInject requirement : injectedRequirements) { + requirement.setInternalReward(true); + } + sortInjectedRequirements(); + } + + public void loadInjectedRewards() { + injectedRewards.clear(); + com.bencodez.advancedcore.rewards.builtin.BuiltinRewards.register(this, plugin); + for (RewardInject reward : injectedRewards) { + reward.setInternalReward(true); + } + sortInjectedRewards(); + } + + /** + * Load rewards. + */ + public void loadRewards() { + rewards = Collections.synchronizedList(new ArrayList()); + setupExample(); + addValidPath("DirectlyDefinedReward"); + addValidPath("Delayed"); + addValidPath("Timed"); + addValidPath("DisplayItem"); + addValidPath("ForceOffline"); + for (File file : rewardFolders) { + loadRewards(file); + } + sortInjectedRewards(); + sortInjectedRequirements(); + plugin.debug("Loaded rewards"); + } + + private void loadRewards(File file) { + for (String reward : getRewardNames(file)) { + if (!reward.equals("")) { + if (!rewardExist(reward)) { + try { + Reward reward1 = new Reward(file, reward); + reward1.validate(); + if (!reward1.getConfig().isDirectlyDefinedReward() + || file.getName().equalsIgnoreCase("DirectlyDefined")) { + rewards.add(reward1); + if (reward1.getConfig().getConfigData().getConfigurationSection("").getKeys(true).size() > 0) { + plugin.extraDebug("Loaded Reward File: " + file.getAbsolutePath() + "/" + reward); + } else { + plugin.debug("Loaded empty reward file" + file.getAbsolutePath() + "/" + reward); + } + } else { + plugin.extraDebug("Ignoring directly defined reward file " + file.getAbsolutePath() + "/" + reward); + } + } catch (Exception e) { + plugin.getLogger().severe("Failed to load reward file " + reward + ".yml: " + e.getMessage()); + e.printStackTrace(); + } + } else { + plugin.debug("Detected that a reward file named " + reward + + " already exists, cannot load reward file " + file.getAbsolutePath() + "/" + reward); + } + } else { + plugin.getLogger().warning( + "Detected getting a reward file with an empty name! That means you either didn't type a name or didn't properly make an empty list"); + } + } + } + + public void openSubReward(Player player, String path, RewardEditData reward) { + if (!reward.getData().contains(path)) { + reward.createSection(path); + } + RewardEditGUI.getInstance().openRewardGUI(player, new RewardEditData(new DirectlyDefinedReward(path) { + @Override + public void createSection(String path) { + reward.createSection(path); + } + + @Override + public ConfigurationSection getFileData() { + return reward.getData(); + } + + @Override + public void save() { + reward.save(); + } + + @Override + public void setData(String path, Object value) { + reward.setValue(path, value); + } + }, reward), reward.getName() + "." + path); + } + + /** + * Reward exist. + * + * @param reward the reward + * @return true, if successful + */ + public boolean rewardExist(String reward) { + if (reward.equals("")) { + return false; + } + for (Reward rewardName : getRewards()) { + if (rewardName.getName().equalsIgnoreCase(reward)) { + return true; + } + } + return false; + } + + /** + * Sets the default folder. + * + * @param defaultFolder the new default folder + */ + public void setDefaultFolder(File defaultFolder) { + this.defaultFolder = defaultFolder; + } + + /** + * Setup example. + */ + public void setupExample() { + if (!plugin.getDataFolder().exists()) { + plugin.getDataFolder().mkdir(); + } + if (AdvancedCorePlugin.getInstance().getOptions().isLoadDefaultRewards()) { + copyFile("ExampleBasic.yml"); + copyFile("ExampleAdvanced.yml"); + } + } + + public void shutdown() { + delayedTimer.shutdown(); + try { + delayedTimer.awaitTermination(10, TimeUnit.SECONDS); + } catch (InterruptedException e) { + e.printStackTrace(); + } + delayedTimer.shutdownNow(); + } + + public void sortInjectedRequirements() { + Collections.sort(injectedRequirements, new Comparator() { + @Override + public int compare(RequirementInject o1, RequirementInject o2) { + return Integer.compare(o2.getPriority(), o1.getPriority()); + } + }); + } + + public void sortInjectedRewards() { + Collections.sort(injectedRewards, new Comparator() { + @Override + public int compare(RewardInject o1, RewardInject o2) { + return Integer.compare(o2.getPriority(), o1.getPriority()); + } + }); + } + + /* + * private void updateReward(Reward reward) { for (int i = getRewards().size() - + * 1; i >= 0; i--) { if + * (getRewards().get(i).getFile().getName().equals(reward.getFile().getName())) + * { getRewards().set(i, reward); return; } } getRewards().add(reward); } + */ + + public void startup() { + plugin.addUserStartup(new UserStartup() { + @Override + public void onFinish() { + } + + @Override + public void onStart() { + plugin.debug("Checking timed/delayed rewards"); + } + + @Override + public void onStartUp(AdvancedCoreUser user) { + try { + HashMap timed = user.getTimedRewards(); + for (Entry entry : timed.entrySet()) { + user.loadTimedDelayedTimer(entry.getValue().longValue()); + } + } catch (Exception ex) { + plugin.debug("Failed to update delayed/timed for: " + user.getUUID()); + plugin.debug(ex); + } + } + }); + } + + public void updateReward(Configuration data, String path, RewardOptions rewardOptions) { + if (rewardOptions == null) { + rewardOptions = new RewardOptions(); + } + if (data.isConfigurationSection(path)) { + String rewardName = ""; + String prefix = rewardOptions.getPrefix(); + if (prefix != null && !prefix.equals("")) { + rewardName += prefix + "_"; + } + rewardName += path.replace(".", "_"); + String suffix = rewardOptions.getSuffix(); + if (suffix != null && !suffix.equals("")) { + rewardName += "_" + suffix; + } + ConfigurationSection section = data.getConfigurationSection(path); + Reward reward = new Reward(rewardName, section); + reward.checkRewardFile(); + } + } + + public void updateReward(Reward reward) { + reward.validate(); + for (int i = getRewards().size() - 1; i >= 0; i--) { + if (getRewards().get(i).getFile().getPath().equals(reward.getFile().getPath())) { + getRewards().set(i, reward); + return; + } + } + getRewards().add(reward); + } +} From 5457bc56b53f2c901f4778c533db66234286cc4d Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:24:27 -0600 Subject: [PATCH 03/20] Preserve built-in reward registration order --- .../rewards/builtin/RewardCommands.java | 93 +------------------ 1 file changed, 1 insertion(+), 92 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java index 13c9369df..71e846b11 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java @@ -3,7 +3,6 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; -import java.util.concurrent.ThreadLocalRandom; import org.bukkit.Material; import org.bukkit.configuration.ConfigurationSection; @@ -12,7 +11,6 @@ import com.bencodez.advancedcore.AdvancedCorePlugin; import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; import com.bencodez.advancedcore.api.item.ItemBuilder; import com.bencodez.advancedcore.api.misc.MiscUtils; import com.bencodez.advancedcore.api.rewards.Reward; @@ -20,64 +18,17 @@ import com.bencodez.advancedcore.api.rewards.RewardHandler; import com.bencodez.advancedcore.api.rewards.injected.RewardInject; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +/** Built-in plural Commands reward forms. */ public final class RewardCommands { private RewardCommands() { } public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { - handler.getInjectedRewards().add(new RewardInjectConfigurationSection("NumberCommand") { - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - int min = section.getInt("Min", 0); - int max = section.getInt("Max", 100); - int number = ThreadLocalRandom.current().nextInt(min, max + 1); - String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); - return String.valueOf(number); - } - }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") - || !data.isString("NumberCommand.Command")) { - warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); - return; - } - int min = data.getInt("NumberCommand.Min"); - int max = data.getInt("NumberCommand.Max"); - if (min > max) { - warning(reward, inject, "NumberCommand Min can not be greater than Max"); - } - if (min == max) { - warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); - } - } - })); - - handler.getInjectedRewards().add(new RewardInjectString("Command") { - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute single console command"))).validator(commandValidator())); - handler.getInjectedRewards().add(new RewardInjectStringList("Commands") { @Override public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, @@ -146,47 +97,5 @@ public void setValue(Player player, ArrayList value) { reward.reOpenEditGUI(player); } }.addLore("Execute commands as player")))); - - handler.getInjectedRewards().add(new RewardInjectStringList("RandomCommand") { - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (!list.isEmpty()) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), - list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); - } - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute random command"))).validator(new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - List list = data.getStringList(inject.getPath()); - if (list.isEmpty()) { - warning(reward, inject, "No rewards listed for random reward"); - } else if (list.size() == 1) { - warning(reward, inject, "Only one reward listed for random reward"); - } - } - })); - } - - private static RewardInjectValidator commandValidator() { - return new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - String command = data.getString(inject.getPath()); - if (command != null && command.startsWith("/")) { - warning(reward, inject, "Can't start command with /"); - } - } - }; } } From b5ae77db38efa19ea0927f388e960865c4300b6c Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:24:36 -0600 Subject: [PATCH 04/20] Extract NumberCommand built-in reward --- .../rewards/builtin/RewardNumberCommand.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java new file mode 100644 index 000000000..22efadcc4 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java @@ -0,0 +1,54 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.configuration.ConfigurationSection; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +/** Built-in NumberCommand reward. */ +public final class RewardNumberCommand { + + private RewardNumberCommand() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("NumberCommand") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + int min = section.getInt("Min", 0); + int max = section.getInt("Max", 100); + int number = ThreadLocalRandom.current().nextInt(min, max + 1); + String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); + return String.valueOf(number); + } + }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") + || !data.isString("NumberCommand.Command")) { + warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); + return; + } + int min = data.getInt("NumberCommand.Min"); + int max = data.getInt("NumberCommand.Max"); + if (min > max) { + warning(reward, inject, "NumberCommand Min can not be greater than Max"); + } + if (min == max) { + warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); + } + } + })); + } +} From 8687892ad655ab2b87b46d0d352ed541cca1d16b Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:24:44 -0600 Subject: [PATCH 05/20] Extract Command built-in reward --- .../rewards/builtin/RewardCommand.java | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java new file mode 100644 index 000000000..d61bcfab5 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java @@ -0,0 +1,53 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.HashMap; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +/** Built-in singular Command reward. */ +public final class RewardCommand { + + private RewardCommand() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectString("Command") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute single console command"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String command = data.getString(inject.getPath()); + if (command != null && command.startsWith("/")) { + warning(reward, inject, "Can't start command with /"); + } + } + })); + } +} From 66aec65af2085023142c825e77eb5a82074073b3 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:24:55 -0600 Subject: [PATCH 06/20] Extract RandomCommand built-in reward --- .../rewards/builtin/RewardRandomCommand.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java new file mode 100644 index 000000000..940925d59 --- /dev/null +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java @@ -0,0 +1,62 @@ +package com.bencodez.advancedcore.rewards.builtin; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardEditData; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; + +/** Built-in RandomCommand reward. */ +public final class RewardRandomCommand { + + private RewardRandomCommand() { + } + + public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectStringList("RandomCommand") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), + list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute random command"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + List list = data.getStringList(inject.getPath()); + if (list.isEmpty()) { + warning(reward, inject, "No rewards listed for random reward"); + } else if (list.size() == 1) { + warning(reward, inject, "Only one reward listed for random reward"); + } + } + })); + } +} From b41d3cfcd94c4003b858eefded9a947cbea30e49 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:25:03 -0600 Subject: [PATCH 07/20] Restore built-in reward registration order --- .../advancedcore/rewards/builtin/BuiltinRewards.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java index b228f02fc..4d7a3ac65 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java @@ -10,15 +10,20 @@ private BuiltinRewards() { } public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + // Preserve the historical registration order because sorting by priority is stable, + // so order still matters for injects with the same priority. RewardMoney.register(handler, plugin); + RewardNumberCommand.register(handler, plugin); RewardExp.register(handler, plugin); RewardMessages.register(handler, plugin); - RewardCommands.register(handler, plugin); + RewardCommand.register(handler, plugin); RewardActionBar.register(handler, plugin); + RewardCommands.register(handler, plugin); RewardJavascript.register(handler, plugin); RewardLucky.register(handler, plugin); RewardRandom.register(handler, plugin); RewardSubRewards.register(handler, plugin); + RewardRandomCommand.register(handler, plugin); RewardRandomReward.register(handler, plugin); RewardTempPermission.register(handler, plugin); RewardAdvancedRewards.register(handler, plugin); @@ -31,9 +36,9 @@ public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { RewardEffect.register(handler, plugin); RewardFirework.register(handler, plugin); RewardItems.register(handler, plugin); + RewardChoices.register(handler, plugin); RewardAdvancedPriority.register(handler, plugin); RewardAdvancedWorld.register(handler, plugin); RewardSpecialChance.register(handler, plugin); - RewardChoices.register(handler, plugin); } } From 6f312629cb032163c05347630df9a2f8fee21e4d Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:34:02 -0600 Subject: [PATCH 08/20] Fix RequirementWorld registration syntax --- .../rewards/builtin/requirements/RequirementWorld.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java index 014fd04e4..e3da795c7 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/requirements/RequirementWorld.java @@ -74,7 +74,7 @@ public void setValue(Player player, ArrayList value) { reward.reOpenEditGUI(player); } }.addLore("Worlds to execute reward in, only executes into one reward"))) - .validator(listValidator("Worlds")); + .validator(listValidator("Worlds"))); handler.getInjectedRequirements().add(new RequirementInjectStringList("BlackListedWorlds", new ArrayList<>()) { @Override @@ -126,7 +126,7 @@ public void setValue(Player player, ArrayList value) { plugin.reloadAdvancedCore(false); reward.reOpenEditGUI(player); } - }.addLore("Worlds to never execute the reward in"))).validator(listValidator("BlackListedWorlds")); + }.addLore("Worlds to never execute the reward in"))).validator(listValidator("BlackListedWorlds"))); } private static RequirementInjectValidator listValidator(String path) { From 9247d582235d881d61d95e4193e2145917e56060 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:34:50 -0600 Subject: [PATCH 09/20] Remove obsolete split command reward class --- .../rewards/builtin/RewardCommand.java | 53 ------------------- 1 file changed, 53 deletions(-) delete mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java deleted file mode 100644 index d61bcfab5..000000000 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommand.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.bencodez.advancedcore.rewards.builtin; - -import java.util.HashMap; - -import org.bukkit.configuration.ConfigurationSection; -import org.bukkit.entity.Player; - -import com.bencodez.advancedcore.AdvancedCorePlugin; -import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; -import com.bencodez.advancedcore.api.item.ItemBuilder; -import com.bencodez.advancedcore.api.misc.MiscUtils; -import com.bencodez.advancedcore.api.rewards.Reward; -import com.bencodez.advancedcore.api.rewards.RewardEditData; -import com.bencodez.advancedcore.api.rewards.RewardHandler; -import com.bencodez.advancedcore.api.rewards.injected.RewardInject; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; -import com.bencodez.advancedcore.api.user.AdvancedCoreUser; - -/** Built-in singular Command reward. */ -public final class RewardCommand { - - private RewardCommand() { - } - - public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { - handler.getInjectedRewards().add(new RewardInjectString("Command") { - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, - HashMap placeholders) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { - @Override - public void setValue(Player player, String value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute single console command"))).validator(new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - String command = data.getString(inject.getPath()); - if (command != null && command.startsWith("/")) { - warning(reward, inject, "Can't start command with /"); - } - } - })); - } -} From fbfdc324f220e024d68f2e2f1629f1d206bcd154 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:34:56 -0600 Subject: [PATCH 10/20] Remove obsolete split number command reward class --- .../rewards/builtin/RewardNumberCommand.java | 54 ------------------- 1 file changed, 54 deletions(-) delete mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java deleted file mode 100644 index 22efadcc4..000000000 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardNumberCommand.java +++ /dev/null @@ -1,54 +0,0 @@ -package com.bencodez.advancedcore.rewards.builtin; - -import java.util.HashMap; -import java.util.concurrent.ThreadLocalRandom; - -import org.bukkit.configuration.ConfigurationSection; - -import com.bencodez.advancedcore.AdvancedCorePlugin; -import com.bencodez.advancedcore.api.misc.MiscUtils; -import com.bencodez.advancedcore.api.rewards.Reward; -import com.bencodez.advancedcore.api.rewards.RewardHandler; -import com.bencodez.advancedcore.api.rewards.injected.RewardInject; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; -import com.bencodez.advancedcore.api.user.AdvancedCoreUser; - -/** Built-in NumberCommand reward. */ -public final class RewardNumberCommand { - - private RewardNumberCommand() { - } - - public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { - handler.getInjectedRewards().add(new RewardInjectConfigurationSection("NumberCommand") { - @Override - public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, - HashMap placeholders) { - int min = section.getInt("Min", 0); - int max = section.getInt("Max", 100); - int number = ThreadLocalRandom.current().nextInt(min, max + 1); - String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); - return String.valueOf(number); - } - }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") - || !data.isString("NumberCommand.Command")) { - warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); - return; - } - int min = data.getInt("NumberCommand.Min"); - int max = data.getInt("NumberCommand.Max"); - if (min > max) { - warning(reward, inject, "NumberCommand Min can not be greater than Max"); - } - if (min == max) { - warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); - } - } - })); - } -} From e04ef1758078e76102a3db009d3bb9ed81659be5 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:35:00 -0600 Subject: [PATCH 11/20] Remove obsolete split random command reward class --- .../rewards/builtin/RewardRandomCommand.java | 62 ------------------- 1 file changed, 62 deletions(-) delete mode 100644 AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java deleted file mode 100644 index 940925d59..000000000 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardRandomCommand.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.bencodez.advancedcore.rewards.builtin; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.concurrent.ThreadLocalRandom; - -import org.bukkit.Material; -import org.bukkit.configuration.ConfigurationSection; -import org.bukkit.entity.Player; - -import com.bencodez.advancedcore.AdvancedCorePlugin; -import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; -import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; -import com.bencodez.advancedcore.api.item.ItemBuilder; -import com.bencodez.advancedcore.api.misc.MiscUtils; -import com.bencodez.advancedcore.api.rewards.Reward; -import com.bencodez.advancedcore.api.rewards.RewardEditData; -import com.bencodez.advancedcore.api.rewards.RewardHandler; -import com.bencodez.advancedcore.api.rewards.injected.RewardInject; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; -import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; -import com.bencodez.advancedcore.api.user.AdvancedCoreUser; - -/** Built-in RandomCommand reward. */ -public final class RewardRandomCommand { - - private RewardRandomCommand() { - } - - public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { - handler.getInjectedRewards().add(new RewardInjectStringList("RandomCommand") { - @Override - public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, - HashMap placeholders) { - if (!list.isEmpty()) { - MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), - list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); - } - return null; - } - }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { - @Override - public void setValue(Player player, ArrayList value) { - RewardEditData reward = (RewardEditData) getInv().getData("Reward"); - reward.setValue(getKey(), value); - plugin.reloadAdvancedCore(false); - reward.reOpenEditGUI(player); - } - }.addLore("Execute random command"))).validator(new RewardInjectValidator() { - @Override - public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { - List list = data.getStringList(inject.getPath()); - if (list.isEmpty()) { - warning(reward, inject, "No rewards listed for random reward"); - } else if (list.size() == 1) { - warning(reward, inject, "Only one reward listed for random reward"); - } - } - })); - } -} From 5531b6c1ac9204c589439c661df0f0bd594bbdac Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:36:21 -0600 Subject: [PATCH 12/20] Consolidate command reward implementations --- .../rewards/builtin/RewardCommands.java | 107 +++++++++++++++++- 1 file changed, 106 insertions(+), 1 deletion(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java index 71e846b11..639a880d8 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardCommands.java @@ -3,6 +3,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.concurrent.ThreadLocalRandom; import org.bukkit.Material; import org.bukkit.configuration.ConfigurationSection; @@ -11,6 +12,7 @@ import com.bencodez.advancedcore.AdvancedCorePlugin; import com.bencodez.advancedcore.api.inventory.editgui.EditGUIButton; import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueList; +import com.bencodez.advancedcore.api.inventory.editgui.valuetypes.EditGUIValueString; import com.bencodez.advancedcore.api.item.ItemBuilder; import com.bencodez.advancedcore.api.misc.MiscUtils; import com.bencodez.advancedcore.api.rewards.Reward; @@ -18,17 +20,88 @@ import com.bencodez.advancedcore.api.rewards.RewardHandler; import com.bencodez.advancedcore.api.rewards.injected.RewardInject; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; import com.bencodez.advancedcore.api.rewards.injected.RewardInjectValidator; import com.bencodez.advancedcore.api.user.AdvancedCoreUser; -/** Built-in plural Commands reward forms. */ +/** Registers all built-in command reward forms. */ public final class RewardCommands { private RewardCommands() { } + /** + * Convenience registration for consumers that do not need to preserve the + * historical cross-feature ordering used by {@link BuiltinRewards}. + */ public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + registerNumberCommand(handler, plugin); + registerCommand(handler, plugin); + registerCommands(handler, plugin); + registerRandomCommand(handler, plugin); + } + + public static void registerNumberCommand(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectConfigurationSection("NumberCommand") { + @Override + public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, + HashMap placeholders) { + int min = section.getInt("Min", 0); + int max = section.getInt("Max", 100); + int number = ThreadLocalRandom.current().nextInt(min, max + 1); + String command = section.getString("Command", "").replace("%number%", String.valueOf(number)); + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), command, placeholders); + return String.valueOf(number); + } + }.asPlaceholder("Number").priority(100).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + if (!data.isInt("NumberCommand.Min") || !data.isInt("NumberCommand.Max") + || !data.isString("NumberCommand.Command")) { + warning(reward, inject, "NumberCommand requires Min, Max, and Command to be set"); + return; + } + int min = data.getInt("NumberCommand.Min"); + int max = data.getInt("NumberCommand.Max"); + if (min > max) { + warning(reward, inject, "NumberCommand Min can not be greater than Max"); + } + if (min == max) { + warning(reward, inject, "NumberCommand Min and Max are the same, random range is unnecessary"); + } + } + })); + } + + public static void registerCommand(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectString("Command") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, String value, + HashMap placeholders) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), value, placeholders); + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder("COMMAND_BLOCK"), new EditGUIValueString("Command", null) { + @Override + public void setValue(Player player, String value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute single console command"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + String command = data.getString(inject.getPath()); + if (command != null && command.startsWith("/")) { + warning(reward, inject, "Can't start command with /"); + } + } + })); + } + + public static void registerCommands(RewardHandler handler, AdvancedCorePlugin plugin) { handler.getInjectedRewards().add(new RewardInjectStringList("Commands") { @Override public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, @@ -98,4 +171,36 @@ public void setValue(Player player, ArrayList value) { } }.addLore("Execute commands as player")))); } + + public static void registerRandomCommand(RewardHandler handler, AdvancedCorePlugin plugin) { + handler.getInjectedRewards().add(new RewardInjectStringList("RandomCommand") { + @Override + public String onRewardRequest(Reward reward, AdvancedCoreUser user, ArrayList list, + HashMap placeholders) { + if (!list.isEmpty()) { + MiscUtils.getInstance().executeConsoleCommands(user.getPlayerName(), + list.get(ThreadLocalRandom.current().nextInt(list.size())), placeholders); + } + return null; + } + }.addEditButton(new EditGUIButton(new ItemBuilder(Material.PAPER), new EditGUIValueList("RandomCommand", null) { + @Override + public void setValue(Player player, ArrayList value) { + RewardEditData reward = (RewardEditData) getInv().getData("Reward"); + reward.setValue(getKey(), value); + plugin.reloadAdvancedCore(false); + reward.reOpenEditGUI(player); + } + }.addLore("Execute random command"))).validator(new RewardInjectValidator() { + @Override + public void onValidate(Reward reward, RewardInject inject, ConfigurationSection data) { + List list = data.getStringList(inject.getPath()); + if (list.isEmpty()) { + warning(reward, inject, "No rewards listed for random reward"); + } else if (list.size() == 1) { + warning(reward, inject, "Only one reward listed for random reward"); + } + } + })); + } } From 7c28bebc8fa883e7c2ddfcc47424767e1a4ab592 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:36:30 -0600 Subject: [PATCH 13/20] Preserve command reward registration order --- .../advancedcore/rewards/builtin/BuiltinRewards.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java index 4d7a3ac65..0193cd501 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java @@ -11,19 +11,20 @@ private BuiltinRewards() { public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { // Preserve the historical registration order because sorting by priority is stable, - // so order still matters for injects with the same priority. + // so order still matters for injects with the same priority. Command implementations + // live together in RewardCommands, but are registered at their original positions. RewardMoney.register(handler, plugin); - RewardNumberCommand.register(handler, plugin); + RewardCommands.registerNumberCommand(handler, plugin); RewardExp.register(handler, plugin); RewardMessages.register(handler, plugin); - RewardCommand.register(handler, plugin); + RewardCommands.registerCommand(handler, plugin); RewardActionBar.register(handler, plugin); - RewardCommands.register(handler, plugin); + RewardCommands.registerCommands(handler, plugin); RewardJavascript.register(handler, plugin); RewardLucky.register(handler, plugin); RewardRandom.register(handler, plugin); RewardSubRewards.register(handler, plugin); - RewardRandomCommand.register(handler, plugin); + RewardCommands.registerRandomCommand(handler, plugin); RewardRandomReward.register(handler, plugin); RewardTempPermission.register(handler, plugin); RewardAdvancedRewards.register(handler, plugin); From 48b8b0f3c34b9a9e5f8a876be10a5e9dbbf9cf8f Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:37:28 -0600 Subject: [PATCH 14/20] Preserve item reward registration boundaries --- .../advancedcore/rewards/builtin/RewardItems.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java index b0c4ee140..3212f43ae 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/RewardItems.java @@ -22,12 +22,23 @@ import com.bencodez.advancedcore.api.user.AdvancedCoreUser; import com.bencodez.simpleapi.array.ArrayUtils; +/** Registers all built-in item reward forms. */ public final class RewardItems { private RewardItems() { } + /** + * Convenience registration for consumers that do not need to preserve the + * historical cross-feature ordering used by {@link BuiltinRewards}. + */ public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { + registerItem(handler, plugin); + registerRandomItem(handler, plugin); + registerItems(handler, plugin); + } + + public static void registerItem(RewardHandler handler, AdvancedCorePlugin plugin) { handler.getInjectedRewards().add(new RewardInjectConfigurationSection("Item") { @Override public String onRewardRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, @@ -38,7 +49,9 @@ public String onRewardRequested(Reward reward, AdvancedCoreUser user, Configurat return null; } }.validator(itemValidator())); + } + public static void registerRandomItem(RewardHandler handler, AdvancedCorePlugin plugin) { handler.getInjectedRewards().add(new RewardInjectKeys("RandomItem") { @Override public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, @@ -53,7 +66,9 @@ public String onRewardRequested(Reward reward, AdvancedCoreUser user, Set section, From de4b5ab4237e8472f885ef7b0c3d08ae2db89f00 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:37:36 -0600 Subject: [PATCH 15/20] Restore historical built-in reward order --- .../advancedcore/rewards/builtin/BuiltinRewards.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java index 0193cd501..3ebeb63e8 100644 --- a/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java +++ b/AdvancedCore/src/main/java/com/bencodez/advancedcore/rewards/builtin/BuiltinRewards.java @@ -11,8 +11,9 @@ private BuiltinRewards() { public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { // Preserve the historical registration order because sorting by priority is stable, - // so order still matters for injects with the same priority. Command implementations - // live together in RewardCommands, but are registered at their original positions. + // so order still matters for injects with the same priority. Feature implementations + // remain grouped in their classes, but split registration methods are invoked at the + // same positions as the original RewardHandler implementation. RewardMoney.register(handler, plugin); RewardCommands.registerNumberCommand(handler, plugin); RewardExp.register(handler, plugin); @@ -36,10 +37,12 @@ public static void register(RewardHandler handler, AdvancedCorePlugin plugin) { RewardSound.register(handler, plugin); RewardEffect.register(handler, plugin); RewardFirework.register(handler, plugin); - RewardItems.register(handler, plugin); - RewardChoices.register(handler, plugin); + RewardItems.registerItem(handler, plugin); RewardAdvancedPriority.register(handler, plugin); RewardAdvancedWorld.register(handler, plugin); RewardSpecialChance.register(handler, plugin); + RewardItems.registerRandomItem(handler, plugin); + RewardChoices.register(handler, plugin); + RewardItems.registerItems(handler, plugin); } } From 4d270391a2c377122d59df9716bee444e0445ae3 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 10:47:57 -0600 Subject: [PATCH 16/20] Fix PlaceholderUtils static mock conflict --- .../tests/messages/PlaceholderUtilsTest.java | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/messages/PlaceholderUtilsTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/messages/PlaceholderUtilsTest.java index a2f5b0ee8..f60503ed5 100644 --- a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/messages/PlaceholderUtilsTest.java +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/messages/PlaceholderUtilsTest.java @@ -10,8 +10,8 @@ import org.mockito.MockedStatic; import com.bencodez.advancedcore.AdvancedCoreConfigOptions; -import com.bencodez.advancedcore.AdvancedCorePlugin; import com.bencodez.advancedcore.api.messages.PlaceholderUtils; +import com.bencodez.advancedcore.tests.BaseTest; import me.clip.placeholderapi.PlaceholderAPI; @@ -19,18 +19,13 @@ public class PlaceholderUtilsTest { @Test public void replaceJavascriptOnlyDoesNotExpandPlaceholderApiOutput() { - AdvancedCorePlugin plugin = mock(AdvancedCorePlugin.class); - AdvancedCoreConfigOptions options = mock(AdvancedCoreConfigOptions.class); + AdvancedCoreConfigOptions options = BaseTest.getInstance().options; Player player = mock(Player.class); String command = "say %untrusted%"; - when(plugin.getOptions()).thenReturn(options); when(options.isJavascriptEngineEnabled()).thenReturn(false); - try (MockedStatic pluginStatic = mockStatic(AdvancedCorePlugin.class); - MockedStatic placeholderApiStatic = mockStatic(PlaceholderAPI.class)) { - pluginStatic.when(AdvancedCorePlugin::getInstance).thenReturn(plugin); - + try (MockedStatic placeholderApiStatic = mockStatic(PlaceholderAPI.class)) { assertEquals(command, PlaceholderUtils.replaceJavascriptOnly(player, command)); placeholderApiStatic.verifyNoInteractions(); } From 492c7b69ad9a317947a14810b868923ed8362be5 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 12:08:22 -0600 Subject: [PATCH 17/20] Add coverage for every built-in reward registration --- .../BuiltinRewardRegistrationTest.java | 216 ++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardRegistrationTest.java diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardRegistrationTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardRegistrationTest.java new file mode 100644 index 000000000..56e6bffb7 --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardRegistrationTest.java @@ -0,0 +1,216 @@ +package com.bencodez.advancedcore.tests.rewards; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.io.File; +import java.util.List; +import java.util.function.BiConsumer; +import java.util.logging.Logger; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.rewards.builtin.BuiltinRewards; +import com.bencodez.advancedcore.rewards.builtin.RewardActionBar; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedPriority; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedRandomReward; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedRewards; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedWorld; +import com.bencodez.advancedcore.rewards.builtin.RewardBossBar; +import com.bencodez.advancedcore.rewards.builtin.RewardChoices; +import com.bencodez.advancedcore.rewards.builtin.RewardCommands; +import com.bencodez.advancedcore.rewards.builtin.RewardEffect; +import com.bencodez.advancedcore.rewards.builtin.RewardExp; +import com.bencodez.advancedcore.rewards.builtin.RewardFirework; +import com.bencodez.advancedcore.rewards.builtin.RewardItems; +import com.bencodez.advancedcore.rewards.builtin.RewardJavascript; +import com.bencodez.advancedcore.rewards.builtin.RewardLucky; +import com.bencodez.advancedcore.rewards.builtin.RewardMessages; +import com.bencodez.advancedcore.rewards.builtin.RewardMoney; +import com.bencodez.advancedcore.rewards.builtin.RewardPotions; +import com.bencodez.advancedcore.rewards.builtin.RewardPriority; +import com.bencodez.advancedcore.rewards.builtin.RewardRandom; +import com.bencodez.advancedcore.rewards.builtin.RewardRandomReward; +import com.bencodez.advancedcore.rewards.builtin.RewardSound; +import com.bencodez.advancedcore.rewards.builtin.RewardSpecialChance; +import com.bencodez.advancedcore.rewards.builtin.RewardSubRewards; +import com.bencodez.advancedcore.rewards.builtin.RewardTempPermission; +import com.bencodez.advancedcore.rewards.builtin.RewardTitle; + +public class BuiltinRewardRegistrationTest { + + @TempDir + File tempDir; + + private AdvancedCorePlugin plugin; + private RewardHandler rewardHandler; + + @BeforeEach + public void setUp() { + plugin = mock(AdvancedCorePlugin.class); + when(plugin.getDataFolder()).thenReturn(tempDir); + when(plugin.getLogger()).thenReturn(mock(Logger.class)); + rewardHandler = new RewardHandler(plugin); + } + + @AfterEach + public void tearDown() { + rewardHandler.getDelayedTimer().shutdownNow(); + } + + @Test + public void actionBarRegistersExpectedPaths() { + assertRewardPaths(RewardActionBar::register, "ActionBar"); + } + + @Test + public void advancedPriorityRegistersExpectedPaths() { + assertRewardPaths(RewardAdvancedPriority::register, "AdvancedPriority"); + } + + @Test + public void advancedRandomRewardRegistersExpectedPaths() { + assertRewardPaths(RewardAdvancedRandomReward::register, "AdvancedRandomReward"); + } + + @Test + public void advancedRewardsRegistersExpectedPaths() { + assertRewardPaths(RewardAdvancedRewards::register, "AdvancedRewards"); + } + + @Test + public void advancedWorldRegistersExpectedPaths() { + assertRewardPaths(RewardAdvancedWorld::register, "AdvancedWorld"); + } + + @Test + public void bossBarRegistersExpectedPaths() { + assertRewardPaths(RewardBossBar::register, "BossBar"); + } + + @Test + public void choicesRegistersExpectedPaths() { + assertRewardPaths(RewardChoices::register, "EnableChoices"); + } + + @Test + public void commandsRegistersEveryLegacyForm() { + assertRewardPaths(RewardCommands::register, "NumberCommand", "Command", "Commands", "Commands", "RandomCommand"); + } + + @Test + public void effectRegistersExpectedPaths() { + assertRewardPaths(RewardEffect::register, "Effect"); + } + + @Test + public void expRegistersScalarAndRangeForms() { + assertRewardPaths(RewardExp::register, "EXP", "EXPLevels", "EXP", "EXPLevels"); + } + + @Test + public void fireworkRegistersExpectedPaths() { + assertRewardPaths(RewardFirework::register, "Firework"); + } + + @Test + public void itemsRegistersEveryLegacyForm() { + assertRewardPaths(RewardItems::register, "Item", "RandomItem", "Items"); + } + + @Test + public void javascriptRegistersListAndConditionalForms() { + assertRewardPaths(RewardJavascript::register, "Javascripts", "Javascript"); + } + + @Test + public void luckyRegistersExpectedPaths() { + assertRewardPaths(RewardLucky::register, "Lucky"); + } + + @Test + public void messagesRegistersEveryLegacyForm() { + assertRewardPaths(RewardMessages::register, "Message", "Messages.Player", "Message", "RandomMessage", + "Messages.Player", "Messages.Broadcast", "Messages.Broadcast"); + } + + @Test + public void moneyRegistersScalarAndRangeForms() { + assertRewardPaths(RewardMoney::register, "Money", "Money"); + } + + @Test + public void potionsRegistersExpectedPaths() { + assertRewardPaths(RewardPotions::register, "Potions"); + } + + @Test + public void priorityRegistersExpectedPaths() { + assertRewardPaths(RewardPriority::register, "Priority"); + } + + @Test + public void randomRegistersExpectedPaths() { + assertRewardPaths(RewardRandom::register, "Random"); + } + + @Test + public void randomRewardRegistersExpectedPaths() { + assertRewardPaths(RewardRandomReward::register, "RandomReward"); + } + + @Test + public void soundRegistersExpectedPaths() { + assertRewardPaths(RewardSound::register, "Sound"); + } + + @Test + public void specialChanceRegistersExpectedPaths() { + assertRewardPaths(RewardSpecialChance::register, "SpecialChance"); + } + + @Test + public void subRewardsRegistersExpectedPaths() { + assertRewardPaths(RewardSubRewards::register, "Rewards"); + } + + @Test + public void tempPermissionRegistersExpectedPaths() { + assertRewardPaths(RewardTempPermission::register, "TempPermission"); + } + + @Test + public void titleRegistersExpectedPaths() { + assertRewardPaths(RewardTitle::register, "Title"); + } + + @Test + public void builtinCatalogRegistersAllRewardPathsInHistoricalOrder() { + assertRewardPaths(BuiltinRewards::register, + "Money", "Money", "NumberCommand", + "EXP", "EXPLevels", "EXP", "EXPLevels", + "Message", "Messages.Player", "Message", "RandomMessage", "Messages.Player", "Messages.Broadcast", + "Messages.Broadcast", + "Command", "ActionBar", "Commands", "Commands", "Javascripts", "Javascript", "Lucky", "Random", + "Rewards", "RandomCommand", "RandomReward", "TempPermission", "AdvancedRewards", "AdvancedRandomReward", + "Priority", "Potions", "Title", "BossBar", "Sound", "Effect", "Firework", "Item", + "AdvancedPriority", "AdvancedWorld", "SpecialChance", "RandomItem", "EnableChoices", "Items"); + } + + private void assertRewardPaths(BiConsumer registrar, String... expectedPaths) { + int before = rewardHandler.getInjectedRewards().size(); + registrar.accept(rewardHandler, plugin); + + List actualPaths = rewardHandler.getInjectedRewards().subList(before, rewardHandler.getInjectedRewards().size()) + .stream().map(RewardInject::getPath).toList(); + + assertEquals(List.of(expectedPaths), actualPaths); + } +} From 26e4f29208d4ffa608dd9e4c080b3a2429533f07 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 12:08:40 -0600 Subject: [PATCH 18/20] Add coverage for every built-in reward requirement --- .../BuiltinRequirementRegistrationTest.java | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementRegistrationTest.java diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementRegistrationTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementRegistrationTest.java new file mode 100644 index 000000000..8cec17656 --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementRegistrationTest.java @@ -0,0 +1,134 @@ +package com.bencodez.advancedcore.tests.rewards; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.when; + +import java.io.File; +import java.util.List; +import java.util.function.BiConsumer; +import java.util.logging.Logger; + +import org.bukkit.Bukkit; +import org.bukkit.Server; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.mockito.MockedStatic; + +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.rewards.builtin.requirements.BuiltinRequirements; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementChance; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementDate; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementDayOfMonth; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementJavascript; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementLocationDistance; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementPermission; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementRewardExpiration; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementRewardType; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementServer; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementWorld; + +public class BuiltinRequirementRegistrationTest { + + @TempDir + File tempDir; + + private AdvancedCorePlugin plugin; + private RewardHandler rewardHandler; + + @BeforeEach + public void setUp() { + plugin = mock(AdvancedCorePlugin.class); + when(plugin.getDataFolder()).thenReturn(tempDir); + when(plugin.getLogger()).thenReturn(mock(Logger.class)); + rewardHandler = new RewardHandler(plugin); + } + + @AfterEach + public void tearDown() { + rewardHandler.getDelayedTimer().shutdownNow(); + } + + @Test + public void chanceRegistersExpectedPaths() { + assertRequirementPaths(RequirementChance::register, "Chance"); + } + + @Test + public void dateRegistersExpectedPaths() { + assertRequirementPaths(RequirementDate::register, "Date"); + } + + @Test + public void dayOfMonthRegistersExpectedPaths() { + assertRequirementPaths(RequirementDayOfMonth::register, "DayOfMonth"); + } + + @Test + public void javascriptRegistersExpectedPaths() { + assertRequirementPaths(RequirementJavascript::register, "JavascriptExpression"); + } + + @Test + public void locationDistanceRegistersExpectedPaths() { + assertRequirementPaths(RequirementLocationDistance::register, "LocationDistance"); + } + + @Test + public void permissionRegistersExpectedPaths() { + assertRequirementPaths(RequirementPermission::register, "Permission"); + } + + @Test + public void rewardExpirationRegistersExpectedPaths() { + assertRequirementPaths(RequirementRewardExpiration::register, "RewardExpiration"); + } + + @Test + public void rewardTypeRegistersExpectedPaths() { + assertRequirementPaths(RequirementRewardType::register, "RewardType"); + } + + @Test + public void serverRegistersAllowedAndBlockedForms() { + withMockedServer(() -> assertRequirementPaths(RequirementServer::register, "Server", "BlockedServers")); + } + + @Test + public void worldRegistersAllowedAndBlacklistedForms() { + assertRequirementPaths(RequirementWorld::register, "Worlds", "BlackListedWorlds"); + } + + @Test + public void builtinCatalogRegistersAllRequirementPathsInHistoricalOrder() { + withMockedServer(() -> assertRequirementPaths(BuiltinRequirements::register, + "Chance", "RewardExpiration", "Permission", "DayOfMonth", "Server", "BlockedServers", "Worlds", + "BlackListedWorlds", "RewardType", "JavascriptExpression", "Date", "LocationDistance")); + } + + private void assertRequirementPaths(BiConsumer registrar, + String... expectedPaths) { + int before = rewardHandler.getInjectedRequirements().size(); + registrar.accept(rewardHandler, plugin); + + List actualPaths = rewardHandler.getInjectedRequirements() + .subList(before, rewardHandler.getInjectedRequirements().size()).stream() + .map(RequirementInject::getPath).toList(); + + assertEquals(List.of(expectedPaths), actualPaths); + } + + private void withMockedServer(Runnable test) { + Server server = mock(Server.class); + when(server.getName()).thenReturn("TestServer"); + try (MockedStatic bukkit = mockStatic(Bukkit.class)) { + bukkit.when(Bukkit::getServer).thenReturn(server); + test.run(); + } + } +} From b2eea7fcdee32c09c3340a155c8e9ae960997e5a Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 12:15:29 -0600 Subject: [PATCH 19/20] Test built-in reward behavior --- .../rewards/BuiltinRewardBehaviorTest.java | 603 ++++++++++++++++++ 1 file changed, 603 insertions(+) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardBehaviorTest.java diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardBehaviorTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardBehaviorTest.java new file mode 100644 index 000000000..4f79d4605 --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRewardBehaviorTest.java @@ -0,0 +1,603 @@ +package com.bencodez.advancedcore.tests.rewards; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyDouble; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockConstruction; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.withSettings; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.function.BiConsumer; + +import org.bukkit.Location; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Answers; +import org.mockito.ArgumentCaptor; +import org.mockito.MockedConstruction; +import org.mockito.MockedStatic; + +import com.bencodez.advancedcore.AdvancedCoreConfigOptions; +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.item.ItemBuilder; +import com.bencodez.advancedcore.api.javascript.JavascriptEngine; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.misc.effects.FireworkHandler; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardBuilder; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injected.RewardInject; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectBoolean; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectDouble; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectInt; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectKeys; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectString; +import com.bencodez.advancedcore.api.rewards.injected.RewardInjectStringList; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.advancedcore.rewards.builtin.RewardActionBar; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedPriority; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedRandomReward; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedRewards; +import com.bencodez.advancedcore.rewards.builtin.RewardAdvancedWorld; +import com.bencodez.advancedcore.rewards.builtin.RewardBossBar; +import com.bencodez.advancedcore.rewards.builtin.RewardChoices; +import com.bencodez.advancedcore.rewards.builtin.RewardCommands; +import com.bencodez.advancedcore.rewards.builtin.RewardEffect; +import com.bencodez.advancedcore.rewards.builtin.RewardExp; +import com.bencodez.advancedcore.rewards.builtin.RewardFirework; +import com.bencodez.advancedcore.rewards.builtin.RewardItems; +import com.bencodez.advancedcore.rewards.builtin.RewardJavascript; +import com.bencodez.advancedcore.rewards.builtin.RewardLucky; +import com.bencodez.advancedcore.rewards.builtin.RewardMessages; +import com.bencodez.advancedcore.rewards.builtin.RewardMoney; +import com.bencodez.advancedcore.rewards.builtin.RewardPotions; +import com.bencodez.advancedcore.rewards.builtin.RewardPriority; +import com.bencodez.advancedcore.rewards.builtin.RewardRandom; +import com.bencodez.advancedcore.rewards.builtin.RewardRandomReward; +import com.bencodez.advancedcore.rewards.builtin.RewardSound; +import com.bencodez.advancedcore.rewards.builtin.RewardSpecialChance; +import com.bencodez.advancedcore.rewards.builtin.RewardSubRewards; +import com.bencodez.advancedcore.rewards.builtin.RewardTempPermission; +import com.bencodez.advancedcore.rewards.builtin.RewardTitle; + +public class BuiltinRewardBehaviorTest { + + private AdvancedCorePlugin plugin; + private AdvancedCoreConfigOptions options; + private RewardHandler handler; + private AdvancedCoreUser user; + private Reward reward; + private CopyOnWriteArrayList injects; + private HashMap placeholders; + + @BeforeEach + public void setUp() { + plugin = mock(AdvancedCorePlugin.class); + options = mock(AdvancedCoreConfigOptions.class); + handler = mock(RewardHandler.class); + user = mock(AdvancedCoreUser.class); + reward = mock(Reward.class, Answers.RETURNS_DEEP_STUBS); + injects = new CopyOnWriteArrayList<>(); + placeholders = new HashMap<>(); + + AdvancedCorePlugin.setInstance(plugin); + when(plugin.getOptions()).thenReturn(options); + when(options.getBroadcastBlacklist()).thenReturn(new ArrayList<>()); + when(handler.getInjectedRewards()).thenReturn(injects); + when(reward.getName()).thenReturn("SourceReward"); + when(reward.getRewardName()).thenReturn("SourceReward"); + when(user.getPlayerName()).thenReturn("Ben"); + } + + @Test + public void expActuallyGivesExperienceAndLevels() { + RewardExp.register(handler, plugin); + + ((RewardInjectInt) injects.get(0)).onRewardRequest(reward, user, 12, placeholders); + ((RewardInjectInt) injects.get(1)).onRewardRequest(reward, user, 4, placeholders); + + verify(user).giveExp(12); + verify(user).giveExpLevels(4); + + ConfigurationSection exp = section("EXP"); + exp.set("Min", 5); + exp.set("Max", 6); + String expResult = ((RewardInjectConfigurationSection) injects.get(2)) + .onRewardRequested(reward, user, exp, placeholders); + assertEquals("5", expResult); + verify(user).giveExp(5); + + ConfigurationSection levels = section("EXPLevels"); + levels.set("Min", 8); + levels.set("Max", 9); + String levelResult = ((RewardInjectConfigurationSection) injects.get(3)) + .onRewardRequested(reward, user, levels, placeholders); + assertEquals("8", levelResult); + verify(user).giveExpLevels(8); + } + + @Test + public void moneyActuallyGivesFixedAndRangedAmounts() { + RewardMoney.register(handler, plugin); + + String fixed = ((RewardInjectDouble) injects.get(0)).onRewardRequest(reward, user, 12.75, placeholders); + assertEquals("12", fixed); + verify(user).giveMoney(12.75); + + ConfigurationSection range = section("Money"); + range.set("Min", 5.0); + range.set("Max", 6.0); + range.set("Round", false); + String result = ((RewardInjectConfigurationSection) injects.get(1)) + .onRewardRequested(reward, user, range, placeholders); + + ArgumentCaptor amount = ArgumentCaptor.forClass(Double.class); + verify(user, atLeastOnce()).giveMoney(amount.capture()); + double ranged = amount.getAllValues().get(amount.getAllValues().size() - 1); + assertTrue(ranged >= 5.0 && ranged < 6.0); + assertNotNull(result); + } + + @Test + public void actionBarActuallySendsConfiguredMessage() { + RewardActionBar.register(handler, plugin); + placeholders.put("player", "Ben"); + ConfigurationSection section = section("ActionBar"); + section.set("Message", "Hello %player%"); + section.set("Delay", 42); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).sendActionBar("Hello Ben", 42); + } + + @Test + public void bossBarActuallySendsConfiguredBossBar() { + RewardBossBar.register(handler, plugin); + ConfigurationSection section = section("BossBar"); + section.set("Enabled", true); + section.set("Message", "Boss"); + section.set("Color", "RED"); + section.set("Style", "SEGMENTED_10"); + section.set("Progress", 0.75); + section.set("Delay", 25); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).sendBossBar("Boss", "RED", "SEGMENTED_10", 0.75, 25); + } + + @Test + public void titleActuallySendsConfiguredTitle() { + RewardTitle.register(handler, plugin); + placeholders.put("player", "Ben"); + ConfigurationSection section = section("Title"); + section.set("Enabled", true); + section.set("Title", "Hi %player%"); + section.set("SubTitle", "Welcome"); + section.set("FadeIn", 2); + section.set("ShowTime", 30); + section.set("FadeOut", 4); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).sendTitle("Hi Ben", "Welcome", 2, 30, 4); + } + + @Test + public void soundActuallyPlaysConfiguredSound() { + RewardSound.register(handler, plugin); + ConfigurationSection section = section("Sound"); + section.set("Enabled", true); + section.set("Sound", "ENTITY_PLAYER_LEVELUP"); + section.set("Volume", 0.5); + section.set("Pitch", 1.25); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).playSound("ENTITY_PLAYER_LEVELUP", 0.5f, 1.25f); + } + + @Test + public void effectActuallyPlaysConfiguredParticles() { + RewardEffect.register(handler, plugin); + ConfigurationSection section = section("Effect"); + section.set("Enabled", true); + section.set("Effect", "FLAME"); + section.set("Data", 2); + section.set("Particles", 7); + section.set("Radius", 9); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).playParticle("FLAME", 2, 7, 9); + } + + @Test + public void potionsActuallyGiveEveryConfiguredEffect() { + RewardPotions.register(handler, plugin); + ConfigurationSection section = section("Potions"); + section.createSection("SPEED"); + section.set("SPEED.Duration", 120); + section.set("SPEED.Amplifier", 2); + section.createSection("JUMP_BOOST"); + section.set("JUMP_BOOST.Duration", 60); + section.set("JUMP_BOOST.Amplifier", 1); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).givePotionEffect("SPEED", 120, 2); + verify(user).givePotionEffect("JUMP_BOOST", 60, 1); + } + + @Test + public void temporaryPermissionActuallyAddsPermission() { + RewardTempPermission.register(handler, plugin); + ConfigurationSection section = section("TempPermission"); + section.set("Permission", "advancedcore.test"); + section.set("Expiration", 90); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(user).addPermission("advancedcore.test", 90); + } + + @Test + public void commandsActuallyDispatchEveryCommandForm() { + RewardCommands.register(handler, plugin); + MiscUtils misc = mock(MiscUtils.class); + try (MockedStatic miscStatic = mockStatic(MiscUtils.class)) { + miscStatic.when(MiscUtils::getInstance).thenReturn(misc); + + ConfigurationSection number = section("NumberCommand"); + number.set("Min", 5); + number.set("Max", 5); + number.set("Command", "give Ben stone %number%"); + String generated = ((RewardInjectConfigurationSection) injects.get(0)) + .onRewardRequested(reward, user, number, placeholders); + assertEquals("5", generated); + verify(misc).executeConsoleCommands("Ben", "give Ben stone 5", placeholders); + + ((RewardInjectString) injects.get(1)).onRewardRequest(reward, user, "say hi", placeholders); + verify(misc).executeConsoleCommands("Ben", "say hi", placeholders); + + ArrayList list = new ArrayList<>(List.of("say one", "say two")); + ((RewardInjectStringList) injects.get(2)).onRewardRequest(reward, user, list, placeholders); + verify(misc).executeConsoleCommands("Ben", list, placeholders, true); + + ConfigurationSection commands = section("Commands"); + ArrayList console = new ArrayList<>(List.of("say console")); + ArrayList player = new ArrayList<>(List.of("spawn")); + commands.set("Console", console); + commands.set("Player", player); + commands.set("Stagger", false); + ((RewardInjectConfigurationSection) injects.get(3)).onRewardRequested(reward, user, commands, placeholders); + verify(misc).executeConsoleCommands("Ben", console, placeholders, false); + verify(user).preformCommand(player, placeholders); + + ArrayList random = new ArrayList<>(List.of("say only")); + ((RewardInjectStringList) injects.get(4)).onRewardRequest(reward, user, random, placeholders); + verify(misc).executeConsoleCommands("Ben", "say only", placeholders); + } + } + + @Test + public void messagesActuallySendPlayerAndBroadcastForms() { + RewardMessages.register(handler, plugin); + MiscUtils misc = mock(MiscUtils.class); + try (MockedStatic miscStatic = mockStatic(MiscUtils.class)) { + miscStatic.when(MiscUtils::getInstance).thenReturn(misc); + + ((RewardInjectString) injects.get(0)).onRewardRequest(reward, user, "hello", placeholders); + verify(user).sendMessage("hello", placeholders); + + ArrayList playerList = new ArrayList<>(List.of("one", "two")); + ((RewardInjectStringList) injects.get(1)).onRewardRequest(reward, user, playerList, placeholders); + verify(user).sendMessage(playerList, placeholders); + + ArrayList legacyList = new ArrayList<>(List.of("legacy")); + ((RewardInjectStringList) injects.get(2)).onRewardRequest(reward, user, legacyList, placeholders); + verify(user).sendMessage(legacyList, placeholders); + + ArrayList random = new ArrayList<>(List.of("only random")); + ((RewardInjectStringList) injects.get(3)).onRewardRequest(reward, user, random, placeholders); + verify(user).sendMessage("only random", placeholders); + + ((RewardInjectString) injects.get(4)).onRewardRequest(reward, user, "nested player", placeholders); + verify(user).sendMessage("nested player", placeholders); + + ArrayList broadcasts = new ArrayList<>(List.of("broadcast one", "broadcast two")); + ((RewardInjectStringList) injects.get(5)).onRewardRequest(reward, user, broadcasts, placeholders); + verify(misc).broadcast("broadcast one"); + verify(misc).broadcast("broadcast two"); + + ((RewardInjectString) injects.get(6)).onRewardRequest(reward, user, "single broadcast", placeholders); + verify(misc).broadcast("single broadcast"); + } + } + + @Test + public void itemRewardsActuallyGiveBuiltItems() { + try (MockedConstruction builders = mockConstruction(ItemBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + RewardItems.registerItem(handler, plugin); + configInject(0).onRewardRequested(reward, user, section("Item"), placeholders); + verify(user).giveItem(any(ItemBuilder.class)); + + injects.clear(); + RewardItems.registerRandomItem(handler, plugin); + ConfigurationSection random = section("RandomItem"); + random.createSection("OnlyItem"); + String selected = ((RewardInjectKeys) injects.get(0)).onRewardRequested(reward, user, + random.getKeys(false), random, placeholders); + assertEquals("OnlyItem", selected); + verify(user, atLeastOnce()).giveItem(any(ItemBuilder.class)); + + injects.clear(); + RewardItems.registerItems(handler, plugin); + ConfigurationSection items = section("Items"); + items.createSection("FirstItem"); + ((RewardInjectKeys) injects.get(0)).onRewardRequested(reward, user, items.getKeys(false), items, placeholders); + verify(user, atLeastOnce()).giveItem(any(ItemBuilder.class)); + assertTrue(builders.constructed().size() >= 3); + } + } + + @Test + public void fireworkActuallyLaunchesConfiguredFirework() { + RewardFirework.register(handler, plugin); + FireworkHandler fireworkHandler = mock(FireworkHandler.class); + Player player = mock(Player.class); + Location location = mock(Location.class); + when(user.getPlayer()).thenReturn(player); + when(player.getLocation()).thenReturn(location); + + ConfigurationSection section = section("Firework"); + section.set("Enabled", true); + section.set("Power", 2); + section.set("Colors", new ArrayList<>(List.of("RED"))); + section.set("FadeOutColor", new ArrayList<>(List.of("BLUE"))); + section.set("Trail", true); + section.set("Flicker", false); + section.set("Types", new ArrayList<>(List.of("BALL"))); + section.set("Detonate", true); + + try (MockedStatic fireworks = mockStatic(FireworkHandler.class)) { + fireworks.when(FireworkHandler::getInstance).thenReturn(fireworkHandler); + configInject(0).onRewardRequested(reward, user, section, placeholders); + } + + verify(fireworkHandler).launchFirework(eq(location), eq(2), eq(new ArrayList<>(List.of("RED"))), + eq(new ArrayList<>(List.of("BLUE"))), eq(true), eq(false), + eq(new ArrayList<>(List.of("BALL"))), eq(true)); + } + + @Test + public void randomRewardActuallyDispatchesSelectedReward() { + RewardRandomReward.register(handler, plugin); + ArrayList rewards = new ArrayList<>(List.of("OnlyReward")); + + String selected = ((RewardInjectStringList) injects.get(0)).onRewardRequest(reward, user, rewards, placeholders); + + assertEquals("OnlyReward", selected); + verify(handler).giveReward(eq(user), eq("OnlyReward"), any(RewardOptions.class)); + } + + @Test + public void advancedRandomRewardActuallyDispatchesSelectedChild() { + RewardAdvancedRandomReward.register(handler, plugin); + ConfigurationSection section = section("AdvancedRandomReward"); + section.createSection("OnlyReward"); + + String selected = configInject(0).onRewardRequested(reward, user, section, placeholders); + + assertEquals("OnlyReward", selected); + verify(handler).giveReward(eq(user), eq(section), eq("OnlyReward"), any(RewardOptions.class)); + } + + @Test + public void advancedRewardsActuallyDispatchesEveryChild() { + RewardAdvancedRewards.register(handler, plugin); + ConfigurationSection section = section("AdvancedRewards"); + section.createSection("One"); + section.createSection("Two"); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + verify(handler).giveReward(eq(user), eq(section), eq("One"), any(RewardOptions.class)); + verify(handler).giveReward(eq(user), eq(section), eq("Two"), any(RewardOptions.class)); + } + + @Test + public void advancedPriorityActuallyRunsFirstEligibleChild() { + RewardAdvancedPriority.register(handler, plugin); + ConfigurationSection section = section("AdvancedPriority"); + section.createSection("First"); + section.createSection("Second"); + Reward first = mock(Reward.class); + Reward second = mock(Reward.class); + when(handler.getReward(eq(section), eq("First"), any(RewardOptions.class))).thenReturn(first); + when(handler.getReward(eq(section), eq("Second"), any(RewardOptions.class))).thenReturn(second); + when(first.canGiveReward(eq(user), any(RewardOptions.class))).thenReturn(false); + when(second.canGiveReward(eq(user), any(RewardOptions.class))).thenReturn(true); + when(second.getName()).thenReturn("Second"); + + String selected = configInject(0).onRewardRequested(reward, user, section, placeholders); + + assertEquals("Second", selected); + verify(first, never()).giveReward(eq(user), any(RewardOptions.class)); + verify(second).giveReward(eq(user), any(RewardOptions.class)); + } + + @Test + public void advancedWorldActuallyScopesEachChildToItsWorld() { + RewardAdvancedWorld.register(handler, plugin); + ConfigurationSection section = section("AdvancedWorld"); + section.createSection("world_nether"); + + configInject(0).onRewardRequested(reward, user, section, placeholders); + + assertEquals(List.of("world_nether"), section.getStringList("world_nether.Worlds")); + verify(handler).giveReward(eq(user), eq(section), eq("world_nether"), any(RewardOptions.class)); + } + + @Test + public void priorityActuallySkipsIneligibleRewardAndSendsEligibleReward() { + RewardPriority.register(handler, plugin); + Reward first = mock(Reward.class); + Reward second = mock(Reward.class); + when(handler.getReward("First")).thenReturn(first); + when(handler.getReward("Second")).thenReturn(second); + when(first.canGiveReward(eq(user), any(RewardOptions.class))).thenReturn(false); + when(second.canGiveReward(eq(user), any(RewardOptions.class))).thenReturn(true); + when(second.getName()).thenReturn("Second"); + + try (MockedConstruction builders = mockConstruction(RewardBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + String selected = ((RewardInjectStringList) injects.get(0)).onRewardRequest(reward, user, + new ArrayList<>(List.of("First", "Second")), placeholders); + assertEquals("Second", selected); + assertEquals(1, builders.constructed().size()); + verify(builders.constructed().get(0)).send(user); + } + } + + @Test + public void randomActuallyDispatchesConfiguredRewardWhenChancePasses() { + RewardRandom.register(handler, plugin); + MiscUtils misc = mock(MiscUtils.class); + when(misc.checkChance(anyDouble(), anyDouble())).thenReturn(true); + ConfigurationSection section = section("Random"); + section.set("Chance", 100.0); + section.set("PickRandom", true); + section.set("Rewards", new ArrayList<>(List.of("OnlyReward"))); + + try (MockedStatic miscStatic = mockStatic(MiscUtils.class)) { + miscStatic.when(MiscUtils::getInstance).thenReturn(misc); + configInject(0).onRewardRequested(reward, user, section, placeholders); + } + + verify(handler).giveReward(eq(user), eq("OnlyReward"), any(RewardOptions.class)); + } + + @Test + public void luckyActuallySendsPassingLuckyReward() { + RewardLucky.register(handler, plugin); + MiscUtils misc = mock(MiscUtils.class); + when(misc.checkChance(1, 1)).thenReturn(true); + when(reward.getConfig().getConfigData().getBoolean("OnlyOneLucky", false)).thenReturn(true); + ConfigurationSection section = section("Lucky"); + section.createSection("1"); + + try (MockedStatic miscStatic = mockStatic(MiscUtils.class); + MockedConstruction builders = mockConstruction(RewardBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + miscStatic.when(MiscUtils::getInstance).thenReturn(misc); + configInject(0).onRewardRequested(reward, user, section, placeholders); + assertEquals(1, builders.constructed().size()); + verify(builders.constructed().get(0)).send(user); + } + } + + @Test + public void specialChanceActuallySendsSelectedBucket() { + RewardSpecialChance.register(handler, plugin); + ConfigurationSection section = section("SpecialChance"); + section.createSection("100"); + + try (MockedConstruction builders = mockConstruction(RewardBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + configInject(0).onRewardRequested(reward, user, section, placeholders); + assertEquals(1, builders.constructed().size()); + verify(builders.constructed().get(0)).send(user); + } + } + + @Test + public void subRewardsActuallyBuildAndSendNestedRewards() { + RewardSubRewards.register(handler, plugin); + ConfigurationSection section = section("Rewards"); + + try (MockedConstruction builders = mockConstruction(RewardBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + configInject(0).onRewardRequested(reward, user, section, placeholders); + assertEquals(1, builders.constructed().size()); + verify(builders.constructed().get(0)).send(user); + } + } + + @Test + public void choicesActuallyQueuesOrDispatchesSelectedChoice() { + RewardChoices.register(handler, plugin); + RewardInjectBoolean choices = (RewardInjectBoolean) injects.get(0); + + when(user.getChoicePreference("SourceReward")).thenReturn(""); + choices.onRewardRequest(reward, user, true, placeholders); + verify(user).addUnClaimedChoiceReward("SourceReward"); + + when(user.getChoicePreference("SourceReward")).thenReturn("OptionA"); + choices.onRewardRequest(reward, user, true, placeholders); + verify(handler).giveChoicesReward(reward, user, "OptionA"); + } + + @Test + public void javascriptActuallyExecutesScriptsAndTrueBranch() { + RewardJavascript.register(handler, plugin); + + try (MockedConstruction engines = mockConstruction(JavascriptEngine.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF))) { + ((RewardInjectStringList) injects.get(0)).onRewardRequest(reward, user, + new ArrayList<>(List.of("run()")), placeholders); + assertEquals(1, engines.constructed().size()); + verify(engines.constructed().get(0)).execute("run()"); + } + + ConfigurationSection section = section("Javascript"); + section.set("Enabled", true); + section.set("Expression", "true"); + List> constructorArgs = new ArrayList<>(); + try (MockedConstruction engines = mockConstruction(JavascriptEngine.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF), + (engine, context) -> when(engine.getBooleanValue("true")).thenReturn(true)); + MockedConstruction builders = mockConstruction(RewardBuilder.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF), + (builder, context) -> constructorArgs.add(context.arguments()))) { + configInject(1).onRewardRequested(reward, user, section, placeholders); + assertEquals(1, builders.constructed().size()); + assertEquals("TrueRewards", constructorArgs.get(0).get(1)); + verify(builders.constructed().get(0)).send(user); + } + } + + private RewardInjectConfigurationSection configInject(int index) { + return (RewardInjectConfigurationSection) injects.get(index); + } + + private ConfigurationSection section(String name) { + return new YamlConfiguration().createSection(name); + } + + @SuppressWarnings("unused") + private RewardInject register(BiConsumer registrar) { + injects.clear(); + registrar.accept(handler, plugin); + return injects.get(0); + } +} From d1e01de4b318af9f60a0aeaebda01d11d8c5d2e7 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 23 Aug 2026 12:17:00 -0600 Subject: [PATCH 20/20] Test built-in reward requirement behavior --- .../BuiltinRequirementBehaviorTest.java | 281 ++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementBehaviorTest.java diff --git a/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementBehaviorTest.java b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementBehaviorTest.java new file mode 100644 index 000000000..472dd92fd --- /dev/null +++ b/AdvancedCore/src/test/java/com/bencodez/advancedcore/tests/rewards/BuiltinRequirementBehaviorTest.java @@ -0,0 +1,281 @@ +package com.bencodez.advancedcore.tests.rewards; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockConstruction; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.withSettings; + +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.CopyOnWriteArrayList; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Server; +import org.bukkit.World; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Answers; +import org.mockito.MockedConstruction; +import org.mockito.MockedStatic; + +import com.bencodez.advancedcore.AdvancedCoreConfigOptions; +import com.bencodez.advancedcore.AdvancedCorePlugin; +import com.bencodez.advancedcore.api.javascript.JavascriptEngine; +import com.bencodez.advancedcore.api.misc.MiscUtils; +import com.bencodez.advancedcore.api.misc.PlayerManager; +import com.bencodez.advancedcore.api.rewards.Reward; +import com.bencodez.advancedcore.api.rewards.RewardHandler; +import com.bencodez.advancedcore.api.rewards.RewardOptions; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInject; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectConfigurationSection; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectDouble; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectInt; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectString; +import com.bencodez.advancedcore.api.rewards.injectedrequirement.RequirementInjectStringList; +import com.bencodez.advancedcore.api.user.AdvancedCoreUser; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementChance; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementDate; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementDayOfMonth; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementJavascript; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementLocationDistance; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementPermission; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementRewardExpiration; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementRewardType; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementServer; +import com.bencodez.advancedcore.rewards.builtin.requirements.RequirementWorld; + +public class BuiltinRequirementBehaviorTest { + + private AdvancedCorePlugin plugin; + private AdvancedCoreConfigOptions options; + private RewardHandler handler; + private AdvancedCoreUser user; + private Reward reward; + private CopyOnWriteArrayList requirements; + + @BeforeEach + public void setUp() { + plugin = mock(AdvancedCorePlugin.class); + options = mock(AdvancedCoreConfigOptions.class); + handler = mock(RewardHandler.class); + user = mock(AdvancedCoreUser.class); + reward = mock(Reward.class, Answers.RETURNS_DEEP_STUBS); + requirements = new CopyOnWriteArrayList<>(); + + AdvancedCorePlugin.setInstance(plugin); + when(plugin.getOptions()).thenReturn(options); + when(handler.getInjectedRequirements()).thenReturn(requirements); + when(reward.getName()).thenReturn("SourceReward"); + when(reward.getRewardName()).thenReturn("SourceReward"); + } + + @Test + public void chanceActuallyHonorsIgnoreFlagAndChanceResult() { + RequirementChance.register(handler, plugin); + RequirementInjectDouble chance = (RequirementInjectDouble) requirements.get(0); + RewardOptions rewardOptions = mock(RewardOptions.class); + MiscUtils misc = mock(MiscUtils.class); + + when(rewardOptions.isIgnoreChance()).thenReturn(true); + assertTrue(chance.onRequirementsRequest(reward, user, 1.0, rewardOptions)); + + try (MockedStatic miscStatic = mockStatic(MiscUtils.class)) { + miscStatic.when(MiscUtils::getInstance).thenReturn(misc); + verify(misc, never()).checkChance(1.0, 100); + + when(rewardOptions.isIgnoreChance()).thenReturn(false); + when(misc.checkChance(25.0, 100)).thenReturn(false); + assertFalse(chance.onRequirementsRequest(reward, user, 25.0, rewardOptions)); + verify(misc).checkChance(25.0, 100); + } + } + + @Test + public void rewardExpirationActuallyAllowsFreshAndRejectsExpiredTriggers() { + RequirementRewardExpiration.register(handler, plugin); + RequirementInjectInt expiration = (RequirementInjectInt) requirements.get(0); + RewardOptions rewardOptions = mock(RewardOptions.class); + + when(rewardOptions.getOrginalTrigger()).thenReturn(System.currentTimeMillis() - 30_000); + assertTrue(expiration.onRequirementsRequest(reward, user, 1, rewardOptions)); + + when(rewardOptions.getOrginalTrigger()).thenReturn(System.currentTimeMillis() - 120_000); + assertFalse(expiration.onRequirementsRequest(reward, user, 1, rewardOptions)); + } + + @Test + public void permissionActuallyChecksAndSupportsReversePermission() { + RequirementPermission.register(handler, plugin); + RequirementInjectString permission = (RequirementInjectString) requirements.get(0); + RewardOptions rewardOptions = new RewardOptions(); + PlayerManager playerManager = mock(PlayerManager.class); + String uuid = UUID.randomUUID().toString(); + when(user.getUUID()).thenReturn(uuid); + when(user.getPlayerName()).thenReturn("Ben"); + when(reward.getConfig().getRequirePermission()).thenReturn(true); + when(playerManager.hasServerPermission(UUID.fromString(uuid), "Ben", "advancedcore.test")).thenReturn(true); + + try (MockedStatic managerStatic = mockStatic(PlayerManager.class)) { + managerStatic.when(PlayerManager::getInstance).thenReturn(playerManager); + + assertTrue(permission.onRequirementsRequest(reward, user, "advancedcore.test", rewardOptions)); + assertFalse(permission.onRequirementsRequest(reward, user, "!advancedcore.test", rewardOptions)); + } + } + + @Test + public void dayOfMonthActuallyMatchesCurrentDay() { + RequirementDayOfMonth.register(handler, plugin); + RequirementInjectConfigurationSection day = configRequirement(0); + ConfigurationSection section = section("DayOfMonth"); + section.set("Enabled", true); + int today = LocalDateTime.now().getDayOfMonth(); + section.set("Days", List.of(today)); + + assertTrue(day.onRequirementsRequested(reward, user, section, new RewardOptions())); + + int differentDay = today == 1 ? 2 : 1; + section.set("Days", List.of(differentDay)); + assertFalse(day.onRequirementsRequested(reward, user, section, new RewardOptions())); + } + + @Test + public void serverActuallyAllowsMatchingAndRejectsBlockedServer() { + Server server = mock(Server.class); + when(server.getName()).thenReturn("Lobby"); + when(options.getServer()).thenReturn("Lobby"); + + try (MockedStatic bukkit = mockStatic(Bukkit.class)) { + bukkit.when(Bukkit::getServer).thenReturn(server); + RequirementServer.register(handler, plugin); + } + + RequirementInjectString serverRequirement = (RequirementInjectString) requirements.get(0); + RequirementInjectStringList blocked = (RequirementInjectStringList) requirements.get(1); + RewardOptions rewardOptions = new RewardOptions(); + + assertTrue(serverRequirement.onRequirementsRequest(reward, user, "Lobby", rewardOptions)); + assertFalse(serverRequirement.onRequirementsRequest(reward, user, "Other", rewardOptions)); + assertFalse(blocked.onRequirementsRequest(reward, user, new ArrayList<>(List.of("Lobby")), rewardOptions)); + assertTrue(blocked.onRequirementsRequest(reward, user, new ArrayList<>(List.of("Other")), rewardOptions)); + } + + @Test + public void worldActuallyAllowsWhitelistAndRejectsBlacklist() { + RequirementWorld.register(handler, plugin); + RequirementInjectStringList worlds = (RequirementInjectStringList) requirements.get(0); + RequirementInjectStringList blacklist = (RequirementInjectStringList) requirements.get(1); + RewardOptions rewardOptions = new RewardOptions(); + Player player = mock(Player.class); + World world = mock(World.class); + when(user.getPlayer()).thenReturn(player); + when(player.getWorld()).thenReturn(world); + when(world.getName()).thenReturn("world"); + + assertTrue(worlds.onRequirementsRequest(reward, user, new ArrayList<>(List.of("world")), rewardOptions)); + assertFalse(worlds.onRequirementsRequest(reward, user, new ArrayList<>(List.of("other")), rewardOptions)); + verify(user).setCheckWorld(true); + + assertFalse(blacklist.onRequirementsRequest(reward, user, new ArrayList<>(List.of("world")), rewardOptions)); + assertTrue(blacklist.onRequirementsRequest(reward, user, new ArrayList<>(List.of("other")), rewardOptions)); + } + + @Test + public void rewardTypeActuallyDistinguishesOnlineAndOfflineDelivery() { + RequirementRewardType.register(handler, plugin); + RequirementInjectString type = (RequirementInjectString) requirements.get(0); + RewardOptions rewardOptions = mock(RewardOptions.class); + + when(rewardOptions.isOnline()).thenReturn(true); + assertTrue(type.onRequirementsRequest(reward, user, "ONLINE", rewardOptions)); + assertFalse(type.onRequirementsRequest(reward, user, "OFFLINE", rewardOptions)); + + when(rewardOptions.isOnline()).thenReturn(false); + assertTrue(type.onRequirementsRequest(reward, user, "OFFLINE", rewardOptions)); + assertFalse(type.onRequirementsRequest(reward, user, "ONLINE", rewardOptions)); + assertTrue(type.onRequirementsRequest(reward, user, "BOTH", rewardOptions)); + } + + @Test + public void javascriptActuallyUsesExpressionResult() { + RequirementJavascript.register(handler, plugin); + RequirementInjectString javascript = (RequirementInjectString) requirements.get(0); + RewardOptions rewardOptions = new RewardOptions(); + + try (MockedConstruction engines = mockConstruction(JavascriptEngine.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF), + (engine, context) -> when(engine.getBooleanValue(anyString())).thenReturn(true))) { + assertTrue(javascript.onRequirementsRequest(reward, user, "true", rewardOptions)); + assertTrue(engines.constructed().size() == 1); + } + + try (MockedConstruction engines = mockConstruction(JavascriptEngine.class, + withSettings().defaultAnswer(Answers.RETURNS_SELF), + (engine, context) -> when(engine.getBooleanValue(anyString())).thenReturn(false))) { + assertFalse(javascript.onRequirementsRequest(reward, user, "false", rewardOptions)); + } + } + + @Test + public void dateActuallyMatchesCurrentDateAndRejectsDifferentDate() { + RequirementDate.register(handler, plugin); + RequirementInjectConfigurationSection date = configRequirement(0); + LocalDateTime now = LocalDateTime.now(); + ConfigurationSection section = section("Date"); + section.set("WeekDay", now.getDayOfWeek().name()); + section.set("DayOfMonth", now.getDayOfMonth()); + section.set("Month", now.getMonth().name()); + + assertTrue(date.onRequirementsRequested(reward, user, section, new RewardOptions())); + + section.set("WeekDay", now.getDayOfWeek().plus(1).name()); + assertFalse(date.onRequirementsRequested(reward, user, section, new RewardOptions())); + } + + @Test + public void locationDistanceActuallyChecksWorldAndDistance() { + RequirementLocationDistance.register(handler, plugin); + RequirementInjectConfigurationSection distance = configRequirement(0); + World world = mock(World.class); + Player player = mock(Player.class); + when(world.getName()).thenReturn("world"); + when(user.isOnline()).thenReturn(true); + when(user.getPlayer()).thenReturn(player); + when(player.getLocation()).thenReturn(new Location(world, 3, 0, 0)); + + ConfigurationSection section = section("LocationDistance"); + section.set("World", "world"); + section.set("X", 0); + section.set("Y", 0); + section.set("Z", 0); + section.set("Distance", 5); + + try (MockedStatic bukkit = mockStatic(Bukkit.class)) { + bukkit.when(() -> Bukkit.getWorld("world")).thenReturn(world); + assertTrue(distance.onRequirementsRequested(reward, user, section, new RewardOptions())); + + section.set("Distance", 2); + assertFalse(distance.onRequirementsRequested(reward, user, section, new RewardOptions())); + } + } + + private RequirementInjectConfigurationSection configRequirement(int index) { + return (RequirementInjectConfigurationSection) requirements.get(index); + } + + private ConfigurationSection section(String name) { + return new YamlConfiguration().createSection(name); + } +}