Added backwards compatibility

Author: tastybento

src/main/java/world/bentobox/level/LevelsManager.java

@@ -1,7 +1,9 @@
 package world.bentobox.level;
 
+import java.io.IOException;
 import java.math.BigInteger;
 import java.text.DecimalFormat;
+import java.text.ParseException;
 import java.time.Instant;
 import java.util.AbstractMap;
 import java.util.Collections;
@@ -26,6 +28,7 @@
 
 import world.bentobox.bentobox.database.Database;
 import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.calculators.EquationEvaluator;
 import world.bentobox.level.calculators.Results;
 import world.bentobox.level.events.IslandLevelCalculatedEvent;
 import world.bentobox.level.events.IslandPreLevelEvent;
@@ -130,7 +133,6 @@ private boolean fireIslandLevelCalcEvent(UUID targetPlayer, Island island, Resul
             return true;
         // Set the values if they were altered
         results.setLevel((Long) ilce.getKeyValues().getOrDefault("level", results.getLevel()));
-        // TODO: results.setInitialLevel((Long) ilce.getKeyValues().getOrDefault("initialLevel", results.getInitialLevel()));
         results.setInitialCount((Long) ilce.getKeyValues().getOrDefault("initialCount", results.getInitialCount()));
         results.setDeathHandicap((int) ilce.getKeyValues().getOrDefault("deathHandicap", results.getDeathHandicap()));
         results.setPointsToNextLevel(
@@ -168,25 +170,66 @@ public String formatLevel(@Nullable Long lvl) {
         return level;
     }
 
-    /**
-     * Get the initial level of the island. Used to zero island levels
-     * 
-     * @param island - island
-     * @return initial level of island
-     */
-    /*TODO
-    public long getInitialLevel(Island island) {
-        return getLevelsData(island).getInitialLevel();
-    }*/
-
     /**
      * Get the initial count of the island. Used to zero island levels
      * 
      * @param island - island
      * @return initial count of island
      */
+    @SuppressWarnings("deprecation")
     public long getInitialCount(Island island) {
-        return getLevelsData(island).getInitialCount();
+        Long initialLevel = getLevelsData(island).getInitialLevel(); // Backward compatibility check. For all new islands, this should be null.
+        Long initialCount = getLevelsData(island).getInitialCount();
+        if (initialLevel != null) {
+            // Initial level exists so convert it
+            if (initialCount == null) { // If initialCount is not null, then this is an edge case and initialCount will be used and initialLevel discarded
+                // Convert from level to count
+                initialCount = 0L;
+                try {
+                    initialCount = getNumBlocks(initialLevel);
+                } catch (Exception e) {
+                    addon.logError("Could not convert legacy initial level to count, so it will be set to 0. Error is: "
+                            + e.getLocalizedMessage());
+                    initialCount = 0L;
+                }
+            }
+            // Null out the old initial level and save
+            getLevelsData(island).setInitialLevel(null);
+            // Save
+            this.setInitialIslandCount(island, initialCount);
+        }
+        // If initialCount doesn't exist, set it to 0L
+        if (initialCount == null) {
+            initialCount = 0L;
+            getLevelsData(island).setInitialCount(0L);
+        }
+        return initialCount;
+    }
+
+    /**
+     * Runs the level calculation using the current formula until the level matches the initial value, or fails.
+     * @param initialLevel - the old initial level
+     * @return block count to obtain this level now
+     * @throws ParseException if the formula for level calc is bugged
+     * @throws IOException if the number of blocks cannot be found for this level
+     */
+    private long getNumBlocks(final long initialLevel) throws ParseException, IOException {
+        String calcString = addon.getSettings().getLevelCalc();
+        int result = -1;
+        long calculatedLevel = 0;
+        String withCost = calcString.replace("level_cost", String.valueOf(this.addon.getSettings().getLevelCost()));
+        long time = System.currentTimeMillis() + 10 * 1000; // 10 seconds
+        do {
+            result++;
+            if (System.currentTimeMillis() > time) {
+                throw new IOException("Timeout: Blocks cannot be found to create this initial level");
+            }
+            // Paste in the values to the formula
+            String withValues = withCost.replace("blocks", String.valueOf(result));
+            // Try and evaluate it
+            calculatedLevel = (long) EquationEvaluator.eval(withValues);
+        } while (calculatedLevel != initialLevel);
+        return result;
     }
 
     /**
@@ -433,23 +476,6 @@ public void removeEntry(World world, String uuid) {
         }
     }
 
-    /**
-     * Set an initial island level
-     * 
-     * @param island - the island to set. Must have a non-null world
-     * @param lv     - initial island level
-     * @deprecated Use {@link #setInitialIslandCount(Island, long)}
-     */
-    /*
-    @Deprecated
-    public void setInitialIslandLevel(@NonNull Island island, long lv) {
-        // TODO convert to a count
-        if (island.getWorld() == null)
-            return;
-        levelsCache.computeIfAbsent(island.getUniqueId(), IslandLevels::new).setInitialLevel(lv);
-        handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
-    }
-     */
     /**
      * Set an initial island count
      * 

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

@@ -118,13 +118,13 @@ public IslandLevelCalculator(Level addon, Island island, CompletableFuture<Resul
     /**
      * Calculate the level based on the raw points
      * 
-     * @param blockAndDeathPoints - raw points counted on island
+     * @param rawPoints - raw points counted on island
      * @return level of island
      */
-    private long calculateLevel(final long blockAndDeathPoints) {
+    private long calculateLevel(final long rawPoints) {
         String calcString = addon.getSettings().getLevelCalc();
         // Reduce count by initial count, if zeroing is done
-        long modifiedPoints = blockAndDeathPoints
+        long modifiedPoints = rawPoints
                 - (addon.getSettings().isZeroNewIslandLevels() ? results.initialCount.get() : 0);
         // Paste in the values to the formula
         String withValues = calcString.replace("blocks", String.valueOf(modifiedPoints)).replace("level_cost",

src/main/java/world/bentobox/level/objects/IslandLevels.java

@@ -38,14 +38,13 @@ public class IslandLevels implements DataObject {
     /**
      * Initial level
      */
-    /*
     @Expose
-    private long initialLevel;*/
+    private Long initialLevel;
     /**
      * Initial count
      */
     @Expose
-    private long initialCount;
+    private Long initialCount;
     /**
      * Points to next level
      */
@@ -241,15 +240,31 @@ public void setMdCount(Map<Object, Integer> mdCount) {
     /**
      * @return the initialCount
      */
-    public long getInitialCount() {
+    public Long getInitialCount() {
         return initialCount;
     }
 
     /**
      * @param initialCount the initialCount to set
      */
-    public void setInitialCount(long initialCount) {
+    public void setInitialCount(Long initialCount) {
         this.initialCount = initialCount;
     }
 
+    /**
+     * @return the initialLevel
+     * @deprecated only used for backwards compatibility. Use {@link #getInitialCount()} instead
+     */
+    public Long getInitialLevel() {
+        return initialLevel;
+    }
+
+    /**
+     * @param initialLevel the initialLevel to set
+     * @deprecated only used for backwards compatil
+     */
+    public void setInitialLevel(Long initialLevel) {
+        this.initialLevel = initialLevel;
+    }
+
 }

src/test/java/world/bentobox/level/LevelsManagerTest.java

@@ -128,6 +128,7 @@ public static void beforeClass() {
     /**
      * @throws java.lang.Exception
      */
+    @SuppressWarnings("deprecation")
     @Before
     public void setUp() throws Exception {
         when(addon.getPlugin()).thenReturn(plugin);
@@ -208,15 +209,18 @@ public void setUp() throws Exception {
         List<Object> islands = new ArrayList<>();
         for (long i = -5; i < 5; i ++) {
             IslandLevels il = new IslandLevels(UUID.randomUUID().toString());
-            il.setInitialCount(3);
+            il.setInitialCount(null);
             il.setLevel(i);
             il.setPointsToNextLevel(3);
+            il.setInitialLevel(26145L); // Legacy
             islands.add(il);
         }
         // Supply no island levels first (for migrate), then islands
         when(handler.loadObjects()).thenReturn(islands);
         when(handler.objectExists(anyString())).thenReturn(true);
         when(levelsData.getLevel()).thenReturn(-5L, -4L, -3L, -2L, -1L, 0L, 1L, 2L, 3L, 4L, 5L, 45678L);
+        when(levelsData.getInitialLevel()).thenReturn(26145L, -4L, -3L, -2L, -1L, 0L, 1L, 2L, 3L, 4L, 5L, 45678L);
+        when(levelsData.getInitialCount()).thenReturn(null);
         when(levelsData.getUniqueId()).thenReturn(uuid.toString());
         when(handler.loadObject(anyString())).thenReturn(levelsData );
 
@@ -279,11 +283,11 @@ public void testCalculateLevel() {
 
     /**
      * Test method for
-     * {@link world.bentobox.level.LevelsManager#getInitialLevel(world.bentobox.bentobox.database.objects.Island)}.
+     * {@link world.bentobox.level.LevelsManager#getInitialCount(world.bentobox.bentobox.database.objects.Island)}.
      */
     @Test
-    public void testGetInitialLevel() {
-        assertEquals(0, lm.getInitialCount(island));
+    public void testGetInitialCount() {
+        assertEquals(2614500L, lm.getInitialCount(island));
     }
 
     /**