// TODO: Convert this to use one of the new text classes?
public static String listKits(final IEssentials ess, final User user) throws Exception {
try {
final ConfigurationSection kits = ess.getSettings().getKits();
final StringBuilder list = new StringBuilder();
for (String kitItem : kits.getKeys(false)) {
if (user == null) {
list.append(" ").append(capitalCase(kitItem));
} else if (user.isAuthorized("essentials.kits." + kitItem.toLowerCase(Locale.ENGLISH))) {
String cost = "";
String name = capitalCase(kitItem);
BigDecimal costPrice =
new Trade("kit-" + kitItem.toLowerCase(Locale.ENGLISH), ess).getCommandCost(user);
if (costPrice.signum() > 0) {
cost = tl("kitCost", NumberUtil.displayCurrency(costPrice, ess));
}
Kit kit = new Kit(kitItem, ess);
if (kit.getNextUse(user) != 0) {
name = tl("kitDelay", name);
}
list.append(" ").append(name).append(cost);
}
}
return list.toString().trim();
} catch (Exception ex) {
throw new Exception(tl("kitError"), ex);
}
}
@Override
public ResourceFactory parse(ConfigurationSection input, String key) throws ParsingException {
if (input == null) throw new NullArgumentException("input");
if (key == null) throw new NullArgumentException("key");
// Move to the next section
if (key != null && input.isConfigurationSection(key)) {
input = input.getConfigurationSection(key);
}
ItemsFactory factory = new ItemsFactory();
for (String node : input.getKeys(false)) {
Query query = itemParser.parse(node);
// Handle both item queries and potion queries
if (query instanceof ItemQuery)
factory.addItems((ItemQuery) query, rangeParser.parse(input, node));
else if (query instanceof PotionQuery)
factory.addItems(((PotionQuery) query).toItemQuery(true), rangeParser.parse(input, node));
else throw ParsingException.fromFormat("Unable to parse range on item %s.", key);
}
return factory;
}
// ItemStack
public static HashMap<Integer, ItemStack> loadInventory(final ConfigurationSection config) {
final Set<String> entries = config.getKeys(false);
final HashMap<Integer, ItemStack> res = new HashMap<Integer, ItemStack>(entries.size());
for (final String key : entries)
res.put(Integer.parseInt(key), loadItemStack(config.getConfigurationSection(key)));
return res;
}
private boolean importIsland(uSkyBlock plugin, File file) {
log.info("Importing " + file);
FileConfiguration config = new YamlConfiguration();
readConfig(config, file);
if (config.contains("party.leader") && !config.contains("party.leader.name")) {
String leaderName = config.getString("party.leader");
ConfigurationSection leaderSection = config.createSection("party.leader");
leaderSection.set("name", leaderName);
leaderSection.set("uuid", UUIDUtil.asString(getUUID(leaderName)));
}
ConfigurationSection members = config.getConfigurationSection("party.members");
if (members != null) {
for (String member : members.getKeys(false)) {
ConfigurationSection section = members.getConfigurationSection(member);
if (!section.contains("name")) {
members.set(member, null);
String uuid = UUIDUtil.asString(getUUID(member));
members.createSection(uuid, section.getValues(true));
members.set(uuid + ".name", member);
} else {
log.info("Skipping " + member + ", already has a name");
}
}
}
try {
config.save(file);
return true;
} catch (IOException e) {
log.log(Level.SEVERE, "Failed to import " + file, e);
return false;
}
}
public static void loadClasses(ConfigurationSection cs) {
if (cs == null) {
Log.info(BattleArena.getPName() + " has no classes");
return;
}
StringBuilder sb = new StringBuilder();
Set<String> keys = cs.getKeys(false);
boolean first = true;
for (String className : keys) {
ArenaClass ac = parseArenaClass(cs.getConfigurationSection(className));
if (ac == null) continue;
if (first) first = false;
else sb.append(", ");
sb.append(ac.getName());
ArenaClassController.addClass(ac);
}
if (first) {
Log.info(
BattleArena.getPName()
+ " no predefined classes found. inside of "
+ cs.getCurrentPath());
} else {
Log.info(BattleArena.getPName() + " registering classes: " + sb.toString());
}
}
@Override
public void initialize(Spell spell, ConfigurationSection parameters)
{
super.initialize(spell, parameters);
if (parameters.contains("biomes"))
{
ConfigurationSection biomeConfig = ConfigurationUtils.getConfigurationSection(parameters, "biomes");
biomeMap = new HashMap<>();
Collection<String> biomeKeys = biomeConfig.getKeys(false);
for (String biomeKey : biomeKeys)
{
try {
Biome biome = Biome.valueOf(biomeKey.toUpperCase());
List<String> treeTypes = ConfigurationUtils.getStringList(biomeConfig, biomeKey);
for (String typeKey : treeTypes)
{
try {
TreeType treeType = TreeType.valueOf(typeKey.toUpperCase());
List<TreeType> biomeTypes = biomeMap.get(biome);
if (biomeTypes == null) {
biomeTypes = new ArrayList<>();
biomeMap.put(biome, biomeTypes);
}
biomeTypes.add(treeType);
} catch (Exception treeEx) {
Bukkit.getLogger().warning("Invalid tree type: " + typeKey);
}
}
} catch (Exception biomeEx) {
Bukkit.getLogger().warning("Invalid biome: " + biomeKey);
}
}
}
}
public static AbstractRewardSettings<EntityType> parseConfig(ConfigurationSection config) {
Map<EntityType, List<AbstractRewardSource>> sources =
new HashMap<EntityType, List<AbstractRewardSource>>();
ConfigurationSection rewardTable = config.getConfigurationSection("RewardTable");
if (rewardTable != null) {
for (String typeName : rewardTable.getKeys(false)) {
EntityType type = EntityType.fromName(typeName);
if (type != null) {
AbstractRewardSource source =
configureRewardSource(
RewardSourceFactory.createSource(
typeName, rewardTable.getConfigurationSection(typeName)),
config);
if (!sources.containsKey(type)) {
sources.put(type, new ArrayList<AbstractRewardSource>());
}
sources
.get(type)
.add(
mergeSets(
source,
rewardTable.getConfigurationSection(typeName),
config.getConfigurationSection("RewardSets")));
}
}
}
EntityRewardSettings settings = new EntityRewardSettings(sources);
settings.setHuntingRules(loadHuntingRules(config));
return settings;
}
private static ConfigurationSection getSection(String name) {
ConfigurationSection section = yaml.getConfigurationSection(name);
if (section == null)
for (String key : yaml.getKeys(false))
if (key.equalsIgnoreCase(name)) section = yaml.getConfigurationSection(key);
return section;
}
@SuppressWarnings({"rawtypes", "unchecked"})
protected List getList(Field field, ConfigurationSection cs, String path, int depth)
throws Exception {
depth++;
int listSize = cs.getKeys(false).size();
String key = path;
if (key.lastIndexOf(".") >= 0) {
key = key.substring(key.lastIndexOf("."));
}
List list = new ArrayList();
if (listSize > 0) {
int loaded = 0;
int i = 0;
while (loaded < listSize) {
if (cs.isSet(key + i)) {
Object in = cs.get(key + i);
in = loadObject(field, cs, key + i, depth);
list.add(in);
loaded++;
}
i++;
// ugly overflow guard... should only be needed if config was manually edited very badly
if (i > (listSize * 3)) loaded = listSize;
}
}
return list;
}
/**
* Loads a list of ItemStack objects from a ConfigurationSection.
*
* @param section Where to read the saved list.
* @return A correctly build List of Itemstack Objects.
*/
public static List<ItemStack> loadItemStack(ConfigurationSection section) {
List<ItemStack> stacks = new LinkedList<>();
for (String key : section.getKeys(false)) {
stacks.add((ItemStack) section.get(key));
}
return stacks;
}
public void load(MagickElement element, ConfigurationSection spellSection) throws Exception {
for (String spellKey : spellSection.getKeys(false)) {
ConfigurationSection spell = spellSection.getConfigurationSection(spellKey);
SpellEntry spellEntry = new SpellEntry(this.element);
spellEntry.load(element, spell);
spellRegistries.put(spellKey, spellEntry);
}
}
public void setCooldown(String command, OfflinePlayer p) {
ConfigurationSection cmdCds = plugin.getConfig().getConfigurationSection("command_cooldowns");
if (cmdCds == null) return;
boolean contains = cmdCds.getKeys(false).contains(command);
if (plugin.cooldownAliases)
if (plugin.getCommand(command) != null)
for (String alias : plugin.getCommand(command).getAliases())
if (cmdCds.getKeys(false).contains(alias)) {
contains = true;
break;
}
if (contains) {
long cooldown = cmdCds.getLong(command);
PConfManager.setPValLong(
p, new Date().getTime() + (cooldown * 1000), "command_cooldowns." + command);
}
}
private Set<ChatColor> possibleColors() {
Set<ChatColor> result = EnumSet.noneOf(ChatColor.class);
ConfigurationSection colorSection = getConfig().getConfigurationSection("colors");
for (String colorName : colorSection.getKeys(false)) {
ConfigurationSection singleColor = colorSection.getConfigurationSection(colorName);
result.add(ChatColor.getByChar(singleColor.getString("code")));
}
return result;
}
private ChatColor getPermColor(Player player) {
ConfigurationSection colorSection = getConfig().getConfigurationSection("colors");
for (String colorName : colorSection.getKeys(false)) {
if (player.hasPermission("coloredplayernames." + colorName)) {
return ChatColor.getByChar(colorSection.getString(colorName + ".code"));
}
}
return null;
}
/**
* Gets the group of a world.
*
* @param w World to get group of
* @return String of group name or null if no group
*/
public String getWorldGroup(World w) {
ConfigurationSection cs =
this.plugin.getConfig().getConfigurationSection("worldmanager.inventory_separation.groups");
Set<String> s = cs.getKeys(false);
for (String group : s) {
List<String> worlds = cs.getStringList(group);
if (worlds.contains(w.getName())) return group;
}
return null;
}
/** Method to add all the head kits to the kit list */
private void parseKits() {
ConfigurationSection headSec =
plugin.getConfigManager().getConfig("kits.yml").getConfig().getConfigurationSection("kits");
for (String s : headSec.getKeys(false)) {
Kit newKit = parseKit(headSec.getConfigurationSection(s), s);
if (newKit != null) {
headKits.add(newKit);
}
}
}
/** Get all boughthomes from the config */
private void getBoughtHomes() {
if (config.contains("boughthome")) { // See if the config contains the boughthomes section
ConfigurationSection boughtConfig =
config.getConfigurationSection("boughthome"); // Get the section
for (String key : boughtConfig.getKeys(false)) { // Loop thru all players
boughtHomes.put(
Integer.valueOf(key), boughtConfig.getInt(key)); // Put the player in the map
}
}
}
private double weight(ChatColor color) {
ConfigurationSection colorSection = getConfig().getConfigurationSection("colors");
for (String colorName : colorSection.getKeys(false)) {
ConfigurationSection singleColor = colorSection.getConfigurationSection(colorName);
if (singleColor.getString("code").equals(String.valueOf(color.getChar()))) {
return singleColor.getDouble("weight");
}
}
return 0.0;
}
public static <T> List<T> loadList(
final ConfigurationSection config,
final Class<T> parentClazz,
final Class<?>[] paraClazzes,
final Object[] paraObjects) {
final ArrayList<T> list = new ArrayList<T>();
if (config == null) return list;
for (final String key : config.getKeys(false))
list.add(load(config.getConfigurationSection(key), parentClazz, paraClazzes, paraObjects));
return list;
}
/**
* Util for YAMLReader to get all child-keys as Set<String> for a given Node
*
* @param config the YAMLConfiguration to search through
* @param yamlNode the Node to get the children from
* @return the children as Set<String>
*/
public Set<String> getYAMLChildren(String yamlNode) {
try {
ConfigurationSection tempMem = getConfigurationSection(yamlNode);
Set<String> tempSet = tempMem.getKeys(false);
return tempSet;
} catch (Exception e) {
Set<String> empty = new LinkedHashSet<String>();
return empty;
}
}
@Override
protected void load(ConfigurationSection config) {
super.load(config);
offers.clear();
ConfigurationSection costsSection = config.getConfigurationSection("costs");
if (costsSection != null) {
for (String key : costsSection.getKeys(false)) {
offers.put(key, costsSection.getInt(key));
}
}
}
public Map<String, String[]> getCommandAliases() {
Map<String, String[]> aliases = new HashMap<String, String[]>();
ConfigurationSection section = config.getConfigurationSection("aliases");
if (section == null) return aliases;
List<String> cmdAliases = new ArrayList<String>();
for (String key : section.getKeys(false)) {
cmdAliases.clear();
cmdAliases.addAll(section.getStringList(key));
aliases.put(key, cmdAliases.toArray(new String[cmdAliases.size()]));
}
return aliases;
}
public ArrayList<ItemStack> deserializeIngredients(ConfigurationSection matSection) {
ArrayList<ItemStack> ingredients = new ArrayList<ItemStack>();
for (String mat : matSection.getKeys(false)) {
String[] matSplit = mat.split(",");
ItemStack item = new ItemStack(Material.getMaterial(matSplit[0]), matSection.getInt(mat));
if (matSplit.length == 2) {
item.setDurability((short) P.p.parseInt(matSplit[1]));
}
ingredients.add(item);
}
return ingredients;
}
private void setPlayers() {
ConfigurationSection section =
this.getConfiguration().getConfigurationSection("reserved-players");
this.reservedPlayers.clear();
for (String key : section.getKeys(false)) {
try {
this.reservedPlayers.put(key, ReservationType.valueOf(section.getString(key)));
} catch (final IllegalArgumentException exception) {
this.getLogger().warning(this, "invalid-reservation", key);
}
}
}
@Override
public void loadSettings(FileConfiguration config) {
ConfigurationSection sectionE = config.getConfigurationSection("Skills.Weaponry.Entities");
ConfigurationSection section = config.getConfigurationSection("Skills.Weaponry");
if (sectionE.getKeys(false) != null) {
for (String s : sectionE.getKeys(false)) {
if (EntityType.valueOf(s.toUpperCase()) != null) {
EntityType type = EntityType.valueOf(s.toUpperCase());
Double val = sectionE.getDouble(s);
entities.put(type, val);
}
}
}
if (section.getStringList("Weapons") != null) {
for (String s : section.getStringList("Weapons")) {
if (Material.valueOf(s.toUpperCase()) != null) {
Material type = Material.valueOf(s.toUpperCase());
weapons.add(type);
}
}
}
}
private List<ServerInfo> loadServers() {
List<ServerInfo> list = new ArrayList<>();
ConfigurationSection server = config.getConfigurationSection("servers");
for (String servername : server.getKeys(false)) {
ConfigurationSection cs = server.getConfigurationSection(servername);
String displayname = cs.getString("displayname");
String[] addre = cs.getString("address").split(":");
InetSocketAddress address = new InetSocketAddress(addre[0], Integer.parseInt(addre[1]));
ServerInfo si = new ServerInfo(servername, address, displayname);
list.add(si);
}
return list;
}
@Override
public Map<String, List<String>> getAllWorldInheritance() {
ConfigurationSection worldsSection = this.permissions.getConfigurationSection("worlds");
if (worldsSection == null) {
return Collections.emptyMap();
}
Map<String, List<String>> ret = new HashMap<String, List<String>>();
for (String world : worldsSection.getKeys(false)) {
ret.put(world, getWorldInheritance(world));
}
return Collections.unmodifiableMap(ret);
}
@Override
public PermissionUser[] getRegisteredUsers() {
List<PermissionUser> users = new LinkedList<PermissionUser>();
ConfigurationSection usersSection = this.permissions.getConfigurationSection("users");
if (usersSection != null) {
for (String userName : usersSection.getKeys(false)) {
users.add(this.manager.getUser(userName));
}
}
return users.toArray(new PermissionUser[users.size()]);
}
public static List<Scoreboard> load(FileConfiguration config) {
List<Scoreboard> scoreboards = new ArrayList<>();
ConfigurationSection boards = config.getConfigurationSection("boards");
if (boards != null) {
for (String id : boards.getKeys(false)) {
ConfigurationSection section = boards.getConfigurationSection(id);
if (section != null) {
scoreboards.add(loadScoreboard(section, id));
}
}
}
return scoreboards;
}
@Override
public Map<String, String[]> getCommandAliases() {
Map<String, String[]> aliases = new HashMap<>();
ConfigurationSection section =
config.getConfigFile(ServerConfig.Key.COMMANDS_FILE).getConfigurationSection("aliases");
if (section == null) {
return aliases;
}
for (String key : section.getKeys(false)) {
List<String> list = section.getStringList(key);
aliases.put(key, list.toArray(new String[list.size()]));
}
return aliases;
}