Upstream/Level
1
0
Fork 0
mirror of https://github.com/BentoBoxWorld/Level.git synced 2025-02-13 18:21:26 +01:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/develop'

Browse Source
This commit is contained in:
tastybento 2019-08-16 14:04:53 -07:00
commit cc93175098
25 changed files with 989 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
pom.xml
View File

@ -6,13 +6,24 @@
<groupId>world.bentobox</groupId> <groupId>world.bentobox</groupId>
<artifactId>level</artifactId> <artifactId>level</artifactId>
<version>1.5.0</version> <version>${revision}</version>
<name>Level</name> <name>Level</name>
<description>Level is an add-on for BentoBox, an expandable Minecraft Bukkit plugin for island-type games like SkyBlock or AcidIsland.</description> <description>Level is an add-on for BentoBox, an expandable Minecraft Bukkit plugin for island-type games like SkyBlock or AcidIsland.</description>
<url>https://github.com/BentoBoxWorld/Level</url> <url>https://github.com/BentoBoxWorld/Level</url>
<inceptionYear>2017</inceptionYear> <inceptionYear>2017</inceptionYear>
<developers>
<developer>
<id>tastybento</id>
<email>tastybento@bentobox.world</email>
<timezone>-8</timezone>
<roles>
<role>Lead Developer</role>
</roles>
</developer>
</developers>
<scm> <scm>
<connection>scm:git:https://github.com/BentoBoxWorld/Level.git</connection> <connection>scm:git:https://github.com/BentoBoxWorld/Level.git</connection>
<developerConnection>scm:git:git@github.com:BentoBoxWorld/Level.git</developerConnection> <developerConnection>scm:git:git@github.com:BentoBoxWorld/Level.git</developerConnection>
@ -41,12 +52,59 @@
</distributionManagement> </distributionManagement>
<properties> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version> <java.version>1.8</java.version>
<powermock.version>1.7.4</powermock.version> <!-- Non-minecraft related dependencies -->
<powermock.version>2.0.2</powermock.version>
<!-- More visible way how to change dependency versions -->
<spigot.version>1.13.2-R0.1-SNAPSHOT</spigot.version>
<bentobox.version>1.6.0-SNAPSHOT</bentobox.version>
<!-- Revision variable removes warning about dynamic version -->
<revision>${build.version}-SNAPSHOT</revision>
<!-- Do not change unless you want different name for local builds. -->
<build.number>-LOCAL</build.number>
<!-- This allows to change between versions. -->
<build.version>1.6.0</build.version>
</properties> </properties>
<!-- Profiles will allow to automatically change build version. -->
<profiles>
<profile>
<!-- ci profile is activated if exist environment variable BUILD_NUMBER. -->
<!-- It replaces ${build.number} that is currently '-LOCAL' with correct build number from JENKINS machine. -->
<id>ci</id>
<activation>
<property>
<name>env.BUILD_NUMBER</name>
</property>
</activation>
<properties>
<!-- Override only if necessary -->
<build.number>-b${env.BUILD_NUMBER}</build.number>
</properties>
</profile>
<profile>
<!-- Master profile is activated if exist environment variable GIT_BRANCH and its value is origin/master. -->
<!-- It will replace 'revision' with '${build.version}' so it removes '-SNAPSHOT' string at the end. -->
<!-- Also, as this is release build, build number can be set to empty string. -->
<!-- This profile will be used only if exist environment variable GIT_BRANCH with value origin/master. -->
<id>master</id>
<activation>
<property>
<name>env.GIT_BRANCH</name>
<value>origin/master</value>
</property>
</activation>
<properties>
<!-- Override only if necessary -->
<revision>${build.version}</revision>
<!-- Empties build number variable.-->
<build.number></build.number>
</properties>
</profile>
</profiles>
<repositories> <repositories>
<repository> <repository>
<id>spigot-repo</id> <id>spigot-repo</id>
@ -62,40 +120,50 @@
</repository> </repository>
</repositories> </repositories>
<dependencies> <dependencies>
<dependency> <!-- Spigot API -->
<groupId>org.spigotmc</groupId> <dependency>
<artifactId>spigot-api</artifactId> <groupId>org.spigotmc</groupId>
<version>1.14.1-R0.1-SNAPSHOT</version> <artifactId>spigot-api</artifactId>
<scope>provided</scope> <version>${spigot.version}</version>
</dependency> <scope>provided</scope>
<dependency> </dependency>
<groupId>org.mockito</groupId> <!-- Mockito (Unit testing) -->
<artifactId>mockito-all</artifactId> <dependency>
<version>1.10.19</version> <groupId>org.mockito</groupId>
<scope>test</scope> <artifactId>mockito-core</artifactId>
</dependency> <version>3.0.0</version>
<dependency> <scope>test</scope>
<groupId>org.powermock</groupId> </dependency>
<artifactId>powermock-module-junit4</artifactId> <dependency>
<version>${powermock.version}</version> <groupId>org.powermock</groupId>
<scope>test</scope> <artifactId>powermock-module-junit4</artifactId>
</dependency> <version>${powermock.version}</version>
<dependency> <scope>test</scope>
<groupId>org.powermock</groupId> </dependency>
<artifactId>powermock-api-mockito</artifactId> <dependency>
<version>${powermock.version}</version> <groupId>org.powermock</groupId>
<scope>test</scope> <artifactId>powermock-api-mockito2</artifactId>
</dependency> <version>${powermock.version}</version>
<dependency> <scope>test</scope>
<groupId>world.bentobox</groupId> </dependency>
<artifactId>bentobox</artifactId> <dependency>
<version>1.5.0</version> <groupId>world.bentobox</groupId>
<scope>provided</scope> <artifactId>bentobox</artifactId>
</dependency> <version>${bentobox.version}</version>
</dependencies> <scope>provided</scope>
</dependency>
</dependencies>
<build> <build>
<!-- By default ${revision} is ${build.version}-SNAPSHOT -->
<!-- If GIT_BRANCH variable is set to origin/master, then it will be only ${build.version}. -->
<!-- By default ${build.number} is -LOCAL. -->
<!-- If the BUILD_NUMBER variable is set, then it will be -b[number]. -->
<!-- If GIT_BRANCH variable is set to origin/master, then it will be the empty string. -->
<finalName>${project.name}-${revision}${build.number}</finalName>
<defaultGoal>clean package</defaultGoal> <defaultGoal>clean package</defaultGoal>
<resources> <resources>
<resource> <resource>

20
src/main/java/world/bentobox/level/Level.java
View File

@ -5,6 +5,7 @@ import java.util.Map;
import java.util.UUID; import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
import org.eclipse.jdt.annotation.Nullable;
import world.bentobox.bentobox.api.addons.Addon; import world.bentobox.bentobox.api.addons.Addon;
import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.api.user.User;
@ -46,7 +47,7 @@ public class Level extends Addon {
private TopTen topTen; private TopTen topTen;
// Level calculator // Level calculator
private LevelPresenter levelCalc; private LevelPresenter levelPresenter;
/** /**
* Calculates a user's island * Calculates a user's island
@ -54,8 +55,8 @@ public class Level extends Addon {
* @param user - the user who is asking, or null if none * @param user - the user who is asking, or null if none
* @param playerUUID - the target island member's UUID * @param playerUUID - the target island member's UUID
*/ */
public void calculateIslandLevel(World world, User user, UUID playerUUID) { public void calculateIslandLevel(World world, @Nullable User user, UUID playerUUID) {
levelCalc.calculateIslandLevel(world, user, playerUUID); levelPresenter.calculateIslandLevel(world, user, playerUUID);
} }
/** /**
@ -85,7 +86,7 @@ public class Level extends Addon {
/** /**
* @return the settings * @return the settings
*/ */
public final Settings getSettings() { public Settings getSettings() {
return settings; return settings;
} }
@ -93,6 +94,13 @@ public class Level extends Addon {
return topTen; return topTen;
} }
/**
* @return the levelPresenter
*/
public LevelPresenter getLevelPresenter() {
return levelPresenter;
}
@Override @Override
public void onDisable(){ public void onDisable(){
// Save the cache // Save the cache
@ -115,7 +123,7 @@ public class Level extends Addon {
// Initialize the cache // Initialize the cache
levelsCache = new HashMap<>(); levelsCache = new HashMap<>();
// Load the calculator // Load the calculator
levelCalc = new LevelPresenter(this, this.getPlugin()); levelPresenter = new LevelPresenter(this, this.getPlugin());
// Start the top ten and register it for clicks // Start the top ten and register it for clicks
topTen = new TopTen(this); topTen = new TopTen(this);
registerListener(topTen); registerListener(topTen);
@ -208,7 +216,7 @@ public class Level extends Addon {
public long getInitialIslandLevel(Island island) { public long getInitialIslandLevel(Island island) {
return levelsCache.containsKey(island.getOwner()) ? levelsCache.get(island.getOwner()).getInitialLevel(island.getWorld()) : 0L; return levelsCache.containsKey(island.getOwner()) ? levelsCache.get(island.getOwner()).getInitialLevel(island.getWorld()) : 0L;
} }
public Database<LevelsData> getHandler() { public Database<LevelsData> getHandler() {
return handler; return handler;
} }

58
src/main/java/world/bentobox/level/LevelPresenter.java
View File

@ -1,7 +1,11 @@
package world.bentobox.level; package world.bentobox.level;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.Calendar; import java.util.Calendar;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID; import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
@ -10,7 +14,18 @@ import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.api.user.User;
import world.bentobox.level.calculators.PlayerLevel; import world.bentobox.level.calculators.PlayerLevel;
class LevelPresenter { public class LevelPresenter {
private static final BigInteger THOUSAND = BigInteger.valueOf(1000);
private static final TreeMap<BigInteger, String> LEVELS;
static {
LEVELS = new TreeMap<>();
LEVELS.put(THOUSAND, "k");
LEVELS.put(THOUSAND.pow(2), "M");
LEVELS.put(THOUSAND.pow(3), "G");
LEVELS.put(THOUSAND.pow(4), "T");
}
private int levelWait; private int levelWait;
private final Level addon; private final Level addon;
@ -41,16 +56,18 @@ class LevelPresenter {
targetPlayer = plugin.getIslands().getOwner(world, targetPlayer); targetPlayer = plugin.getIslands().getOwner(world, targetPlayer);
inTeam = true; inTeam = true;
} else { } else {
sender.sendMessage("general.errors.player-has-no-island"); if (sender != null) sender.sendMessage("general.errors.player-has-no-island");
return; return;
} }
} }
// Player asking for their own island calc // Player asking for their own island calc
if (inTeam || !sender.isPlayer() || sender.getUniqueId().equals(targetPlayer) || sender.isOp() || sender.hasPermission(permPrefix + "mod.info")) { if (sender == null || inTeam || !sender.isPlayer() || sender.getUniqueId().equals(targetPlayer) || sender.isOp() || sender.hasPermission(permPrefix + "mod.info")) {
// Newer better system - uses chunks // Newer better system - uses chunks
if (!onLevelWaitTime(sender) || levelWait <= 0 || sender.isOp() || sender.hasPermission(permPrefix + "mod.info")) { if (sender == null || !onLevelWaitTime(sender) || levelWait <= 0 || sender.isOp() || sender.hasPermission(permPrefix + "mod.info")) {
sender.sendMessage("island.level.calculating"); if (sender != null) {
setLevelWaitTime(sender); sender.sendMessage("island.level.calculating");
setLevelWaitTime(sender);
}
new PlayerLevel(addon, plugin.getIslands().getIsland(world, targetPlayer), targetPlayer, sender); new PlayerLevel(addon, plugin.getIslands().getIsland(world, targetPlayer), targetPlayer, sender);
} else { } else {
// Cooldown // Cooldown
@ -58,11 +75,36 @@ class LevelPresenter {
} }
} else { } else {
// Asking for the level of another player long lvl = addon.getIslandLevel(world, targetPlayer);
sender.sendMessage("island.level.island-level-is","[level]", String.valueOf(addon.getIslandLevel(world, targetPlayer)));
sender.sendMessage("island.level.island-level-is","[level]", getLevelString(lvl));
} }
} }
/**
* Get the string representation of the level. May be converted to shorthand notation, e.g., 104556 -> 10.5k
* @param lvl - long value to represent
* @return string of the level.
*/
public String getLevelString(long lvl) {
String level = String.valueOf(lvl);
// Asking for the level of another player
if(addon.getSettings().isShortHand()) {
BigInteger levelValue = BigInteger.valueOf(lvl);
Map.Entry<BigInteger, String> stage = LEVELS.floorEntry(levelValue);
if (stage != null) { // level > 1000
// 1 052 -> 1.0k
// 1 527 314 -> 1.5M
// 3 874 130 021 -> 3.8G
// 4 002 317 889 -> 4.0T
level = new DecimalFormat("#.#").format(levelValue.divide(stage.getKey().divide(THOUSAND)).doubleValue()/1000.0) + stage.getValue();
}
}
return level;
}
/** /**
* Sets cool down for the level command * Sets cool down for the level command
* *

43
src/main/java/world/bentobox/level/TopTen.java
View File

@ -28,11 +28,11 @@ import world.bentobox.level.objects.TopTenData;
* *
*/ */
public class TopTen implements Listener { public class TopTen implements Listener {
private final Level addon; private Level addon;
// Top ten list of players // Top ten list of players
private Map<World,TopTenData> topTenList; private Map<World,TopTenData> topTenList;
private final int[] SLOTS = new int[] {4, 12, 14, 19, 20, 21, 22, 23, 24, 25}; private final int[] SLOTS = new int[] {4, 12, 14, 19, 20, 21, 22, 23, 24, 25};
private final Database<TopTenData> handler; private Database<TopTenData> handler;
public TopTen(Level addon) { public TopTen(Level addon) {
this.addon = addon; this.addon = addon;
@ -42,6 +42,21 @@ public class TopTen implements Listener {
loadTopTen(); loadTopTen();
} }
/**
* Loads all the top tens from the database
*/
private void loadTopTen() {
topTenList = new HashMap<>();
handler.loadObjects().forEach(tt -> {
World world = Bukkit.getWorld(tt.getUniqueId());
if (world != null) {
topTenList.put(world, tt);
} else {
addon.logError("TopTen world " + tt.getUniqueId() + " is not known on server. Skipping...");
}
});
}
/** /**
* Adds a player to the top ten, if the level is good enough * Adds a player to the top ten, if the level is good enough
* *
@ -58,8 +73,8 @@ public class TopTen implements Listener {
topTenList.get(world).setUniqueId(world.getName()); topTenList.get(world).setUniqueId(world.getName());
// Try and see if the player is online // Try and see if the player is online
Player player = addon.getServer().getPlayer(ownerUUID); Player player = Bukkit.getServer().getPlayer(ownerUUID);
if (player != null && !player.hasPermission(addon.getPlugin().getIWM().getPermissionPrefix(world) + ".intopten")) { if (player != null && !player.hasPermission(addon.getPlugin().getIWM().getPermissionPrefix(world) + "intopten")) {
topTenList.get(world).remove(ownerUUID); topTenList.get(world).remove(ownerUUID);
return; return;
} }
@ -86,7 +101,7 @@ public class TopTen implements Listener {
Map.Entry<UUID, Long> m = it.next(); Map.Entry<UUID, Long> m = it.next();
UUID topTenUUID = m.getKey(); UUID topTenUUID = m.getKey();
// Remove from TopTen if the player is online and has the permission // Remove from TopTen if the player is online and has the permission
Player entry = addon.getServer().getPlayer(topTenUUID); Player entry = Bukkit.getServer().getPlayer(topTenUUID);
boolean show = true; boolean show = true;
if (entry != null) { if (entry != null) {
if (!entry.hasPermission(permPrefix + "intopten")) { if (!entry.hasPermission(permPrefix + "intopten")) {
@ -110,12 +125,12 @@ public class TopTen implements Listener {
* @param asker - the asker of the top ten * @param asker - the asker of the top ten
* @return PanelItem * @return PanelItem
*/ */
private PanelItem getHead(int rank, Long level, UUID playerUUID, User asker, World world) { private PanelItem getHead(int rank, long level, UUID playerUUID, User asker, World world) {
final String name = addon.getPlayers().getName(playerUUID); final String name = addon.getPlayers().getName(playerUUID);
List<String> description = new ArrayList<>(); List<String> description = new ArrayList<>();
if (name != null) { if (name != null) {
description.add(asker.getTranslation("island.top.gui-heading", "[name]", name, "[rank]", String.valueOf(rank))); description.add(asker.getTranslation("island.top.gui-heading", "[name]", name, "[rank]", String.valueOf(rank)));
description.add(asker.getTranslation("island.top.island-level","[level]", String.valueOf(level))); description.add(asker.getTranslation("island.top.island-level","[level]", addon.getLevelPresenter().getLevelString(level)));
if (addon.getIslands().inTeam(world, playerUUID)) { if (addon.getIslands().inTeam(world, playerUUID)) {
List<String> memberList = new ArrayList<>(); List<String> memberList = new ArrayList<>();
for (UUID members : addon.getIslands().getMembers(world, playerUUID)) { for (UUID members : addon.getIslands().getMembers(world, playerUUID)) {
@ -131,16 +146,14 @@ public class TopTen implements Listener {
return builder.build(); return builder.build();
} }
public TopTenData getTopTenList(World world) {
return topTenList.get(world);
}
/** /**
* Loads all the top tens from the database * Get the top ten list for this world
* @param world - world
* @return top ten data object
*/ */
private void loadTopTen() { public TopTenData getTopTenList(World world) {
topTenList = new HashMap<>(); topTenList.putIfAbsent(world, new TopTenData());
handler.loadObjects().forEach(tt -> topTenList.put(Bukkit.getWorld(tt.getUniqueId()), tt)); return topTenList.get(world);
} }
/** /**

80
src/main/java/world/bentobox/level/calculators/CalcIslandLevel.java
View File

@ -12,7 +12,10 @@ import java.util.UUID;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChunkSnapshot; import org.bukkit.ChunkSnapshot;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.Tag;
import org.bukkit.World; import org.bukkit.World;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.type.Slab;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
import com.google.common.collect.HashMultiset; import com.google.common.collect.HashMultiset;
@ -28,8 +31,8 @@ import world.bentobox.level.Level;
public class CalcIslandLevel { public class CalcIslandLevel {
private static final int MAX_CHUNKS = 200; private final int MAX_CHUNKS;
private static final long SPEED = 1; private final long SPEED;
private static final String LINE_BREAK = "=================================="; private static final String LINE_BREAK = "==================================";
private boolean checking; private boolean checking;
private final BukkitTask task; private final BukkitTask task;
@ -38,12 +41,13 @@ public class CalcIslandLevel {
private final Set<Pair<Integer, Integer>> chunksToScan; private final Set<Pair<Integer, Integer>> chunksToScan;
private final Island island; private final Island island;
private final World world;
private final Results result; private final Results result;
private final Runnable onExit; private final Runnable onExit;
// Copy the limits hash map // Copy the limits hash map
private final HashMap<Material, Integer> limitCount; private final HashMap<Material, Integer> limitCount;
private final World world;
private final List<World> worlds;
/** /**
@ -56,7 +60,17 @@ public class CalcIslandLevel {
public CalcIslandLevel(final Level addon, final Island island, final Runnable onExit) { public CalcIslandLevel(final Level addon, final Island island, final Runnable onExit) {
this.addon = addon; this.addon = addon;
this.island = island; this.island = island;
this.world = island.getCenter().getWorld(); this.world = island.getWorld();
this.worlds = new ArrayList<>();
this.worlds.add(world);
if (addon.getSettings().isNether()) {
World netherWorld = addon.getPlugin().getIWM().getNetherWorld(world);
if (netherWorld != null) this.worlds.add(netherWorld);
}
if (addon.getSettings().isEnd()) {
World endWorld = addon.getPlugin().getIWM().getEndWorld(world);
if (endWorld != null) this.worlds.add(endWorld);
}
this.limitCount = new HashMap<>(addon.getSettings().getBlockLimits()); this.limitCount = new HashMap<>(addon.getSettings().getBlockLimits());
this.onExit = onExit; this.onExit = onExit;
@ -66,6 +80,9 @@ public class CalcIslandLevel {
// Set the initial island handicap // Set the initial island handicap
result.initialLevel = addon.getInitialIslandLevel(island); result.initialLevel = addon.getInitialIslandLevel(island);
SPEED = addon.getSettings().getUpdateTickDelay();
MAX_CHUNKS = addon.getSettings().getChunksPerTick();
// Get chunks to scan // Get chunks to scan
chunksToScan = getChunksToScan(island); chunksToScan = getChunksToScan(island);
@ -85,12 +102,14 @@ public class CalcIslandLevel {
// Add chunk snapshots to the list // Add chunk snapshots to the list
while (it.hasNext() && chunkSnapshot.size() < MAX_CHUNKS) { while (it.hasNext() && chunkSnapshot.size() < MAX_CHUNKS) {
Pair<Integer, Integer> pair = it.next(); Pair<Integer, Integer> pair = it.next();
if (!world.isChunkLoaded(pair.x, pair.z)) { for (World world : worlds) {
world.loadChunk(pair.x, pair.z); if (!world.isChunkLoaded(pair.x, pair.z)) {
chunkSnapshot.add(world.getChunkAt(pair.x, pair.z).getChunkSnapshot()); world.loadChunk(pair.x, pair.z);
world.unloadChunk(pair.x, pair.z); chunkSnapshot.add(world.getChunkAt(pair.x, pair.z).getChunkSnapshot());
} else { world.unloadChunk(pair.x, pair.z);
chunkSnapshot.add(world.getChunkAt(pair.x, pair.z).getChunkSnapshot()); } else {
chunkSnapshot.add(world.getChunkAt(pair.x, pair.z).getChunkSnapshot());
}
} }
it.remove(); it.remove();
} }
@ -114,6 +133,10 @@ public class CalcIslandLevel {
} }
private void scanChunk(ChunkSnapshot chunk) { private void scanChunk(ChunkSnapshot chunk) {
World chunkWorld = Bukkit.getWorld(chunk.getWorldName());
if (chunkWorld == null) return;
int maxHeight = chunkWorld.getMaxHeight();
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 count it // Check if the block coordinate is inside the protection zone and if not, don't count it
if (chunk.getX() * 16 + x < island.getMinProtectedX() || chunk.getX() * 16 + x >= island.getMinProtectedX() + island.getProtectionRange() * 2) { if (chunk.getX() * 16 + x < island.getMinProtectedX() || chunk.getX() * 16 + x >= island.getMinProtectedX() + island.getProtectionRange() * 2) {
@ -125,27 +148,31 @@ public class CalcIslandLevel {
continue; continue;
} }
for (int y = 0; y < island.getCenter().getWorld().getMaxHeight(); y++) { for (int y = 0; y < maxHeight; y++) {
Material blockData = chunk.getBlockType(x, y, z); BlockData blockData = chunk.getBlockData(x, y, z);
int seaHeight = addon.getPlugin().getIWM().getSeaHeight(world); int seaHeight = addon.getPlugin().getIWM().getSeaHeight(chunkWorld);
boolean belowSeaLevel = seaHeight > 0 && y <= seaHeight; boolean belowSeaLevel = seaHeight > 0 && y <= seaHeight;
// Air is free // Slabs can be doubled, so check them twice
if (!blockData.equals(Material.AIR)) { if (Tag.SLABS.isTagged(blockData.getMaterial())) {
checkBlock(blockData, belowSeaLevel); Slab slab = (Slab)blockData;
if (slab.getType().equals(Slab.Type.DOUBLE)) {
checkBlock(blockData, belowSeaLevel);
}
} }
checkBlock(blockData, belowSeaLevel);
} }
} }
} }
} }
private void checkBlock(Material md, boolean belowSeaLevel) { private void checkBlock(BlockData bd, boolean belowSeaLevel) {
int count = limitCount(md); int count = limitCount(bd.getMaterial());
if (belowSeaLevel) { if (belowSeaLevel) {
result.underWaterBlockCount += count; result.underWaterBlockCount += count;
result.uwCount.add(md); result.uwCount.add(bd.getMaterial());
} else { } else {
result.rawBlockCount += count; result.rawBlockCount += count;
result.mdCount.add(md); result.mdCount.add(bd.getMaterial());
} }
} }
@ -194,8 +221,7 @@ public class CalcIslandLevel {
Set<Pair<Integer, Integer>> chunkSnapshot = new HashSet<>(); Set<Pair<Integer, Integer>> chunkSnapshot = new HashSet<>();
for (int x = island.getMinProtectedX(); x < (island.getMinProtectedX() + island.getProtectionRange() * 2 + 16); x += 16) { for (int x = island.getMinProtectedX(); x < (island.getMinProtectedX() + island.getProtectionRange() * 2 + 16); x += 16) {
for (int z = island.getMinProtectedZ(); z < (island.getMinProtectedZ() + island.getProtectionRange() * 2 + 16); z += 16) { for (int z = island.getMinProtectedZ(); z < (island.getMinProtectedZ() + island.getProtectionRange() * 2 + 16); z += 16) {
Pair<Integer, Integer> pair = new Pair<>(world.getBlockAt(x, 0, z).getChunk().getX(), world.getBlockAt(x, 0, z).getChunk().getZ()); chunkSnapshot.add(new Pair<>(x >> 4, z >> 4));
chunkSnapshot.add(pair);
} }
} }
return chunkSnapshot; return chunkSnapshot;
@ -222,9 +248,6 @@ public class CalcIslandLevel {
this.addon.getPlayers().getDeaths(this.world, this.island.getOwner()); this.addon.getPlayers().getDeaths(this.world, this.island.getOwner());
} }
// Just lazy check for min death count.
this.result.deathHandicap = Math.min(this.result.deathHandicap, this.addon.getSettings().getMaxDeaths());
long blockAndDeathPoints = this.result.rawBlockCount; long blockAndDeathPoints = this.result.rawBlockCount;
if (this.addon.getSettings().getDeathPenalty() > 0) if (this.addon.getSettings().getDeathPenalty() > 0)
@ -308,10 +331,11 @@ public class CalcIslandLevel {
if (addon.getSettings().getBlockValues().containsKey(type)) { if (addon.getSettings().getBlockValues().containsKey(type)) {
// Specific // Specific
value = addon.getSettings().getBlockValues().get(type); value = addon.getSettings().getBlockValues().get(type);
r.add(type.toString() + ":"
+ String.format("%,d", en.getCount()) + " blocks x " + value + " = " + (value * en.getCount()));
total += (value * en.getCount());
} }
r.add(type.toString() + ":"
+ String.format("%,d", en.getCount()) + " blocks x " + value + " = " + (value * en.getCount()));
total += (value * en.getCount());
} }
r.add("Subtotal = " + total); r.add("Subtotal = " + total);
r.add(LINE_BREAK); r.add(LINE_BREAK);

5
src/main/java/world/bentobox/level/calculators/PlayerLevel.java
View File

@ -5,6 +5,7 @@ import java.util.Map;
import java.util.UUID; import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
import org.eclipse.jdt.annotation.Nullable;
import world.bentobox.bentobox.api.events.addon.AddonEvent; import world.bentobox.bentobox.api.events.addon.AddonEvent;
import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.api.user.User;
@ -34,7 +35,7 @@ public class PlayerLevel {
private CalcIslandLevel calc; private CalcIslandLevel calc;
public PlayerLevel(final Level addon, final Island island, final UUID targetPlayer, final User asker) { public PlayerLevel(final Level addon, final Island island, final UUID targetPlayer, @Nullable final User asker) {
this.addon = addon; this.addon = addon;
this.island = island; this.island = island;
this.world = island.getCenter().getWorld(); this.world = island.getCenter().getWorld();
@ -70,7 +71,7 @@ public class PlayerLevel {
// Save the results // Save the results
island.getMemberSet().forEach(m -> addon.setIslandLevel(world, m, results.getLevel())); island.getMemberSet().forEach(m -> addon.setIslandLevel(world, m, results.getLevel()));
// Display result if event is not cancelled // Display result if event is not cancelled
if (!ilce.isCancelled()) { if (!ilce.isCancelled() && asker != null) {
informPlayers(results); informPlayers(results);
} }
} }

13
src/main/java/world/bentobox/level/commands/admin/AdminLevelCommand.java
View File

@ -6,17 +6,18 @@ import java.util.Optional;
import java.util.UUID; import java.util.UUID;
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.user.User; import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.util.Util; import world.bentobox.bentobox.util.Util;
import world.bentobox.level.Level; import world.bentobox.level.Level;
public class AdminLevelCommand extends CompositeCommand { public class AdminLevelCommand extends CompositeCommand {
private final Level levelPlugin; private final Level addon;
public AdminLevelCommand(Level levelPlugin, CompositeCommand parent) { public AdminLevelCommand(Level addon, CompositeCommand parent) {
super(parent, "level"); super(parent, "level");
this.levelPlugin = levelPlugin; this.addon = addon;
} }
@Override @Override
@ -34,10 +35,10 @@ public class AdminLevelCommand extends CompositeCommand {
// Convert name to a UUID // Convert name to a UUID
final UUID playerUUID = getPlugin().getPlayers().getUUID(args.get(0)); final UUID playerUUID = getPlugin().getPlayers().getUUID(args.get(0));
if (playerUUID == null) { if (playerUUID == null) {
user.sendMessage("general.errors.unknown-player"); user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
return true; return true;
} else { } else {
levelPlugin.calculateIslandLevel(getWorld(), user, playerUUID); addon.calculateIslandLevel(getWorld(), user, playerUUID);
} }
return true; return true;
} else { } else {
@ -45,7 +46,7 @@ public class AdminLevelCommand extends CompositeCommand {
return false; return false;
} }
} }
@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) {
String lastArg = !args.isEmpty() ? args.get(args.size()-1) : ""; String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";

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

@ -4,6 +4,7 @@ import java.util.List;
import java.util.UUID; import java.util.UUID;
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.user.User; import world.bentobox.bentobox.api.user.User;
import world.bentobox.level.Level; import world.bentobox.level.Level;
@ -31,7 +32,7 @@ public class IslandLevelCommand extends CompositeCommand {
// Convert name to a UUID // Convert name to a UUID
final UUID playerUUID = getPlugin().getPlayers().getUUID(args.get(0)); final UUID playerUUID = getPlugin().getPlayers().getUUID(args.get(0));
if (playerUUID == null) { if (playerUUID == null) {
user.sendMessage("general.errors.unknown-player"); user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
return true; return true;
} else if (user.getUniqueId().equals(playerUUID) ) { } else if (user.getUniqueId().equals(playerUUID) ) {
return this.calculateLevel(user); return this.calculateLevel(user);

149
src/main/java/world/bentobox/level/config/Settings.java
View File

@ -1,6 +1,5 @@
package world.bentobox.level.config; package world.bentobox.level.config;
import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -14,6 +13,7 @@ import world.bentobox.level.Level;
public class Settings { public class Settings {
private Level level;
private boolean sumTeamDeaths; private boolean sumTeamDeaths;
private Map<Material, Integer> blockLimits = new HashMap<>(); private Map<Material, Integer> blockLimits = new HashMap<>();
private Map<Material, Integer> blockValues = new HashMap<>(); private Map<Material, Integer> blockValues = new HashMap<>();
@ -22,27 +22,49 @@ public class Settings {
private int deathpenalty; private int deathpenalty;
private long levelCost; private long levelCost;
private int levelWait; private int levelWait;
private int maxDeaths;
private boolean islandResetDeathReset; /**
private boolean teamJoinDeathReset; * Stores number of chunks that can be updated in single tick.
private List<String> gameModes = new ArrayList<>(); */
private int chunksPerTick;
/**
* Stores number of tick delay between each chunk loading.
*/
private long updateTickDelay;
private List<String> gameModes;
public Settings(Level level) { public Settings(Level level) {
this.level = level;
level.saveDefaultConfig(); level.saveDefaultConfig();
// GameModes // GameModes
gameModes = level.getConfig().getStringList("game-modes"); gameModes = level.getConfig().getStringList("game-modes");
// Level calculation chunk load speed
this.setUpdateTickDelay(level.getConfig().getLong("updatetickdelay", 1));
if (this.getUpdateTickDelay() <= 0)
{
this.setUpdateTickDelay(1);
}
// Level calculation chunk count per update
this.setChunksPerTick(level.getConfig().getInt("chunkspertick", 200));
if (this.getChunksPerTick() <= 0)
{
this.setChunksPerTick(200);
}
setLevelWait(level.getConfig().getInt("levelwait", 60)); setLevelWait(level.getConfig().getInt("levelwait", 60));
if (getLevelWait() < 0) { if (getLevelWait() < 0) {
setLevelWait(0); setLevelWait(0);
} }
setDeathpenalty(level.getConfig().getInt("deathpenalty", 0)); setDeathpenalty(level.getConfig().getInt("deathpenalty", 0));
setSumTeamDeaths(level.getConfig().getBoolean("sumteamdeaths")); setSumTeamDeaths(level.getConfig().getBoolean("sumteamdeaths"));
setMaxDeaths(level.getConfig().getInt("maxdeaths", 10));
setIslandResetDeathReset(level.getConfig().getBoolean("islandresetdeathreset", true));
setTeamJoinDeathReset(level.getConfig().getBoolean("teamjoindeathreset", true));
setUnderWaterMultiplier(level.getConfig().getDouble("underwater", 1D)); setUnderWaterMultiplier(level.getConfig().getDouble("underwater", 1D));
setLevelCost(level.getConfig().getInt("levelcost", 100)); setLevelCost(level.getConfig().getInt("levelcost", 100));
if (getLevelCost() < 1) { if (getLevelCost() < 1) {
@ -91,7 +113,7 @@ public class Settings {
worldBlockValues.put(bWorld, values); worldBlockValues.put(bWorld, values);
} }
} else { } else {
level.getLogger().severe(() -> "Level Addon: No such world : " + world); level.getLogger().severe(() -> "Level Addon: No such world in config.yml : " + world);
} }
} }
} }
@ -182,44 +204,6 @@ public class Settings {
private void setLevelWait(int levelWait) { private void setLevelWait(int levelWait) {
this.levelWait = levelWait; this.levelWait = levelWait;
} }
/**
* TODO: Use max deaths
* @return the maxDeaths
*/
public final int getMaxDeaths() {
return maxDeaths;
}
/**
* @param maxDeaths the maxDeaths to set
*/
private void setMaxDeaths(int maxDeaths) {
this.maxDeaths = maxDeaths;
}
/**
* @return the islandResetDeathReset
*/
public final boolean isIslandResetDeathReset() {
return islandResetDeathReset;
}
/**
* @param islandResetDeathReset the islandResetDeathReset to set
*/
private void setIslandResetDeathReset(boolean islandResetDeathReset) {
this.islandResetDeathReset = islandResetDeathReset;
}
/**
* @return the teamJoinDeathReset
*/
public final boolean isTeamJoinDeathReset() {
return teamJoinDeathReset;
}
/**
* @param teamJoinDeathReset the teamJoinDeathReset to set
*/
private void setTeamJoinDeathReset(boolean teamJoinDeathReset) {
this.teamJoinDeathReset = teamJoinDeathReset;
}
/** /**
* @return the worldBlockValues * @return the worldBlockValues
*/ */
@ -234,4 +218,73 @@ public class Settings {
return gameModes; return gameModes;
} }
/**
* @return if the nether island should be included in the level calc or not
*/
public boolean isNether() {
return level.getConfig().getBoolean("nether");
}
/**
* @return if the end island should be included in the level calc or not
*/
public boolean isEnd() {
return level.getConfig().getBoolean("end");
}
/**
* @return true if level should be calculated on login
*/
public boolean isLogin() {
return level.getConfig().getBoolean("login");
}
/**
* @return true if levels should be shown in shorthand notation, e.g., 10,234 -> 10k
*/
public boolean isShortHand() {
return level.getConfig().getBoolean("shorthand");
}
/**
* This method returns the number of chunks that can be processed at single tick.
* @return the value of chunksPerTick.
*/
public int getChunksPerTick()
{
return this.chunksPerTick;
}
/**
* This method sets the chunksPerTick value.
* @param chunksPerTick the chunksPerTick new value.
*
*/
public void setChunksPerTick(int chunksPerTick)
{
this.chunksPerTick = chunksPerTick;
}
/**
* This method returns the delay between each update call.
* @return the value of updateTickDelay.
*/
public long getUpdateTickDelay()
{
return this.updateTickDelay;
}
/**
* This method sets the updateTickDelay value.
* @param updateTickDelay the updateTickDelay new value.
*
*/
public void setUpdateTickDelay(long updateTickDelay)
{
this.updateTickDelay = updateTickDelay;
}
} }

7
src/main/java/world/bentobox/level/listeners/IslandTeamListeners.java
View File

@ -100,6 +100,13 @@ public class IslandTeamListeners implements Listener {
private void zeroLevel(Island island) { private void zeroLevel(Island island) {
if (cil.containsKey(island)) { if (cil.containsKey(island)) {
long level = cil.get(island).getResult().getLevel(); long level = cil.get(island).getResult().getLevel();
// Get deaths
int deaths = addon.getPlayers().getDeaths(island.getWorld(), island.getOwner());
// Death penalty calculation.
if (addon.getSettings().getLevelCost() != 0) {
// Add the deaths because this makes the original island that much "bigger"
level += deaths * addon.getSettings().getDeathPenalty() / addon.getSettings().getLevelCost();
}
addon.setInitialIslandLevel(island, level); addon.setInitialIslandLevel(island, level);
cil.remove(island); cil.remove(island);
} }

8
src/main/java/world/bentobox/level/listeners/JoinLeaveListener.java
View File

@ -28,6 +28,14 @@ public class JoinLeaveListener implements Listener {
public void onPlayerJoin(PlayerJoinEvent e) { public void onPlayerJoin(PlayerJoinEvent e) {
// Load player into cache // Load player into cache
addon.getLevelsData(e.getPlayer().getUniqueId()); addon.getLevelsData(e.getPlayer().getUniqueId());
// If level calc on login is enabled, run through all the worlds and calculate the level
if (addon.getSettings().isLogin()) {
addon.getPlugin().getAddonsManager().getGameModeAddons().stream()
.filter(gm -> addon.getSettings().getGameModes().contains(gm.getDescription().getName()))
.forEach(gm -> {
addon.calculateIslandLevel(gm.getOverWorld(), null, e.getPlayer().getUniqueId());
});
}
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)

8
src/main/java/world/bentobox/level/objects/LevelsData.java
View File

@ -1,7 +1,7 @@
package world.bentobox.level.objects; package world.bentobox.level.objects;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.TreeMap;
import java.util.UUID; import java.util.UUID;
import org.bukkit.World; import org.bukkit.World;
@ -20,12 +20,12 @@ public class LevelsData implements DataObject {
* Map of world name and island level * Map of world name and island level
*/ */
@Expose @Expose
private Map<String, Long> levels = new HashMap<>(); private Map<String, Long> levels = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
/** /**
* Map of world name to island initial level * Map of world name to island initial level
*/ */
@Expose @Expose
private Map<String, Long> initialLevel = new HashMap<>(); private Map<String, Long> initialLevel = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
public LevelsData() {} // For Bean loading public LevelsData() {} // For Bean loading
@ -89,7 +89,7 @@ public class LevelsData implements DataObject {
* @param level - level * @param level - level
*/ */
public void setInitialLevel(World world, long level) { public void setInitialLevel(World world, long level) {
this.initialLevel.put(world.getName(), level); this.initialLevel.put(world.getName(), level);
} }
/** /**

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

@ -24,6 +24,8 @@ public class TopTenData implements DataObject {
private Map<UUID, Long> topTen = new LinkedHashMap<>(); private Map<UUID, Long> topTen = new LinkedHashMap<>();
public Map<UUID, Long> getTopTen() { public Map<UUID, Long> getTopTen() {
// Remove any entries that have level values less than 1
topTen.values().removeIf(l -> l < 1);
return topTen.entrySet().stream() return topTen.entrySet().stream()
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).limit(10) .sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).limit(10)
.collect(Collectors.toMap( .collect(Collectors.toMap(
@ -36,12 +38,14 @@ public class TopTenData implements DataObject {
@Override @Override
public String getUniqueId() { public String getUniqueId() {
// This is the world name
return uniqueId; return uniqueId;
} }
@Override @Override
public void setUniqueId(String uniqueId) { public void setUniqueId(String uniqueId) {
this.uniqueId = uniqueId; // This is the world name - make it always lowercase
this.uniqueId = uniqueId.toLowerCase();
} }
/** /**

5
src/main/java/world/bentobox/level/placeholders/LevelPlaceholder.java
View File

@ -1,6 +1,3 @@
/**
*
*/
package world.bentobox.level.placeholders; package world.bentobox.level.placeholders;
import world.bentobox.bentobox.api.addons.GameModeAddon; import world.bentobox.bentobox.api.addons.GameModeAddon;
@ -32,7 +29,7 @@ public class LevelPlaceholder implements PlaceholderReplacer {
*/ */
@Override @Override
public String onReplace(User user) { public String onReplace(User user) {
return String.valueOf(addon.getIslandLevel(gm.getOverWorld(), user.getUniqueId())); return addon.getLevelPresenter().getLevelString(addon.getIslandLevel(gm.getOverWorld(), user.getUniqueId()));
} }
} }

3
src/main/java/world/bentobox/level/placeholders/TopTenNamePlaceholder.java
View File

@ -1,6 +1,3 @@
/**
*
*/
package world.bentobox.level.placeholders; package world.bentobox.level.placeholders;
import java.util.Collection; import java.util.Collection;

3
src/main/java/world/bentobox/level/placeholders/TopTenPlaceholder.java
View File

@ -1,6 +1,3 @@
/**
*
*/
package world.bentobox.level.placeholders; package world.bentobox.level.placeholders;
import java.util.Collection; import java.util.Collection;

54
src/main/java/world/bentobox/level/requests/TopTenRequestHandler.java
View File

@ -16,26 +16,26 @@ import world.bentobox.level.objects.TopTenData;
*/ */
public class TopTenRequestHandler extends AddonRequestHandler { public class TopTenRequestHandler extends AddonRequestHandler {
/** /**
* The level addon field. * The level addon field.
*/ */
private Level addon; private Level addon;
/** /**
* This constructor creates a new TopTenRequestHandler instance. * This constructor creates a new TopTenRequestHandler instance.
* *
* @param addon of type Level * @param addon of type Level
*/ */
public TopTenRequestHandler(Level addon) { public TopTenRequestHandler(Level addon) {
super("top-ten-level"); super("top-ten-level");
this.addon = addon; this.addon = addon;
} }
/** /**
* @see AddonRequestHandler#handle(Map<String, Object>) * @see {@link AddonRequestHandler#handle(Map)}
*/ */
@Override @Override
public Object handle(Map<String, Object> map) { public Object handle(Map<String, Object> map) {
/* /*
What we need in the map: What we need in the map:
@ -47,14 +47,14 @@ public class TopTenRequestHandler extends AddonRequestHandler {
- the map of top ten player UUIDs and their island levels. Can be less then 10. - the map of top ten player UUIDs and their island levels. Can be less then 10.
*/ */
if (map == null || map.isEmpty() if (map == null || map.isEmpty()
|| map.get("world-name") == null || !(map.get("world-name") instanceof String) || map.get("world-name") == null || !(map.get("world-name") instanceof String)
|| Bukkit.getWorld((String) map.get("world-name")) == null) { || Bukkit.getWorld((String) map.get("world-name")) == null) {
return Collections.emptyMap(); return Collections.emptyMap();
} }
// Null-point check. // Null-point check.
TopTenData data = addon.getTopTen().getTopTenList(Bukkit.getWorld((String) map.get("world-name"))); TopTenData data = addon.getTopTen().getTopTenList(Bukkit.getWorld((String) map.get("world-name")));
return data != null ? data.getTopTen() : Collections.emptyMap(); return data != null ? data.getTopTen() : Collections.emptyMap();
} }
} }

2
src/main/resources/addon.yml
View File

@ -1,6 +1,6 @@
name: Level name: Level
main: world.bentobox.level.Level main: world.bentobox.level.Level
version: ${version} version: ${version}${build.number}
softdepend: AcidIsland, BSkyBlock softdepend: AcidIsland, BSkyBlock

37
src/main/resources/config.yml
View File

@ -14,6 +14,21 @@ game-modes:
# Players with the permission askyblock.island.multiplier.# will have their blocks # Players with the permission askyblock.island.multiplier.# will have their blocks
# multiplied in value by that amount. # multiplied in value by that amount.
# Calculate island level on login
# This silently calculates the player's island level when they login
# This applies to all islands the player has on the server, e.g., BSkyBlock, AcidIsland
login: false
# Include nether island in level calculations.
# Warning: Enabling this mid-game will give players with an island a jump in
# island level. New islands will be correctly zeroed.
nether: false
# Include end island in level calculations
# Warning: Enabling this mid-game will give players with an island a jump in
# island level. New islands will be correctly zeroed.
end: false
# Underwater block multiplier # Underwater block multiplier
# If blocks are below sea-level, they can have a higher value. e.g. 2x # If blocks are below sea-level, they can have a higher value. e.g. 2x
# Promotes under-water development if there is a sea. Value can be fractional. # Promotes under-water development if there is a sea. Value can be fractional.
@ -25,6 +40,14 @@ levelcost: 100
# Cooldown between level requests in seconds # Cooldown between level requests in seconds
levelwait: 60 levelwait: 60
# Delay between each task that loads chunks for calculating island level.
# Increasing this will increase time to calculate island level.
updatetickdelay: 1
# Number of chunks that will be processed at the same tick.
# Decreasing this will increase time to calculate island level.
chunkspertick: 200
# Death penalty # Death penalty
# How many block values a player will lose per death. # How many block values a player will lose per death.
# Default value of 100 means that for every death, the player will lose 1 level (if levelcost is 100) # Default value of 100 means that for every death, the player will lose 1 level (if levelcost is 100)
@ -33,15 +56,11 @@ deathpenalty: 100
# Sum team deaths - if true, all the teams deaths are summed # Sum team deaths - if true, all the teams deaths are summed
# If false, only the leader's deaths counts # If false, only the leader's deaths counts
sumteamdeaths: false sumteamdeaths: false
# Max deaths # For other death related settings, see the GameModeAddon's config.yml settings.
# If player dies more than this, it doesn't count anymore
# Stops players from getting into an impossible situation
maxdeaths: 10
# Reset deaths on island reset
islandresetdeathreset: true
# Reset deaths on team join
teamjoindeathreset: true
# Shorthand island level
# Shows large level values rounded down, e.g., 10,345 -> 10k
shorthand: false
# This section lists the limits for any particular block. Blocks over this amount # This section lists the limits for any particular block. Blocks over this amount
# are not counted. # are not counted.
@ -651,7 +670,7 @@ blocks:
# If a block is not listed, the default value will be used # If a block is not listed, the default value will be used
# Prefix with world name # Prefix with world name
worlds: worlds:
AcidIsland_world: acidisland_world:
SAND: 0 SAND: 0
SANDSTONE: 0 SANDSTONE: 0
ICE: 0 ICE: 0

41
src/main/resources/locales/fr-FR.yml Normal file
View File

@ -0,0 +1,41 @@
###########################################################################################
# This is a YML file. Be careful when editing. Check your edits in a YAML checker like #
# the one at http://yaml-online-parser.appspot.com #
###########################################################################################
meta:
authors:
- plagoutte
admin:
level:
parameters: "<joueur>"
description: "calcule le niveau d'île d'un joueur"
top:
description: "affiche le top 10 des îles"
unknown-world: "&cMonde inconnu."
display: "&f[rank]. &a[name] &7- &b[level]"
island:
level:
parameters: "[joueur]"
description: "calcule le niveau de votre île ou affiche le niveau d'un [joueur]"
calculating: "&aCalcul du niveau en cours..."
island-level-is: "&aLe niveau d'île est &b[level]"
required-points-to-next-level: "&a[points] points avant le prochain niveau"
deaths: "&c([number] morts)"
cooldown: "&cVous devez attendre &b[time] &csecondes avant de pouvoir re-faire cette action"
top:
description: "affiche le top 10"
gui-title: "&aTop 10"
gui-heading: "&6[name]: &B[rank]"
island-level: "&BNiveau [level]"
warp-to: "&ATéléportation vers l'île de [name]"
value:
description: "affiche la valeur d'un bloc"
success: "§7Valeur de ce bloc : §e[value]"
success-underwater: "§7Valeur de ce bloc en dessous du niveau de la mer : §e[value]"
empty-hand: "§cIl n'y a aucun bloc dans votre main"
no-value: "§cCet objet n'a pas de valeur."

37
src/main/resources/locales/lv-LV.yml Normal file
View File

@ -0,0 +1,37 @@
###########################################################################################
# This is a YML file. Be careful when editing. Check your edits in a YAML checker like #
# the one at http://yaml-online-parser.appspot.com #
###########################################################################################
admin:
level:
parameters: "<spēlētājs>"
description: "aprēķina spēlētāja salas līmeni"
top:
description: "rādīt labākās 10 salas"
unknown-world: "&cNezināma pasaule!"
display: "&f[rank]. &a[name] &7- &b[level]"
island:
level:
parameters: "[player]"
description: "aprēķina tavas salas līmeni, vai parāda spēlētāja [player] līmeni"
calculating: "&aAprēķina līmeni..."
island-level-is: "&aSalas līmenis ir &b[level]"
required-points-to-next-level: "&aNepieciešami [points] punkti, lai sasniegtu nākošo līmeni"
deaths: "&c([number] nāves)"
cooldown: "&cTev ir jāuzgaida &b[time]&c sekundes, lai vēlreiz aprēķinātu salas līmeni!"
top:
description: "rādīt labākos 10"
gui-title: "&aLabākie 10"
gui-heading: "&6[name]: &B[rank]"
island-level: "&BLīmenis [level]"
warp-to: "&APārvietoties uz [name] salu."
value:
description: "rādīt vērtību jebkuram blokam"
success: "&7Vērtība šim blokam ir: &e[value]"
success-underwater: "&7Vērtība šim blokam zem jūras līmeņa: &e[value]"
empty-hand: "&cTev nav bloks rokās."
no-value: "&cŠim blokam/priekšmetam nav vērtības."

37
src/main/resources/locales/tr-TR.yml Normal file
View File

@ -0,0 +1,37 @@
###########################################################################################
# This is a YML file. Be careful when editing. Check your edits in a YAML checker like #
# the one at http://yaml-online-parser.appspot.com #
###########################################################################################
admin:
level:
parameters: "<player>"
description: "Bir oyuncunun ada seviyesini hesapla"
top:
description: "Ilk 10 adayı sırala"
unknown-world: "&cBilinmeyen kelime"
display: "&f[rank]. &a[name] &7- &b[level]"
island:
level:
parameters: "[player]"
description: "&7Kendi ada seviyeni hesapla veya başka oyuncunun ada seviyesini öğren"
calculating: "&aLevel hesaplanıyor..."
island-level-is: "&7Ada seviyesi &b[level]"
required-points-to-next-level: "&7Adayı yükseltmek için &a[points] &7Puan gerekiyor"
deaths: "&c(Ölümler: [number])"
cooldown: "&7Bunu tekrar yapmak için &b[time] &7beklemelisin"
top:
description: "Ilk 10 adayı sırala"
gui-title: "&aIlk 10 Ada"
gui-heading: "&6Sıralama: &3[rank]"
island-level: "&7Seviye: &a[level]"
warp-to: "&a[name] &7oyuncusunun adasına ışınlanıyor"
value:
description: "Herhangi bir bloğun değerini gösterir"
success: "&7Bu bloğun değeri: &e[value]"
success-underwater: "&7Deniz seviyesinin altındaki bu bloğun değeri: &e[value]"
empty-hand: "&cElinde hiç blok yok"
no-value: "&cBu eşyanın bir değeri yok."

44
src/test/java/world/bentobox/level/LevelPresenterTest.java
View File

@ -1,5 +1,6 @@
package world.bentobox.level; package world.bentobox.level;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@ -10,6 +11,7 @@ import org.bukkit.World;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.core.classloader.annotations.PrepareForTest;
@ -20,6 +22,7 @@ import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.managers.IslandWorldManager; import world.bentobox.bentobox.managers.IslandWorldManager;
import world.bentobox.bentobox.managers.IslandsManager; import world.bentobox.bentobox.managers.IslandsManager;
import world.bentobox.level.calculators.PlayerLevel; import world.bentobox.level.calculators.PlayerLevel;
import world.bentobox.level.config.Settings;
/** /**
* @author tastybento * @author tastybento
@ -29,14 +32,17 @@ import world.bentobox.level.calculators.PlayerLevel;
@PrepareForTest({Bukkit.class, LevelPresenter.class}) @PrepareForTest({Bukkit.class, LevelPresenter.class})
public class LevelPresenterTest { public class LevelPresenterTest {
@Mock
private BentoBox plugin; private BentoBox plugin;
@Mock
private Level addon; private Level addon;
@Mock
private PlayerLevel pl; private PlayerLevel pl;
@Mock
private Settings settings;
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
plugin = mock(BentoBox.class);
addon = mock(Level.class);
IslandWorldManager iwm = mock(IslandWorldManager.class); IslandWorldManager iwm = mock(IslandWorldManager.class);
when(plugin.getIWM()).thenReturn(iwm); when(plugin.getIWM()).thenReturn(iwm);
when(iwm.getPermissionPrefix(Mockito.any())).thenReturn("world"); when(iwm.getPermissionPrefix(Mockito.any())).thenReturn("world");
@ -48,10 +54,12 @@ public class LevelPresenterTest {
when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true); when(im.inTeam(Mockito.any(), Mockito.any())).thenReturn(true);
// team leader // team leader
when(im.getOwner(Mockito.any(), Mockito.any())).thenReturn(UUID.randomUUID()); when(im.getOwner(Mockito.any(), Mockito.any())).thenReturn(UUID.randomUUID());
pl = mock(PlayerLevel.class); // Player level
PowerMockito.whenNew(PlayerLevel.class).withAnyArguments().thenReturn(pl); PowerMockito.whenNew(PlayerLevel.class).withAnyArguments().thenReturn(pl);
// Settings
when(addon.getSettings()).thenReturn(settings);
} }
/** /**
@ -72,10 +80,32 @@ public class LevelPresenterTest {
User sender = mock(User.class); User sender = mock(User.class);
UUID targetPlayer = UUID.randomUUID(); UUID targetPlayer = UUID.randomUUID();
lp.calculateIslandLevel(world, sender, targetPlayer); lp.calculateIslandLevel(world, sender, targetPlayer);
Mockito.verify(sender).sendMessage("island.level.calculating"); Mockito.verify(sender).sendMessage("island.level.calculating");
// Verify PlayerLevel was called
Mockito.verify(pl);
} }
/**
* Test method for {@link LevelPresenter#getLevelString(long)}.
*/
@Test
public void testGetLevelStringLong() {
LevelPresenter lp = new LevelPresenter(addon, plugin);
assertEquals("123456789", lp.getLevelString(123456789L));
}
/**
* Test method for {@link LevelPresenter#getLevelString(long)}.
*/
@Test
public void testGetLevelStringLongShorthand() {
when(settings.isShortHand()).thenReturn(true);
LevelPresenter lp = new LevelPresenter(addon, plugin);
assertEquals("123.5M", lp.getLevelString(123456789L));
assertEquals("1.2k", lp.getLevelString(1234L));
assertEquals("123.5G", lp.getLevelString(123456789352L));
assertEquals("1.2T", lp.getLevelString(1234567893524L));
assertEquals("12345.7T", lp.getLevelString(12345678345345349L));
}
} }

280
src/test/java/world/bentobox/level/TopTenTest.java Normal file
View File

@ -0,0 +1,280 @@
package world.bentobox.level;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemFactory;
import org.bukkit.inventory.meta.ItemMeta;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.panels.builders.PanelBuilder;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.AbstractDatabaseHandler;
import world.bentobox.bentobox.database.DatabaseSetup;
import world.bentobox.bentobox.managers.IslandWorldManager;
import world.bentobox.bentobox.managers.IslandsManager;
import world.bentobox.bentobox.managers.PlayersManager;
import world.bentobox.level.config.Settings;
import world.bentobox.level.objects.TopTenData;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Bukkit.class, BentoBox.class, DatabaseSetup.class, PanelBuilder.class})
public class TopTenTest {
@Mock
private Level addon;
@Mock
private World world;
@Mock
private BentoBox plugin;
@Mock
private static AbstractDatabaseHandler<Object> handler;
private List<Object> topTen;
@Mock
private IslandsManager im;
@Mock
private Player player;
@Mock
private IslandWorldManager iwm;
@Mock
private User user;
@Mock
private PlayersManager pm;
@Mock
private Inventory inv;
@Mock
private LevelPresenter lp;
@Mock
private Settings settings;
@SuppressWarnings("unchecked")
@BeforeClass
public static void beforeClass() {
// This has to be done beforeClass otherwise the tests will interfere with each other
handler = mock(AbstractDatabaseHandler.class);
// Database
PowerMockito.mockStatic(DatabaseSetup.class);
DatabaseSetup dbSetup = mock(DatabaseSetup.class);
when(DatabaseSetup.getDatabase()).thenReturn(dbSetup);
when(dbSetup.getHandler(any())).thenReturn(handler);
}
@Before
public void setUp() throws Exception {
Whitebox.setInternalState(BentoBox.class, "instance", plugin);
when(addon.getPlugin()).thenReturn(plugin);
PowerMockito.mockStatic(Bukkit.class);
when(Bukkit.getWorld(anyString())).thenReturn(world);
Server server = mock(Server.class);
when(server.getPlayer(any(UUID.class))).thenReturn(player);
when(Bukkit.getServer()).thenReturn(server);
// Has perms
when(player.hasPermission(anyString())).thenReturn(true);
// Fill the top ten
TopTenData ttd = new TopTenData();
ttd.setUniqueId("world");
topTen = new ArrayList<>();
for (long i = -100; i < 100; i ++) {
ttd.addLevel(UUID.randomUUID(), i);
topTen.add(ttd);
}
when(handler.loadObjects()).thenReturn(topTen);
// Islands
when(addon.getIslands()).thenReturn(im);
// World
when(world.getName()).thenReturn("world");
// IWM
when(plugin.getIWM()).thenReturn(iwm);
// User
when(user.getTranslation(anyString())).thenAnswer((Answer<String>) invocation -> invocation.getArgument(0, String.class));
when(user.getTranslation(eq("island.top.gui-heading"), eq("[name]"), anyString(), eq("[rank]"), anyString())).thenReturn("gui-heading");
when(user.getTranslation(eq("island.top.island-level"),eq("[level]"), anyString())).thenReturn("island-level");
when(user.getPlayer()).thenReturn(player);
// Player Manager
when(addon.getPlayers()).thenReturn(pm);
when(pm.getName(any())).thenReturn("player1",
"player2",
"player3",
"player4",
"player5",
"player6",
"player7",
"player8",
"player9",
"player10"
);
// Mock item factory (for itemstacks)
ItemFactory itemFactory = mock(ItemFactory.class);
when(Bukkit.getItemFactory()).thenReturn(itemFactory);
ItemMeta itemMeta = mock(ItemMeta.class);
when(itemFactory.getItemMeta(any())).thenReturn(itemMeta);
// Inventory GUI
when(Bukkit.createInventory(any(), anyInt(), anyString())).thenReturn(inv);
// Level presenter
when(addon.getLevelPresenter()).thenReturn(lp);
when(lp.getLevelString(anyLong())).thenAnswer((Answer<String>) invocation -> String.valueOf(invocation.getArgument(0, Long.class)));
}
@Test
public void testTopTen() {
new TopTen(addon);
PowerMockito.verifyStatic(Bukkit.class, times(200)); // 1
Bukkit.getWorld(eq("world"));
}
@Test
public void testTopTenNullWorld() {
when(Bukkit.getWorld(anyString())).thenReturn(null);
new TopTen(addon);
verify(addon, times(200)).logError("TopTen world world is not known on server. Skipping...");
}
@Test
public void testAddEntryNotOwner() throws Exception {
// Database
when(handler.loadObjects()).thenReturn(new ArrayList<>());
TopTen tt = new TopTen(addon);
UUID ownerUUID = UUID.randomUUID();
tt.addEntry(world, ownerUUID, 200L);
assertEquals(0, tt.getTopTenList(world).getTopTen().size());
}
@Test
public void testAddEntryIsOwner() throws Exception {
when(im.isOwner(any(), any())).thenReturn(true);
when(handler.loadObjects()).thenReturn(new ArrayList<>());
TopTen tt = new TopTen(addon);
UUID ownerUUID = UUID.randomUUID();
tt.addEntry(world, ownerUUID, 200L);
assertTrue(tt.getTopTenList(world).getTopTen().get(ownerUUID) == 200L);
}
@Test
public void testAddEntryIsOwnerNoPermission() throws Exception {
when(player.hasPermission(anyString())).thenReturn(false);
when(im.isOwner(any(), any())).thenReturn(true);
when(handler.loadObjects()).thenReturn(new ArrayList<>());
TopTen tt = new TopTen(addon);
UUID ownerUUID = UUID.randomUUID();
tt.addEntry(world, ownerUUID, 200L);
assertNull(tt
.getTopTenList(world)
.getTopTen()
.get(ownerUUID));
}
@Test
public void testGetGUIFullTopTen() {
TopTen tt = new TopTen(addon);
tt.getGUI(world, user, "bskyblock");
verify(user).getTranslation(eq("island.top.gui-title"));
verify(player).openInventory(inv);
int[] SLOTS = new int[] {4, 12, 14, 19, 20, 21, 22, 23, 24, 25};
for (int i : SLOTS) {
verify(inv).setItem(eq(i), any());
}
}
@Test
public void testGetGUINoPerms() {
when(player.hasPermission(anyString())).thenReturn(false);
TopTen tt = new TopTen(addon);
tt.getGUI(world, user, "bskyblock");
verify(user).getTranslation(eq("island.top.gui-title"));
verify(player).openInventory(inv);
int[] SLOTS = new int[] {4, 12, 14, 19, 20, 21, 22, 23, 24, 25};
for (int i : SLOTS) {
verify(inv, Mockito.never()).setItem(eq(i), any());
}
}
@Test
public void testGetGUINoTopTen() throws Exception {
when(handler.loadObjects()).thenReturn(new ArrayList<>());
TopTen tt = new TopTen(addon);
tt.getGUI(world, user, "bskyblock");
verify(user).getTranslation(eq("island.top.gui-title"));
verify(player).openInventory(inv);
int[] SLOTS = new int[] {4, 12, 14, 19, 20, 21, 22, 23, 24, 25};
for (int i : SLOTS) {
verify(inv, Mockito.never()).setItem(eq(i), any());
}
}
@Test
public void testGetTopTenList() {
TopTen tt = new TopTen(addon);
TopTenData ttdList = tt.getTopTenList(world);
assertEquals(plugin, ttdList.getPlugin());
}
@Test
public void testGetTopTenListNewWorld() {
TopTen tt = new TopTen(addon);
TopTenData ttdList = tt.getTopTenList(mock(World.class));
assertEquals(plugin, ttdList.getPlugin());
}
@Test
public void testRemoveEntry() throws Exception {
// Add entry
when(im.isOwner(any(), any())).thenReturn(true);
when(handler.loadObjects()).thenReturn(new ArrayList<>());
TopTen tt = new TopTen(addon);
UUID ownerUUID = UUID.randomUUID();
tt.addEntry(world, ownerUUID, 200L);
assertTrue(tt.getTopTenList(world).getTopTen().get(ownerUUID) == 200L);
// Remove it
tt.removeEntry(world, ownerUUID);
assertNull(tt.getTopTenList(world).getTopTen().get(ownerUUID));
}
@Test
public void testSaveTopTen() throws Exception {
TopTen tt = new TopTen(addon);
tt.saveTopTen();
verify(handler).saveObject(any());
}
}

114
src/test/java/world/bentobox/level/objects/TopTenDataTest.java Normal file
View File

@ -0,0 +1,114 @@
package world.bentobox.level.objects;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
/**
* @author tastybento
*
*/
public class TopTenDataTest {
private Map<UUID, Long> topTen = new LinkedHashMap<>();
private TopTenData ttd;
private UUID uuid = UUID.randomUUID();
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
// Create a top ten map
for (long i = 0; i < 100; i++) {
topTen.put(UUID.randomUUID(), i);
}
// Add the top player
topTen.put(uuid, 100L);
// Add negative values
for (long i = 0; i < 100; i++) {
topTen.put(UUID.randomUUID(), - i);
}
ttd = new TopTenData();
}
/**
* @throws java.lang.Exception
*/
@After
public void tearDown() throws Exception {
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#getTopTen()}.
*/
@Test
public void testGetTopTen() {
assertTrue(ttd.getTopTen().isEmpty());
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#setTopTen(java.util.Map)}.
*/
@Test
public void testSetAndGetTopTen() {
ttd.setTopTen(topTen);
// Ten only
assertEquals(10, ttd.getTopTen().size());
// Check order
long i = 100;
for (long l : ttd.getTopTen().values()) {
assertEquals(i--, l);
}
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#getUniqueId()}.
*/
@Test
public void testGetUniqueId() {
assertTrue(ttd.getUniqueId().isEmpty());
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#setUniqueId(java.lang.String)}.
*/
@Test
public void testSetUniqueId() {
ttd.setUniqueId("unique");
assertEquals("unique", ttd.getUniqueId());
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#addLevel(java.util.UUID, java.lang.Long)}.
*/
@Test
public void testAddAndGetLevel() {
topTen.forEach(ttd::addLevel);
topTen.keySet().forEach(k -> {
assertTrue(topTen.get(k) == ttd.getLevel(k));
});
}
/**
* Test method for {@link world.bentobox.level.objects.TopTenData#remove(java.util.UUID)}.
*/
@Test
public void testRemove() {
ttd.remove(uuid);
// Check order
long i = 99;
for (long l : ttd.getTopTen().values()) {
assertEquals(i--, l);
}
}
}