Upstream/addon-level
1
0
Fork 0
mirror of https://github.com/BentoBoxWorld/Level.git synced 2024-11-22 02:25:56 +01:00
Code Issues Projects Releases Wiki Activity

Release 2.13.0 (#310)

Browse Source 
* Update tipped arrows in GUI Panel

* Version 2.13.0

* Add more string replacements for /is level output (#303)

* Update hooks and fix UltimateStacker API (#305)

* Isolate UltimateStacker imports so no errors if US is not installed (#307) Fixes #306

* Implement a cache for top tens (#309)
This commit is contained in:
tastybento 2024-05-05 13:40:14 -07:00 committed by GitHub
parent 3061e80097
commit 3983764353
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 577 additions and 510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
pom.xml
View File

@ -71,7 +71,7 @@
<!-- Do not change unless you want different name for local builds. --> <!-- Do not change unless you want different name for local builds. -->
<build.number>-LOCAL</build.number> <build.number>-LOCAL</build.number>
<!-- This allows to change between versions. --> <!-- This allows to change between versions. -->
<build.version>2.12.0</build.version> <build.version>2.13.0</build.version>
<sonar.projectKey>BentoBoxWorld_Level</sonar.projectKey> <sonar.projectKey>BentoBoxWorld_Level</sonar.projectKey>
<sonar.organization>bentobox-world</sonar.organization> <sonar.organization>bentobox-world</sonar.organization>
<sonar.host.url>https://sonarcloud.io</sonar.host.url> <sonar.host.url>https://sonarcloud.io</sonar.host.url>
@ -129,8 +129,8 @@
<repositories> <repositories>
<!--Wild Stacker repo --> <!--Wild Stacker repo -->
<repository> <repository>
<id>jitpack.io</id> <id>bg-repo</id>
<url>https://jitpack.io</url> <url>https://repo.bg-software.com/repository/api/</url>
</repository> </repository>
<!-- RoseStacker repo --> <!-- RoseStacker repo -->
<repository> <repository>
@ -139,8 +139,8 @@
</repository> </repository>
<!-- UltimateStacker repo --> <!-- UltimateStacker repo -->
<repository> <repository>
<id>songoda-public</id> <id>songoda-plugins</id>
<url>https://repo.songoda.com/repository/public/</url> <url>https://repo.songoda.com/repository/minecraft-plugins/</url>
</repository> </repository>
<repository> <repository>
<id>spigot-repo</id> <id>spigot-repo</id>
@ -154,6 +154,10 @@
<id>codemc-public</id> <id>codemc-public</id>
<url>https://repo.codemc.org/repository/maven-public/</url> <url>https://repo.codemc.org/repository/maven-public/</url>
</repository> </repository>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
</repositories> </repositories>
<dependencies> <dependencies>
@ -208,9 +212,9 @@
</dependency> </dependency>
<!-- Wild Stacker dependency --> <!-- Wild Stacker dependency -->
<dependency> <dependency>
<groupId>com.github.OmerBenGera</groupId> <groupId>com.bgsoftware</groupId>
<artifactId>WildStackerAPI</artifactId> <artifactId>WildStackerAPI</artifactId>
<version>b18</version> <version>2023.3</version>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
<!-- Static analysis --> <!-- Static analysis -->
@ -234,10 +238,11 @@
<version>1.3.0</version> <version>1.3.0</version>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
<!-- Ultimate Stacker dependency -->
<dependency> <dependency>
<groupId>com.songoda</groupId> <groupId>com.craftaro</groupId>
<artifactId>UltimateStacker</artifactId> <artifactId>UltimateStacker-API</artifactId>
<version>2.4.0</version> <version>1.0.0-20240329.173606-35</version>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
</dependencies> </dependencies>

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

@ -2,6 +2,7 @@ package world.bentobox.level;
import java.math.BigInteger; import java.math.BigInteger;
import java.text.DecimalFormat; import java.text.DecimalFormat;
import java.time.Instant;
import java.util.AbstractMap; import java.util.AbstractMap;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
@ -31,6 +32,7 @@ import world.bentobox.level.events.IslandPreLevelEvent;
import world.bentobox.level.objects.IslandLevels; import world.bentobox.level.objects.IslandLevels;
import world.bentobox.level.objects.LevelsData; import world.bentobox.level.objects.LevelsData;
import world.bentobox.level.objects.TopTenData; import world.bentobox.level.objects.TopTenData;
import world.bentobox.level.util.CachedData;
public class LevelsManager { public class LevelsManager {
private static final String INTOPTEN = "intopten"; private static final String INTOPTEN = "intopten";
@ -52,6 +54,8 @@ public class LevelsManager {
private final Map<String, IslandLevels> levelsCache; private final Map<String, IslandLevels> levelsCache;
// Top ten lists // Top ten lists
private final Map<World, TopTenData> topTenLists; private final Map<World, TopTenData> topTenLists;
// Cache for top tens
private Map<World, CachedData> cache = new HashMap<>();
public LevelsManager(Level addon) { public LevelsManager(Level addon) {
this.addon = addon; this.addon = addon;
@ -66,35 +70,35 @@ public class LevelsManager {
} }
public void migrate() { public void migrate() {
Database<LevelsData> oldDb = new Database<>(addon, LevelsData.class); Database<LevelsData> oldDb = new Database<>(addon, LevelsData.class);
oldDb.loadObjects().forEach(ld -> { oldDb.loadObjects().forEach(ld -> {
try { try {
UUID owner = UUID.fromString(ld.getUniqueId()); UUID owner = UUID.fromString(ld.getUniqueId());
// Step through each world // Step through each world
ld.getLevels().keySet().stream() ld.getLevels().keySet().stream()
// World // World
.map(Bukkit::getWorld).filter(Objects::nonNull) .map(Bukkit::getWorld).filter(Objects::nonNull)
// Island // Island
.map(w -> addon.getIslands().getIsland(w, owner)).filter(Objects::nonNull).forEach(i -> { .map(w -> addon.getIslands().getIsland(w, owner)).filter(Objects::nonNull).forEach(i -> {
// Make new database entry // Make new database entry
World w = i.getWorld(); World w = i.getWorld();
IslandLevels il = new IslandLevels(i.getUniqueId()); IslandLevels il = new IslandLevels(i.getUniqueId());
il.setInitialLevel(ld.getInitialLevel(w)); il.setInitialLevel(ld.getInitialLevel(w));
il.setLevel(ld.getLevel(w)); il.setLevel(ld.getLevel(w));
il.setMdCount(ld.getMdCount(w)); il.setMdCount(ld.getMdCount(w));
il.setPointsToNextLevel(ld.getPointsToNextLevel(w)); il.setPointsToNextLevel(ld.getPointsToNextLevel(w));
il.setUwCount(ld.getUwCount(w)); il.setUwCount(ld.getUwCount(w));
// Save it // Save it
handler.saveObjectAsync(il); handler.saveObjectAsync(il);
}); });
// Now delete the old database entry // Now delete the old database entry
oldDb.deleteID(ld.getUniqueId()); oldDb.deleteID(ld.getUniqueId());
} catch (Exception e) { } catch (Exception e) {
addon.logError("Could not migrate level data database! " + e.getMessage()); addon.logError("Could not migrate level data database! " + e.getMessage());
e.printStackTrace(); e.printStackTrace();
return; return;
} }
}); });
} }
/** /**
@ -105,12 +109,12 @@ public class LevelsManager {
* @return true if successful, false if not added * @return true if successful, false if not added
*/ */
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.getUniqueId(), lv); .put(island.getUniqueId(), lv);
return true; return true;
} }
return false; return false;
} }
/** /**
@ -122,26 +126,26 @@ public class LevelsManager {
* @return completable future with the results of the calculation * @return completable future with the results of the calculation
*/ */
public CompletableFuture<Results> calculateLevel(UUID targetPlayer, Island island) { public CompletableFuture<Results> calculateLevel(UUID targetPlayer, Island island) {
CompletableFuture<Results> result = new CompletableFuture<>(); CompletableFuture<Results> result = new CompletableFuture<>();
// Fire pre-level calc event // Fire pre-level calc event
IslandPreLevelEvent e = new IslandPreLevelEvent(targetPlayer, island); IslandPreLevelEvent e = new IslandPreLevelEvent(targetPlayer, island);
Bukkit.getPluginManager().callEvent(e); Bukkit.getPluginManager().callEvent(e);
if (e.isCancelled()) { if (e.isCancelled()) {
return CompletableFuture.completedFuture(null); return CompletableFuture.completedFuture(null);
} }
// Add island to the pipeline // Add island to the pipeline
addon.getPipeliner().addIsland(island).thenAccept(r -> { addon.getPipeliner().addIsland(island).thenAccept(r -> {
// Results are irrelevant because the island is unowned or deleted, or // Results are irrelevant because the island is unowned or deleted, or
// IslandLevelCalcEvent is cancelled // IslandLevelCalcEvent is cancelled
if (r == null || fireIslandLevelCalcEvent(targetPlayer, island, r)) { if (r == null || fireIslandLevelCalcEvent(targetPlayer, island, r)) {
result.complete(null); result.complete(null);
} }
// Save result // Save result
setIslandResults(island, r); setIslandResults(island, r);
// Save the island scan details // Save the island scan details
result.complete(r); result.complete(r);
}); });
return result; return result;
} }
/** /**
@ -153,19 +157,19 @@ public class LevelsManager {
* @return true if canceled * @return true if canceled
*/ */
private boolean fireIslandLevelCalcEvent(UUID targetPlayer, Island island, Results results) { private boolean fireIslandLevelCalcEvent(UUID targetPlayer, Island island, Results results) {
// Fire post calculation event // Fire post calculation event
IslandLevelCalculatedEvent ilce = new IslandLevelCalculatedEvent(targetPlayer, island, results); IslandLevelCalculatedEvent ilce = new IslandLevelCalculatedEvent(targetPlayer, island, results);
Bukkit.getPluginManager().callEvent(ilce); Bukkit.getPluginManager().callEvent(ilce);
if (ilce.isCancelled()) if (ilce.isCancelled())
return true; return true;
// Set the values if they were altered // Set the values if they were altered
results.setLevel((Long) ilce.getKeyValues().getOrDefault("level", results.getLevel())); results.setLevel((Long) ilce.getKeyValues().getOrDefault("level", results.getLevel()));
results.setInitialLevel((Long) ilce.getKeyValues().getOrDefault("initialLevel", results.getInitialLevel())); results.setInitialLevel((Long) ilce.getKeyValues().getOrDefault("initialLevel", results.getInitialLevel()));
results.setDeathHandicap((int) ilce.getKeyValues().getOrDefault("deathHandicap", results.getDeathHandicap())); results.setDeathHandicap((int) ilce.getKeyValues().getOrDefault("deathHandicap", results.getDeathHandicap()));
results.setPointsToNextLevel( results.setPointsToNextLevel(
(Long) ilce.getKeyValues().getOrDefault("pointsToNextLevel", results.getPointsToNextLevel())); (Long) ilce.getKeyValues().getOrDefault("pointsToNextLevel", results.getPointsToNextLevel()));
results.setTotalPoints((Long) ilce.getKeyValues().getOrDefault("totalPoints", results.getTotalPoints())); results.setTotalPoints((Long) ilce.getKeyValues().getOrDefault("totalPoints", results.getTotalPoints()));
return ((Boolean) ilce.getKeyValues().getOrDefault("isCancelled", false)); return ((Boolean) ilce.getKeyValues().getOrDefault("isCancelled", false));
} }
/** /**
@ -176,25 +180,25 @@ public class LevelsManager {
* @return string of the level. * @return string of the level.
*/ */
public String formatLevel(@Nullable Long lvl) { public String formatLevel(@Nullable Long lvl) {
if (lvl == null) if (lvl == null)
return ""; return "";
String level = String.valueOf(lvl); String level = String.valueOf(lvl);
// Asking for the level of another player // Asking for the level of another player
if (addon.getSettings().isShorthand()) { if (addon.getSettings().isShorthand()) {
BigInteger levelValue = BigInteger.valueOf(lvl); BigInteger levelValue = BigInteger.valueOf(lvl);
Map.Entry<BigInteger, String> stage = LEVELS.floorEntry(levelValue); Map.Entry<BigInteger, String> stage = LEVELS.floorEntry(levelValue);
if (stage != null) { // level > 1000 if (stage != null) { // level > 1000
// 1 052 -> 1.0k // 1 052 -> 1.0k
// 1 527 314 -> 1.5M // 1 527 314 -> 1.5M
// 3 874 130 021 -> 3.8G // 3 874 130 021 -> 3.8G
// 4 002 317 889 -> 4.0T // 4 002 317 889 -> 4.0T
level = new DecimalFormat("#.#").format( level = new DecimalFormat("#.#").format(
levelValue.divide(stage.getKey().divide(THOUSAND)).doubleValue() / 1000.0) + stage.getValue(); levelValue.divide(stage.getKey().divide(THOUSAND)).doubleValue() / 1000.0) + stage.getValue();
} }
} }
return level; return level;
} }
/** /**
@ -216,11 +220,11 @@ public class LevelsManager {
* null * null
*/ */
public long getIslandLevel(@NonNull World world, @Nullable UUID targetPlayer) { public long getIslandLevel(@NonNull World world, @Nullable UUID targetPlayer) {
if (targetPlayer == null) if (targetPlayer == null)
return 0L; return 0L;
// Get the island // Get the island
Island island = addon.getIslands().getIsland(world, targetPlayer); Island island = addon.getIslands().getIsland(world, targetPlayer);
return island == null ? 0L : getLevelsData(island).getLevel(); return island == null ? 0L : getLevelsData(island).getLevel();
} }
/** /**
@ -232,11 +236,11 @@ public class LevelsManager {
* is null * is null
*/ */
public long getIslandMaxLevel(@NonNull World world, @Nullable UUID targetPlayer) { public long getIslandMaxLevel(@NonNull World world, @Nullable UUID targetPlayer) {
if (targetPlayer == null) if (targetPlayer == null)
return 0L; return 0L;
// Get the island // Get the island
Island island = addon.getIslands().getIsland(world, targetPlayer); Island island = addon.getIslands().getIsland(world, targetPlayer);
return island == null ? 0L : getLevelsData(island).getMaxLevel(); return island == null ? 0L : getLevelsData(island).getMaxLevel();
} }
/** /**
@ -288,10 +292,10 @@ public class LevelsManager {
* @return string with the number required or blank if the player is unknown * @return string with the number required or blank if the player is unknown
*/ */
public String getPointsToNextString(@NonNull World world, @Nullable UUID targetPlayer) { public String getPointsToNextString(@NonNull World world, @Nullable UUID targetPlayer) {
if (targetPlayer == null) if (targetPlayer == null)
return ""; return "";
Island island = addon.getIslands().getIsland(world, targetPlayer); Island island = addon.getIslands().getIsland(world, targetPlayer);
return island == null ? "" : String.valueOf(getLevelsData(island).getPointsToNextLevel()); return island == null ? "" : String.valueOf(getLevelsData(island).getPointsToNextLevel());
} }
/** /**
@ -304,28 +308,27 @@ public class LevelsManager {
*/ */
@NonNull @NonNull
public Map<Island, Long> getWeightedTopTen(@NonNull World world, int size) { public Map<Island, Long> getWeightedTopTen(@NonNull World world, int size) {
createAndCleanRankings(world); createAndCleanRankings(world);
Map<Island, Long> weightedTopTen = topTenLists.get(world).getTopTen().entrySet().stream() Map<Island, Long> weightedTopTen = topTenLists.get(world).getTopTen().entrySet().stream()
.map(en -> addon.getIslands().getIslandById(en.getKey()).map(island -> { .map(en -> addon.getIslands().getIslandById(en.getKey()).map(island -> {
long value = (long) (en.getValue() / (double) Math.max(1, island.getMemberSet().size())); // Calculate long value = (long) (en.getValue() / (double) Math.max(1, island.getMemberSet().size())); // Calculate
// weighted // weighted
// value // value
return new AbstractMap.SimpleEntry<>(island, value); return new AbstractMap.SimpleEntry<>(island, value);
}).orElse(null)) // Handle islands that do not exist according to this ID - old deleted ones }).orElse(null)) // Handle islands that do not exist according to this ID - old deleted ones
.filter(Objects::nonNull) // Filter out null entries .filter(Objects::nonNull) // Filter out null entries
.filter(en -> en.getValue() > 0) // Filter out entries with non-positive values .filter(en -> en.getValue() > 0) // Filter out entries with non-positive values
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())) // Sort in descending order of values .sorted(Collections.reverseOrder(Map.Entry.comparingByValue())) // Sort in descending order of values
.limit(size) // Limit to the top 'size' entries .limit(size) // Limit to the top 'size' entries
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, // In case of key .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, // In case of key
// collision, choose // collision, choose
// the first one // the first one
LinkedHashMap::new // Preserves the order of entries LinkedHashMap::new // Preserves the order of entries
)); ));
// Return the unmodifiable map
return Collections.unmodifiableMap(weightedTopTen);
// Return the unmodifiable map
return Collections.unmodifiableMap(weightedTopTen);
} }
/** /**
@ -338,26 +341,38 @@ public class LevelsManager {
*/ */
@NonNull @NonNull
public Map<String, 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 CachedData cachedData = cache.get(world);
return Collections.unmodifiableMap(topTenLists.get(world).getTopTen().entrySet().stream() Instant now = Instant.now();
.filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.limit(size) if (cachedData != null && cachedData.getLastUpdated().plusSeconds(1).isAfter(now)) {
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new))); return cachedData.getCachedMap();
} else {
Map<String, Long> newTopTen = calculateTopTen(world, size);
cache.put(world, new CachedData(newTopTen, now));
return newTopTen;
}
}
private Map<String, Long> calculateTopTen(@NonNull World world, int size) {
return Collections.unmodifiableMap(topTenLists.get(world).getTopTen().entrySet().stream()
.filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.limit(size)
.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 -> addon.getIslands().getIslandById(u) topTenLists.get(world).getTopTen().keySet().removeIf(u -> addon.getIslands().getIslandById(u)
.filter(i -> i.getOwner() == null || !hasTopTenPerm(world, i.getOwner())).isPresent()); .filter(i -> i.getOwner() == null || !hasTopTenPerm(world, i.getOwner())).isPresent());
} }
/** /**
* @return the topTenLists * @return the topTenLists
*/ */
public Map<World, TopTenData> getTopTenLists() { public Map<World, TopTenData> getTopTenLists() {
return topTenLists; return topTenLists;
} }
/** /**
@ -368,13 +383,13 @@ public class LevelsManager {
* @return rank placing - note - placing of 1 means top ranked * @return rank placing - note - placing of 1 means top ranked
*/ */
public int getRank(@NonNull World world, UUID uuid) { public int getRank(@NonNull World world, UUID uuid) {
createAndCleanRankings(world); createAndCleanRankings(world);
Stream<Entry<String, Long>> stream = topTenLists.get(world).getTopTen().entrySet().stream() Stream<Entry<String, Long>> stream = topTenLists.get(world).getTopTen().entrySet().stream()
.filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue())); .filter(l -> l.getValue() > 0).sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));
// Get player's current island // Get player's current island
Island island = addon.getIslands().getIsland(world, uuid); Island island = addon.getIslands().getIsland(world, uuid);
String id = island == null ? null : island.getUniqueId(); String id = island == null ? null : island.getUniqueId();
return (int) (stream.takeWhile(x -> !x.getKey().equals(id)).map(Map.Entry::getKey).count() + 1); return (int) (stream.takeWhile(x -> !x.getKey().equals(id)).map(Map.Entry::getKey).count() + 1);
} }
/** /**
@ -385,26 +400,26 @@ public class LevelsManager {
* @return true if player has the perm or the player is offline * @return true if player has the perm or the player is offline
*/ */
boolean hasTopTenPerm(@NonNull World world, @NonNull UUID targetPlayer) { boolean hasTopTenPerm(@NonNull World world, @NonNull UUID targetPlayer) {
String permPrefix = addon.getPlugin().getIWM().getPermissionPrefix(world); String permPrefix = addon.getPlugin().getIWM().getPermissionPrefix(world);
return Bukkit.getPlayer(targetPlayer) == null return Bukkit.getPlayer(targetPlayer) == null
|| Bukkit.getPlayer(targetPlayer).hasPermission(permPrefix + INTOPTEN); || Bukkit.getPlayer(targetPlayer).hasPermission(permPrefix + INTOPTEN);
} }
/** /**
* Loads all the top tens from the database * Loads all the top tens from the database
*/ */
public void loadTopTens() { public void loadTopTens() {
topTenLists.clear(); topTenLists.clear();
Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> { Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
addon.log("Generating rankings"); addon.log("Generating rankings");
handler.loadObjects().forEach(il -> { handler.loadObjects().forEach(il -> {
if (il.getLevel() > 0) { if (il.getLevel() > 0) {
addon.getIslands().getIslandById(il.getUniqueId()) addon.getIslands().getIslandById(il.getUniqueId())
.ifPresent(i -> this.addToTopTen(i, il.getLevel())); .ifPresent(i -> this.addToTopTen(i, il.getLevel()));
} }
}); });
topTenLists.keySet().forEach(w -> addon.log("Generated rankings for " + w.getName())); topTenLists.keySet().forEach(w -> addon.log("Generated rankings for " + w.getName()));
}); });
} }
/** /**
@ -414,10 +429,11 @@ public class LevelsManager {
* @param uuid - the island's uuid * @param uuid - the island's uuid
*/ */
public void removeEntry(World world, String 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);
} // Invalidate the cache because of this deletion
cache.remove(world);
}
} }
/** /**
@ -427,10 +443,10 @@ public class LevelsManager {
* @param lv - initial island level * @param lv - initial island level
*/ */
public void setInitialIslandLevel(@NonNull Island island, long lv) { public void setInitialIslandLevel(@NonNull Island island, long lv) {
if (island.getWorld() == null) if (island.getWorld() == null)
return; return;
levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new).setInitialLevel(lv); levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new).setInitialLevel(lv);
handler.saveObjectAsync(levelsCache.get(island.getUniqueId())); handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
} }
/** /**
@ -442,21 +458,21 @@ public class LevelsManager {
* @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) {
// Get the island // Get the island
Island island = addon.getIslands().getIsland(world, targetPlayer); Island island = addon.getIslands().getIsland(world, targetPlayer);
if (island != null) { if (island != null) {
String id = island.getUniqueId(); String id = island.getUniqueId();
IslandLevels il = levelsCache.computeIfAbsent(id, IslandLevels::new); IslandLevels il = levelsCache.computeIfAbsent(id, IslandLevels::new);
// Remove the initial level // Remove the initial level
if (addon.getSettings().isZeroNewIslandLevels()) { if (addon.getSettings().isZeroNewIslandLevels()) {
il.setLevel(lv - il.getInitialLevel()); il.setLevel(lv - il.getInitialLevel());
} else { } else {
il.setLevel(lv); il.setLevel(lv);
} }
handler.saveObjectAsync(levelsCache.get(id)); handler.saveObjectAsync(levelsCache.get(id));
// Update TopTen // Update TopTen
addToTopTen(island, levelsCache.get(id).getLevel()); addToTopTen(island, levelsCache.get(id).getLevel());
} }
} }
/** /**
@ -468,18 +484,18 @@ public class LevelsManager {
* @param r - results of the calculation * @param r - results of the calculation
*/ */
private void setIslandResults(Island island, Results r) { private void setIslandResults(Island island, Results r) {
if (island == null) if (island == null)
return; return;
IslandLevels ld = levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new); IslandLevels ld = levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new);
ld.setLevel(r.getLevel()); ld.setLevel(r.getLevel());
ld.setUwCount(Maps.asMap(r.getUwCount().elementSet(), elem -> r.getUwCount().count(elem))); ld.setUwCount(Maps.asMap(r.getUwCount().elementSet(), elem -> r.getUwCount().count(elem)));
ld.setMdCount(Maps.asMap(r.getMdCount().elementSet(), elem -> r.getMdCount().count(elem))); ld.setMdCount(Maps.asMap(r.getMdCount().elementSet(), elem -> r.getMdCount().count(elem)));
ld.setPointsToNextLevel(r.getPointsToNextLevel()); ld.setPointsToNextLevel(r.getPointsToNextLevel());
ld.setTotalPoints(r.getTotalPoints()); ld.setTotalPoints(r.getTotalPoints());
levelsCache.put(island.getUniqueId(), ld); levelsCache.put(island.getUniqueId(), ld);
handler.saveObjectAsync(ld); handler.saveObjectAsync(ld);
// Update TopTen // Update TopTen
addToTopTen(island, ld.getLevel()); addToTopTen(island, ld.getLevel());
} }
/** /**

597
src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java
View File

@ -40,9 +40,6 @@ import com.bgsoftware.wildstacker.api.objects.StackedBarrel;
import com.google.common.collect.Multiset; import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry; import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.Multisets; import com.google.common.collect.Multisets;
import com.songoda.ultimatestacker.UltimateStacker;
import com.songoda.ultimatestacker.core.compatibility.CompatibleMaterial;
import com.songoda.ultimatestacker.stackable.block.BlockStack;
import dev.rosewood.rosestacker.api.RoseStackerAPI; import dev.rosewood.rosestacker.api.RoseStackerAPI;
import us.lynuxcraft.deadsilenceiv.advancedchests.AdvancedChestsAPI; import us.lynuxcraft.deadsilenceiv.advancedchests.AdvancedChestsAPI;
@ -59,13 +56,13 @@ public class IslandLevelCalculator {
private static final String LINE_BREAK = "=================================="; private static final String LINE_BREAK = "==================================";
public static final long MAX_AMOUNT = 10000000; public static final long MAX_AMOUNT = 10000000;
private static final List<Material> CHESTS = Arrays.asList(Material.CHEST, Material.CHEST_MINECART, private static final List<Material> CHESTS = Arrays.asList(Material.CHEST, Material.CHEST_MINECART,
Material.TRAPPED_CHEST, Material.SHULKER_BOX, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX, Material.TRAPPED_CHEST, Material.SHULKER_BOX, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX,
Material.GREEN_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX,
Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX, Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX,
Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.RED_SHULKER_BOX,
Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX, Material.COMPOSTER, Material.BARREL, Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX, Material.COMPOSTER, Material.BARREL,
Material.DISPENSER, Material.DROPPER, Material.SMOKER, Material.BLAST_FURNACE); Material.DISPENSER, Material.DROPPER, Material.SMOKER, Material.BLAST_FURNACE);
private static final int CHUNKS_TO_SCAN = 100; private static final int CHUNKS_TO_SCAN = 100;
private final Level addon; private final Level addon;
private final Queue<Pair<Integer, Integer>> chunksToCheck; private final Queue<Pair<Integer, Integer>> chunksToCheck;
@ -129,18 +126,18 @@ public class IslandLevelCalculator {
* @return level of island * @return level of island
*/ */
private long calculateLevel(long blockAndDeathPoints) { private long calculateLevel(long blockAndDeathPoints) {
String calcString = addon.getSettings().getLevelCalc(); String calcString = addon.getSettings().getLevelCalc();
String withValues = calcString.replace("blocks", String.valueOf(blockAndDeathPoints)).replace("level_cost", String withValues = calcString.replace("blocks", String.valueOf(blockAndDeathPoints)).replace("level_cost",
String.valueOf(this.addon.getSettings().getLevelCost())); String.valueOf(this.addon.getSettings().getLevelCost()));
long evalWithValues; long evalWithValues;
try { try {
evalWithValues = (long) EquationEvaluator.eval(withValues); evalWithValues = (long) EquationEvaluator.eval(withValues);
return evalWithValues - (addon.getSettings().isZeroNewIslandLevels() ? results.initialLevel.get() : 0); return evalWithValues - (addon.getSettings().isZeroNewIslandLevels() ? results.initialLevel.get() : 0);
} catch (ParseException e) { } catch (ParseException e) {
addon.getPlugin().logStacktrace(e); addon.getPlugin().logStacktrace(e);
return 0L; return 0L;
} }
} }
/** /**
@ -168,15 +165,15 @@ public class IslandLevelCalculator {
* @return - set of pairs of x,z coordinates to check * @return - set of pairs of x,z coordinates to check
*/ */
private Queue<Pair<Integer, Integer>> getChunksToScan(Island island) { private Queue<Pair<Integer, Integer>> getChunksToScan(Island island) {
Queue<Pair<Integer, Integer>> chunkQueue = new ConcurrentLinkedQueue<>(); Queue<Pair<Integer, Integer>> chunkQueue = new ConcurrentLinkedQueue<>();
for (int x = island.getMinProtectedX(); x < (island.getMinProtectedX() + island.getProtectionRange() * 2 for (int x = island.getMinProtectedX(); x < (island.getMinProtectedX() + island.getProtectionRange() * 2
+ 16); x += 16) { + 16); x += 16) {
for (int z = island.getMinProtectedZ(); z < (island.getMinProtectedZ() + island.getProtectionRange() * 2 for (int z = island.getMinProtectedZ(); z < (island.getMinProtectedZ() + island.getProtectionRange() * 2
+ 16); z += 16) { + 16); z += 16) {
chunkQueue.add(new Pair<>(x >> 4, z >> 4)); chunkQueue.add(new Pair<>(x >> 4, z >> 4));
} }
} }
return chunkQueue; return chunkQueue;
} }
/** /**
@ -201,60 +198,60 @@ public class IslandLevelCalculator {
* @return a list of lines * @return a list of lines
*/ */
private List<String> getReport() { private List<String> getReport() {
List<String> reportLines = new ArrayList<>(); List<String> reportLines = new ArrayList<>();
// provide counts // provide counts
reportLines.add("Level Log for island in " + addon.getPlugin().getIWM().getFriendlyName(island.getWorld()) reportLines.add("Level Log for island in " + addon.getPlugin().getIWM().getFriendlyName(island.getWorld())
+ " at " + Util.xyz(island.getCenter().toVector())); + " at " + Util.xyz(island.getCenter().toVector()));
reportLines.add("Island owner UUID = " + island.getOwner()); reportLines.add("Island owner UUID = " + island.getOwner());
reportLines.add("Total block value count = " + String.format("%,d", results.rawBlockCount.get())); reportLines.add("Total block value count = " + String.format("%,d", results.rawBlockCount.get()));
reportLines.add("Formula to calculate island level: " + addon.getSettings().getLevelCalc()); reportLines.add("Formula to calculate island level: " + addon.getSettings().getLevelCalc());
reportLines.add("Level cost = " + addon.getSettings().getLevelCost()); reportLines.add("Level cost = " + addon.getSettings().getLevelCost());
reportLines.add("Deaths handicap = " + results.deathHandicap.get()); reportLines.add("Deaths handicap = " + results.deathHandicap.get());
if (addon.getSettings().isZeroNewIslandLevels()) { if (addon.getSettings().isZeroNewIslandLevels()) {
reportLines.add("Initial island level = " + (0L - addon.getManager().getInitialLevel(island))); reportLines.add("Initial island level = " + (0L - addon.getManager().getInitialLevel(island)));
} }
reportLines.add("Previous level = " + addon.getManager().getIslandLevel(island.getWorld(), island.getOwner())); reportLines.add("Previous level = " + addon.getManager().getIslandLevel(island.getWorld(), island.getOwner()));
reportLines.add("New level = " + results.getLevel()); reportLines.add("New level = " + results.getLevel());
reportLines.add(LINE_BREAK); reportLines.add(LINE_BREAK);
int total = 0; int total = 0;
if (!results.uwCount.isEmpty()) { if (!results.uwCount.isEmpty()) {
reportLines.add("Underwater block count (Multiplier = x" + addon.getSettings().getUnderWaterMultiplier() reportLines.add("Underwater block count (Multiplier = x" + addon.getSettings().getUnderWaterMultiplier()
+ ") value"); + ") value");
reportLines.add("Total number of underwater blocks = " + String.format("%,d", results.uwCount.size())); reportLines.add("Total number of underwater blocks = " + String.format("%,d", results.uwCount.size()));
reportLines.addAll(sortedReport(total, results.uwCount)); reportLines.addAll(sortedReport(total, results.uwCount));
} }
reportLines.add("Regular block count"); reportLines.add("Regular block count");
reportLines.add("Total number of blocks = " + String.format("%,d", results.mdCount.size())); reportLines.add("Total number of blocks = " + String.format("%,d", results.mdCount.size()));
reportLines.addAll(sortedReport(total, results.mdCount)); reportLines.addAll(sortedReport(total, results.mdCount));
reportLines.add( reportLines.add(
"Blocks not counted because they exceeded limits: " + String.format("%,d", results.ofCount.size())); "Blocks not counted because they exceeded limits: " + String.format("%,d", results.ofCount.size()));
Iterable<Multiset.Entry<Material>> entriesSortedByCount = results.ofCount.entrySet(); Iterable<Multiset.Entry<Material>> entriesSortedByCount = results.ofCount.entrySet();
Iterator<Entry<Material>> it = entriesSortedByCount.iterator(); Iterator<Entry<Material>> it = entriesSortedByCount.iterator();
while (it.hasNext()) { while (it.hasNext()) {
Entry<Material> type = it.next(); Entry<Material> type = it.next();
Integer limit = addon.getBlockConfig().getBlockLimits().get(type.getElement()); Integer limit = addon.getBlockConfig().getBlockLimits().get(type.getElement());
String explain = ")"; String explain = ")";
if (limit == null) { if (limit == null) {
Material generic = type.getElement(); Material generic = type.getElement();
limit = addon.getBlockConfig().getBlockLimits().get(generic); limit = addon.getBlockConfig().getBlockLimits().get(generic);
explain = " - All types)"; explain = " - All types)";
} }
reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount()) reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount())
+ " blocks (max " + limit + explain); + " blocks (max " + limit + explain);
} }
reportLines.add(LINE_BREAK); reportLines.add(LINE_BREAK);
reportLines.add("Blocks on island that are not in config.yml"); reportLines.add("Blocks on island that are not in config.yml");
reportLines.add("Total number = " + String.format("%,d", results.ncCount.size())); reportLines.add("Total number = " + String.format("%,d", results.ncCount.size()));
entriesSortedByCount = results.ncCount.entrySet(); entriesSortedByCount = results.ncCount.entrySet();
it = entriesSortedByCount.iterator(); it = entriesSortedByCount.iterator();
while (it.hasNext()) { while (it.hasNext()) {
Entry<Material> type = it.next(); Entry<Material> type = it.next();
reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount()) + " blocks"); reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount()) + " blocks");
} }
reportLines.add(LINE_BREAK); reportLines.add(LINE_BREAK);
return reportLines; return reportLines;
} }
/** /**
@ -356,39 +353,39 @@ public class IslandLevelCalculator {
* @param chunk - the chunk to scan * @param chunk - the chunk to scan
*/ */
private void scanChests(Chunk chunk) { private void scanChests(Chunk chunk) {
// Count blocks in chests // Count blocks in chests
for (BlockState bs : chunk.getTileEntities()) { for (BlockState bs : chunk.getTileEntities()) {
if (bs instanceof Container container) { if (bs instanceof Container container) {
if (addon.isAdvChestEnabled()) { if (addon.isAdvChestEnabled()) {
AdvancedChest<?, ?> aChest = AdvancedChestsAPI.getChestManager().getAdvancedChest(bs.getLocation()); AdvancedChest<?, ?> aChest = AdvancedChestsAPI.getChestManager().getAdvancedChest(bs.getLocation());
if (aChest != null && aChest.getChestType().getName().equals("NORMAL")) { if (aChest != null && aChest.getChestType().getName().equals("NORMAL")) {
aChest.getPages().stream().map(ChestPage::getItems).forEach(c -> { aChest.getPages().stream().map(ChestPage::getItems).forEach(c -> {
for (Object i : c) { for (Object i : c) {
countItemStack((ItemStack) i); countItemStack((ItemStack) i);
} }
}); });
continue; continue;
} }
} }
// Regular chest // Regular chest
container.getSnapshotInventory().forEach(this::countItemStack); container.getSnapshotInventory().forEach(this::countItemStack);
} }
} }
} }
private void countItemStack(ItemStack i) { private void countItemStack(ItemStack i) {
if (i == null || !i.getType().isBlock()) if (i == null || !i.getType().isBlock())
return; return;
for (int c = 0; c < i.getAmount(); c++) { for (int c = 0; c < i.getAmount(); c++) {
if (addon.getSettings().isIncludeShulkersInChest() if (addon.getSettings().isIncludeShulkersInChest()
&& i.getItemMeta() instanceof BlockStateMeta blockStateMeta && i.getItemMeta() instanceof BlockStateMeta blockStateMeta
&& blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox) { && blockStateMeta.getBlockState() instanceof ShulkerBox shulkerBox) {
shulkerBox.getSnapshotInventory().forEach(this::countItemStack); shulkerBox.getSnapshotInventory().forEach(this::countItemStack);
} }
checkBlock(i.getType(), false); checkBlock(i.getType(), false);
} }
} }
/** /**
@ -401,26 +398,26 @@ public class IslandLevelCalculator {
* that will be true if the scan was successful, false if not * that will be true if the scan was successful, false if not
*/ */
private CompletableFuture<Boolean> scanChunk(List<Chunk> chunks) { private CompletableFuture<Boolean> scanChunk(List<Chunk> chunks) {
// If the chunk hasn't been generated, return // If the chunk hasn't been generated, return
if (chunks == null || chunks.isEmpty()) { if (chunks == null || chunks.isEmpty()) {
return CompletableFuture.completedFuture(false); return CompletableFuture.completedFuture(false);
} }
// Count blocks in chunk // Count blocks in chunk
CompletableFuture<Boolean> result = new CompletableFuture<>(); CompletableFuture<Boolean> result = new CompletableFuture<>();
/* /*
* At this point, we need to grab a snapshot of each chunk and then scan it * At this point, we need to grab a snapshot of each chunk and then scan it
* async. At the end, we make the CompletableFuture true to show it is done. I'm * async. At the end, we make the CompletableFuture true to show it is done. I'm
* not sure how much lag this will cause, but as all the chunks are loaded, * not sure how much lag this will cause, but as all the chunks are loaded,
* maybe not that much. * maybe not that much.
*/ */
List<ChunkPair> preLoad = chunks.stream().map(c -> new ChunkPair(c.getWorld(), c, c.getChunkSnapshot())) List<ChunkPair> preLoad = chunks.stream().map(c -> new ChunkPair(c.getWorld(), c, c.getChunkSnapshot()))
.toList(); .toList();
Bukkit.getScheduler().runTaskAsynchronously(BentoBox.getInstance(), () -> { Bukkit.getScheduler().runTaskAsynchronously(BentoBox.getInstance(), () -> {
preLoad.forEach(this::scanAsync); preLoad.forEach(this::scanAsync);
// Once they are all done, return to the main thread. // Once they are all done, return to the main thread.
Bukkit.getScheduler().runTask(addon.getPlugin(), () -> result.complete(true)); Bukkit.getScheduler().runTask(addon.getPlugin(), () -> result.complete(true));
}); });
return result; return result;
} }
record ChunkPair(World world, Chunk chunk, ChunkSnapshot chunkSnapshot) { record ChunkPair(World world, Chunk chunk, ChunkSnapshot chunkSnapshot) {
@ -432,67 +429,53 @@ public class IslandLevelCalculator {
* @param cp chunk to scan * @param cp chunk to scan
*/ */
private void scanAsync(ChunkPair cp) { private void scanAsync(ChunkPair cp) {
for (int x = 0; x < 16; x++) { for (int x = 0; x < 16; x++) {
// Check if the block coordinate is inside the protection zone and if not, don't // Check if the block coordinate is inside the protection zone and if not, don't
// count it // count it
if (cp.chunkSnapshot.getX() * 16 + x < island.getMinProtectedX() || cp.chunkSnapshot.getX() * 16 if (cp.chunkSnapshot.getX() * 16 + x < island.getMinProtectedX() || cp.chunkSnapshot.getX() * 16
+ x >= island.getMinProtectedX() + island.getProtectionRange() * 2) { + x >= island.getMinProtectedX() + island.getProtectionRange() * 2) {
continue; continue;
} }
for (int z = 0; z < 16; z++) { for (int z = 0; z < 16; z++) {
// Check if the block coordinate is inside the protection zone and if not, don't // Check if the block coordinate is inside the protection zone and if not, don't
// count it // count it
if (cp.chunkSnapshot.getZ() * 16 + z < island.getMinProtectedZ() || cp.chunkSnapshot.getZ() * 16 if (cp.chunkSnapshot.getZ() * 16 + z < island.getMinProtectedZ() || cp.chunkSnapshot.getZ() * 16
+ z >= island.getMinProtectedZ() + island.getProtectionRange() * 2) { + z >= island.getMinProtectedZ() + island.getProtectionRange() * 2) {
continue; continue;
} }
// Only count to the highest block in the world for some optimization // Only count to the highest block in the world for some optimization
for (int y = cp.world.getMinHeight(); y < cp.world.getMaxHeight(); y++) { for (int y = cp.world.getMinHeight(); y < cp.world.getMaxHeight(); y++) {
BlockData blockData = cp.chunkSnapshot.getBlockData(x, y, z); BlockData blockData = cp.chunkSnapshot.getBlockData(x, y, z);
boolean belowSeaLevel = seaHeight > 0 && y <= seaHeight; Material m = blockData.getMaterial();
// Slabs can be doubled, so check them twice boolean belowSeaLevel = seaHeight > 0 && y <= seaHeight;
if (Tag.SLABS.isTagged(blockData.getMaterial())) { // Slabs can be doubled, so check them twice
Slab slab = (Slab) blockData; if (Tag.SLABS.isTagged(m)) {
if (slab.getType().equals(Slab.Type.DOUBLE)) { Slab slab = (Slab) blockData;
checkBlock(blockData.getMaterial(), belowSeaLevel); if (slab.getType().equals(Slab.Type.DOUBLE)) {
} checkBlock(m, belowSeaLevel);
} }
// Hook for Wild Stackers (Blocks and Spawners Only) - this has to use the real }
// chunk // Hook for Wild Stackers (Blocks and Spawners Only) - this has to use the real
if (addon.isStackersEnabled() && (blockData.getMaterial().equals(Material.CAULDRON) // chunk
|| blockData.getMaterial().equals(Material.SPAWNER))) { if (addon.isStackersEnabled() && (m.equals(Material.CAULDRON) || m.equals(Material.SPAWNER))) {
stackedBlocks.add(new Location(cp.world, (double) x + cp.chunkSnapshot.getX() * 16, y, stackedBlocks.add(new Location(cp.world, (double) x + cp.chunkSnapshot.getX() * 16, y,
(double) z + cp.chunkSnapshot.getZ() * 16)); (double) z + cp.chunkSnapshot.getZ() * 16));
} }
Block block = cp.chunk.getBlock(x, y, z); if (addon.isUltimateStackerEnabled() && !m.isAir()) {
Location l = new Location(cp.chunk.getWorld(), x, y, z);
UltimateStackerCalc.addStackers(m, l, results, belowSeaLevel, limitCount(m));
}
if (addon.isUltimateStackerEnabled()) { // Scan chests
if (!blockData.getMaterial().equals(Material.AIR)) { if (addon.getSettings().isIncludeChests() && CHESTS.contains(m)) {
BlockStack stack = UltimateStacker.getInstance().getBlockStackManager().getBlock(block, chestBlocks.add(cp.chunk);
CompatibleMaterial.getMaterial(block)); }
if (stack != null) { // Add the value of the block's material
int value = limitCount(blockData.getMaterial()); checkBlock(m, belowSeaLevel);
if (belowSeaLevel) { }
results.underWaterBlockCount.addAndGet((long) stack.getAmount() * value); }
results.uwCount.add(blockData.getMaterial()); }
} else {
results.rawBlockCount.addAndGet((long) stack.getAmount() * value);
results.mdCount.add(blockData.getMaterial());
}
}
}
}
// Scan chests
if (addon.getSettings().isIncludeChests() && CHESTS.contains(blockData.getMaterial())) {
chestBlocks.add(cp.chunk);
}
// Add the value of the block's material
checkBlock(blockData.getMaterial(), belowSeaLevel);
}
}
}
} }
/** /**
@ -502,94 +485,94 @@ public class IslandLevelCalculator {
* to be scanned, and false if not * to be scanned, and false if not
*/ */
public CompletableFuture<Boolean> scanNextChunk() { public CompletableFuture<Boolean> scanNextChunk() {
if (chunksToCheck.isEmpty()) { if (chunksToCheck.isEmpty()) {
addon.logError("Unexpected: no chunks to scan!"); addon.logError("Unexpected: no chunks to scan!");
// This should not be needed, but just in case // This should not be needed, but just in case
return CompletableFuture.completedFuture(false); return CompletableFuture.completedFuture(false);
} }
// Retrieve and remove from the queue // Retrieve and remove from the queue
Queue<Pair<Integer, Integer>> pairList = new ConcurrentLinkedQueue<>(); Queue<Pair<Integer, Integer>> pairList = new ConcurrentLinkedQueue<>();
int i = 0; int i = 0;
while (!chunksToCheck.isEmpty() && i++ < CHUNKS_TO_SCAN) { while (!chunksToCheck.isEmpty() && i++ < CHUNKS_TO_SCAN) {
pairList.add(chunksToCheck.poll()); pairList.add(chunksToCheck.poll());
} }
Queue<Pair<Integer, Integer>> endPairList = new ConcurrentLinkedQueue<>(pairList); Queue<Pair<Integer, Integer>> endPairList = new ConcurrentLinkedQueue<>(pairList);
Queue<Pair<Integer, Integer>> netherPairList = new ConcurrentLinkedQueue<>(pairList); Queue<Pair<Integer, Integer>> netherPairList = new ConcurrentLinkedQueue<>(pairList);
// Set up the result // Set up the result
CompletableFuture<Boolean> result = new CompletableFuture<>(); CompletableFuture<Boolean> result = new CompletableFuture<>();
// Get chunks and scan // Get chunks and scan
// Get chunks and scan // Get chunks and scan
getWorldChunk(Environment.THE_END, endPairList).thenAccept( getWorldChunk(Environment.THE_END, endPairList).thenAccept(
endChunks -> scanChunk(endChunks).thenAccept(b -> getWorldChunk(Environment.NETHER, netherPairList) endChunks -> scanChunk(endChunks).thenAccept(b -> getWorldChunk(Environment.NETHER, netherPairList)
.thenAccept(netherChunks -> scanChunk(netherChunks) .thenAccept(netherChunks -> scanChunk(netherChunks)
.thenAccept(b2 -> getWorldChunk(Environment.NORMAL, pairList) .thenAccept(b2 -> getWorldChunk(Environment.NORMAL, pairList)
.thenAccept(normalChunks -> scanChunk(normalChunks).thenAccept(b3 -> .thenAccept(normalChunks -> scanChunk(normalChunks).thenAccept(b3 ->
// Complete the result now that all chunks have been scanned // Complete the result now that all chunks have been scanned
result.complete(!chunksToCheck.isEmpty()))))))); result.complete(!chunksToCheck.isEmpty())))))));
return result; return result;
} }
private Collection<String> sortedReport(int total, Multiset<Material> materialCount) { private Collection<String> sortedReport(int total, Multiset<Material> materialCount) {
Collection<String> result = new ArrayList<>(); Collection<String> result = new ArrayList<>();
Iterable<Multiset.Entry<Material>> entriesSortedByCount = Multisets.copyHighestCountFirst(materialCount) Iterable<Multiset.Entry<Material>> entriesSortedByCount = Multisets.copyHighestCountFirst(materialCount)
.entrySet(); .entrySet();
for (Entry<Material> en : entriesSortedByCount) { for (Entry<Material> en : entriesSortedByCount) {
Material type = en.getElement(); Material type = en.getElement();
int value = getValue(type); int value = getValue(type);
result.add(type.toString() + ":" + String.format("%,d", en.getCount()) + " blocks x " + value + " = " result.add(type.toString() + ":" + String.format("%,d", en.getCount()) + " blocks x " + value + " = "
+ (value * en.getCount())); + (value * en.getCount()));
total += (value * en.getCount()); total += (value * en.getCount());
} }
result.add("Subtotal = " + total); result.add("Subtotal = " + total);
result.add(LINE_BREAK); result.add(LINE_BREAK);
return result; return result;
} }
/** /**
* Finalizes the calculations and makes the report * Finalizes the calculations and makes the report
*/ */
public void tidyUp() { public void tidyUp() {
// Finalize calculations // Finalize calculations
results.rawBlockCount results.rawBlockCount
.addAndGet((long) (results.underWaterBlockCount.get() * addon.getSettings().getUnderWaterMultiplier())); .addAndGet((long) (results.underWaterBlockCount.get() * addon.getSettings().getUnderWaterMultiplier()));
// Set the death penalty // Set the death penalty
if (this.addon.getSettings().isSumTeamDeaths()) { if (this.addon.getSettings().isSumTeamDeaths()) {
for (UUID uuid : this.island.getMemberSet()) { for (UUID uuid : this.island.getMemberSet()) {
this.results.deathHandicap.addAndGet(this.addon.getPlayers().getDeaths(island.getWorld(), uuid)); this.results.deathHandicap.addAndGet(this.addon.getPlayers().getDeaths(island.getWorld(), uuid));
} }
} else { } else {
// At this point, it may be that the island has become unowned. // At this point, it may be that the island has become unowned.
this.results.deathHandicap.set(this.island.getOwner() == null ? 0 this.results.deathHandicap.set(this.island.getOwner() == null ? 0
: this.addon.getPlayers().getDeaths(island.getWorld(), this.island.getOwner())); : this.addon.getPlayers().getDeaths(island.getWorld(), this.island.getOwner()));
} }
long blockAndDeathPoints = this.results.rawBlockCount.get(); long blockAndDeathPoints = this.results.rawBlockCount.get();
this.results.totalPoints.set(blockAndDeathPoints); this.results.totalPoints.set(blockAndDeathPoints);
if (this.addon.getSettings().getDeathPenalty() > 0) { if (this.addon.getSettings().getDeathPenalty() > 0) {
// Proper death penalty calculation. // Proper death penalty calculation.
blockAndDeathPoints -= this.results.deathHandicap.get() * this.addon.getSettings().getDeathPenalty(); blockAndDeathPoints -= this.results.deathHandicap.get() * this.addon.getSettings().getDeathPenalty();
} }
this.results.level.set(calculateLevel(blockAndDeathPoints)); this.results.level.set(calculateLevel(blockAndDeathPoints));
// Calculate how many points are required to get to the next level // Calculate how many points are required to get to the next level
long nextLevel = this.results.level.get(); long nextLevel = this.results.level.get();
long blocks = blockAndDeathPoints; long blocks = blockAndDeathPoints;
while (nextLevel < this.results.level.get() + 1 && blocks - blockAndDeathPoints < MAX_AMOUNT) { while (nextLevel < this.results.level.get() + 1 && blocks - blockAndDeathPoints < MAX_AMOUNT) {
nextLevel = calculateLevel(++blocks); nextLevel = calculateLevel(++blocks);
} }
this.results.pointsToNextLevel.set(blocks - blockAndDeathPoints); this.results.pointsToNextLevel.set(blocks - blockAndDeathPoints);
// Report // Report
results.report = getReport(); results.report = getReport();
// Set the duration // Set the duration
addon.getPipeliner().setTime(System.currentTimeMillis() - duration); addon.getPipeliner().setTime(System.currentTimeMillis() - duration);
// All done. // All done.
} }
/** /**
@ -600,58 +583,58 @@ public class IslandLevelCalculator {
} }
public void scanIsland(Pipeliner pipeliner) { public void scanIsland(Pipeliner pipeliner) {
// Scan the next chunk // Scan the next chunk
scanNextChunk().thenAccept(result -> { scanNextChunk().thenAccept(result -> {
if (!Bukkit.isPrimaryThread()) { if (!Bukkit.isPrimaryThread()) {
addon.getPlugin().logError("scanChunk not on Primary Thread!"); addon.getPlugin().logError("scanChunk not on Primary Thread!");
} }
// Timeout check // Timeout check
if (System.currentTimeMillis() if (System.currentTimeMillis()
- pipeliner.getInProcessQueue().get(this) > addon.getSettings().getCalculationTimeout() * 60000) { - pipeliner.getInProcessQueue().get(this) > addon.getSettings().getCalculationTimeout() * 60000) {
// Done // Done
pipeliner.getInProcessQueue().remove(this); pipeliner.getInProcessQueue().remove(this);
getR().complete(new Results(Result.TIMEOUT)); getR().complete(new Results(Result.TIMEOUT));
addon.logError("Level calculation timed out after " + addon.getSettings().getCalculationTimeout() addon.logError("Level calculation timed out after " + addon.getSettings().getCalculationTimeout()
+ "m for island: " + getIsland()); + "m for island: " + getIsland());
if (!isNotZeroIsland()) { if (!isNotZeroIsland()) {
addon.logError("Island level was being zeroed."); addon.logError("Island level was being zeroed.");
} }
return; return;
} }
if (Boolean.TRUE.equals(result) && !pipeliner.getTask().isCancelled()) { if (Boolean.TRUE.equals(result) && !pipeliner.getTask().isCancelled()) {
// scanNextChunk returns true if there are more chunks to scan // scanNextChunk returns true if there are more chunks to scan
scanIsland(pipeliner); scanIsland(pipeliner);
} else { } else {
// Done // Done
pipeliner.getInProcessQueue().remove(this); pipeliner.getInProcessQueue().remove(this);
// Chunk finished // Chunk finished
// This was the last chunk // This was the last chunk
handleStackedBlocks(); handleStackedBlocks();
handleChests(); handleChests();
long checkTime = System.currentTimeMillis(); long checkTime = System.currentTimeMillis();
finishTask = Bukkit.getScheduler().runTaskTimer(addon.getPlugin(), () -> { finishTask = Bukkit.getScheduler().runTaskTimer(addon.getPlugin(), () -> {
// Check every half second if all the chests and stacks have been cleared // Check every half second if all the chests and stacks have been cleared
if ((chestBlocks.isEmpty() && stackedBlocks.isEmpty()) if ((chestBlocks.isEmpty() && stackedBlocks.isEmpty())
|| System.currentTimeMillis() - checkTime > MAX_AMOUNT) { || System.currentTimeMillis() - checkTime > MAX_AMOUNT) {
this.tidyUp(); this.tidyUp();
this.getR().complete(getResults()); this.getR().complete(getResults());
finishTask.cancel(); finishTask.cancel();
} }
}, 0, 10L); }, 0, 10L);
} }
}); });
} }
private void handleChests() { private void handleChests() {
Iterator<Chunk> it = chestBlocks.iterator(); Iterator<Chunk> it = chestBlocks.iterator();
while (it.hasNext()) { while (it.hasNext()) {
Chunk v = it.next(); Chunk v = it.next();
Util.getChunkAtAsync(v.getWorld(), v.getX(), v.getZ()).thenAccept(c -> { Util.getChunkAtAsync(v.getWorld(), v.getX(), v.getZ()).thenAccept(c -> {
scanChests(c); scanChests(c);
it.remove(); it.remove();
}); });
} }
} }
private void handleStackedBlocks() { private void handleStackedBlocks() {

29
src/main/java/world/bentobox/level/calculators/UltimateStackerCalc.java Normal file
View File

@ -0,0 +1,29 @@
package world.bentobox.level.calculators;
import org.bukkit.Location;
import org.bukkit.Material;
import com.craftaro.ultimatestacker.api.UltimateStackerApi;
import com.craftaro.ultimatestacker.api.utils.Stackable;
import world.bentobox.bentobox.BentoBox;
/**
* Isolates UltimateStacker imports so that they are only loaded if the plugin exists
*/
public class UltimateStackerCalc {
public static void addStackers(Material material, Location location, Results results, boolean belowSeaLevel,
int value) {
Stackable stack = UltimateStackerApi.getBlockStackManager().getBlock(location);
if (stack != null) {
if (belowSeaLevel) {
results.underWaterBlockCount.addAndGet((long) stack.getAmount() * value);
results.uwCount.add(material);
} else {
results.rawBlockCount.addAndGet((long) stack.getAmount() * value);
results.mdCount.add(material);
}
}
}
}

6
src/main/java/world/bentobox/level/commands/IslandLevelCommand.java
View File

@ -111,7 +111,11 @@ public class IslandLevelCommand extends CompositeCommand {
} }
// Send player how many points are required to reach next island level // Send player how many points are required to reach next island level
if (results.getPointsToNextLevel() >= 0) { if (results.getPointsToNextLevel() >= 0) {
user.sendMessage("island.level.required-points-to-next-level", "[points]", String.valueOf(results.getPointsToNextLevel())); user.sendMessage("island.level.required-points-to-next-level",
"[points]", String.valueOf(results.getPointsToNextLevel()),
"[progress]", String.valueOf(this.addon.getSettings().getLevelCost()-results.getPointsToNextLevel()),
"[levelcost]", String.valueOf(this.addon.getSettings().getLevelCost())
);
} }
// Tell other team members // Tell other team members
if (results.getLevel() != oldLevel) { if (results.getLevel() != oldLevel) {

30
src/main/java/world/bentobox/level/util/CachedData.java Normal file
View File

@ -0,0 +1,30 @@
package world.bentobox.level.util;
import java.time.Instant;
import java.util.Map;
/**
* Cache for top tens
*/
public class CachedData {
private Map<String, Long> cachedMap;
private Instant lastUpdated;
public CachedData(Map<String, Long> cachedMap, Instant lastUpdated) {
this.cachedMap = cachedMap;
this.lastUpdated = lastUpdated;
}
public Map<String, Long> getCachedMap() {
return cachedMap;
}
public Instant getLastUpdated() {
return lastUpdated;
}
public void updateCache(Map<String, Long> newMap, Instant newUpdateTime) {
this.cachedMap = newMap;
this.lastUpdated = newUpdateTime;
}
}

4
src/main/resources/locales/en-US.yml
View File

@ -42,8 +42,8 @@ island:
estimated-wait: "&a Estimated wait: [number] seconds" estimated-wait: "&a Estimated wait: [number] seconds"
in-queue: "&a You are number [number] in the queue" in-queue: "&a You are number [number] in the queue"
island-level-is: "&a Island level is &b[level]" island-level-is: "&a Island level is &b[level]"
required-points-to-next-level: "&a [points] points required until the next level" required-points-to-next-level: "&a Level progress: &6 [progress]&b /&e [levelcost] &a points"
deaths: "&c([number] deaths)" deaths: "&c ([number] deaths)"
cooldown: "&c You must wait &b[time] &c seconds until you can do that again" cooldown: "&c You must wait &b[time] &c seconds until you can do that again"
in-progress: "&6 Island level calculation is in progress..." in-progress: "&6 Island level calculation is in progress..."
time-out: "&c The level calculation took too long. Please try again later." time-out: "&c The level calculation took too long. Please try again later."

4
src/main/resources/panels/detail_panel.yml
View File

@ -121,7 +121,7 @@ detail_panel:
# TIPPED_ARROW:INSTANT_DAMAGE:2::LINGER:2 # TIPPED_ARROW:INSTANT_DAMAGE:2::LINGER:2
# TIPPED_ARROW:JUMP:2:NOTEXTENDED:NOSPLASH:1 # TIPPED_ARROW:JUMP:2:NOTEXTENDED:NOSPLASH:1
# TIPPED_ARROW:WEAKNESS::::1 - any weakness enchantment # TIPPED_ARROW:WEAKNESS::::1 - any weakness enchantment
icon: TIPPED_ARROW:INSTANT_HEAL::::1 icon: tipped_arrow{CustomPotionColor:11546150}
title: level.gui.buttons.previous.name title: level.gui.buttons.previous.name
description: level.gui.buttons.previous.description description: level.gui.buttons.previous.description
data: data:
@ -139,7 +139,7 @@ detail_panel:
7: material_button 7: material_button
8: material_button 8: material_button
9: 9:
icon: TIPPED_ARROW:JUMP::::1 icon: tipped_arrow{CustomPotionColor:8439583}
title: level.gui.buttons.next.name title: level.gui.buttons.next.name
description: level.gui.buttons.next.description description: level.gui.buttons.next.description
data: data:

4
src/main/resources/panels/value_panel.yml
View File

@ -64,7 +64,7 @@ value_panel:
8: material_button 8: material_button
3: 3:
1: 1:
icon: TIPPED_ARROW:INSTANT_HEAL::::1 icon: tipped_arrow{CustomPotionColor:11546150}
title: level.gui.buttons.previous.name title: level.gui.buttons.previous.name
description: level.gui.buttons.previous.description description: level.gui.buttons.previous.description
data: data:
@ -82,7 +82,7 @@ value_panel:
7: material_button 7: material_button
8: material_button 8: material_button
9: 9:
icon: TIPPED_ARROW:JUMP::::1 icon: tipped_arrow{CustomPotionColor:8439583}
title: level.gui.buttons.next.name title: level.gui.buttons.next.name
description: level.gui.buttons.next.description description: level.gui.buttons.next.description
data: data: