Examples with ItemBuilder com.bencodez.advancedcore.api.item.ItemBuilder used on opensource projects

Example 36 with ItemBuilder

use of com.bencodez.advancedcore.api.item.ItemBuilder in project AdvancedCore by BenCodez.

the class ChoiceGUI method openClaimChoices.

public void openClaimChoices(Player player) {
    AdvancedCoreUser user = plugin.getUserManager().getUser(player);
    BInventory inv = new BInventory("UnClaimed Choices");
    ArrayList<String> choices = user.getUnClaimedChoices();
    Set<String> unClaimedChoices = new HashSet<String>();
    for (String str : choices) {
        unClaimedChoices.add(str);
    }
    for (String rewardName : unClaimedChoices) {
        Reward reward = plugin.getRewardHandler().getReward(rewardName);
        if (reward.getConfig().getEnableChoices()) {
            inv.addButton(new BInventoryButton(new ItemBuilder(reward.getConfig().getDisplayItem())) {

                @Override
                public void onClick(ClickEvent clickEvent) {
                    openClaimChoices(clickEvent.getPlayer(), (Reward) getData("Reward"));
                }
            }.addData("Reward", reward));
        }
    }
    inv.openInventory(player);
}

Example 37 with ItemBuilder

use of com.bencodez.advancedcore.api.item.ItemBuilder in project AdvancedCore by BenCodez.

the class RewardEditGUI method openRewardGUIRewards.

public void openRewardGUIRewards(Player player, RewardEditData rewardEditData, String rewardName, boolean unsetValuesShown) {
    EditGUI inv = new EditGUI("Rewards: " + rewardName);
    inv.requirePermission(AdvancedCorePlugin.getInstance().getOptions().getPermPrefix() + ".RewardEdit");
    inv.addData("Reward", rewardEditData);
    for (RewardInject injectReward : plugin.getRewardHandler().getInjectedRewards()) {
        if (injectReward.isEditable()) {
            for (BInventoryButton b : injectReward.getEditButtons()) {
                if (b instanceof EditGUIButton) {
                    EditGUIButton eb = (EditGUIButton) b;
                    if (unsetValuesShown || eb.getEditor().containsKey(rewardEditData)) {
                        if (eb.getEditor().isCanGetValue()) {
                            eb.getEditor().setCurrentValue(rewardEditData.getValue(eb.getEditor().getKey()));
                        }
                        inv.addButton(eb);
                    }
                } else {
                    inv.addButton(b);
                }
            }
        }
    }
    inv.sort();
    if (!unsetValuesShown) {
        inv.addButton(new BInventoryButton(new ItemBuilder(Material.CHEST).setName("&cUnset Values")) {

            @Override
            public void onClick(ClickEvent clickEvent) {
                openRewardGUIRewards(player, rewardEditData, rewardName, true);
            }
        });
    } else {
        inv.addButton(new BInventoryButton(new ItemBuilder(Material.BOOK).setName("&cValues not setable in GUI yet:").setLore("&aRandom, Item, Items(WIP), RandomItem", "&bThese will eventually be aded to edit gui", "&3Also looking for feedback on GUI")) {

            @Override
            public void onClick(ClickEvent clickEvent) {
            }
        });
    }
    inv.addButton(new BInventoryButton(new ItemBuilder(Material.BARRIER).setName("&cGo back")) {

        @Override
        public void onClick(ClickEvent clickEvent) {
            openRewardGUI(clickEvent.getPlayer(), rewardEditData, rewardName);
        }
    });
    inv.openInventory(player);
}

Example 38 with ItemBuilder

use of com.bencodez.advancedcore.api.item.ItemBuilder in project AdvancedCore by BenCodez.

the class RewardHandler method loadInjectedRequirements.

public void loadInjectedRequirements() {
    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.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);
            }
            boolean perm = PlayerUtils.getInstance().hasServerPermission(UUID.fromString(user.getUUID()), str);
            if (reverse) {
                perm = !perm;
            }
            if (!perm) {
                plugin.getLogger().info(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 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("Worlds", new ArrayList<String>()) {

        @Override
        public boolean onRequirementsRequest(Reward reward, AdvancedCoreUser user, ArrayList<String> worlds, RewardOptions rewardOptions) {
            if (worlds.isEmpty()) {
                return true;
            }
            Player player = user.getPlayer();
            if (player == null) {
                return false;
            }
            reward.checkRewardFile();
            String world = player.getWorld().getName();
            if (worlds.contains(world)) {
                return true;
            }
            user.setCheckWorld(true);
            return false;
        }
    }.priority(100).allowReattempt().alwaysForce().addEditButton(new EditGUIButton(new ItemBuilder("END_PORTAL_FRAME"), new EditGUIValueList("Worlds", null) {

        @Override
        public void setValue(Player player, ArrayList<String> 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<String> list = (ArrayList<String>) data.getList("Worlds", 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")) {
                    plugin.debug("Reward Type Don't match");
                    return false;
                }
            } else {
                if (type.equalsIgnoreCase("online")) {
                    plugin.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(StringParser.getInstance().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("LocationDistance") {

        @Override
        public boolean onRequirementsRequested(Reward reward, AdvancedCoreUser user, ConfigurationSection section, RewardOptions rewardOptions) {
            if (!user.isOnline()) {
                plugin.debug("user not online");
                return false;
            }
            Location loc = new Location(Bukkit.getWorld(section.getString("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 locaction to get reward"))));
    for (RequirementInject reward : injectedRequirements) {
        reward.setInternalReward(true);
    }
    sortInjectedRequirements();
}

Example 39 with ItemBuilder

use of com.bencodez.advancedcore.api.item.ItemBuilder in project AdvancedCore by BenCodez.

the class RewardEdit method getBackButton.

public EditGUIButton getBackButton(RewardEditData reward) {
    EditGUIButton b = new EditGUIButton(new ItemBuilder("BARRIER").setName("&cGo back"), new EditGUIValueInventory("") {

        @Override
        public void openInventory(ClickEvent clickEvent) {
            reward.reOpenEditGUI(clickEvent.getPlayer());
        }
    });
    b.setSlot(-2);
    return b;
}

Example 40 with ItemBuilder

use of com.bencodez.advancedcore.api.item.ItemBuilder in project AdvancedCore by BenCodez.

the class RewardEditAdvancedPriority method openRemove.

public void openRemove(Player player, RewardEditData reward) {
    EditGUI inv = new EditGUI("Edit AdvancedPriority Remove: " + reward.getName());
    inv.addData("Reward", reward);
    for (String key : reward.getData().getConfigurationSection("AdvancedPriority").getKeys(false)) {
        inv.addButton(new BInventoryButton(new ItemBuilder(Material.PAPER).setName("&c" + key).addLoreLine("&cClick to remove")) {

            @Override
            public void onClick(ClickEvent clickEvent) {
                RewardEditData reward = (RewardEditData) getInv().getData("Reward");
                reward.setValue("AdvancedPriority." + key, null);
                reloadAdvancedCore();
                open(player, reward);
            }
        });
    }
    inv.addButton(getBackButtonCustom(reward, new EditGUIValueInventory("") {

        @Override
        public void openInventory(ClickEvent clickEvent) {
            RewardEditData reward = (RewardEditData) getInv().getData("Reward");
            open(player, reward);
        }
    }));
    inv.openInventory(player);
}