2018-10-31 14:09:56 +01:00
|
|
|
package world.bentobox.level;
|
2017-10-21 20:32:32 +02:00
|
|
|
|
2020-04-19 19:46:41 +02:00
|
|
|
import java.io.File;
|
|
|
|
import java.io.IOException;
|
2021-06-05 17:33:03 +02:00
|
|
|
import java.util.ArrayList;
|
2021-09-06 20:57:32 +02:00
|
|
|
import java.util.Collections;
|
2021-06-05 17:33:03 +02:00
|
|
|
import java.util.List;
|
2021-09-06 20:57:32 +02:00
|
|
|
import java.util.Map;
|
2020-06-22 04:15:43 +02:00
|
|
|
import java.util.UUID;
|
2021-09-06 20:57:32 +02:00
|
|
|
import java.util.stream.Collectors;
|
2017-10-21 20:32:32 +02:00
|
|
|
|
2020-02-02 04:56:28 +01:00
|
|
|
import org.bukkit.Bukkit;
|
2018-05-26 04:59:44 +02:00
|
|
|
import org.bukkit.World;
|
2020-04-19 19:46:41 +02:00
|
|
|
import org.bukkit.configuration.InvalidConfigurationException;
|
|
|
|
import org.bukkit.configuration.file.YamlConfiguration;
|
2020-07-05 00:46:36 +02:00
|
|
|
import org.bukkit.event.EventHandler;
|
|
|
|
import org.bukkit.event.Listener;
|
2021-02-25 02:29:29 +01:00
|
|
|
import org.bukkit.plugin.Plugin;
|
2020-06-22 04:15:43 +02:00
|
|
|
import org.eclipse.jdt.annotation.NonNull;
|
|
|
|
import org.eclipse.jdt.annotation.Nullable;
|
2018-05-26 04:59:44 +02:00
|
|
|
|
2019-01-03 19:27:20 +01:00
|
|
|
import world.bentobox.bentobox.api.addons.Addon;
|
2020-04-19 23:02:45 +02:00
|
|
|
import world.bentobox.bentobox.api.addons.GameModeAddon;
|
2020-04-19 19:46:41 +02:00
|
|
|
import world.bentobox.bentobox.api.configuration.Config;
|
2020-07-05 00:46:36 +02:00
|
|
|
import world.bentobox.bentobox.api.events.BentoBoxReadyEvent;
|
2019-01-03 19:27:20 +01:00
|
|
|
import world.bentobox.bentobox.api.user.User;
|
2020-06-22 04:15:43 +02:00
|
|
|
import world.bentobox.bentobox.database.objects.Island;
|
2021-06-05 17:33:03 +02:00
|
|
|
import world.bentobox.bentobox.util.Util;
|
2020-06-22 02:54:51 +02:00
|
|
|
import world.bentobox.level.calculators.Pipeliner;
|
|
|
|
import world.bentobox.level.commands.AdminLevelCommand;
|
|
|
|
import world.bentobox.level.commands.AdminLevelStatusCommand;
|
2020-07-26 23:40:17 +02:00
|
|
|
import world.bentobox.level.commands.AdminSetInitialLevelCommand;
|
2020-06-22 02:54:51 +02:00
|
|
|
import world.bentobox.level.commands.AdminTopCommand;
|
|
|
|
import world.bentobox.level.commands.IslandLevelCommand;
|
|
|
|
import world.bentobox.level.commands.IslandTopCommand;
|
|
|
|
import world.bentobox.level.commands.IslandValueCommand;
|
2020-04-19 19:46:41 +02:00
|
|
|
import world.bentobox.level.config.BlockConfig;
|
|
|
|
import world.bentobox.level.config.ConfigSettings;
|
2020-06-22 02:54:51 +02:00
|
|
|
import world.bentobox.level.listeners.IslandActivitiesListeners;
|
2019-02-03 06:43:27 +01:00
|
|
|
import world.bentobox.level.listeners.JoinLeaveListener;
|
2020-08-22 01:21:02 +02:00
|
|
|
import world.bentobox.level.objects.LevelsData;
|
2021-07-24 23:54:06 +02:00
|
|
|
import world.bentobox.level.objects.TopTenData;
|
2018-12-23 21:20:15 +01:00
|
|
|
import world.bentobox.level.requests.LevelRequestHandler;
|
2019-02-27 23:14:20 +01:00
|
|
|
import world.bentobox.level.requests.TopTenRequestHandler;
|
|
|
|
|
2017-10-25 01:24:43 +02:00
|
|
|
/**
|
|
|
|
* @author tastybento
|
|
|
|
*
|
|
|
|
*/
|
2020-07-05 00:46:36 +02:00
|
|
|
public class Level extends Addon implements Listener {
|
2018-04-16 02:32:09 +02:00
|
|
|
|
2021-05-02 16:54:28 +02:00
|
|
|
// The 10 in top ten
|
|
|
|
public static final int TEN = 10;
|
|
|
|
|
2018-02-14 05:48:27 +01:00
|
|
|
// Settings
|
2020-04-19 19:46:41 +02:00
|
|
|
private ConfigSettings settings;
|
|
|
|
private Config<ConfigSettings> configObject = new Config<>(this, ConfigSettings.class);
|
|
|
|
private BlockConfig blockConfig;
|
2020-06-22 02:54:51 +02:00
|
|
|
private Pipeliner pipeliner;
|
|
|
|
private LevelsManager manager;
|
2020-06-22 03:21:53 +02:00
|
|
|
private boolean stackersEnabled;
|
2021-02-24 03:59:20 +01:00
|
|
|
private boolean advChestEnabled;
|
2021-08-10 05:00:55 +02:00
|
|
|
private boolean roseStackersEnabled;
|
2021-06-05 17:33:03 +02:00
|
|
|
private final List<GameModeAddon> registeredGameModes = new ArrayList<>();
|
2018-02-19 22:06:58 +01:00
|
|
|
|
2020-04-19 19:46:41 +02:00
|
|
|
@Override
|
|
|
|
public void onLoad() {
|
|
|
|
// Save the default config from config.yml
|
|
|
|
saveDefaultConfig();
|
2020-04-20 00:17:34 +02:00
|
|
|
if (loadSettings()) {
|
2020-06-22 02:54:51 +02:00
|
|
|
// Disable
|
|
|
|
logError("Level settings could not load! Addon disabled.");
|
|
|
|
setState(State.DISABLED);
|
|
|
|
} else {
|
2020-04-20 00:17:34 +02:00
|
|
|
configObject.saveConfigObject(settings);
|
|
|
|
}
|
2022-03-13 13:28:08 +01:00
|
|
|
|
|
|
|
// Save existing panels.
|
|
|
|
this.saveResource("panels/top_panel.yml", false);
|
|
|
|
this.saveResource("panels/detail_panel.yml", false);
|
2020-04-19 19:46:41 +02:00
|
|
|
}
|
|
|
|
|
2020-04-20 00:17:34 +02:00
|
|
|
private boolean loadSettings() {
|
2020-04-19 19:46:41 +02:00
|
|
|
// Load settings again to get worlds
|
|
|
|
settings = configObject.loadConfigObject();
|
2022-03-12 11:52:44 +01:00
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
return settings == null;
|
2020-04-19 19:46:41 +02:00
|
|
|
}
|
|
|
|
|
2017-10-21 20:32:32 +02:00
|
|
|
@Override
|
2017-10-22 04:52:11 +02:00
|
|
|
public void onEnable() {
|
2020-04-19 19:46:41 +02:00
|
|
|
loadBlockSettings();
|
2020-06-22 02:54:51 +02:00
|
|
|
// Start pipeline
|
|
|
|
pipeliner = new Pipeliner(this);
|
|
|
|
// Start Manager
|
|
|
|
manager = new LevelsManager(this);
|
|
|
|
// Register listeners
|
|
|
|
this.registerListener(new IslandActivitiesListeners(this));
|
|
|
|
this.registerListener(new JoinLeaveListener(this));
|
2020-07-05 00:46:36 +02:00
|
|
|
this.registerListener(this);
|
2020-04-19 23:02:45 +02:00
|
|
|
// Register commands for GameModes
|
2021-06-05 17:33:03 +02:00
|
|
|
registeredGameModes.clear();
|
2019-01-16 04:35:08 +01:00
|
|
|
getPlugin().getAddonsManager().getGameModeAddons().stream()
|
2020-06-22 02:54:51 +02:00
|
|
|
.filter(gm -> !settings.getGameModes().contains(gm.getDescription().getName()))
|
2019-01-16 04:35:08 +01:00
|
|
|
.forEach(gm -> {
|
2019-02-04 07:30:27 +01:00
|
|
|
log("Level hooking into " + gm.getDescription().getName());
|
2020-04-19 23:02:45 +02:00
|
|
|
registerCommands(gm);
|
2020-06-22 02:54:51 +02:00
|
|
|
registerPlaceholders(gm);
|
2021-06-05 17:33:03 +02:00
|
|
|
registeredGameModes.add(gm);
|
2018-05-27 03:20:33 +02:00
|
|
|
});
|
2018-12-23 21:20:15 +01:00
|
|
|
// Register request handlers
|
|
|
|
registerRequestHandler(new LevelRequestHandler(this));
|
2019-02-27 23:14:20 +01:00
|
|
|
registerRequestHandler(new TopTenRequestHandler(this));
|
2018-12-23 21:20:15 +01:00
|
|
|
|
2020-01-28 17:32:52 +01:00
|
|
|
// Check if WildStackers is enabled on the server
|
2020-04-19 23:02:45 +02:00
|
|
|
// I only added support for counting blocks into the island level
|
|
|
|
// Someone else can PR if they want spawners added to the Leveling system :)
|
2021-08-10 05:00:55 +02:00
|
|
|
stackersEnabled = Bukkit.getPluginManager().isPluginEnabled("WildStacker");
|
2021-02-21 04:07:08 +01:00
|
|
|
if (stackersEnabled) {
|
|
|
|
log("Hooked into WildStackers.");
|
|
|
|
}
|
2021-02-24 03:59:20 +01:00
|
|
|
// Check if AdvancedChests is enabled on the server
|
2021-02-25 02:29:29 +01:00
|
|
|
Plugin advChest = Bukkit.getPluginManager().getPlugin("AdvancedChests");
|
|
|
|
advChestEnabled = advChest != null;
|
2021-02-24 03:59:20 +01:00
|
|
|
if (advChestEnabled) {
|
2021-02-25 02:29:29 +01:00
|
|
|
// Check version
|
|
|
|
if (compareVersions(advChest.getDescription().getVersion(), "14.2") > 0) {
|
|
|
|
log("Hooked into AdvancedChests.");
|
|
|
|
} else {
|
|
|
|
logError("Could not hook into AdvancedChests " + advChest.getDescription().getVersion() + " - requires version 14.3 or later");
|
|
|
|
advChestEnabled = false;
|
|
|
|
}
|
2021-02-24 03:59:20 +01:00
|
|
|
}
|
2021-08-10 05:00:55 +02:00
|
|
|
// Check if RoseStackers is enabled
|
|
|
|
roseStackersEnabled = Bukkit.getPluginManager().isPluginEnabled("RoseStacker");
|
|
|
|
if (roseStackersEnabled) {
|
|
|
|
log("Hooked into RoseStackers.");
|
|
|
|
}
|
2017-10-21 20:32:32 +02:00
|
|
|
}
|
2017-10-22 08:09:21 +02:00
|
|
|
|
2021-02-25 02:29:29 +01:00
|
|
|
/**
|
|
|
|
* Compares versions
|
|
|
|
* @param version1
|
|
|
|
* @param version2
|
|
|
|
* @return <0 if version 1 is older than version 2, =0 if the same, >0 if version 1 is newer than version 2
|
|
|
|
*/
|
|
|
|
public static int compareVersions(String version1, String version2) {
|
|
|
|
int comparisonResult = 0;
|
|
|
|
|
|
|
|
String[] version1Splits = version1.split("\\.");
|
|
|
|
String[] version2Splits = version2.split("\\.");
|
|
|
|
int maxLengthOfVersionSplits = Math.max(version1Splits.length, version2Splits.length);
|
|
|
|
|
|
|
|
for (int i = 0; i < maxLengthOfVersionSplits; i++){
|
|
|
|
Integer v1 = i < version1Splits.length ? Integer.parseInt(version1Splits[i]) : 0;
|
|
|
|
Integer v2 = i < version2Splits.length ? Integer.parseInt(version2Splits[i]) : 0;
|
|
|
|
int compare = v1.compareTo(v2);
|
|
|
|
if (compare != 0) {
|
|
|
|
comparisonResult = compare;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return comparisonResult;
|
|
|
|
}
|
|
|
|
|
2020-07-05 00:46:36 +02:00
|
|
|
@EventHandler
|
|
|
|
public void onBentoBoxReady(BentoBoxReadyEvent e) {
|
2020-07-26 23:40:17 +02:00
|
|
|
// Perform upgrade check
|
|
|
|
manager.migrate();
|
|
|
|
// Load TopTens
|
2020-07-05 00:46:36 +02:00
|
|
|
manager.loadTopTens();
|
2020-07-18 22:39:10 +02:00
|
|
|
/*
|
|
|
|
* DEBUG code to generate fake islands and then try to level them all.
|
|
|
|
Bukkit.getScheduler().runTaskLater(getPlugin(), () -> {
|
|
|
|
getPlugin().getAddonsManager().getGameModeAddons().stream()
|
|
|
|
.filter(gm -> !settings.getGameModes().contains(gm.getDescription().getName()))
|
|
|
|
.forEach(gm -> {
|
|
|
|
for (int i = 0; i < 1000; i++) {
|
|
|
|
try {
|
|
|
|
NewIsland.builder().addon(gm).player(User.getInstance(UUID.randomUUID())).name("default").reason(Reason.CREATE).noPaste().build();
|
|
|
|
} catch (IOException e1) {
|
|
|
|
// TODO Auto-generated catch block
|
|
|
|
e1.printStackTrace();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// Queue all islands DEBUG
|
|
|
|
|
|
|
|
getIslands().getIslands().stream().filter(Island::isOwned).forEach(is -> {
|
|
|
|
|
2020-07-26 23:40:17 +02:00
|
|
|
this.getManager().calculateLevel(is.getOwner(), is).thenAccept(r ->
|
|
|
|
log("Result for island calc " + r.getLevel() + " at " + is.getCenter()));
|
2020-07-18 22:39:10 +02:00
|
|
|
|
|
|
|
});
|
|
|
|
}, 60L);*/
|
2020-07-05 00:46:36 +02:00
|
|
|
}
|
|
|
|
|
2020-07-18 22:39:10 +02:00
|
|
|
|
2020-04-19 23:02:45 +02:00
|
|
|
private void registerPlaceholders(GameModeAddon gm) {
|
2020-06-22 02:54:51 +02:00
|
|
|
if (getPlugin().getPlaceholdersManager() == null) return;
|
2020-04-19 23:02:45 +02:00
|
|
|
// Island Level
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_island_level",
|
2020-06-22 02:54:51 +02:00
|
|
|
user -> getManager().getIslandLevelString(gm.getOverWorld(), user.getUniqueId()));
|
2021-11-26 22:11:30 +01:00
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_island_level_raw",
|
|
|
|
user -> String.valueOf(getManager().getIslandLevel(gm.getOverWorld(), user.getUniqueId())));
|
2020-06-22 02:54:51 +02:00
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_points_to_next_level",
|
|
|
|
user -> getManager().getPointsToNextString(gm.getOverWorld(), user.getUniqueId()));
|
2020-04-19 23:02:45 +02:00
|
|
|
|
|
|
|
// Visited Island Level
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_visited_island_level", user -> getVisitedIslandLevel(gm, user));
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
// Register Top Ten Placeholders
|
|
|
|
for (int i = 1; i < 11; i++) {
|
2020-04-19 23:02:45 +02:00
|
|
|
final int rank = i;
|
|
|
|
// Name
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
2020-06-22 02:54:51 +02:00
|
|
|
gm.getDescription().getName().toLowerCase() + "_top_name_" + i, u -> getRankName(gm.getOverWorld(), rank));
|
2021-09-06 20:57:32 +02:00
|
|
|
// Island Name
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_top_island_name_" + i, u -> getRankIslandName(gm.getOverWorld(), rank));
|
|
|
|
// Members
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_top_members_" + i, u -> getRankMembers(gm.getOverWorld(), rank));
|
2020-06-22 02:54:51 +02:00
|
|
|
// Level
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_top_value_" + i, u -> getRankLevel(gm.getOverWorld(), rank));
|
2020-04-19 23:02:45 +02:00
|
|
|
}
|
|
|
|
|
2021-07-24 23:54:06 +02:00
|
|
|
// Personal rank
|
|
|
|
getPlugin().getPlaceholdersManager().registerPlaceholder(this,
|
|
|
|
gm.getDescription().getName().toLowerCase() + "_rank_value", u -> getRankValue(gm.getOverWorld(), u));
|
2020-04-19 23:02:45 +02:00
|
|
|
}
|
|
|
|
|
2020-06-27 00:44:03 +02:00
|
|
|
String getRankName(World world, int rank) {
|
2020-06-22 02:54:51 +02:00
|
|
|
if (rank < 1) rank = 1;
|
2021-05-02 16:54:28 +02:00
|
|
|
if (rank > TEN) rank = TEN;
|
|
|
|
return getPlayers().getName(getManager().getTopTen(world, TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null));
|
2020-06-22 02:54:51 +02:00
|
|
|
}
|
|
|
|
|
2021-09-06 20:57:32 +02:00
|
|
|
String getRankIslandName(World world, int rank) {
|
|
|
|
if (rank < 1) rank = 1;
|
|
|
|
if (rank > TEN) rank = TEN;
|
|
|
|
UUID owner = getManager().getTopTen(world, TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null);
|
|
|
|
if (owner != null) {
|
|
|
|
Island island = getIslands().getIsland(world, owner);
|
|
|
|
if (island != null) {
|
|
|
|
return island.getName() == null ? "" : island.getName();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
String getRankMembers(World world, int rank) {
|
|
|
|
if (rank < 1) rank = 1;
|
|
|
|
if (rank > TEN) rank = TEN;
|
|
|
|
UUID owner = getManager().getTopTen(world, TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null);
|
|
|
|
if (owner != null) {
|
|
|
|
Island island = getIslands().getIsland(world, owner);
|
|
|
|
if (island != null) {
|
|
|
|
// Sort members by rank
|
|
|
|
return island.getMembers().entrySet().stream()
|
|
|
|
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
|
|
|
|
.map(Map.Entry::getKey)
|
|
|
|
.map(getPlayers()::getName)
|
|
|
|
.collect(Collectors.joining(","));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2020-06-27 00:44:03 +02:00
|
|
|
String getRankLevel(World world, int rank) {
|
2020-06-22 02:54:51 +02:00
|
|
|
if (rank < 1) rank = 1;
|
2021-05-02 16:54:28 +02:00
|
|
|
if (rank > TEN) rank = TEN;
|
2020-06-27 00:44:03 +02:00
|
|
|
return getManager()
|
|
|
|
.formatLevel(getManager()
|
2021-05-02 16:54:28 +02:00
|
|
|
.getTopTen(world, TEN)
|
2020-06-27 00:44:03 +02:00
|
|
|
.values()
|
|
|
|
.stream()
|
|
|
|
.skip(rank - 1L)
|
|
|
|
.limit(1L)
|
|
|
|
.findFirst()
|
|
|
|
.orElse(null));
|
2020-06-22 02:54:51 +02:00
|
|
|
}
|
|
|
|
|
2021-07-24 23:54:06 +02:00
|
|
|
/**
|
|
|
|
* Return the rank of the player in a world
|
|
|
|
* @param world world
|
|
|
|
* @param user player
|
|
|
|
* @return rank where 1 is the top rank.
|
|
|
|
*/
|
|
|
|
String getRankValue(World world, User user) {
|
|
|
|
if (user == null) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
// Get the island level for this user
|
|
|
|
long level = getManager().getIslandLevel(world, user.getUniqueId());
|
|
|
|
return String.valueOf(getManager().getTopTenLists().getOrDefault(world, new TopTenData(world)).getTopTen().values().stream().filter(l -> l > level).count() + 1);
|
|
|
|
}
|
|
|
|
|
2020-06-27 00:44:03 +02:00
|
|
|
String getVisitedIslandLevel(GameModeAddon gm, User user) {
|
2021-07-24 23:54:06 +02:00
|
|
|
if (user == null || !gm.inWorld(user.getLocation())) return "";
|
2020-04-19 23:02:45 +02:00
|
|
|
return getIslands().getIslandAt(user.getLocation())
|
2020-06-22 02:54:51 +02:00
|
|
|
.map(island -> getManager().getIslandLevelString(gm.getOverWorld(), island.getOwner()))
|
2020-04-19 23:02:45 +02:00
|
|
|
.orElse("0");
|
|
|
|
}
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
|
2020-04-19 23:02:45 +02:00
|
|
|
private void registerCommands(GameModeAddon gm) {
|
|
|
|
gm.getAdminCommand().ifPresent(adminCommand -> {
|
|
|
|
new AdminLevelCommand(this, adminCommand);
|
|
|
|
new AdminTopCommand(this, adminCommand);
|
2020-06-22 02:54:51 +02:00
|
|
|
new AdminLevelStatusCommand(this, adminCommand);
|
2020-08-15 19:16:56 +02:00
|
|
|
if (getSettings().isZeroNewIslandLevels()) {
|
|
|
|
new AdminSetInitialLevelCommand(this, adminCommand);
|
|
|
|
}
|
2020-04-19 23:02:45 +02:00
|
|
|
});
|
|
|
|
gm.getPlayerCommand().ifPresent(playerCmd -> {
|
|
|
|
new IslandLevelCommand(this, playerCmd);
|
|
|
|
new IslandTopCommand(this, playerCmd);
|
|
|
|
new IslandValueCommand(this, playerCmd);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
@Override
|
|
|
|
public void onDisable() {
|
2020-07-18 22:39:10 +02:00
|
|
|
// Stop the pipeline
|
|
|
|
this.getPipeliner().stop();
|
2017-10-21 20:32:32 +02:00
|
|
|
}
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
private void loadBlockSettings() {
|
|
|
|
// Save the default blockconfig.yml
|
|
|
|
this.saveResource("blockconfig.yml", false);
|
|
|
|
|
|
|
|
YamlConfiguration blockValues = new YamlConfiguration();
|
|
|
|
try {
|
|
|
|
File file = new File(this.getDataFolder(), "blockconfig.yml");
|
|
|
|
blockValues.load(file);
|
|
|
|
// Load the block config class
|
|
|
|
blockConfig = new BlockConfig(this, blockValues, file);
|
|
|
|
} catch (IOException | InvalidConfigurationException e) {
|
|
|
|
// Disable
|
|
|
|
logError("Level blockconfig.yml settings could not load! Addon disabled.");
|
|
|
|
setState(State.DISABLED);
|
2019-01-07 16:29:03 +01:00
|
|
|
}
|
2020-06-22 02:54:51 +02:00
|
|
|
|
2018-07-28 22:38:04 +02:00
|
|
|
}
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
|
2018-07-28 22:38:04 +02:00
|
|
|
/**
|
2020-06-22 02:54:51 +02:00
|
|
|
* @return the blockConfig
|
2018-07-28 22:38:04 +02:00
|
|
|
*/
|
2020-06-22 02:54:51 +02:00
|
|
|
public BlockConfig getBlockConfig() {
|
|
|
|
return blockConfig;
|
2017-10-22 04:52:11 +02:00
|
|
|
}
|
|
|
|
|
2019-02-22 04:56:44 +01:00
|
|
|
/**
|
2020-06-22 02:54:51 +02:00
|
|
|
* @return the settings
|
2019-02-22 04:56:44 +01:00
|
|
|
*/
|
2020-06-22 02:54:51 +02:00
|
|
|
public ConfigSettings getSettings() {
|
|
|
|
return settings;
|
2019-02-22 04:56:44 +01:00
|
|
|
}
|
2019-08-09 01:30:10 +02:00
|
|
|
|
2019-12-01 03:30:08 +01:00
|
|
|
/**
|
2020-06-22 02:54:51 +02:00
|
|
|
* @return the pipeliner
|
2019-12-01 03:30:08 +01:00
|
|
|
*/
|
2020-06-22 02:54:51 +02:00
|
|
|
public Pipeliner getPipeliner() {
|
|
|
|
return pipeliner;
|
2018-04-16 02:32:09 +02:00
|
|
|
}
|
|
|
|
|
2020-06-22 02:54:51 +02:00
|
|
|
/**
|
|
|
|
* @return the manager
|
|
|
|
*/
|
|
|
|
public LevelsManager getManager() {
|
|
|
|
return manager;
|
2020-04-19 19:46:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-06-22 02:54:51 +02:00
|
|
|
* Set the config settings - used for tests only
|
|
|
|
* @param configSettings - config settings
|
2020-04-19 19:46:41 +02:00
|
|
|
*/
|
2020-06-22 02:54:51 +02:00
|
|
|
void setSettings(ConfigSettings configSettings) {
|
|
|
|
this.settings = configSettings;
|
|
|
|
|
2020-04-19 19:46:41 +02:00
|
|
|
}
|
|
|
|
|
2020-06-22 03:21:53 +02:00
|
|
|
/**
|
|
|
|
* @return the stackersEnabled
|
|
|
|
*/
|
|
|
|
public boolean isStackersEnabled() {
|
|
|
|
return stackersEnabled;
|
|
|
|
}
|
|
|
|
|
2021-02-24 03:59:20 +01:00
|
|
|
/**
|
|
|
|
* @return the advChestEnabled
|
|
|
|
*/
|
|
|
|
public boolean isAdvChestEnabled() {
|
|
|
|
return advChestEnabled;
|
|
|
|
}
|
|
|
|
|
2020-06-22 04:15:43 +02:00
|
|
|
/**
|
|
|
|
* Get level from cache for a player.
|
|
|
|
* @param targetPlayer - target player UUID
|
|
|
|
* @return Level of player or zero if player is unknown or UUID is null
|
|
|
|
*/
|
|
|
|
public long getIslandLevel(World world, @Nullable UUID targetPlayer) {
|
|
|
|
return getManager().getIslandLevel(world, targetPlayer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the player's level to a value
|
|
|
|
* @param world - world
|
|
|
|
* @param targetPlayer - target player
|
|
|
|
* @param level - level
|
|
|
|
*/
|
|
|
|
public void setIslandLevel(World world, UUID targetPlayer, long level) {
|
|
|
|
getManager().setIslandLevel(world, targetPlayer, level);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Zeros the initial island level
|
|
|
|
* @param island - island
|
|
|
|
* @param level - initial calculated island level
|
|
|
|
*/
|
|
|
|
public void setInitialIslandLevel(@NonNull Island island, long level) {
|
|
|
|
getManager().setInitialIslandLevel(island, level);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the initial island level
|
|
|
|
* @param island - island
|
|
|
|
* @return level or 0 by default
|
|
|
|
*/
|
|
|
|
public long getInitialIslandLevel(@NonNull Island island) {
|
|
|
|
return getManager().getInitialLevel(island);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Calculates a user's island
|
|
|
|
* @param world - the world where this island is
|
|
|
|
* @param user - not used! See depecration message
|
|
|
|
* @param playerUUID - the target island member's UUID
|
|
|
|
* @deprecated Do not use this anymore. Use getManager().calculateLevel(playerUUID, island)
|
|
|
|
*/
|
|
|
|
@Deprecated
|
|
|
|
public void calculateIslandLevel(World world, @Nullable User user, @NonNull UUID playerUUID) {
|
|
|
|
Island island = getIslands().getIsland(world, playerUUID);
|
|
|
|
if (island != null) getManager().calculateLevel(playerUUID, island);
|
|
|
|
}
|
2020-07-03 18:48:41 +02:00
|
|
|
|
2020-08-22 01:21:02 +02:00
|
|
|
/**
|
|
|
|
* Provide the levels data for the target player
|
|
|
|
* @param targetPlayer - UUID of target player
|
|
|
|
* @return LevelsData object or null if not found. Only island levels are set!
|
|
|
|
* @deprecated Do not use this anymore. Use {@link #getIslandLevel(World, UUID)}
|
|
|
|
*/
|
|
|
|
@Deprecated
|
|
|
|
public LevelsData getLevelsData(UUID targetPlayer) {
|
|
|
|
LevelsData ld = new LevelsData(targetPlayer);
|
|
|
|
getPlugin().getAddonsManager().getGameModeAddons().stream()
|
|
|
|
.filter(gm -> !settings.getGameModes().contains(gm.getDescription().getName()))
|
|
|
|
.forEach(gm -> {
|
2020-08-22 01:40:32 +02:00
|
|
|
if (getSettings().isZeroNewIslandLevels()) {
|
|
|
|
Island island = getIslands().getIsland(gm.getOverWorld(), targetPlayer);
|
|
|
|
if (island != null) {
|
|
|
|
ld.setInitialLevel(gm.getOverWorld(), this.getInitialIslandLevel(island));
|
|
|
|
}
|
|
|
|
}
|
2020-08-22 01:21:02 +02:00
|
|
|
ld.setLevel(gm.getOverWorld(), this.getIslandLevel(gm.getOverWorld(), targetPlayer));
|
|
|
|
});
|
|
|
|
return ld;
|
|
|
|
}
|
2021-06-05 17:33:03 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return the registeredGameModes
|
|
|
|
*/
|
|
|
|
public List<GameModeAddon> getRegisteredGameModes() {
|
|
|
|
return registeredGameModes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if Level addon is active in game mode
|
|
|
|
* @param gm Game Mode Addon
|
|
|
|
* @return true if active, false if not
|
|
|
|
*/
|
|
|
|
public boolean isRegisteredGameMode(GameModeAddon gm) {
|
|
|
|
return registeredGameModes.contains(gm);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if Level addon is active in world
|
|
|
|
* @param world world
|
|
|
|
* @return true if active, false if not
|
|
|
|
*/
|
|
|
|
public boolean isRegisteredGameModeWorld(World world) {
|
|
|
|
return registeredGameModes.stream().map(GameModeAddon::getOverWorld).anyMatch(w -> Util.sameWorld(world, w));
|
|
|
|
}
|
|
|
|
|
2021-08-10 05:00:55 +02:00
|
|
|
/**
|
|
|
|
* @return the roseStackersEnabled
|
|
|
|
*/
|
|
|
|
public boolean isRoseStackersEnabled() {
|
|
|
|
return roseStackersEnabled;
|
|
|
|
}
|
|
|
|
|
2017-10-21 20:32:32 +02:00
|
|
|
}
|