Update Luminol

lophine-server/src/main/java/fun/bm/lophine/config/modules/optimizations/WayPointOptimizedTableConfig.java

@@ -1,17 +0,0 @@
-package fun.bm.lophine.config.modules.optimizations;
-
-import me.earthme.luminol.config.IConfigModule;
-import me.earthme.luminol.config.flags.ConfigClassInfo;
-import me.earthme.luminol.config.flags.ConfigInfo;
-import me.earthme.luminol.config.flags.HotReloadUnsupported;
-import me.earthme.luminol.enums.EnumConfigCategory;
-
-@ConfigClassInfo(category = EnumConfigCategory.OPTIMIZATIONS, name = "waypoint")
-public class WayPointOptimizedTableConfig implements IConfigModule {
-    @HotReloadUnsupported
-    @ConfigInfo(name = "optimizedTable", comments = """
-            Should use optimized table instead of normal concurrent table for waypoints.
-            May improve performance when there are many waypoints and players.
-            When enabled, more memory is needed to store data.""")
-    public static boolean optimizedTable = false;
-}

lophine-server/src/main/java/fun/bm/lophine/config/modules/removed/RemovedConfig.java

@@ -8,6 +8,7 @@ import me.earthme.luminol.enums.EnumConfigCategory;
 
 @ConfigClassInfo(category = EnumConfigCategory.REMOVED, name = "removed_config")
 public class RemovedConfig implements IConfigModule {
+    @TransformedConfig(name = "optimizedTable", directory = {"optimizations", "waypoint"}, transform = false)
     @TransformedConfig(name = "enabled", directory = {"fixes", "end-void-ring"}, transform = false)
     @TransformedConfig(name = "enabled", directory = {"gameplay", "end_void_rings"}, transform = false)
     @TransformedConfig(name = "datapack_command_enabled", directory = {"experiment", "command"}, transform = false)

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/AbstractConcurrentTable.java

@@ -1,38 +0,0 @@
-package fun.bm.lophine.utils.concurrent;
-
-import java.util.List;
-import java.util.Map;
-
-public abstract class AbstractConcurrentTable<X, Y, Z> {
-    public abstract void putOrUpdate(X x, Y y, Z z);
-
-    public abstract void put(X x, Y y, Z z);
-
-    public abstract void remove(X x, Y y, Z z);
-
-    public abstract List<Z> getZ(X x, Y y);
-
-    public abstract List<Y> getY(X x, Z z);
-
-    public abstract List<X> getX(Y y, Z z);
-
-    public abstract List<Map.Entry<X, Y>> getXY(Z z);
-
-    public abstract List<Map.Entry<Y, Z>> getYZ(X x);
-
-    public abstract List<Map.Entry<X, Z>> getXZ(Y y);
-
-    public abstract List<X> getAllX();
-
-    public abstract List<Y> getAllY();
-
-    public abstract List<Z> getAllZ();
-
-    public abstract void clearXY(Z z);
-
-    public abstract void clearYZ(X x);
-
-    public abstract void clearXZ(Y y);
-
-    public abstract void clearAll();
-}

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/ConcurrentTable.java

@@ -1,150 +0,0 @@
-package fun.bm.lophine.utils.concurrent;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentLinkedDeque;
-import java.util.function.Predicate;
-
-public class ConcurrentTable<X, Y, Z> extends AbstractConcurrentTable<X, Y, Z> {
-    protected final ConcurrentLinkedDeque<TableEntry<X, Y, Z>> data = new ConcurrentLinkedDeque<>();
-
-    @Override
-    public void putOrUpdate(X x, Y y, Z z) {
-        for (TableEntry<X, Y, Z> entry : data) {
-            if (entry.getX().equals(x) && entry.getY().equals(y)) {
-                entry.setZ(z);
-                return;
-            }
-        }
-        this.put(x, y, z);
-    }
-
-    @Override
-    public void put(X x, Y y, Z z) {
-        data.add(new TableEntry<>(x, y, z));
-    }
-
-    @Override
-    public void remove(X x, Y y, Z z) {
-        data.removeIf(entry -> entry.getX().equals(x) && entry.getY().equals(y) && entry.getZ().equals(z));
-    }
-
-    @Override
-    public List<Z> getZ(X x, Y y) {
-        return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getY().equals(y),
-                TableEntry::getZ
-        );
-    }
-
-    @Override
-    public List<Y> getY(X x, Z z) {
-        return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getZ().equals(z),
-                TableEntry::getY
-        );
-    }
-
-    @Override
-    public List<X> getX(Y y, Z z) {
-        return filterAndCollect(
-                entry -> entry.getY().equals(y) && entry.getZ().equals(z),
-                TableEntry::getX
-        );
-    }
-
-    @Override
-    public List<Map.Entry<X, Y>> getXY(Z z) {
-        return filterAndMap(
-                entry -> entry.getZ().equals(z),
-                TableEntry::getX,
-                TableEntry::getY
-        );
-    }
-
-    @Override
-    public List<Map.Entry<Y, Z>> getYZ(X x) {
-        return filterAndMap(
-                entry -> entry.getX().equals(x),
-                TableEntry::getY,
-                TableEntry::getZ
-        );
-    }
-
-    @Override
-    public List<Map.Entry<X, Z>> getXZ(Y y) {
-        return filterAndMap(
-                entry -> entry.getY().equals(y),
-                TableEntry::getX,
-                TableEntry::getZ
-        );
-    }
-
-    @Override
-    public List<X> getAllX() {
-        return collectAll(TableEntry::getX);
-    }
-
-    @Override
-    public List<Y> getAllY() {
-        return collectAll(TableEntry::getY);
-    }
-
-    @Override
-    public List<Z> getAllZ() {
-        return collectAll(TableEntry::getZ);
-    }
-
-    @Override
-    public void clearXY(Z z) {
-        data.removeIf(entry -> entry.getZ().equals(z));
-    }
-
-    @Override
-    public void clearYZ(X x) {
-        data.removeIf(entry -> entry.getX().equals(x));
-    }
-
-    @Override
-    public void clearXZ(Y y) {
-        data.removeIf(entry -> entry.getY().equals(y));
-    }
-
-    @Override
-    public void clearAll() {
-        data.clear();
-    }
-
-    private <T> List<T> filterAndCollect(Predicate<TableEntry<X, Y, Z>> filter,
-                                         java.util.function.Function<TableEntry<X, Y, Z>, T> mapper) {
-        List<T> result = new ArrayList<>();
-        for (TableEntry<X, Y, Z> entry : data) {
-            if (filter.test(entry)) {
-                result.add(mapper.apply(entry));
-            }
-        }
-        return result;
-    }
-
-    private <K, V> List<Map.Entry<K, V>> filterAndMap(Predicate<TableEntry<X, Y, Z>> filter,
-                                                      java.util.function.Function<TableEntry<X, Y, Z>, K> keyMapper,
-                                                      java.util.function.Function<TableEntry<X, Y, Z>, V> valueMapper) {
-        List<Map.Entry<K, V>> list = new ArrayList<>();
-        for (TableEntry<X, Y, Z> entry : data) {
-            if (filter.test(entry)) {
-                list.add(new AbstractMap.SimpleEntry<>(keyMapper.apply(entry), valueMapper.apply(entry)));
-            }
-        }
-        return list;
-    }
-
-    private <T> List<T> collectAll(java.util.function.Function<TableEntry<X, Y, Z>, T> mapper) {
-        List<T> result = new ArrayList<>();
-        for (TableEntry<X, Y, Z> entry : data) {
-            result.add(mapper.apply(entry));
-        }
-        return result;
-    }
-}

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/OptimizedConcurrentTable.java

@@ -1,197 +0,0 @@
-package fun.bm.lophine.utils.concurrent;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.BiFunction;
-import java.util.function.Predicate;
-
-public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z> {
-    private final ConcurrentHashMap<X, ConcurrentHashMap<Y, Set<Z>>> xyIndex = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<Y, ConcurrentHashMap<Z, Set<X>>> yzIndex = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<Z, ConcurrentHashMap<X, Set<Y>>> zxIndex = new ConcurrentHashMap<>();
-
-    @Override
-    public void putOrUpdate(X x, Y y, Z z) {
-        boolean updated = false;
-
-        for (TableEntry<X, Y, Z> entry : data) {
-            if (entry.getX().equals(x) && entry.getY().equals(y)) {
-                removeFromIndex(xyIndex, entry.getX(), entry.getY(), entry.getZ());
-                removeFromIndex(yzIndex, entry.getY(), entry.getZ(), entry.getX());
-                removeFromIndex(zxIndex, entry.getZ(), entry.getX(), entry.getY());
-
-                entry.setZ(z);
-
-                putData(x, y, z);
-
-                updated = true;
-                break;
-            }
-        }
-
-        if (!updated) {
-            this.put(x, y, z);
-        }
-    }
-
-    private void putData(X x, Y y, Z z) {
-        xyIndex.computeIfAbsent(x, k -> new ConcurrentHashMap<>())
-                .computeIfAbsent(y, k -> ConcurrentHashMap.newKeySet()).add(z);
-        yzIndex.computeIfAbsent(y, k -> new ConcurrentHashMap<>())
-                .computeIfAbsent(z, k -> ConcurrentHashMap.newKeySet()).add(x);
-        zxIndex.computeIfAbsent(z, k -> new ConcurrentHashMap<>())
-                .computeIfAbsent(x, k -> ConcurrentHashMap.newKeySet()).add(y);
-    }
-
-
-    @Override
-    public void put(X x, Y y, Z z) {
-        super.put(x, y, z);
-        putData(x, y, z);
-    }
-
-    @Override
-    public void remove(X x, Y y, Z z) {
-        super.remove(x, y, z);
-        removeFromIndex(xyIndex, x, y, z);
-        removeFromIndex(yzIndex, y, z, x);
-        removeFromIndex(zxIndex, z, x, y);
-    }
-
-    private <K, V, T> void removeFromIndex(ConcurrentHashMap<K, ConcurrentHashMap<V, Set<T>>> index,
-                                           K key1, V key2, T value) {
-        index.computeIfPresent(key1, (k, map) -> {
-            map.computeIfPresent(key2, (k2, set) -> {
-                set.remove(value);
-                return set.isEmpty() ? null : set;
-            });
-            return map.isEmpty() ? null : map;
-        });
-    }
-
-    public void removeAll(Predicate<TableEntry<X, Y, Z>> predicate) {
-        data.removeIf(entry -> {
-            boolean shouldRemove = predicate.test(entry);
-            if (shouldRemove) {
-                removeFromIndex(xyIndex, entry.getX(), entry.getY(), entry.getZ());
-                removeFromIndex(yzIndex, entry.getY(), entry.getZ(), entry.getX());
-                removeFromIndex(zxIndex, entry.getZ(), entry.getX(), entry.getY());
-            }
-            return shouldRemove;
-        });
-    }
-
-    public boolean putIfAbsent(X x, Y y, Z z) {
-        if (data.stream().anyMatch(entry ->
-                Objects.equals(entry.getX(), x) &&
-                        Objects.equals(entry.getY(), y) &&
-                        Objects.equals(entry.getZ(), z))) {
-            return false;
-        }
-        put(x, y, z);
-        return true;
-    }
-
-    @Override
-    public List<Z> getZ(X x, Y y) {
-        Set<Z> result = xyIndex.getOrDefault(x, new ConcurrentHashMap<>()).get(y);
-        return result != null ? new ArrayList<>(result) : new ArrayList<>();
-    }
-
-    @Override
-    public List<Y> getY(X x, Z z) {
-        Set<Y> result = zxIndex.getOrDefault(z, new ConcurrentHashMap<>()).get(x);
-        return result != null ? new ArrayList<>(result) : new ArrayList<>();
-    }
-
-    public List<X> getX(Y y, Z z) {
-        Set<X> result = yzIndex.getOrDefault(y, new ConcurrentHashMap<>()).get(z);
-        return result != null ? new ArrayList<>(result) : new ArrayList<>();
-    }
-
-    @Override
-    public List<Map.Entry<X, Y>> getXY(Z z) {
-        return buildDataFromIndex(zxIndex.get(z));
-    }
-
-    @Override
-    public List<Map.Entry<Y, Z>> getYZ(X x) {
-        return buildDataFromIndex(xyIndex.get(x));
-    }
-
-    @Override
-    public List<Map.Entry<X, Z>> getXZ(Y y) {
-        return reverseDataFromIndex(yzIndex.get(y));
-    }
-
-    @Override
-    public List<X> getAllX() {
-        Set<X> resultSet = new HashSet<>(xyIndex.keySet());
-        return new ArrayList<>(resultSet);
-    }
-
-    @Override
-    public List<Y> getAllY() {
-        Set<Y> resultSet = new HashSet<>(yzIndex.keySet());
-        return new ArrayList<>(resultSet);
-    }
-
-    @Override
-    public List<Z> getAllZ() {
-        Set<Z> resultSet = new HashSet<>(zxIndex.keySet());
-        return new ArrayList<>(resultSet);
-    }
-
-
-    @Override
-    public void clearXY(Z z) {
-        super.clearXY(z);
-        zxIndex.remove(z);
-    }
-
-    @Override
-    public void clearYZ(X x) {
-        super.clearYZ(x);
-        xyIndex.remove(x);
-    }
-
-    @Override
-    public void clearXZ(Y y) {
-        super.clearXZ(y);
-        yzIndex.remove(y);
-    }
-
-    @Override
-    public void clearAll() {
-        super.clearAll();
-        xyIndex.clear();
-        yzIndex.clear();
-        zxIndex.clear();
-    }
-
-
-    private <K, V, R> List<R> buildEntriesFromIndex(ConcurrentHashMap<K, Set<V>> indexMap,
-                                                    BiFunction<K, V, R> entryCreator) {
-        List<R> result = new ArrayList<>();
-        if (indexMap != null) {
-            for (Map.Entry<K, Set<V>> entry : indexMap.entrySet()) {
-                K key = entry.getKey();
-                Set<V> valueSet = entry.getValue();
-                if (valueSet != null && !valueSet.isEmpty()) {
-                    for (V value : valueSet) {
-                        result.add(entryCreator.apply(key, value));
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    private <K, V> List<Map.Entry<K, V>> buildDataFromIndex(ConcurrentHashMap<K, Set<V>> indexMap) {
-        return buildEntriesFromIndex(indexMap, AbstractMap.SimpleEntry::new);
-    }
-
-    private <K, V> List<Map.Entry<V, K>> reverseDataFromIndex(ConcurrentHashMap<K, Set<V>> indexMap) {
-        return buildEntriesFromIndex(indexMap, (key, value) -> new AbstractMap.SimpleEntry<>(value, key));
-    }
-}

lophine-server/src/main/java/fun/bm/lophine/utils/concurrent/TableEntry.java

@@ -1,29 +0,0 @@
-package fun.bm.lophine.utils.concurrent;
-
-public class TableEntry<X, Y, Z> {
-    private final X x;
-    private final Y y;
-    private Z z;
-
-    public TableEntry(X x, Y y, Z z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-
-    public X getX() {
-        return x;
-    }
-
-    public Y getY() {
-        return y;
-    }
-
-    public Z getZ() {
-        return z;
-    }
-
-    public void setZ(Z z) {
-        this.z = z;
-    }
-}

lophine-server/src/main/java/org/leavesmc/leaves/bot/agent/configs/LocatorBarConfig.java

@@ -21,6 +21,7 @@ import com.mojang.brigadier.arguments.BoolArgumentType;
 import fun.bm.lophine.LophineLogger;
 import fun.bm.lophine.config.modules.experiment.CommandConfig;
 import fun.bm.lophine.config.modules.function.FakeplayerConfig;
+import me.earthme.luminol.utils.FoliaServerWaypointManager;
 import me.earthme.luminol.utils.NullPlugin;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.waypoints.ServerWaypointManager;
@@ -53,7 +54,7 @@ public class LocatorBarConfig extends AbstractBotConfig<Boolean, LocatorBarConfi
         }
         if (this.bot != null) {
             this.value = value;
-            ServerWaypointManager manager = this.bot.level().getWaypointManager();
+            FoliaServerWaypointManager manager = this.bot.level().getWaypointManager(); // Lophine - waypoint for adapt of luminol ver
             if (value) {
                 manager.trackWaypoint(this.bot);
             } else {