Add ability to specify delay between each task that checks and loads chunks for level calculation.

Add ability to specify how much chunks should be loaded at the same tick.

src/main/java/world/bentobox/level/calculators/CalcIslandLevel.java

@@ -31,8 +31,8 @@ import world.bentobox.level.Level;
 
 public class CalcIslandLevel {
 
-    private static final int MAX_CHUNKS = 200;
-    private static final long SPEED = 1;
+    private final int MAX_CHUNKS;
+    private final long SPEED;
     private static final String LINE_BREAK = "==================================";
     private boolean checking;
     private final BukkitTask task;
@@ -80,6 +80,9 @@ public class CalcIslandLevel {
         // Set the initial island handicap
         result.initialLevel = addon.getInitialIslandLevel(island);
 
+        SPEED = addon.getSettings().getUpdateTickDelay();
+        MAX_CHUNKS = addon.getSettings().getChunksPerTick();
+
         // Get chunks to scan
         chunksToScan = getChunksToScan(island);
 

src/main/java/world/bentobox/level/config/Settings.java

@@ -1,6 +1,5 @@
 package world.bentobox.level.config;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -23,7 +22,19 @@ public class Settings {
     private int deathpenalty;
     private long levelCost;
     private int levelWait;
-    private List<String> gameModes = new ArrayList<>();
+
+    /**
+     * Stores number of chunks that can be updated in single tick.
+     */
+    private int chunksPerTick;
+
+    /**
+     * Stores number of tick delay between each chunk loading.
+     */
+    private long updateTickDelay;
+
+    private List<String> gameModes;
+
 
     public Settings(Level level) {
         this.level = level;
@@ -32,6 +43,22 @@ public class Settings {
         // GameModes
         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));
         if (getLevelWait() < 0) {
             setLevelWait(0);
@@ -218,4 +245,46 @@ public class Settings {
     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;
+    }
 }

src/main/resources/config.yml

@@ -40,6 +40,14 @@ levelcost: 100
 # Cooldown between level requests in seconds
 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
 # 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)