add some new patches

divinemc-server/src/main/java/space/bxteam/divinemc/configuration/DivineConfig.java

@@ -148,8 +148,14 @@ public class DivineConfig {
     }
 
     public static boolean optimizedDragonRespawn = true;
+    public static boolean lagCompensationEnabled = false;
+    public static boolean lagCompensationEnableForWater = false;
+    public static boolean lagCompensationEnableForLava = false;
     private static void optimizations() {
         optimizedDragonRespawn = getBoolean("settings.optimizations.optimized-dragon-respawn", optimizedDragonRespawn);
+        lagCompensationEnabled = getBoolean("settings.optimizations.lag-compensation.enabled", lagCompensationEnabled);
+        lagCompensationEnableForWater = getBoolean("settings.optimizations.lag-compensation.enable-for-water", lagCompensationEnableForWater);
+        lagCompensationEnableForLava = getBoolean("settings.optimizations.lag-compensation.enable-for-lava", lagCompensationEnableForLava);
     }
 
     public static boolean disableNonEditableSignWarning = true;

divinemc-server/src/main/java/space/bxteam/divinemc/util/LagCompensation.java

@@ -0,0 +1,113 @@
+package space.bxteam.divinemc.util;
+
+import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LagCompensation {
+    public static float tt20(float ticks, boolean limitZero) {
+        float newTicks = (float) rawTT20(ticks);
+
+        if (limitZero) return newTicks > 0 ? newTicks : 1;
+        else return newTicks;
+    }
+
+    public static int tt20(int ticks, boolean limitZero) {
+        int newTicks = (int) Math.ceil(rawTT20(ticks));
+
+        if (limitZero) return newTicks > 0 ? newTicks : 1;
+        else return newTicks;
+    }
+
+    public static double tt20(double ticks, boolean limitZero) {
+        double newTicks = rawTT20(ticks);
+
+        if (limitZero) return newTicks > 0 ? newTicks : 1;
+        else return newTicks;
+    }
+
+    public static double rawTT20(double ticks) {
+        return ticks == 0 ? 0 : ticks * TPSCalculator.getMostAccurateTPS() / TPSCalculator.MAX_TPS;
+    }
+
+    public static class TPSCalculator {
+        public static Long lastTick;
+        public static Long currentTick;
+        private static double allMissedTicks = 0;
+        private static final List<Double> tpsHistory = Collections.synchronizedList(new DoubleArrayList());
+        private static final int historyLimit = 40;
+
+        public static final int MAX_TPS = 20;
+        public static final int FULL_TICK = 50;
+
+        private TPSCalculator() {}
+
+        public static void onTick() {
+            if (currentTick != null) {
+                lastTick = currentTick;
+            }
+
+            currentTick = System.currentTimeMillis();
+            addToHistory(getTPS());
+            clearMissedTicks();
+            missedTick();
+        }
+
+        private static void addToHistory(double tps) {
+            if (tpsHistory.size() >= historyLimit) {
+                tpsHistory.removeFirst();
+            }
+
+            tpsHistory.add(tps);
+        }
+
+        public static long getMSPT() {
+            return currentTick - lastTick;
+        }
+
+        public static double getAverageTPS() {
+            double sum = 0.0;
+            for (double value : tpsHistory) {
+                sum += value;
+            }
+            return tpsHistory.isEmpty() ? 0.1 : sum / tpsHistory.size();
+        }
+
+        public static double getTPS() {
+            if (lastTick == null) return -1;
+            if (getMSPT() <= 0) return 0.1;
+
+            double tps = 1000 / (double) getMSPT();
+            return tps > MAX_TPS ? MAX_TPS : tps;
+        }
+
+        public static void missedTick() {
+            if (lastTick == null) return;
+
+            long mspt = getMSPT() <= 0 ? 50 : getMSPT();
+            double missedTicks = (mspt / (double) FULL_TICK) - 1;
+            allMissedTicks += missedTicks <= 0 ? 0 : missedTicks;
+        }
+
+        public static double getMostAccurateTPS() {
+            return Math.min(getTPS(), getAverageTPS());
+        }
+
+        public double getAllMissedTicks() {
+            return allMissedTicks;
+        }
+
+        public static int applicableMissedTicks() {
+            return (int) Math.floor(allMissedTicks);
+        }
+
+        public static void clearMissedTicks() {
+            allMissedTicks -= applicableMissedTicks();
+        }
+
+        public void resetMissedTicks() {
+            allMissedTicks = 0;
+        }
+    }
+}

divinemc-server/src/main/java/space/bxteam/divinemc/util/lithium/IterateOutwardsCache.java

@@ -0,0 +1,69 @@
+package space.bxteam.divinemc.util.lithium;
+
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import it.unimi.dsi.fastutil.longs.LongList;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import net.minecraft.core.BlockPos;
+
+/**
+ * @author 2No2Name, original implemenation by SuperCoder7979 and Gegy1000
+ */
+public class IterateOutwardsCache {
+    // POS_ZERO must not be replaced with BlockPos.ORIGIN, otherwise iterateOutwards at BlockPos.ORIGIN will not use the cache
+    public static final BlockPos POS_ZERO = new BlockPos(0,0,0);
+
+    private final ConcurrentHashMap<Long, LongArrayList> table;
+    private final int capacity;
+    private final Random random;
+
+    public IterateOutwardsCache(int capacity) {
+        this.capacity = capacity;
+        this.table = new ConcurrentHashMap<>(31);
+        this.random = new Random();
+    }
+
+    private void fillPositionsWithIterateOutwards(LongList entry, int xRange, int yRange, int zRange) {
+        // Add all positions to the cached list
+        for (BlockPos pos : BlockPos.withinManhattan(POS_ZERO, xRange, yRange, zRange)) {
+            entry.add(pos.asLong());
+        }
+    }
+
+    public LongList getOrCompute(int xRange, int yRange, int zRange) {
+        long key = BlockPos.asLong(xRange, yRange, zRange);
+
+        LongArrayList entry = this.table.get(key);
+        if (entry != null) {
+            return entry;
+        }
+
+        // Cache miss: compute and store
+        entry = new LongArrayList(128);
+
+        this.fillPositionsWithIterateOutwards(entry, xRange, yRange, zRange);
+
+        // decrease the array size, as of now it won't be modified anymore anyways
+        entry.trim();
+
+        // this might overwrite an entry as the same entry could have been computed and added during this thread's computation
+        // we do not use computeIfAbsent, as it can delay other threads for too long
+        Object previousEntry = this.table.put(key, entry);
+
+        if (previousEntry == null && this.table.size() > this.capacity) {
+            // prevent a memory leak by randomly removing about 1/8th of the elements when the exceed the desired capacity is exceeded
+            final Iterator<Long> iterator = this.table.keySet().iterator();
+            // prevent an unlikely infinite loop caused by another thread filling the table concurrently using counting
+            for (int i = -this.capacity; iterator.hasNext() && i < 5; i++) {
+                Long key2 = iterator.next();
+                // random is not threadsafe, but it doesn't matter here, because we don't need quality random numbers
+                if (this.random.nextInt(8) == 0 && key2 != key) {
+                    iterator.remove();
+                }
+            }
+        }
+
+        return entry;
+    }
+}

divinemc-server/src/main/java/space/bxteam/divinemc/util/lithium/LongList2BlockPosMutableIterable.java

@@ -0,0 +1,43 @@
+package space.bxteam.divinemc.util.lithium;
+
+import it.unimi.dsi.fastutil.longs.LongIterator;
+import it.unimi.dsi.fastutil.longs.LongList;
+import java.util.Iterator;
+import net.minecraft.core.BlockPos;
+
+/**
+ * @author 2No2Name
+ */
+public class LongList2BlockPosMutableIterable implements Iterable<BlockPos> {
+    private final LongList positions;
+    private final int xOffset, yOffset, zOffset;
+
+    public LongList2BlockPosMutableIterable(BlockPos offset, LongList posList) {
+        this.xOffset = offset.getX();
+        this.yOffset = offset.getY();
+        this.zOffset = offset.getZ();
+        this.positions = posList;
+    }
+
+    @Override
+    public Iterator<BlockPos> iterator() {
+        return new Iterator<BlockPos>() {
+            private final LongIterator it = LongList2BlockPosMutableIterable.this.positions.iterator();
+            private final BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+
+            @Override
+            public boolean hasNext() {
+                return it.hasNext();
+            }
+
+            @Override
+            public net.minecraft.core.BlockPos next() {
+                long nextPos = this.it.nextLong();
+                return this.pos.set(
+                    LongList2BlockPosMutableIterable.this.xOffset + BlockPos.getX(nextPos),
+                    LongList2BlockPosMutableIterable.this.yOffset + BlockPos.getY(nextPos),
+                    LongList2BlockPosMutableIterable.this.zOffset + BlockPos.getZ(nextPos));
+            }
+        };
+    }
+}