Upstream/Level
1
0
Fork 0
mirror of https://github.com/BentoBoxWorld/Level.git synced 2025-03-11 06:00:51 +01:00
Code Issues Projects Releases Wiki Activity

Changed top ten internally to use islands instead of players as keys (#295)

Browse Source 
Added %[gamemode]_top_weighted_value_x% placeholder
https://github.com/BentoBoxWorld/Level/issues/294
This commit is contained in:
tastybento 2023-11-19 18:08:47 -08:00 committed by GitHub
parent 26d4839f6a
commit 9d1a5c7476
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 1611 additions and 1674 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
src/main/java/world/bentobox/level/LevelsManager.java
View File

@ -96,28 +96,6 @@ public class LevelsManager {
}); });
} }
/**
* Add a score to the top players list
*
* @param world - world
* @param targetPlayer - target player
* @param lv - island level
*/
private void addToTopTen(@NonNull World world, @NonNull UUID targetPlayer, long lv) {
// Get top ten
Map<UUID, Long> topTen = topTenLists.computeIfAbsent(world, k -> new TopTenData(world)).getTopTen();
// Remove this player from the top list no matter what (we'll put them back
// later if required)
topTen.remove(targetPlayer);
// Get the island
Island island = addon.getIslands().getIsland(world, targetPlayer);
if (island != null && island.getOwner() != null && hasTopTenPerm(world, island.getOwner())) {
// Insert the owner into the top ten
topTen.put(island.getOwner(), lv);
}
}
/** /**
* Add an island to a top ten * Add an island to a top ten
* *
@ -128,7 +106,7 @@ public class LevelsManager {
private boolean addToTopTen(Island island, long lv) { private boolean addToTopTen(Island island, long lv) {
if (island != null && island.getOwner() != null && hasTopTenPerm(island.getWorld(), island.getOwner())) { if (island != null && island.getOwner() != null && hasTopTenPerm(island.getWorld(), island.getOwner())) {
topTenLists.computeIfAbsent(island.getWorld(), k -> new TopTenData(island.getWorld())).getTopTen() topTenLists.computeIfAbsent(island.getWorld(), k -> new TopTenData(island.getWorld())).getTopTen()
.put(island.getOwner(), lv); .put(island.getUniqueId(), lv);
return true; return true;
} }
return false; return false;
@ -158,7 +136,7 @@ public class LevelsManager {
result.complete(null); result.complete(null);
} }
// Save result // Save result
setIslandResults(island.getWorld(), island.getOwner(), r); setIslandResults(island, r);
// Save the island scan details // Save the island scan details
result.complete(r); result.complete(r);
}); });
@ -321,22 +299,23 @@ public class LevelsManager {
* *
* @param world - world requested * @param world - world requested
* @param size - size of the top ten * @param size - size of the top ten
* @return sorted top ten map * @return sorted top ten map. The key is the island unique ID
*/ */
@NonNull @NonNull
public Map<UUID, Long> getTopTen(@NonNull World world, int size) { public Map<String, Long> getTopTen(@NonNull World world, int size) {
createAndCleanRankings(world); createAndCleanRankings(world);
// Return the sorted map // Return the sorted map
return Collections.unmodifiableMap(topTenLists.get(world).getTopTen().entrySet().stream() return Collections.unmodifiableMap(topTenLists.get(world).getTopTen().entrySet().stream()
.filter(e -> addon.getIslands().hasIsland(world, e.getKey())).filter(l -> l.getValue() > 0) .filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).limit(size) .limit(size)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new))); .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)));
} }
void createAndCleanRankings(@NonNull World world) { void createAndCleanRankings(@NonNull World world) {
topTenLists.computeIfAbsent(world, TopTenData::new); topTenLists.computeIfAbsent(world, TopTenData::new);
// Remove player from top ten if they are online and do not have the perm // Remove player from top ten if they are online and do not have the perm
topTenLists.get(world).getTopTen().keySet().removeIf(u -> !hasTopTenPerm(world, u)); topTenLists.get(world).getTopTen().keySet().removeIf(u -> addon.getIslands().getIslandById(u)
.filter(i -> i.getOwner() == null || !hasTopTenPerm(world, i.getOwner())).isPresent());
} }
/** /**
@ -355,10 +334,12 @@ public class LevelsManager {
*/ */
public int getRank(@NonNull World world, UUID uuid) { public int getRank(@NonNull World world, UUID uuid) {
createAndCleanRankings(world); createAndCleanRankings(world);
Stream<Entry<UUID, Long>> stream = topTenLists.get(world).getTopTen().entrySet().stream() Stream<Entry<String, Long>> stream = topTenLists.get(world).getTopTen().entrySet().stream()
.filter(e -> addon.getIslands().hasIsland(world, e.getKey())).filter(l -> l.getValue() > 0) .filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())); // Get player's current island
return (int) (stream.takeWhile(x -> !x.getKey().equals(uuid)).map(Map.Entry::getKey).count() + 1); Island island = addon.getIslands().getIsland(world, uuid);
String id = island == null ? null : island.getUniqueId();
return (int) (stream.takeWhile(x -> !x.getKey().equals(id)).map(Map.Entry::getKey).count() + 1);
} }
/** /**
@ -392,13 +373,12 @@ public class LevelsManager {
} }
/** /**
* Removes a player from a world's top ten and removes world from player's level * Removes an island from a world's top ten
* data
* *
* @param world - world * @param world - world
* @param uuid - the player's uuid * @param uuid - the island's uuid
*/ */
public void removeEntry(World world, UUID uuid) { public void removeEntry(World world, String uuid) {
if (topTenLists.containsKey(world)) { if (topTenLists.containsKey(world)) {
topTenLists.get(world).getTopTen().remove(uuid); topTenLists.get(world).getTopTen().remove(uuid);
} }
@ -423,7 +403,7 @@ public class LevelsManager {
* member * member
* *
* @param world - world * @param world - world
* @param targetPlayer - player, may be a team member * @param island - island
* @param lv - level * @param lv - level
*/ */
public void setIslandLevel(@NonNull World world, @NonNull UUID targetPlayer, long lv) { public void setIslandLevel(@NonNull World world, @NonNull UUID targetPlayer, long lv) {
@ -440,9 +420,8 @@ public class LevelsManager {
} }
handler.saveObjectAsync(levelsCache.get(id)); handler.saveObjectAsync(levelsCache.get(id));
// Update TopTen // Update TopTen
addToTopTen(world, targetPlayer, levelsCache.get(id).getLevel()); addToTopTen(island, levelsCache.get(id).getLevel());
} }
} }
/** /**
@ -453,9 +432,7 @@ public class LevelsManager {
* @param owner - owner of the island * @param owner - owner of the island
* @param r - results of the calculation * @param r - results of the calculation
*/ */
private void setIslandResults(World world, @NonNull UUID owner, Results r) { private void setIslandResults(Island island, Results r) {
// Get the island
Island island = addon.getIslands().getIsland(world, owner);
if (island == null) if (island == null)
return; return;
IslandLevels ld = levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new); IslandLevels ld = levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new);
@ -467,7 +444,7 @@ public class LevelsManager {
levelsCache.put(island.getUniqueId(), ld); levelsCache.put(island.getUniqueId(), ld);
handler.saveObjectAsync(ld); handler.saveObjectAsync(ld);
// Update TopTen // Update TopTen
addToTopTen(world, owner, ld.getLevel()); addToTopTen(island, ld.getLevel());
} }
/** /**

164
src/main/java/world/bentobox/level/PlaceholderManager.java
View File

@ -2,10 +2,13 @@ package world.bentobox.level;
import java.util.Collections; import java.util.Collections;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.bukkit.World; import org.bukkit.World;
import org.eclipse.jdt.annotation.Nullable;
import world.bentobox.bentobox.BentoBox; import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.addons.GameModeAddon; import world.bentobox.bentobox.api.addons.GameModeAddon;
@ -18,6 +21,7 @@ import world.bentobox.level.objects.TopTenData;
/** /**
* Handles Level placeholders * Handles Level placeholders
*
* @author tastybento * @author tastybento
* *
*/ */
@ -32,127 +36,155 @@ public class PlaceholderManager {
} }
protected void registerPlaceholders(GameModeAddon gm) { protected void registerPlaceholders(GameModeAddon gm) {
if (plugin.getPlaceholdersManager() == null) return; if (plugin.getPlaceholdersManager() == null)
return;
PlaceholdersManager bpm = plugin.getPlaceholdersManager(); PlaceholdersManager bpm = plugin.getPlaceholdersManager();
// Island Level // Island Level
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_island_level",
gm.getDescription().getName().toLowerCase() + "_island_level",
user -> addon.getManager().getIslandLevelString(gm.getOverWorld(), user.getUniqueId())); user -> addon.getManager().getIslandLevelString(gm.getOverWorld(), user.getUniqueId()));
bpm.registerPlaceholder(addon, // Unformatted island level
gm.getDescription().getName().toLowerCase() + "_island_level_raw", bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_island_level_raw",
user -> String.valueOf(addon.getManager().getIslandLevel(gm.getOverWorld(), user.getUniqueId()))); user -> String.valueOf(addon.getManager().getIslandLevel(gm.getOverWorld(), user.getUniqueId())));
bpm.registerPlaceholder(addon, // Total number of points counted before applying level formula
gm.getDescription().getName().toLowerCase() + "_island_total_points", bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_island_total_points", user -> {
user -> {
IslandLevels data = addon.getManager().getLevelsData(addon.getIslands().getIsland(gm.getOverWorld(), user)); IslandLevels data = addon.getManager().getLevelsData(addon.getIslands().getIsland(gm.getOverWorld(), user));
return data.getTotalPoints() + ""; return data.getTotalPoints() + "";
}); });
// Points to the next level for player
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_points_to_next_level",
gm.getDescription().getName().toLowerCase() + "_points_to_next_level",
user -> addon.getManager().getPointsToNextString(gm.getOverWorld(), user.getUniqueId())); user -> addon.getManager().getPointsToNextString(gm.getOverWorld(), user.getUniqueId()));
bpm.registerPlaceholder(addon, // Maximum level this island has ever been. Current level maybe lower.
gm.getDescription().getName().toLowerCase() + "_island_level_max", bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_island_level_max",
user -> String.valueOf(addon.getManager().getIslandMaxLevel(gm.getOverWorld(), user.getUniqueId()))); user -> String.valueOf(addon.getManager().getIslandMaxLevel(gm.getOverWorld(), user.getUniqueId())));
// Visited Island Level // Visited Island Level
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_visited_island_level",
gm.getDescription().getName().toLowerCase() + "_visited_island_level", user -> getVisitedIslandLevel(gm, user)); user -> getVisitedIslandLevel(gm, user));
// Register Top Ten Placeholders // Register Top Ten Placeholders
for (int i = 1; i < 11; i++) { for (int i = 1; i < 11; i++) {
final int rank = i; final int rank = i;
// Name // Name
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_top_name_" + i,
gm.getDescription().getName().toLowerCase() + "_top_name_" + i, u -> getRankName(gm.getOverWorld(), rank)); u -> getRankName(gm.getOverWorld(), rank));
// Island Name // Island Name
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_top_island_name_" + i,
gm.getDescription().getName().toLowerCase() + "_top_island_name_" + i, u -> getRankIslandName(gm.getOverWorld(), rank)); u -> getRankIslandName(gm.getOverWorld(), rank));
// Members // Members
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_top_members_" + i,
gm.getDescription().getName().toLowerCase() + "_top_members_" + i, u -> getRankMembers(gm.getOverWorld(), rank)); u -> getRankMembers(gm.getOverWorld(), rank));
// Level // Level
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_top_value_" + i,
gm.getDescription().getName().toLowerCase() + "_top_value_" + i, u -> getRankLevel(gm.getOverWorld(), rank)); u -> getRankLevel(gm.getOverWorld(), rank));
// Weighted Level (Level / number of members)
bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_top_weighted_value_" + i,
u -> getWeightedRankLevel(gm.getOverWorld(), rank));
} }
// Personal rank // Personal rank
bpm.registerPlaceholder(addon, bpm.registerPlaceholder(addon, gm.getDescription().getName().toLowerCase() + "_rank_value",
gm.getDescription().getName().toLowerCase() + "_rank_value", u -> getRankValue(gm.getOverWorld(), u)); u -> getRankValue(gm.getOverWorld(), u));
} }
/** /**
* Get the name of the player who holds the rank in this world * Get the name of the owner of the island who holds the rank in this world.
*
* @param world world * @param world world
* @param rank rank 1 to 10 * @param rank rank 1 to 10
* @return rank name * @return rank name
*/ */
String getRankName(World world, int rank) { String getRankName(World world, int rank) {
if (rank < 1) rank = 1; // Ensure rank is within bounds
if (rank > Level.TEN) rank = Level.TEN; rank = Math.max(1, Math.min(rank, Level.TEN));
return addon.getPlayers().getName(addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null)); @Nullable
UUID owner = addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L).limit(1L)
.findFirst().flatMap(addon.getIslands()::getIslandById).map(Island::getOwner).orElse(null);
return addon.getPlayers().getName(owner);
} }
/** /**
* Get the island name for this rank * Get the island name for this rank
*
* @param world world * @param world world
* @param rank rank 1 to 10 * @param rank rank 1 to 10
* @return name of island or nothing if there isn't one * @return name of island or nothing if there isn't one
*/ */
String getRankIslandName(World world, int rank) { String getRankIslandName(World world, int rank) {
if (rank < 1) rank = 1; // Ensure rank is within bounds
if (rank > Level.TEN) rank = Level.TEN; rank = Math.max(1, Math.min(rank, Level.TEN));
UUID owner = addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null); return addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst()
if (owner != null) { .flatMap(addon.getIslands()::getIslandById).map(Island::getName).orElse("");
Island island = addon.getIslands().getIsland(world, owner);
if (island != null) {
return island.getName() == null ? "" : island.getName();
}
}
return "";
} }
/** /**
* Gets a comma separated string of island member names * Gets a comma separated string of island member names
*
* @param world world * @param world world
* @param rank rank to request * @param rank rank to request
* @return comma separated string of island member names * @return comma separated string of island member names
*/ */
String getRankMembers(World world, int rank) { String getRankMembers(World world, int rank) {
if (rank < 1) rank = 1; // Ensure rank is within bounds
if (rank > Level.TEN) rank = Level.TEN; rank = Math.max(1, Math.min(rank, Level.TEN));
UUID owner = addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L).limit(1L).findFirst().orElse(null); Optional<Island> island = addon.getManager().getTopTen(world, Level.TEN).keySet().stream().skip(rank - 1L)
if (owner != null) { .limit(1L).findFirst().flatMap(addon.getIslands()::getIslandById);
Island island = addon.getIslands().getIsland(world, owner);
if (island != null) { if (island.isPresent()) {
// Sort members by rank // Sort members by rank
return island.getMembers().entrySet().stream() return island.get().getMembers().entrySet().stream().filter(e -> e.getValue() >= RanksManager.MEMBER_RANK)
.filter(e -> e.getValue() >= RanksManager.MEMBER_RANK) .sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).map(Map.Entry::getKey)
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())) .map(addon.getPlayers()::getName).collect(Collectors.joining(","));
.map(Map.Entry::getKey)
.map(addon.getPlayers()::getName)
.collect(Collectors.joining(","));
}
} }
return ""; return "";
} }
/**
* Gets the weighted level, which is the level / number of players
*
* @param world world
* @param rank level
* @return weighted level
*/
String getWeightedRankLevel(World world, int rank) {
// Ensure rank is within bounds
rank = Math.max(1, Math.min(rank, Level.TEN));
// Retrieve the top ten entries
Map<String, Long> topTen = addon.getManager().getTopTen(world, Level.TEN);
if (topTen.isEmpty()) {
return "";
}
// Find the entry corresponding to the rank
Entry<String, Long> entry = topTen.entrySet().stream().skip(rank - 1).findFirst().orElse(null);
if (entry == null) {
return "";
}
// Calculate the score
Island island = addon.getIslands().getIslandById(entry.getKey()).orElse(null);
if (island == null || island.getMemberSet().isEmpty()) {
return "";
}
double score = (double) entry.getValue() / island.getMemberSet().size();
// Format and return the level
return addon.getManager().formatLevel((long) score);
}
String getRankLevel(World world, int rank) { String getRankLevel(World world, int rank) {
if (rank < 1) rank = 1; // Ensure rank is within bounds
if (rank > Level.TEN) rank = Level.TEN; rank = Math.max(1, Math.min(rank, Level.TEN));
return addon.getManager() return addon.getManager().formatLevel(addon.getManager().getTopTen(world, Level.TEN).values().stream()
.formatLevel(addon.getManager() .skip(rank - 1L).limit(1L).findFirst().orElse(null));
.getTopTen(world, Level.TEN)
.values()
.stream()
.skip(rank - 1L)
.limit(1L)
.findFirst()
.orElse(null));
} }
/** /**
* Return the rank of the player in a world * Return the rank of the player in a world
*
* @param world world * @param world world
* @param user player * @param user player
* @return rank where 1 is the top rank. * @return rank where 1 is the top rank.
@ -163,11 +195,13 @@ public class PlaceholderManager {
} }
// Get the island level for this user // Get the island level for this user
long level = addon.getManager().getIslandLevel(world, user.getUniqueId()); long level = addon.getManager().getIslandLevel(world, user.getUniqueId());
return String.valueOf(addon.getManager().getTopTenLists().getOrDefault(world, new TopTenData(world)).getTopTen().values().stream().filter(l -> l > level).count() + 1); return String.valueOf(addon.getManager().getTopTenLists().getOrDefault(world, new TopTenData(world)).getTopTen()
.values().stream().filter(l -> l > level).count() + 1);
} }
String getVisitedIslandLevel(GameModeAddon gm, User user) { String getVisitedIslandLevel(GameModeAddon gm, User user) {
if (user == null || !gm.inWorld(user.getWorld())) return ""; if (user == null || !gm.inWorld(user.getWorld()))
return "";
return addon.getIslands().getIslandAt(user.getLocation()) return addon.getIslands().getIslandAt(user.getLocation())
.map(island -> addon.getManager().getIslandLevelString(gm.getOverWorld(), island.getOwner())) .map(island -> addon.getManager().getIslandLevelString(gm.getOverWorld(), island.getOwner()))
.orElse("0"); .orElse("0");

3
src/main/java/world/bentobox/level/commands/AdminStatsCommand.java
View File

@ -6,7 +6,6 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.TreeMap; import java.util.TreeMap;
import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.bukkit.World; import org.bukkit.World;
@ -45,7 +44,7 @@ public class AdminStatsCommand extends CompositeCommand {
for (Entry<World, TopTenData> en : topTenLists.entrySet()) { for (Entry<World, TopTenData> en : topTenLists.entrySet()) {
user.sendMessage("admin.stats.world", TextVariables.NAME, user.sendMessage("admin.stats.world", TextVariables.NAME,
level.getPlugin().getIWM().getWorldName(en.getKey())); level.getPlugin().getIWM().getWorldName(en.getKey()));
Map<UUID, Long> topTen = en.getValue().getTopTen(); Map<String, Long> topTen = en.getValue().getTopTen();
if (topTen.isEmpty()) { if (topTen.isEmpty()) {
user.sendMessage("admin.stats.no-data"); user.sendMessage("admin.stats.no-data");
return false; return false;

18
src/main/java/world/bentobox/level/commands/AdminTopCommand.java
View File

@ -2,7 +2,7 @@ package world.bentobox.level.commands;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.UUID; import java.util.Optional;
import world.bentobox.bentobox.api.commands.CompositeCommand; import world.bentobox.bentobox.api.commands.CompositeCommand;
import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.api.user.User;
@ -30,20 +30,16 @@ public class AdminTopCommand extends CompositeCommand {
public boolean execute(User user, String label, List<String> args) { public boolean execute(User user, String label, List<String> args) {
user.sendMessage("island.top.gui-title"); user.sendMessage("island.top.gui-title");
int rank = 0; int rank = 0;
for (Map.Entry<UUID, Long> topTen : levelPlugin.getManager().getTopTen(getWorld(), Level.TEN).entrySet()) { for (Map.Entry<String, Long> topTen : levelPlugin.getManager().getTopTen(getWorld(), Level.TEN).entrySet()) {
Island island = getPlugin().getIslands().getIsland(getWorld(), topTen.getKey()); Optional<Island> is = getPlugin().getIslands().getIslandById(topTen.getKey());
if (island != null) { if (is.isPresent()) {
Island island = is.get();
rank++; rank++;
user.sendMessage("admin.top.display", user.sendMessage("admin.top.display", "[rank]", String.valueOf(rank), "[name]",
"[rank]", this.getPlugin().getPlayers().getUser(island.getOwner()).getName(), "[level]",
String.valueOf(rank),
"[name]",
this.getPlugin().getPlayers().getUser(island.getOwner()).getName(),
"[level]",
String.valueOf(topTen.getValue())); String.valueOf(topTen.getValue()));
} }
} }
return true; return true;
} }
} }

19
src/main/java/world/bentobox/level/commands/AdminTopRemoveCommand.java
View File

@ -6,10 +6,12 @@ import java.util.Optional;
import world.bentobox.bentobox.api.commands.CompositeCommand; import world.bentobox.bentobox.api.commands.CompositeCommand;
import world.bentobox.bentobox.api.localization.TextVariables; import world.bentobox.bentobox.api.localization.TextVariables;
import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.objects.Island;
import world.bentobox.level.Level; import world.bentobox.level.Level;
/** /**
* Removes a player from the top ten * Removes a player from the top ten
*
* @author tastybento * @author tastybento
* *
*/ */
@ -31,8 +33,11 @@ public class AdminTopRemoveCommand extends CompositeCommand {
this.setDescription("admin.top.remove.description"); this.setDescription("admin.top.remove.description");
} }
/* (non-Javadoc) /*
* @see world.bentobox.bentobox.api.commands.BentoBoxCommand#canExecute(world.bentobox.bentobox.api.user.User, java.lang.String, java.util.List) * (non-Javadoc)
*
* @see world.bentobox.bentobox.api.commands.BentoBoxCommand#canExecute(world.
* bentobox.bentobox.api.user.User, java.lang.String, java.util.List)
*/ */
@Override @Override
public boolean canExecute(User user, String label, List<String> args) { public boolean canExecute(User user, String label, List<String> args) {
@ -51,14 +56,18 @@ public class AdminTopRemoveCommand extends CompositeCommand {
@Override @Override
public boolean execute(User user, String label, List<String> args) { public boolean execute(User user, String label, List<String> args) {
addon.getManager().removeEntry(getWorld(), target.getUniqueId()); // Removes islands that this target is an owner of
getIslands().getIslands(getWorld(), target.getUniqueId()).stream()
.filter(is -> target.getUniqueId().equals(is.getOwner()))
.forEach(island -> addon.getManager().removeEntry(getWorld(), island.getUniqueId()));
user.sendMessage("general.success"); user.sendMessage("general.success");
return true; return true;
} }
@Override @Override
public Optional<List<String>> tabComplete(User user, String alias, List<String> args) { public Optional<List<String>> tabComplete(User user, String alias, List<String> args) {
return Optional.of(addon.getManager().getTopTen(getWorld(), Level.TEN).keySet().stream().map(addon.getPlayers()::getName) return Optional.of(addon.getManager().getTopTen(getWorld(), Level.TEN).keySet().stream()
.filter(n -> !n.isEmpty()).toList()); .map(getIslands()::getIslandById).flatMap(Optional::stream).map(Island::getOwner)
.map(addon.getPlayers()::getName).filter(n -> !n.isEmpty()).toList());
} }
} }

42
src/main/java/world/bentobox/level/listeners/IslandActivitiesListeners.java
View File

@ -1,7 +1,5 @@
package world.bentobox.level.listeners; package world.bentobox.level.listeners;
import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority; import org.bukkit.event.EventPriority;
@ -21,7 +19,9 @@ import world.bentobox.bentobox.database.objects.Island;
import world.bentobox.level.Level; import world.bentobox.level.Level;
/** /**
* Listens for new islands or ownership changes and sets the level to zero automatically * Listens for new islands or ownership changes and sets the level to zero
* automatically
*
* @author tastybento * @author tastybento
* *
*/ */
@ -54,18 +54,14 @@ public class IslandActivitiesListeners implements Listener {
private void zeroIsland(final Island island) { private void zeroIsland(final Island island) {
// Clear the island setting // Clear the island setting
if (island.getOwner() != null && island.getWorld() != null) { if (island.getOwner() != null && island.getWorld() != null) {
addon.getPipeliner().zeroIsland(island).thenAccept(results -> addon.getPipeliner().zeroIsland(island)
addon.getManager().setInitialIslandLevel(island, results.getLevel())); .thenAccept(results -> addon.getManager().setInitialIslandLevel(island, results.getLevel()));
} }
} }
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onIslandDelete(IslandPreclearEvent e) { public void onIslandDelete(IslandPreclearEvent e) {
remove(e.getIsland().getWorld(), e.getIsland().getUniqueId());
// Remove player from the top ten and level
UUID uuid = e.getIsland().getOwner();
World world = e.getIsland().getWorld();
remove(world, uuid);
} }
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@ -74,7 +70,7 @@ public class IslandActivitiesListeners implements Listener {
addon.getManager().deleteIsland(e.getIsland().getUniqueId()); addon.getManager().deleteIsland(e.getIsland().getUniqueId());
} }
private void remove(World world, UUID uuid) { private void remove(World world, String uuid) {
if (uuid != null && world != null) { if (uuid != null && world != null) {
addon.getManager().removeEntry(world, uuid); addon.getManager().removeEntry(world, uuid);
} }
@ -83,43 +79,43 @@ public class IslandActivitiesListeners implements Listener {
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onNewIslandOwner(TeamSetownerEvent e) { public void onNewIslandOwner(TeamSetownerEvent e) {
// Remove player from the top ten and level // Remove island from the top ten and level
remove(e.getIsland().getWorld(), e.getIsland().getOwner()); remove(e.getIsland().getWorld(), e.getIsland().getUniqueId());
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onIsland(TeamJoinedEvent e) { public void onIsland(TeamJoinedEvent e) {
// TODO: anything to do here?
// Remove player from the top ten and level // Remove player from the top ten and level
remove(e.getIsland().getWorld(), e.getPlayerUUID()); // remove(e.getIsland().getWorld(), e.getPlayerUUID());
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onIsland(IslandUnregisteredEvent e) { public void onIsland(IslandUnregisteredEvent e) {
// Remove player from the top ten // Remove island from the top ten
remove(e.getIsland().getWorld(), e.getPlayerUUID()); remove(e.getIsland().getWorld(), e.getIsland().getUniqueId());
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onIsland(IslandRegisteredEvent e) { public void onIsland(IslandRegisteredEvent e) {
// TODO: anything to do here?
// Remove player from the top ten // Remove player from the top ten
remove(e.getIsland().getWorld(), e.getPlayerUUID()); // remove(e.getIsland().getWorld(), e.getPlayerUUID());
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onIsland(TeamLeaveEvent e) { public void onIsland(TeamLeaveEvent e) {
// TODO: anything to do here?
// Remove player from the top ten and level // Remove player from the top ten and level
remove(e.getIsland().getWorld(), e.getPlayerUUID()); // remove(e.getIsland().getWorld(), e.getPlayerUUID());
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onIsland(TeamKickEvent e) { public void onIsland(TeamKickEvent e) {
//// TODO: anything to do here?
// Remove player from the top ten and level // Remove player from the top ten and level
remove(e.getIsland().getWorld(), e.getPlayerUUID()); // remove(e.getIsland().getWorld(), e.getPlayerUUID());
} }
} }

27
src/main/java/world/bentobox/level/objects/TopTenData.java
View File

@ -3,56 +3,41 @@ package world.bentobox.level.objects;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.Locale; import java.util.Locale;
import java.util.Map; import java.util.Map;
import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
import com.google.gson.annotations.Expose; import com.google.gson.annotations.Expose;
import world.bentobox.bentobox.database.objects.DataObject;
import world.bentobox.bentobox.database.objects.Table;
/** /**
* This class stores the top ten. * This class stores the top ten.
*
* @author tastybento * @author tastybento
* *
*/ */
@Table(name = "TopTenData") public class TopTenData {
public class TopTenData implements DataObject {
// UniqueId is the world name // UniqueId is the world name
@Expose @Expose
private String uniqueId = ""; private String uniqueId = "";
@Expose @Expose
private Map<UUID, Long> topTen = new LinkedHashMap<>(); private Map<String, Long> topTen = new LinkedHashMap<>();
public TopTenData(World k) { public TopTenData(World k) {
uniqueId = k.getName().toLowerCase(Locale.ENGLISH); uniqueId = k.getName().toLowerCase(Locale.ENGLISH);
} }
@Override
public String getUniqueId() {
// This is the world name
return uniqueId;
}
@Override
public void setUniqueId(String uniqueId) {
// This is the world name - make it always lowercase
this.uniqueId = uniqueId.toLowerCase(Locale.ENGLISH);
}
/** /**
* @return the topTen * @return the topTen
*/ */
public Map<UUID, Long> getTopTen() { public Map<String, Long> getTopTen() {
return topTen; return topTen;
} }
/** /**
* @param topTen the topTen to set * @param topTen the topTen to set
*/ */
public void setTopTen(Map<UUID, Long> topTen) { public void setTopTen(Map<String, Long> topTen) {
this.topTen = topTen; this.topTen = topTen;
} }
} }

334
src/main/java/world/bentobox/level/panels/TopLevelPanel.java
View File

@ -5,10 +5,11 @@
package world.bentobox.level.panels; package world.bentobox.level.panels;
import java.io.File; import java.io.File;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -29,50 +30,44 @@ import world.bentobox.bentobox.managers.RanksManager;
import world.bentobox.level.Level; import world.bentobox.level.Level;
import world.bentobox.level.util.Utils; import world.bentobox.level.util.Utils;
/** /**
* This panel opens top likes panel * This panel opens top likes panel
*/ */
public class TopLevelPanel public class TopLevelPanel {
{
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
// Section: Internal Constructor // Section: Internal Constructor
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** /**
* This is internal constructor. It is used internally in current class to avoid creating objects everywhere. * This is internal constructor. It is used internally in current class to avoid
* creating objects everywhere.
* *
* @param addon Level object. * @param addon Level object.
* @param user User who opens Panel. * @param user User who opens Panel.
* @param world World where gui is opened * @param world World where gui is opened
* @param permissionPrefix Permission Prefix * @param permissionPrefix Permission Prefix
*/ */
private TopLevelPanel(Level addon, User user, World world, String permissionPrefix) private TopLevelPanel(Level addon, User user, World world, String permissionPrefix) {
{
this.addon = addon; this.addon = addon;
this.user = user; this.user = user;
this.world = world; this.world = world;
this.iconPermission = permissionPrefix + "level.icon"; this.iconPermission = permissionPrefix + "level.icon";
topIslands = new ArrayList<>();
this.topIslands = this.addon.getManager().getTopTen(this.world, 10).entrySet().stream(). for (Map.Entry<String, Long> en : addon.getManager().getTopTen(this.world, Level.TEN).entrySet()) {
map(entry -> { Optional<Island> is = addon.getIslands().getIslandById(en.getKey());
Island island = this.addon.getIslandsManager().getIsland(this.world, entry.getKey()); if (is.isPresent()) {
return new IslandTopRecord(island, entry.getValue()); topIslands.add(new IslandTopRecord(is.get(), en.getValue()));
}). }
collect(Collectors.toList()); }
} }
/** /**
* Build method manages current panel opening. It uses BentoBox PanelAPI that is easy to use and users can get nice * Build method manages current panel opening. It uses BentoBox PanelAPI that is
* panels. * easy to use and users can get nice panels.
*/ */
public void build() public void build() {
{
TemplatedPanelBuilder panelBuilder = new TemplatedPanelBuilder(); TemplatedPanelBuilder panelBuilder = new TemplatedPanelBuilder();
panelBuilder.user(this.user); panelBuilder.user(this.user);
@ -87,47 +82,38 @@ public class TopLevelPanel
panelBuilder.build(); panelBuilder.build();
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
// Section: Methods // Section: Methods
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
/** /**
* Creates fallback based on template. * Creates fallback based on template.
*
* @param template Template record for fallback button. * @param template Template record for fallback button.
* @param index Place of the fallback. * @param index Place of the fallback.
* @return Fallback panel item. * @return Fallback panel item.
*/ */
private PanelItem createFallback(ItemTemplateRecord template, long index) private PanelItem createFallback(ItemTemplateRecord template, long index) {
{ if (template == null) {
if (template == null)
{
return null; return null;
} }
PanelItemBuilder builder = new PanelItemBuilder(); PanelItemBuilder builder = new PanelItemBuilder();
if (template.icon() != null) if (template.icon() != null) {
{
builder.icon(template.icon().clone()); builder.icon(template.icon().clone());
} }
if (template.title() != null) if (template.title() != null) {
{ builder.name(
builder.name(this.user.getTranslation(this.world, template.title(), this.user.getTranslation(this.world, template.title(), TextVariables.NAME, String.valueOf(index)));
TextVariables.NAME, String.valueOf(index))); } else {
} builder.name(this.user.getTranslation(this.world, REFERENCE, TextVariables.NAME, String.valueOf(index)));
else
{
builder.name(this.user.getTranslation(this.world, REFERENCE,
TextVariables.NAME, String.valueOf(index)));
} }
if (template.description() != null) if (template.description() != null) {
{ builder.description(this.user.getTranslation(this.world, template.description(), TextVariables.NUMBER,
builder.description(this.user.getTranslation(this.world, template.description(), String.valueOf(index)));
TextVariables.NUMBER, String.valueOf(index)));
} }
builder.amount(index != 0 ? (int) index : 1); builder.amount(index != 0 ? (int) index : 1);
@ -135,46 +121,40 @@ public class TopLevelPanel
return builder.build(); return builder.build();
} }
/** /**
* This method creates player icon with warp functionality. * This method creates player icon with warp functionality.
* *
* @return PanelItem for PanelBuilder. * @return PanelItem for PanelBuilder.
*/ */
private PanelItem createPlayerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot) private PanelItem createPlayerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot) {
{
int index = (int) template.dataMap().getOrDefault("index", 0); int index = (int) template.dataMap().getOrDefault("index", 0);
if (index < 1) if (index < 1) {
{
return this.createFallback(template.fallback(), index); return this.createFallback(template.fallback(), index);
} }
IslandTopRecord islandTopRecord = this.topIslands.size() < index ? null : this.topIslands.get(index - 1); IslandTopRecord islandTopRecord = this.topIslands.size() < index ? null : this.topIslands.get(index - 1);
if (islandTopRecord == null) if (islandTopRecord == null) {
{
return this.createFallback(template.fallback(), index); return this.createFallback(template.fallback(), index);
} }
return this.createIslandIcon(template, islandTopRecord, index); return this.createIslandIcon(template, islandTopRecord, index);
} }
/** /**
* This method creates button from template for given island top record. * This method creates button from template for given island top record.
*
* @param template Icon Template. * @param template Icon Template.
* @param islandTopRecord Island Top Record. * @param islandTopRecord Island Top Record.
* @param index Place Index. * @param index Place Index.
* @return PanelItem for PanelBuilder. * @return PanelItem for PanelBuilder.
*/ */
private PanelItem createIslandIcon(ItemTemplateRecord template, IslandTopRecord islandTopRecord, int index) private PanelItem createIslandIcon(ItemTemplateRecord template, IslandTopRecord islandTopRecord, int index) {
{
// Get player island. // Get player island.
Island island = islandTopRecord.island(); Island island = islandTopRecord.island();
if (island == null) if (island == null) {
{
return this.createFallback(template.fallback(), index); return this.createFallback(template.fallback(), index);
} }
@ -189,23 +169,19 @@ public class TopLevelPanel
// Get only possible actions, by removing all inactive ones. // Get only possible actions, by removing all inactive ones.
List<ItemTemplateRecord.ActionRecords> activeActions = new ArrayList<>(template.actions()); List<ItemTemplateRecord.ActionRecords> activeActions = new ArrayList<>(template.actions());
activeActions.removeIf(action -> activeActions.removeIf(action -> {
{ switch (action.actionType().toUpperCase()) {
switch (action.actionType().toUpperCase())
{
case "WARP" -> { case "WARP" -> {
return island.getOwner() == null || return island.getOwner() == null || this.addon.getWarpHook() == null
this.addon.getWarpHook() == null || || !this.addon.getWarpHook().getWarpSignsManager().hasWarp(this.world, island.getOwner());
!this.addon.getWarpHook().getWarpSignsManager().hasWarp(this.world, island.getOwner());
} }
case "VISIT" -> { case "VISIT" -> {
return island.getOwner() == null || return island.getOwner() == null || this.addon.getVisitHook() == null
this.addon.getVisitHook() == null || || !this.addon.getVisitHook().getAddonManager().preprocessTeleportation(this.user, island);
!this.addon.getVisitHook().getAddonManager().preprocessTeleportation(this.user, island);
} }
case "VIEW" -> { case "VIEW" -> {
return island.getOwner() == null || return island.getOwner() == null
!island.getMemberSet(RanksManager.MEMBER_RANK).contains(this.user.getUniqueId()); || !island.getMemberSet(RanksManager.MEMBER_RANK).contains(this.user.getUniqueId());
} }
default -> { default -> {
return false; return false;
@ -214,33 +190,30 @@ public class TopLevelPanel
}); });
// Add Click handler // Add Click handler
builder.clickHandler((panel, user, clickType, i) -> builder.clickHandler((panel, user, clickType, i) -> {
{ for (ItemTemplateRecord.ActionRecords action : activeActions) {
for (ItemTemplateRecord.ActionRecords action : activeActions) if (clickType == action.clickType() || action.clickType() == ClickType.UNKNOWN) {
{ switch (action.actionType().toUpperCase()) {
if (clickType == action.clickType() || action.clickType() == ClickType.UNKNOWN)
{
switch (action.actionType().toUpperCase())
{
case "WARP" -> { case "WARP" -> {
this.user.closeInventory(); this.user.closeInventory();
this.addon.getWarpHook().getWarpSignsManager().warpPlayer(this.world, this.user, island.getOwner()); this.addon.getWarpHook().getWarpSignsManager().warpPlayer(this.world, this.user,
island.getOwner());
} }
case "VISIT" -> case "VISIT" ->
// The command call implementation solves necessity to check for all visits options, // The command call implementation solves necessity to check for all visits
// like cool down, confirmation and preprocess in single go. Would it be better to write // options,
// like cool down, confirmation and preprocess in single go. Would it be better
// to write
// all logic here? // all logic here?
this.addon.getPlugin().getIWM().getAddon(this.world). this.addon.getPlugin().getIWM().getAddon(this.world).flatMap(GameModeAddon::getPlayerCommand)
flatMap(GameModeAddon::getPlayerCommand).ifPresent(command -> .ifPresent(command -> {
{ String mainCommand = this.addon.getVisitHook().getSettings().getPlayerMainCommand();
String mainCommand =
this.addon.getVisitHook().getSettings().getPlayerMainCommand();
if (!mainCommand.isBlank()) if (!mainCommand.isBlank()) {
{
this.user.closeInventory(); this.user.closeInventory();
this.user.performCommand(command.getTopLabel() + " " + mainCommand + " " + island.getOwner()); this.user.performCommand(
command.getTopLabel() + " " + mainCommand + " " + island.getOwner());
} }
}); });
@ -262,15 +235,12 @@ public class TopLevelPanel
}); });
// Collect tooltips. // Collect tooltips.
List<String> tooltips = activeActions.stream(). List<String> tooltips = activeActions.stream().filter(action -> action.tooltip() != null)
filter(action -> action.tooltip() != null). .map(action -> this.user.getTranslation(this.world, action.tooltip())).filter(text -> !text.isBlank())
map(action -> this.user.getTranslation(this.world, action.tooltip())). .collect(Collectors.toCollection(() -> new ArrayList<>(template.actions().size())));
filter(text -> !text.isBlank()).
collect(Collectors.toCollection(() -> new ArrayList<>(template.actions().size())));
// Add tooltips. // Add tooltips.
if (!tooltips.isEmpty()) if (!tooltips.isEmpty()) {
{
// Empty line and tooltips. // Empty line and tooltips.
builder.description(""); builder.description("");
builder.description(tooltips); builder.description(tooltips);
@ -279,104 +249,75 @@ public class TopLevelPanel
return builder.build(); return builder.build();
} }
/** /**
* Populate given panel item builder name with values from template and island objects. * Populate given panel item builder name with values from template and island
* objects.
* *
* @param builder the builder * @param builder the builder
* @param template the template * @param template the template
* @param island the island * @param island the island
*/ */
private void populateIslandTitle(PanelItemBuilder builder, private void populateIslandTitle(PanelItemBuilder builder, ItemTemplateRecord template, Island island) {
ItemTemplateRecord template,
Island island)
{
// Get Island Name // Get Island Name
String nameText; String nameText;
if (island.getName() == null || island.getName().isEmpty()) if (island.getName() == null || island.getName().isEmpty()) {
{ nameText = this.user.getTranslation(REFERENCE + "owners-island", PLAYER,
nameText = this.user.getTranslation(REFERENCE + "owners-island", island.getOwner() == null ? this.user.getTranslation(REFERENCE + "unknown")
PLAYER, : this.addon.getPlayers().getName(island.getOwner()));
island.getOwner() == null ? } else {
this.user.getTranslation(REFERENCE + "unknown") :
this.addon.getPlayers().getName(island.getOwner()));
}
else
{
nameText = island.getName(); nameText = island.getName();
} }
// Template specific title is always more important than custom one. // Template specific title is always more important than custom one.
if (template.title() != null && !template.title().isBlank()) if (template.title() != null && !template.title().isBlank()) {
{ builder.name(this.user.getTranslation(this.world, template.title(), TextVariables.NAME, nameText));
builder.name(this.user.getTranslation(this.world, template.title(), } else {
TextVariables.NAME, nameText));
}
else
{
builder.name(this.user.getTranslation(REFERENCE + "name", TextVariables.NAME, nameText)); builder.name(this.user.getTranslation(REFERENCE + "name", TextVariables.NAME, nameText));
} }
} }
/** /**
* Populate given panel item builder icon with values from template and island objects. * Populate given panel item builder icon with values from template and island
* objects.
* *
* @param builder the builder * @param builder the builder
* @param template the template * @param template the template
* @param island the island * @param island the island
*/ */
private void populateIslandIcon(PanelItemBuilder builder, private void populateIslandIcon(PanelItemBuilder builder, ItemTemplateRecord template, Island island) {
ItemTemplateRecord template,
Island island)
{
User owner = island.getOwner() == null ? null : User.getInstance(island.getOwner()); User owner = island.getOwner() == null ? null : User.getInstance(island.getOwner());
// Get permission or island icon // Get permission or island icon
String permissionIcon = owner == null ? null : String permissionIcon = owner == null ? null : Utils.getPermissionValue(owner, this.iconPermission, null);
Utils.getPermissionValue(owner, this.iconPermission, null);
Material material; Material material;
if (permissionIcon != null && !permissionIcon.equals("*")) if (permissionIcon != null && !permissionIcon.equals("*")) {
{
material = Material.matchMaterial(permissionIcon); material = Material.matchMaterial(permissionIcon);
} } else {
else
{
material = null; material = null;
} }
if (material != null) if (material != null) {
{ if (!material.equals(Material.PLAYER_HEAD)) {
if (!material.equals(Material.PLAYER_HEAD))
{
builder.icon(material); builder.icon(material);
} } else {
else
{
builder.icon(owner.getName()); builder.icon(owner.getName());
} }
} } else if (template.icon() != null) {
else if (template.icon() != null)
{
builder.icon(template.icon().clone()); builder.icon(template.icon().clone());
} } else if (owner != null) {
else if (owner != null)
{
builder.icon(owner.getName()); builder.icon(owner.getName());
} } else {
else
{
builder.icon(Material.PLAYER_HEAD); builder.icon(Material.PLAYER_HEAD);
} }
} }
/** /**
* Populate given panel item builder description with values from template and island objects. * Populate given panel item builder description with values from template and
* island objects.
* *
* @param builder the builder * @param builder the builder
* @param template the template * @param template the template
@ -384,94 +325,72 @@ public class TopLevelPanel
* @param islandTopRecord the top record object * @param islandTopRecord the top record object
* @param index place index. * @param index place index.
*/ */
private void populateIslandDescription(PanelItemBuilder builder, private void populateIslandDescription(PanelItemBuilder builder, ItemTemplateRecord template, Island island,
ItemTemplateRecord template, IslandTopRecord islandTopRecord, int index) {
Island island,
IslandTopRecord islandTopRecord,
int index)
{
// Get Owner Name // Get Owner Name
String ownerText = this.user.getTranslation(REFERENCE + "owner", String ownerText = this.user.getTranslation(REFERENCE + "owner", PLAYER,
PLAYER, island.getOwner() == null ? this.user.getTranslation(REFERENCE + "unknown")
island.getOwner() == null ? : this.addon.getPlayers().getName(island.getOwner()));
this.user.getTranslation(REFERENCE + "unknown") :
this.addon.getPlayers().getName(island.getOwner()));
// Get Members Text // Get Members Text
String memberText; String memberText;
if (island.getMemberSet().size() > 1) if (island.getMemberSet().size() > 1) {
{
StringBuilder memberBuilder = new StringBuilder( StringBuilder memberBuilder = new StringBuilder(
this.user.getTranslationOrNothing(REFERENCE + "members-title")); this.user.getTranslationOrNothing(REFERENCE + "members-title"));
for (UUID uuid : island.getMemberSet()) for (UUID uuid : island.getMemberSet()) {
{
User member = User.getInstance(uuid); User member = User.getInstance(uuid);
if (memberBuilder.length() > 0) if (memberBuilder.length() > 0) {
{
memberBuilder.append("\n"); memberBuilder.append("\n");
} }
memberBuilder.append( memberBuilder.append(this.user.getTranslationOrNothing(REFERENCE + "member", PLAYER, member.getName()));
this.user.getTranslationOrNothing(REFERENCE + "member",
PLAYER, member.getName()));
} }
memberText = memberBuilder.toString(); memberText = memberBuilder.toString();
} } else {
else
{
memberText = ""; memberText = "";
} }
String placeText = this.user.getTranslation(REFERENCE + "place", String placeText = this.user.getTranslation(REFERENCE + "place", TextVariables.NUMBER, String.valueOf(index));
TextVariables.NUMBER, String.valueOf(index));
String levelText = this.user.getTranslation(REFERENCE + "level", String levelText = this.user.getTranslation(REFERENCE + "level", TextVariables.NUMBER,
TextVariables.NUMBER, this.addon.getManager().formatLevel(islandTopRecord.level())); this.addon.getManager().formatLevel(islandTopRecord.level()));
// Template specific description is always more important than custom one. // Template specific description is always more important than custom one.
if (template.description() != null && !template.description().isBlank()) if (template.description() != null && !template.description().isBlank()) {
{ builder.description(this.user
builder.description(this.user.getTranslation(this.world, template.description(), .getTranslation(this.world, template.description(), "[owner]", ownerText, "[members]", memberText,
"[owner]", ownerText, "[level]", levelText, "[place]", placeText)
"[members]", memberText, .replaceAll("(?m)^[ \\t]*\\r?\\n", "").replaceAll("(?<!\\\\)\\|", "\n").replace("\\\\\\|", "|")); // Not
"[level]", levelText, // a
"[place]", placeText). // regex
replaceAll("(?m)^[ \\t]*\\r?\\n", ""). // -
replaceAll("(?<!\\\\)\\|", "\n"). // replace
replace("\\\\\\|", "|")); // Not a regex - replace is more efficient // is
} // more
else // efficient
{ } else {
// Now combine everything. // Now combine everything.
String descriptionText = this.user.getTranslation(REFERENCE + "description", String descriptionText = this.user.getTranslation(REFERENCE + "description", "[owner]", ownerText,
"[owner]", ownerText, "[members]", memberText, "[level]", levelText, "[place]", placeText);
"[members]", memberText,
"[level]", levelText,
"[place]", placeText);
builder.description(descriptionText. builder.description(descriptionText.replaceAll("(?m)^[ \\t]*\\r?\\n", "").replaceAll("(?<!\\\\)\\|", "\n")
replaceAll("(?m)^[ \\t]*\\r?\\n", ""). .replace("\\\\\\|", "|")); // Not a regex - replace is more efficient
replaceAll("(?<!\\\\)\\|", "\n").
replace("\\\\\\|", "|")); // Not a regex - replace is more efficient
} }
} }
/** /**
* Create viewer button panel item. * Create viewer button panel item.
* *
* @return PanelItem for PanelBuilder. * @return PanelItem for PanelBuilder.
*/ */
private PanelItem createViewerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot) private PanelItem createViewerButton(ItemTemplateRecord template, TemplatedPanel.ItemSlot itemSlot) {
{
Island island = this.addon.getIslands().getIsland(this.world, this.user); Island island = this.addon.getIslands().getIsland(this.world, this.user);
if (island == null || island.getOwner() == null) if (island == null || island.getOwner() == null) {
{
// Player do not have an island. // Player do not have an island.
return null; return null;
} }
@ -484,18 +403,16 @@ public class TopLevelPanel
return this.createIslandIcon(template, topRecord, place); return this.createIslandIcon(template, topRecord, place);
} }
/** /**
* This method is used to open UserPanel outside this class. It will be much easier to open panel with single method * This method is used to open UserPanel outside this class. It will be much
* call then initializing new object. * easier to open panel with single method call then initializing new object.
* *
* @param addon Level Addon object * @param addon Level Addon object
* @param user User who opens panel * @param user User who opens panel
* @param world World where gui is opened * @param world World where gui is opened
* @param permissionPrefix Permission Prefix * @param permissionPrefix Permission Prefix
*/ */
public static void openPanel(Level addon, User user, World world, String permissionPrefix) public static void openPanel(Level addon, User user, World world, String permissionPrefix) {
{
new TopLevelPanel(addon, user, world, permissionPrefix).build(); new TopLevelPanel(addon, user, world, permissionPrefix).build();
} }
@ -512,9 +429,12 @@ public class TopLevelPanel
/** /**
* This record is used internally. It converts user -> level to island -> level. * This record is used internally. It converts user -> level to island -> level.
*
* @param island island
* @param level level
*/ */
private record IslandTopRecord(Island island, Long level) {} private record IslandTopRecord(Island island, Long level) {
}
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
// Section: Variables // Section: Variables

37
src/test/java/world/bentobox/level/LevelsManagerTest.java
View File

@ -160,7 +160,7 @@ public class LevelsManagerTest {
when(island.getMemberSet()).thenReturn(iset); when(island.getMemberSet()).thenReturn(iset);
when(island.getOwner()).thenReturn(uuid); when(island.getOwner()).thenReturn(uuid);
when(island.getWorld()).thenReturn(world); when(island.getWorld()).thenReturn(world);
when(island.getUniqueId()).thenReturn(UUID.randomUUID().toString()); when(island.getUniqueId()).thenReturn(uuid.toString());
// Default to uuid's being island owners // Default to uuid's being island owners
when(im.hasIsland(eq(world), any(UUID.class))).thenReturn(true); when(im.hasIsland(eq(world), any(UUID.class))).thenReturn(true);
when(im.getIsland(world, uuid)).thenReturn(island); when(im.getIsland(world, uuid)).thenReturn(island);
@ -347,7 +347,7 @@ public class LevelsManagerTest {
*/ */
@Test @Test
public void testGetTopTenEmpty() { public void testGetTopTenEmpty() {
Map<UUID, Long> tt = lm.getTopTen(world, Level.TEN); Map<String, Long> tt = lm.getTopTen(world, Level.TEN);
assertTrue(tt.isEmpty()); assertTrue(tt.isEmpty());
} }
@ -358,23 +358,12 @@ public class LevelsManagerTest {
@Test @Test
public void testGetTopTen() { public void testGetTopTen() {
testLoadTopTens(); testLoadTopTens();
Map<UUID, Long> tt = lm.getTopTen(world, Level.TEN); Map<String, Long> tt = lm.getTopTen(world, Level.TEN);
assertFalse(tt.isEmpty()); assertFalse(tt.isEmpty());
assertEquals(1, tt.size()); assertEquals(1, tt.size());
assertEquals(1, lm.getTopTen(world, 1).size()); assertEquals(1, lm.getTopTen(world, 1).size());
} }
/**
* Test method for {@link world.bentobox.level.LevelsManager#getTopTen(org.bukkit.World, int)}.
*/
@Test
public void testGetTopTenNoOwners() {
when(im.hasIsland(eq(world), any(UUID.class))).thenReturn(false);
testLoadTopTens();
Map<UUID, Long> tt = lm.getTopTen(world, Level.TEN);
assertTrue(tt.isEmpty());
}
/** /**
* Test method for * Test method for
* {@link world.bentobox.level.LevelsManager#hasTopTenPerm(org.bukkit.World, java.util.UUID)}. * {@link world.bentobox.level.LevelsManager#hasTopTenPerm(org.bukkit.World, java.util.UUID)}.
@ -407,11 +396,11 @@ public class LevelsManagerTest {
@Test @Test
public void testRemoveEntry() { public void testRemoveEntry() {
testLoadTopTens(); testLoadTopTens();
Map<UUID, Long> tt = lm.getTopTen(world, Level.TEN); Map<String, Long> tt = lm.getTopTen(world, Level.TEN);
assertTrue(tt.containsKey(uuid)); assertTrue(tt.containsKey(uuid.toString()));
lm.removeEntry(world, uuid); lm.removeEntry(world, uuid.toString());
tt = lm.getTopTen(world, Level.TEN); tt = lm.getTopTen(world, Level.TEN);
assertFalse(tt.containsKey(uuid)); assertFalse(tt.containsKey(uuid.toString()));
} }
/** /**
@ -443,15 +432,15 @@ public class LevelsManagerTest {
public void testGetRank() { public void testGetRank() {
lm.createAndCleanRankings(world); lm.createAndCleanRankings(world);
Map<World, TopTenData> ttl = lm.getTopTenLists(); Map<World, TopTenData> ttl = lm.getTopTenLists();
Map<UUID, Long> tt = ttl.get(world).getTopTen(); Map<String, Long> tt = ttl.get(world).getTopTen();
for (long i = 100; i < 150; i++) { for (long i = 100; i < 150; i++) {
tt.put(UUID.randomUUID(), i); tt.put(UUID.randomUUID().toString(), i);
} }
// Put player as lowest rank // Put island as lowest rank
tt.put(uuid, 10L); tt.put(uuid.toString(), 10L);
assertEquals(51, lm.getRank(world, uuid)); assertEquals(51, lm.getRank(world, uuid));
// Put player as highest rank // Put island as highest rank
tt.put(uuid, 1000L); tt.put(uuid.toString(), 1000L);
assertEquals(1, lm.getRank(world, uuid)); assertEquals(1, lm.getRank(world, uuid));
// Unknown UUID - lowest rank + 1 // Unknown UUID - lowest rank + 1
assertEquals(52, lm.getRank(world, UUID.randomUUID())); assertEquals(52, lm.getRank(world, UUID.randomUUID()));

122
src/test/java/world/bentobox/level/PlaceholderManagerTest.java
View File

@ -3,6 +3,7 @@ package world.bentobox.level;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
@ -10,9 +11,10 @@ import static org.mockito.Mockito.when;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional; import java.util.Optional;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -54,7 +56,7 @@ public class PlaceholderManagerTest {
@Mock @Mock
private BentoBox plugin; private BentoBox plugin;
private PlaceholderManager pm; private PlaceholderManager phm;
@Mock @Mock
private PlaceholdersManager bpm; private PlaceholdersManager bpm;
@Mock @Mock
@ -67,13 +69,24 @@ public class PlaceholderManagerTest {
private Island island; private Island island;
@Mock @Mock
private User user; private User user;
private Map<UUID, String> names = new HashMap<>(); private static final Map<UUID, String> names = new LinkedHashMap<>();
private static final List<String> NAMES = List.of("tasty", "bento", "fred", "bonne", "cyprien", "mael", "joe", "horacio", "steph", "vicky"); static {
private Map<UUID, Island> islands = new HashMap<>(); names.put(UUID.randomUUID(), "tasty");
private Map<UUID, Long> map = new HashMap<>(); names.put(UUID.randomUUID(), "bento");
names.put(UUID.randomUUID(), "fred");
names.put(UUID.randomUUID(), "bonne");
names.put(UUID.randomUUID(), "cyprien");
names.put(UUID.randomUUID(), "mael");
names.put(UUID.randomUUID(), "joe");
names.put(UUID.randomUUID(), "horacio");
names.put(UUID.randomUUID(), "steph");
names.put(UUID.randomUUID(), "vicky");
}
private Map<String, Island> islands = new HashMap<>();
private Map<String, Long> map = new HashMap<>();
private @NonNull IslandLevels data; private @NonNull IslandLevels data;
@Mock @Mock
private PlayersManager players; private PlayersManager pm;
/** /**
* @throws java.lang.Exception * @throws java.lang.Exception
@ -83,29 +96,31 @@ public class PlaceholderManagerTest {
when(addon.getPlugin()).thenReturn(plugin); when(addon.getPlugin()).thenReturn(plugin);
// Users // Users
when(addon.getPlayers()).thenReturn(players); when(addon.getPlayers()).thenReturn(pm);
// Users // Users
when(user.getWorld()).thenReturn(world); when(user.getWorld()).thenReturn(world);
when(user.getLocation()).thenReturn(mock(Location.class)); when(user.getLocation()).thenReturn(mock(Location.class));
for (int i = 0; i < Level.TEN; i++) { int i = 0;
UUID uuid = UUID.randomUUID(); for (Entry<UUID, String> n : names.entrySet()) {
names.put(uuid, NAMES.get(i)); UUID uuid = UUID.randomUUID(); // Random island ID
map.put(uuid, (long)(100 - i)); map.put(uuid.toString(), (long)(100 - i++)); // level
Island is = new Island(); Island is = new Island();
is.setOwner(uuid); is.setUniqueId(uuid.toString());
is.setName(NAMES.get(i) + "'s island"); is.setOwner(n.getKey());
islands.put(uuid, is); is.setName(n.getValue() + "'s island");
islands.put(uuid.toString(), is);
} }
// Sort // Sort
map = map.entrySet().stream() map = map.entrySet().stream()
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())) .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new)); .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
when(players.getName(any())).thenAnswer((Answer<String>) invocation -> names.getOrDefault(invocation.getArgument(0, UUID.class), "unknown")); when(pm.getName(any())).thenAnswer((Answer<String>) invocation -> names.getOrDefault(invocation.getArgument(0, UUID.class), "unknown"));
Map<UUID, Integer> members = new HashMap<>(); Map<UUID, Integer> members = new HashMap<>();
map.forEach((uuid, l) -> members.put(uuid, RanksManager.MEMBER_RANK)); names.forEach((uuid, l) -> members.put(uuid, RanksManager.MEMBER_RANK));
islands.values().forEach(i -> i.setMembers(members)); islands.values().forEach(is -> is.setMembers(members));
// Placeholders manager for plugin // Placeholders manager for plugin
@ -120,7 +135,8 @@ public class PlaceholderManagerTest {
// Islands // Islands
when(im.getIsland(any(World.class), any(User.class))).thenReturn(island); when(im.getIsland(any(World.class), any(User.class))).thenReturn(island);
when(im.getIslandAt(any(Location.class))).thenReturn(Optional.of(island)); when(im.getIslandAt(any(Location.class))).thenReturn(Optional.of(island));
when(im.getIsland(any(World.class), any(UUID.class))).thenAnswer((Answer<Island>) invocation -> islands.get(invocation.getArgument(1, UUID.class))); when(im.getIslandById(anyString())).thenAnswer((Answer<Optional<Island>>) invocation -> Optional.of(islands.get(invocation.getArgument(0, String.class))));
when(im.getIslands(any(), any(UUID.class))).thenReturn(new HashSet<>(islands.values()));
when(addon.getIslands()).thenReturn(im); when(addon.getIslands()).thenReturn(im);
// Levels Manager // Levels Manager
@ -136,11 +152,12 @@ public class PlaceholderManagerTest {
when(lm.getLevelsData(island)).thenReturn(data); when(lm.getLevelsData(island)).thenReturn(data);
when(addon.getManager()).thenReturn(lm); when(addon.getManager()).thenReturn(lm);
pm = new PlaceholderManager(addon); phm = new PlaceholderManager(addon);
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#PlaceholderManager(world.bentobox.level.Level)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#PlaceholderManager(world.bentobox.level.Level)}.
*/ */
@Test @Test
public void testPlaceholderManager() { public void testPlaceholderManager() {
@ -148,11 +165,12 @@ public class PlaceholderManagerTest {
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#registerPlaceholders(world.bentobox.bentobox.api.addons.GameModeAddon)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#registerPlaceholders(world.bentobox.bentobox.api.addons.GameModeAddon)}.
*/ */
@Test @Test
public void testRegisterPlaceholders() { public void testRegisterPlaceholders() {
pm.registerPlaceholders(gm); phm.registerPlaceholders(gm);
// Island Level // Island Level
verify(bpm).registerPlaceholder(eq(addon), eq("aoneblock_island_level"), any()); verify(bpm).registerPlaceholder(eq(addon), eq("aoneblock_island_level"), any());
verify(bpm).registerPlaceholder(eq(addon), eq("aoneblock_island_level_raw"), any()); verify(bpm).registerPlaceholder(eq(addon), eq("aoneblock_island_level_raw"), any());
@ -182,78 +200,83 @@ public class PlaceholderManagerTest {
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getRankName(org.bukkit.World, int)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getRankName(org.bukkit.World, int)}.
*/ */
@Test @Test
public void testGetRankName() { public void testGetRankName() {
// Test extremes // Test extremes
assertEquals("tasty", pm.getRankName(world, 0)); assertEquals("tasty", phm.getRankName(world, 0));
assertEquals("vicky", pm.getRankName(world, 100)); assertEquals("vicky", phm.getRankName(world, 100));
// Test the ranks // Test the ranks
int rank = 1; int rank = 1;
for (String name : NAMES) { for (String name : names.values()) {
assertEquals(name, pm.getRankName(world, rank++)); assertEquals(name, phm.getRankName(world, rank++));
} }
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getRankIslandName(org.bukkit.World, int)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getRankIslandName(org.bukkit.World, int)}.
*/ */
@Test @Test
public void testGetRankIslandName() { public void testGetRankIslandName() {
// Test extremes // Test extremes
assertEquals("tasty's island", pm.getRankIslandName(world, 0)); assertEquals("tasty's island", phm.getRankIslandName(world, 0));
assertEquals("vicky's island", pm.getRankIslandName(world, 100)); assertEquals("vicky's island", phm.getRankIslandName(world, 100));
// Test the ranks // Test the ranks
int rank = 1; int rank = 1;
for (String name : NAMES) { for (String name : names.values()) {
assertEquals(name + "'s island", pm.getRankIslandName(world, rank++)); assertEquals(name + "'s island", phm.getRankIslandName(world, rank++));
} }
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getRankMembers(org.bukkit.World, int)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getRankMembers(org.bukkit.World, int)}.
*/ */
@Test @Test
public void testGetRankMembers() { public void testGetRankMembers() {
// Test extremes // Test extremes
check(1, pm.getRankMembers(world, 0)); check(1, phm.getRankMembers(world, 0));
check(2, pm.getRankMembers(world, 100)); check(2, phm.getRankMembers(world, 100));
// Test the ranks // Test the ranks
for (int rank = 1; rank < 11; rank++) { for (int rank = 1; rank < 11; rank++) {
check(3, pm.getRankMembers(world, rank)); check(3, phm.getRankMembers(world, rank));
} }
} }
void check(int indicator, String list) { void check(int indicator, String list) {
for (String n : NAMES) { for (String n : names.values()) {
assertTrue(n + " is missing for twst " + indicator, list.contains(n)); assertTrue(n + " is missing for test " + indicator, list.contains(n));
} }
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getRankLevel(org.bukkit.World, int)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getRankLevel(org.bukkit.World, int)}.
*/ */
@Test @Test
public void testGetRankLevel() { public void testGetRankLevel() {
// Test extremes // Test extremes
assertEquals("100", pm.getRankLevel(world, 0)); assertEquals("100", phm.getRankLevel(world, 0));
assertEquals("91", pm.getRankLevel(world, 100)); assertEquals("91", phm.getRankLevel(world, 100));
// Test the ranks // Test the ranks
for (int rank = 1; rank < 11; rank++) { for (int rank = 1; rank < 11; rank++) {
assertEquals(String.valueOf(101 - rank), pm.getRankLevel(world, rank)); assertEquals(String.valueOf(101 - rank), phm.getRankLevel(world, rank));
} }
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getVisitedIslandLevel(world.bentobox.bentobox.api.addons.GameModeAddon, world.bentobox.bentobox.api.user.User)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getVisitedIslandLevel(world.bentobox.bentobox.api.addons.GameModeAddon, world.bentobox.bentobox.api.user.User)}.
*/ */
@Test @Test
public void testGetVisitedIslandLevelNullUser() { public void testGetVisitedIslandLevelNullUser() {
assertEquals("", pm.getVisitedIslandLevel(gm, null)); assertEquals("", phm.getVisitedIslandLevel(gm, null));
} }
@ -264,16 +287,17 @@ public class PlaceholderManagerTest {
public void testGetVisitedIslandLevelUserNotInWorld() { public void testGetVisitedIslandLevelUserNotInWorld() {
// Another world // Another world
when(user.getWorld()).thenReturn(mock(World.class)); when(user.getWorld()).thenReturn(mock(World.class));
assertEquals("", pm.getVisitedIslandLevel(gm, user)); assertEquals("", phm.getVisitedIslandLevel(gm, user));
} }
/** /**
* Test method for {@link world.bentobox.level.PlaceholderManager#getVisitedIslandLevel(world.bentobox.bentobox.api.addons.GameModeAddon, world.bentobox.bentobox.api.user.User)}. * Test method for
* {@link world.bentobox.level.PlaceholderManager#getVisitedIslandLevel(world.bentobox.bentobox.api.addons.GameModeAddon, world.bentobox.bentobox.api.user.User)}.
*/ */
@Test @Test
public void testGetVisitedIslandLevel() { public void testGetVisitedIslandLevel() {
assertEquals("1234567", pm.getVisitedIslandLevel(gm, user)); assertEquals("1234567", phm.getVisitedIslandLevel(gm, user));
} }
@ -283,7 +307,7 @@ public class PlaceholderManagerTest {
@Test @Test
public void testGetVisitedIslandLevelNoIsland() { public void testGetVisitedIslandLevelNoIsland() {
when(im.getIslandAt(any(Location.class))).thenReturn(Optional.empty()); when(im.getIslandAt(any(Location.class))).thenReturn(Optional.empty());
assertEquals("0", pm.getVisitedIslandLevel(gm, user)); assertEquals("0", phm.getVisitedIslandLevel(gm, user));
} }

4
src/test/java/world/bentobox/level/commands/AdminStatsCommandTest.java
View File

@ -129,10 +129,10 @@ public class AdminStatsCommandTest {
// Top ten // Top ten
ttd = new TopTenData(world); ttd = new TopTenData(world);
Map<UUID, Long> topten = new HashMap<>(); Map<String, Long> topten = new HashMap<>();
Random r = new Random(); Random r = new Random();
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
topten.put(UUID.randomUUID(), r.nextLong(20000)); topten.put(UUID.randomUUID().toString(), r.nextLong(20000));
} }
ttd.setTopTen(topten); ttd.setTopTen(topten);
asc = new AdminStatsCommand(addon, ic); asc = new AdminStatsCommand(addon, ic);

12
src/test/java/world/bentobox/level/commands/AdminTopRemoveCommandTest.java
View File

@ -5,12 +5,12 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import java.util.Collections; import java.util.Collections;
import java.util.Set;
import java.util.UUID; import java.util.UUID;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
@ -89,6 +89,7 @@ public class AdminTopRemoveCommandTest {
BentoBox plugin = mock(BentoBox.class); BentoBox plugin = mock(BentoBox.class);
Whitebox.setInternalState(BentoBox.class, "instance", plugin); Whitebox.setInternalState(BentoBox.class, "instance", plugin);
User.setPlugin(plugin); User.setPlugin(plugin);
// Addon // Addon
when(ic.getAddon()).thenReturn(addon); when(ic.getAddon()).thenReturn(addon);
when(ic.getPermissionPrefix()).thenReturn("bskyblock."); when(ic.getPermissionPrefix()).thenReturn("bskyblock.");
@ -114,6 +115,13 @@ public class AdminTopRemoveCommandTest {
uuid = UUID.randomUUID(); uuid = UUID.randomUUID();
when(user.getUniqueId()).thenReturn(uuid); when(user.getUniqueId()).thenReturn(uuid);
when(user.getTranslation(any())).thenAnswer(invocation -> invocation.getArgument(0, String.class)); when(user.getTranslation(any())).thenAnswer(invocation -> invocation.getArgument(0, String.class));
// Island
when(island.getUniqueId()).thenReturn(uuid.toString());
when(island.getOwner()).thenReturn(uuid);
// Island Manager
when(plugin.getIslands()).thenReturn(im);
when(im.getIslands(any(), any(User.class))).thenReturn(Set.of(island));
when(im.getIslands(any(), any(UUID.class))).thenReturn(Set.of(island));
// Bukkit // Bukkit
PowerMockito.mockStatic(Bukkit.class); PowerMockito.mockStatic(Bukkit.class);
@ -193,7 +201,7 @@ public class AdminTopRemoveCommandTest {
public void testExecuteUserStringListOfString() { public void testExecuteUserStringListOfString() {
testCanExecuteKnown(); testCanExecuteKnown();
assertTrue(atrc.execute(user, "delete", Collections.singletonList("tastybento"))); assertTrue(atrc.execute(user, "delete", Collections.singletonList("tastybento")));
verify(manager).removeEntry(any(World.class), eq(uuid)); verify(manager).removeEntry(world, uuid.toString());
verify(user).sendMessage("general.success"); verify(user).sendMessage("general.success");
} }