2018-12-30 14:31:26 +01:00
|
|
|
package world.bentobox.challenges;
|
|
|
|
|
2019-04-24 06:45:05 +02:00
|
|
|
import java.beans.IntrospectionException;
|
2018-12-30 14:31:26 +01:00
|
|
|
import java.io.File;
|
2019-04-24 23:48:29 +02:00
|
|
|
import java.io.FileWriter;
|
2018-12-30 14:31:26 +01:00
|
|
|
import java.io.IOException;
|
2019-04-24 06:45:05 +02:00
|
|
|
import java.lang.reflect.InvocationTargetException;
|
2019-01-28 16:53:23 +01:00
|
|
|
import java.util.*;
|
2018-12-30 14:31:26 +01:00
|
|
|
|
|
|
|
import org.bukkit.Material;
|
|
|
|
import org.bukkit.World;
|
|
|
|
import org.bukkit.configuration.ConfigurationSection;
|
|
|
|
import org.bukkit.configuration.InvalidConfigurationException;
|
|
|
|
import org.bukkit.configuration.file.YamlConfiguration;
|
|
|
|
import org.bukkit.entity.EntityType;
|
|
|
|
import org.bukkit.inventory.ItemStack;
|
2019-04-24 06:45:05 +02:00
|
|
|
import org.eclipse.jdt.annotation.NonNull;
|
2018-12-30 14:31:26 +01:00
|
|
|
|
2019-04-24 06:45:05 +02:00
|
|
|
import world.bentobox.bentobox.BentoBox;
|
|
|
|
import world.bentobox.bentobox.database.DatabaseConnector;
|
|
|
|
import world.bentobox.bentobox.database.json.AbstractJSONDatabaseHandler;
|
2019-04-24 23:48:29 +02:00
|
|
|
import world.bentobox.bentobox.database.objects.DataObject;
|
2019-01-23 15:33:33 +01:00
|
|
|
import world.bentobox.bentobox.util.ItemParser;
|
2019-01-23 15:09:38 +01:00
|
|
|
import world.bentobox.challenges.database.object.ChallengeLevel;
|
|
|
|
import world.bentobox.challenges.database.object.Challenge;
|
2018-12-30 14:31:26 +01:00
|
|
|
import world.bentobox.bentobox.api.user.User;
|
|
|
|
import world.bentobox.bentobox.util.Util;
|
2019-01-23 15:33:33 +01:00
|
|
|
import world.bentobox.challenges.utils.GuiUtils;
|
|
|
|
|
2018-12-30 14:31:26 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Imports challenges
|
|
|
|
* @author tastybento
|
|
|
|
*
|
|
|
|
*/
|
2019-01-10 10:16:04 +01:00
|
|
|
public class ChallengesImportManager
|
|
|
|
{
|
2018-12-30 14:31:26 +01:00
|
|
|
|
|
|
|
private ChallengesAddon addon;
|
|
|
|
private YamlConfiguration chal;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Import challenges from challenges.yml
|
|
|
|
* @param challengesAddon
|
|
|
|
*/
|
2019-01-10 10:16:04 +01:00
|
|
|
public ChallengesImportManager(ChallengesAddon challengesAddon) {
|
2018-12-30 14:31:26 +01:00
|
|
|
this.addon = challengesAddon;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Import challenges
|
|
|
|
* @param user - user
|
|
|
|
* @param world - world to import into
|
|
|
|
* @param overwrite - true if previous ones should be overwritten
|
|
|
|
* @return true if successful
|
|
|
|
*/
|
|
|
|
public boolean importChallenges(User user, World world, boolean overwrite) {
|
|
|
|
File challengeFile = new File(addon.getDataFolder(), "challenges.yml");
|
|
|
|
if (!challengeFile.exists()) {
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.errors.import-no-file");
|
2018-12-30 14:31:26 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
chal = new YamlConfiguration();
|
|
|
|
try {
|
|
|
|
chal.load(challengeFile);
|
|
|
|
} catch (IOException | InvalidConfigurationException e) {
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.errors.no-load","[message]", e.getMessage());
|
2018-12-30 14:31:26 +01:00
|
|
|
return false;
|
|
|
|
}
|
2019-01-23 15:33:33 +01:00
|
|
|
makeLevels(user, world, overwrite);
|
2018-12-30 14:31:26 +01:00
|
|
|
makeChallenges(user, world, overwrite);
|
2019-01-05 11:17:03 +01:00
|
|
|
addon.getChallengesManager().save();
|
2018-12-30 14:31:26 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-01-23 15:33:33 +01:00
|
|
|
private void makeLevels(User user, World world, boolean overwrite) {
|
2018-12-30 14:31:26 +01:00
|
|
|
// Parse the levels
|
|
|
|
String levels = chal.getString("challenges.levels", "");
|
|
|
|
if (!levels.isEmpty()) {
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.messages.import-levels");
|
2018-12-30 14:31:26 +01:00
|
|
|
String[] lvs = levels.split(" ");
|
|
|
|
int order = 0;
|
|
|
|
for (String level : lvs) {
|
2019-01-23 15:09:38 +01:00
|
|
|
ChallengeLevel challengeLevel = new ChallengeLevel();
|
2018-12-30 14:31:26 +01:00
|
|
|
challengeLevel.setFriendlyName(level);
|
2019-01-23 17:01:19 +01:00
|
|
|
challengeLevel.setUniqueId(Util.getWorld(world).getName() + "_" + level);
|
2018-12-30 14:31:26 +01:00
|
|
|
challengeLevel.setOrder(order++);
|
2019-01-23 15:33:33 +01:00
|
|
|
challengeLevel.setWorld(Util.getWorld(world).getName());
|
|
|
|
challengeLevel.setWaiverAmount(chal.getInt("challenges.waiveramount"));
|
2018-12-30 14:31:26 +01:00
|
|
|
// Check if there is a level reward
|
|
|
|
ConfigurationSection unlock = chal.getConfigurationSection("challenges.levelUnlock." + level);
|
|
|
|
if (unlock != null) {
|
2019-01-29 23:38:26 +01:00
|
|
|
challengeLevel.setUnlockMessage(unlock.getString("message", ""));
|
2019-01-23 15:33:33 +01:00
|
|
|
challengeLevel.setRewardText(unlock.getString("rewardDesc",""));
|
2018-12-30 14:31:26 +01:00
|
|
|
challengeLevel.setRewardItems(parseItems(unlock.getString("itemReward","")));
|
2019-01-23 15:33:33 +01:00
|
|
|
challengeLevel.setRewardMoney(unlock.getInt("moneyReward"));
|
|
|
|
challengeLevel.setRewardExperience(unlock.getInt("expReward"));
|
2018-12-30 14:31:26 +01:00
|
|
|
challengeLevel.setRewardCommands(unlock.getStringList("commands"));
|
|
|
|
}
|
2019-01-23 16:30:30 +01:00
|
|
|
addon.getChallengesManager().loadLevel(challengeLevel, overwrite, user, false);
|
2018-12-30 14:31:26 +01:00
|
|
|
}
|
|
|
|
} else {
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.messages.no-levels");
|
2018-12-30 14:31:26 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Imports challenges
|
|
|
|
* @param overwrite
|
|
|
|
*/
|
|
|
|
private void makeChallenges(User user, World world, boolean overwrite) {
|
|
|
|
int size = 0;
|
|
|
|
// Parse the challenge file
|
|
|
|
ConfigurationSection chals = chal.getConfigurationSection("challenges.challengeList");
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.messages.import-challenges");
|
|
|
|
|
2018-12-30 14:31:26 +01:00
|
|
|
for (String challenge : chals.getKeys(false)) {
|
2019-01-23 15:09:38 +01:00
|
|
|
Challenge newChallenge = new Challenge();
|
2018-12-30 14:31:26 +01:00
|
|
|
newChallenge.setUniqueId(Util.getWorld(world).getName() + "_" + challenge);
|
|
|
|
newChallenge.setDeployed(true);
|
|
|
|
ConfigurationSection details = chals.getConfigurationSection(challenge);
|
|
|
|
newChallenge.setFriendlyName(details.getString("friendlyname", challenge));
|
2019-02-11 14:29:19 +01:00
|
|
|
newChallenge.setDescription(GuiUtils.stringSplit(
|
|
|
|
details.getString("description", ""),
|
|
|
|
this.addon.getChallengesSettings().getLoreLineLength()));
|
2019-01-29 23:38:26 +01:00
|
|
|
newChallenge.setIcon(ItemParser.parse(details.getString("icon", "") + ":1"));
|
2019-01-23 17:01:19 +01:00
|
|
|
|
2019-01-29 23:38:26 +01:00
|
|
|
if (details.getString("type", "").equalsIgnoreCase("level"))
|
2019-01-23 17:01:19 +01:00
|
|
|
{
|
|
|
|
// Fix for older version config
|
|
|
|
newChallenge.setChallengeType(Challenge.ChallengeType.OTHER);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
newChallenge.setChallengeType(Challenge.ChallengeType.valueOf(details.getString("type","INVENTORY").toUpperCase()));
|
|
|
|
}
|
|
|
|
|
2018-12-30 14:31:26 +01:00
|
|
|
newChallenge.setTakeItems(details.getBoolean("takeItems",true));
|
|
|
|
newChallenge.setRewardText(details.getString("rewardText", ""));
|
|
|
|
newChallenge.setRewardCommands(details.getStringList("rewardcommands"));
|
|
|
|
newChallenge.setRewardMoney(details.getInt("moneyReward",0));
|
2019-01-23 15:33:33 +01:00
|
|
|
newChallenge.setRewardExperience(details.getInt("expReward"));
|
2018-12-30 14:31:26 +01:00
|
|
|
newChallenge.setRepeatable(details.getBoolean("repeatable"));
|
|
|
|
newChallenge.setRepeatRewardText(details.getString("repeatRewardText",""));
|
|
|
|
newChallenge.setRepeatMoneyReward(details.getInt("repearMoneyReward"));
|
2019-01-23 15:33:33 +01:00
|
|
|
newChallenge.setRepeatExperienceReward(details.getInt("repeatExpReward"));
|
2018-12-30 14:31:26 +01:00
|
|
|
newChallenge.setRepeatRewardCommands(details.getStringList("repeatrewardcommands"));
|
|
|
|
newChallenge.setMaxTimes(details.getInt("maxtimes"));
|
|
|
|
// TODO reset allowed
|
2019-01-23 15:33:33 +01:00
|
|
|
newChallenge.setRequiredMoney(details.getInt("requiredMoney"));
|
|
|
|
newChallenge.setRequiredExperience(details.getInt("requiredExp"));
|
2018-12-30 14:31:26 +01:00
|
|
|
String reqItems = details.getString("requiredItems","");
|
2019-01-23 15:09:38 +01:00
|
|
|
if (newChallenge.getChallengeType().equals(Challenge.ChallengeType.INVENTORY)) {
|
2018-12-30 14:31:26 +01:00
|
|
|
newChallenge.setRequiredItems(parseItems(reqItems));
|
2019-01-23 15:33:33 +01:00
|
|
|
} else if (newChallenge.getChallengeType().equals(Challenge.ChallengeType.OTHER)) {
|
|
|
|
newChallenge.setRequiredIslandLevel(Long.parseLong(reqItems));
|
2019-01-23 15:09:38 +01:00
|
|
|
} else if (newChallenge.getChallengeType().equals(Challenge.ChallengeType.ISLAND)) {
|
2018-12-30 14:31:26 +01:00
|
|
|
parseEntities(newChallenge, reqItems);
|
|
|
|
}
|
2019-01-29 23:38:26 +01:00
|
|
|
newChallenge.setRewardItems(parseItems(details.getString("itemReward", "")));
|
|
|
|
newChallenge.setRepeatItemReward(parseItems(details.getString("repeatItemReward", "")));
|
2018-12-30 14:31:26 +01:00
|
|
|
// Save
|
2019-01-23 15:33:33 +01:00
|
|
|
this.addon.getChallengesManager().addChallengeToLevel(newChallenge,
|
2019-01-29 23:38:26 +01:00
|
|
|
addon.getChallengesManager().getLevel(Util.getWorld(world).getName() + "_" + details.getString("level", "")));
|
2019-01-23 15:33:33 +01:00
|
|
|
|
2019-01-23 16:30:30 +01:00
|
|
|
if (addon.getChallengesManager().loadChallenge(newChallenge, overwrite, user, false)) {
|
2018-12-30 14:31:26 +01:00
|
|
|
size++;
|
|
|
|
}
|
|
|
|
}
|
2019-01-23 15:33:33 +01:00
|
|
|
|
2019-02-12 00:38:16 +01:00
|
|
|
user.sendMessage("challenges.messages.import-number", "[number]", String.valueOf(size));
|
2018-12-30 14:31:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Run through entity types and materials and try to match to the string given
|
|
|
|
* @param challenge - challenge to be adjusted
|
|
|
|
* @param string - string from YAML file
|
|
|
|
*/
|
2019-01-23 15:09:38 +01:00
|
|
|
private void parseEntities(Challenge challenge, String string) {
|
2018-12-30 14:31:26 +01:00
|
|
|
Map<EntityType, Integer> req = new EnumMap<>(EntityType.class);
|
|
|
|
Map<Material, Integer> blocks = new EnumMap<>(Material.class);
|
|
|
|
if (!string.isEmpty()) {
|
|
|
|
for (String s : string.split(" ")) {
|
|
|
|
String[] part = s.split(":");
|
|
|
|
try {
|
|
|
|
Arrays.asList(EntityType.values()).stream().filter(t -> t.name().equalsIgnoreCase(part[0])).forEach(t -> req.put(t, Integer.valueOf(part[1])));
|
|
|
|
Arrays.asList(Material.values()).stream().filter(t -> t.name().equalsIgnoreCase(part[0])).forEach(t -> blocks.put(t, Integer.valueOf(part[1])));
|
|
|
|
} catch (Exception e) {
|
|
|
|
addon.getLogger().severe("Cannot parse '" + s + "'. Skipping...");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
challenge.setRequiredEntities(req);
|
|
|
|
challenge.setRequiredBlocks(blocks);
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<ItemStack> parseItems(String reqList) {
|
|
|
|
List<ItemStack> result = new ArrayList<>();
|
|
|
|
if (!reqList.isEmpty()) {
|
|
|
|
for (String s : reqList.split(" ")) {
|
2019-01-23 15:33:33 +01:00
|
|
|
ItemStack item = ItemParser.parse(s);
|
2018-12-30 14:31:26 +01:00
|
|
|
if (item != null) {
|
|
|
|
result.add(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
2019-04-24 06:45:05 +02:00
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Section: Default Challenge Loader
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method loads default challenges into memory.
|
|
|
|
* @param user User who calls default challenge loading
|
|
|
|
* @param world Target world.
|
|
|
|
* @return <code>true</code> if everything was successful, otherwise <code>false</code>.
|
|
|
|
*/
|
|
|
|
private boolean loadDefaultChallenges(User user, World world)
|
|
|
|
{
|
|
|
|
ChallengesManager manager = this.addon.getChallengesManager();
|
|
|
|
|
|
|
|
// If exist any challenge or level that is bound to current world, then do not load default challenges.
|
|
|
|
if (manager.hasAnyChallengeData(world.getName()))
|
|
|
|
{
|
|
|
|
if (user.isPlayer())
|
|
|
|
{
|
|
|
|
user.sendMessage("challenges.errors.exist-challenges-or-levels");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this.addon.logWarning("challenges.errors.exist-challenges-or-levels");
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Safe json configuration to Challenges folder.
|
|
|
|
this.addon.saveResource("default.json", true);
|
|
|
|
|
|
|
|
// Init Connector
|
|
|
|
CustomJSONConnector connector = new CustomJSONConnector();
|
|
|
|
|
|
|
|
// Load challenges
|
|
|
|
CustomJSONHandler<Challenge> challengeHandler =
|
|
|
|
new CustomJSONHandler<>(BentoBox.getInstance(), Challenge.class, connector);
|
|
|
|
|
|
|
|
// Load levels
|
|
|
|
CustomJSONHandler<ChallengeLevel> levelHandler =
|
|
|
|
new CustomJSONHandler<>(BentoBox.getInstance(), ChallengeLevel.class, connector);
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
challengeHandler.loadObjects().forEach(challenge -> manager.loadChallenge(challenge, false, user, false));
|
|
|
|
levelHandler.loadObjects().forEach(level -> manager.loadLevel(level, false, user, false));
|
|
|
|
}
|
|
|
|
catch (NoSuchMethodException |
|
|
|
|
ClassNotFoundException |
|
|
|
|
IllegalAccessException |
|
|
|
|
IntrospectionException |
|
|
|
|
InvocationTargetException |
|
|
|
|
InstantiationException e)
|
|
|
|
{
|
|
|
|
e.printStackTrace();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.addon.getChallengesManager().save();
|
|
|
|
|
|
|
|
// Remove default.yml file from resources to avoid interacting with it.
|
|
|
|
new File(this.addon.getDataFolder(), "default.json").delete();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This Class allows to load default challenges and their levels as objects much easier.
|
|
|
|
*/
|
|
|
|
private final class CustomJSONHandler<T> extends AbstractJSONDatabaseHandler<T>
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
CustomJSONHandler(BentoBox plugin, Class<T> type, DatabaseConnector databaseConnector)
|
|
|
|
{
|
|
|
|
super(plugin, type, databaseConnector);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public List<T> loadObjects() throws
|
|
|
|
InstantiationException,
|
|
|
|
IllegalAccessException,
|
|
|
|
InvocationTargetException,
|
|
|
|
ClassNotFoundException,
|
|
|
|
IntrospectionException,
|
|
|
|
NoSuchMethodException
|
|
|
|
{
|
|
|
|
return Collections.emptyList();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public T loadObject(@NonNull String s) throws
|
|
|
|
InstantiationException,
|
|
|
|
IllegalAccessException,
|
|
|
|
InvocationTargetException,
|
|
|
|
ClassNotFoundException,
|
|
|
|
IntrospectionException,
|
|
|
|
NoSuchMethodException
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void saveObject(T t)
|
|
|
|
throws IllegalAccessException, InvocationTargetException, IntrospectionException
|
|
|
|
{
|
|
|
|
// Will not be used in default challenge loading process.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void deleteObject(T t)
|
|
|
|
throws IllegalAccessException, InvocationTargetException, IntrospectionException
|
|
|
|
{
|
|
|
|
// Will not be used in default challenge loading process.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean objectExists(String s)
|
|
|
|
{
|
|
|
|
// Will not be used in default challenge loading process.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void close()
|
|
|
|
{
|
|
|
|
// Will not be used in default challenge loading process.
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void deleteID(String s)
|
|
|
|
{
|
|
|
|
// Will not be used in default challenge loading process.
|
|
|
|
}
|
2019-04-24 23:48:29 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method returns json object that is parsed to string. Json object is made from given instance.
|
|
|
|
* @param instance Instance that must be parsed to json string.
|
|
|
|
* @return String that contains JSON information from instance object.
|
|
|
|
*/
|
|
|
|
public String toJsonString(T instance)
|
|
|
|
{
|
|
|
|
// Null check
|
|
|
|
if (instance == null)
|
|
|
|
{
|
|
|
|
plugin.logError("JSON database request to store a null. ");
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(instance instanceof DataObject))
|
|
|
|
{
|
|
|
|
plugin.logError("This class is not a DataObject: " + instance.getClass().getName());
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.getGson().toJson(instance);
|
|
|
|
}
|
2019-04-24 06:45:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Simple custom connector used for importing default challenges
|
|
|
|
*/
|
2019-04-24 23:48:29 +02:00
|
|
|
private final static class CustomJSONConnector implements DatabaseConnector
|
2019-04-24 06:45:05 +02:00
|
|
|
{
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public Object createConnection()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void closeConnection()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public String getConnectionUrl()
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public String getUniqueId(String s)
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* {@inheritDoc}
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean uniqueIdExists(String s, String s1)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2019-04-24 23:48:29 +02:00
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Section: Default generation
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create method that can generate default challenge file from existing challenges in given world.
|
|
|
|
* This method will create default.json file in Challenges folder.
|
|
|
|
* @param world from which challenges must be stored.
|
|
|
|
*/
|
|
|
|
public void generateDefaultChallengeFile(World world)
|
|
|
|
{
|
|
|
|
File defaultFile = new File(BentoBox.getInstance().getDataFolder() + "/addons/Challenges", "default.json");
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if (defaultFile.createNewFile())
|
|
|
|
{
|
|
|
|
String replacementString = Util.getWorld(world).getName() + "_";
|
|
|
|
ChallengesManager manager = this.addon.getChallengesManager();
|
|
|
|
|
|
|
|
// Store all challenges to single file
|
|
|
|
List<Challenge> challengeList = manager.getAllChallenges(world);
|
|
|
|
|
|
|
|
CustomJSONHandler<Challenge> generateChallengeJSON =
|
|
|
|
new CustomJSONHandler<>(BentoBox.getInstance(), Challenge.class, new CustomJSONConnector());
|
|
|
|
|
|
|
|
StringBuilder outputString = new StringBuilder();
|
|
|
|
outputString.append("{\"challenges\": [");
|
|
|
|
|
|
|
|
// Populate all challenges
|
|
|
|
for (int i = 0, size = challengeList.size(); i < size; i++)
|
|
|
|
{
|
|
|
|
Challenge clone = challengeList.get(i).clone();
|
|
|
|
|
|
|
|
clone.setUniqueId(clone.getUniqueId().replaceFirst(replacementString, ""));
|
|
|
|
clone.setLevel(clone.getLevel().replaceFirst(replacementString, ""));
|
|
|
|
|
|
|
|
if (i != 0)
|
|
|
|
{
|
|
|
|
outputString.append(",");
|
|
|
|
}
|
|
|
|
|
|
|
|
outputString.append(generateChallengeJSON.toJsonString(clone));
|
|
|
|
}
|
|
|
|
|
|
|
|
outputString.append("],\"levels\": [");
|
|
|
|
|
|
|
|
// Populate all levels
|
|
|
|
List<ChallengeLevel> levelList = manager.getLevels(world);
|
|
|
|
CustomJSONHandler<ChallengeLevel> generateLevelJSON =
|
|
|
|
new CustomJSONHandler<>(BentoBox.getInstance(), ChallengeLevel.class, new CustomJSONConnector());
|
|
|
|
|
|
|
|
for (int i = 0, size = levelList.size(); i < size; i++)
|
|
|
|
{
|
|
|
|
ChallengeLevel clone = levelList.get(i).clone();
|
|
|
|
clone.setUniqueId(clone.getUniqueId().replaceFirst(replacementString, ""));
|
|
|
|
clone.getChallenges().forEach(challenge -> challenge = challenge.replaceFirst(replacementString, ""));
|
|
|
|
clone.setWorld("");
|
|
|
|
|
|
|
|
if (i != 0)
|
|
|
|
{
|
|
|
|
outputString.append(",");
|
|
|
|
}
|
|
|
|
|
|
|
|
outputString.append(generateLevelJSON.toJsonString(clone));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add version string
|
|
|
|
outputString.append("],\"version\": \"").append(this.addon.getDescription().getVersion()).append("\"}");
|
|
|
|
|
|
|
|
// Store to file.
|
|
|
|
new FileWriter(defaultFile).write(outputString.toString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (IOException e)
|
|
|
|
{
|
|
|
|
this.addon.logError("Could not save json file: " + e.getMessage());
|
|
|
|
}
|
|
|
|
}
|
2019-01-23 15:33:33 +01:00
|
|
|
}
|