patches 22/44

2026-05-17 02:45:37 +08:00
parent 24a315a368
commit 5b94c79f39
61 changed files with 571 additions and 156 deletions
@@ -13,14 +13,14 @@ public class OldFeatureConfig implements IConfigModule {
    @ConfigInfo(name = "old_zombie_reinforcement")
    public static boolean oldZombieReinforcement = false;

-//    @ConfigInfo(name = "old_explosion_damage_calculator")
-//    public static boolean oldExplosionDamageCalculator = false;
+    @ConfigInfo(name = "old_explosion_damage_calculator")
+    public static boolean oldExplosionDamageCalculator = false;

    @ConfigInfo(name = "old_raid_behavior")
    public static boolean oldRaidBehavior = false;

-//    @ConfigInfo(name = "villager-void-trade", comments =
-//            """
-//                    Allow villager void trade.""")
-//    public static boolean villagerVoidTrade = false;
+    @ConfigInfo(name = "villager-void-trade", comments =
+            """
+                    Allow villager void trade.""")
+    public static boolean villagerVoidTrade = false;
 }
@@ -0,0 +1,15 @@
+package fun.bm.lophine.config.modules.function;
+
+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.TransformedConfig;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "redstone")
+public class RedStoneConfig implements IConfigModule {
+    @ConfigInfo(name = "shears_rotate", comments =
+            """
+                    Allows you to use the Shears to right-click to rotate the block.""")
+    public static boolean shears = false;
+}
@@ -0,0 +1,44 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.CommandSuggestions;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+import java.util.List;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "servux", directory = {"protocol"})
+public class ServuxProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "entity-protocol", directory = {"data"})
+    public static boolean entityProtocol = false;
+
+    @ConfigInfo(name = "hud-logger-protocol")
+    public static boolean hudLoggerProtocol = false;
+
+    @ConfigInfo(name = "hud-metadata-protocol")
+    public static boolean hudMetadataProtocol = false;
+
+    @ConfigInfo(name = "hud-metadata-share-seed")
+    public static boolean hudMetadataShareSeed = false;
+
+    @ConfigInfo(name = "structure-protocol")
+    public static boolean structureProtocol = false;
+
+    @ConfigInfo(name = "hud-enabled-loggers")
+    public static List<String> hudEnabledLoggers = List.of("tps", "mob_caps");
+
+    @ConfigInfo(name = "hud-update-interval")
+    public static int hudUpdateInterval = 1;
+
+    @ConfigInfo(name = "litematics-enabled", directory = {"litematics"})
+    public static boolean litematicsEnabled = false;
+
+    @CommandSuggestions(suggest = {"-1", "2097152"})
+    @ConfigInfo(name = "litematics-max-nbt-size", directory = {"litematics"})
+    public static int litematicsMaxNbtSize = 2097152;
+
+    @CommandSuggestions(suggest = {"-1", "1200"})
+    @ConfigInfo(name = "litematics-print-max-delay-ticks", directory = {"litematics"}, comments = "The max delay ticks for printing litematics, -1 to disable")
+    public static int maxDelay = 1200;
+}
@@ -0,0 +1,36 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractConcurrentTable<X, Y, 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 Map<X, Y> getXY(Z z);
+
+    public abstract Map<Y, Z> getYZ(X x);
+
+    public abstract Map<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();
+}
@@ -0,0 +1,182 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+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<>();
+    protected final boolean flagX;
+    protected final boolean flagY;
+    protected final boolean flagZ;
+
+    public ConcurrentTable() {
+        this(false, false, false);
+    }
+
+    public ConcurrentTable(boolean flagX, boolean flagY, boolean flagZ) {
+        this.flagX = flagX;
+        this.flagY = flagY;
+        this.flagZ = flagZ;
+    }
+
+    @Override
+    public void put(X x, Y y, Z z) {
+        put(x, y, z, false);
+    }
+
+    public void put(X x, Y y, Z z, boolean flag) {
+        if (!flag) {
+            if (flagX) {
+                List<X> datas = getX(y, z);
+                for (X x1 : datas) {
+                    if (!x1.equals(x)) {
+                        remove(x1, y, z);
+                    }
+                }
+            }
+            if (flagY) {
+                List<Y> datas = getY(x, z);
+                for (Y y1 : datas) {
+                    if (!y1.equals(y)) {
+                        remove(x, y1, z);
+                    }
+                }
+            }
+            if (flagZ) {
+                List<Z> datas = getZ(x, y);
+                for (Z z1 : datas) {
+                    if (!z1.equals(z)) {
+                        remove(x, y, z1);
+                    }
+                }
+            }
+        }
+        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 Map<X, Y> getXY(Z z) {
+        return filterAndMap(
+                entry -> entry.getZ().equals(z),
+                TableEntry::getX,
+                TableEntry::getY
+        );
+    }
+
+    @Override
+    public Map<Y, Z> getYZ(X x) {
+        return filterAndMap(
+                entry -> entry.getX().equals(x),
+                TableEntry::getY,
+                TableEntry::getZ
+        );
+    }
+
+    @Override
+    public Map<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> Map<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) {
+        Map<K, V> map = new HashMap<>();
+        for (TableEntry<X, Y, Z> entry : data) {
+            if (filter.test(entry)) {
+                map.put(keyMapper.apply(entry), valueMapper.apply(entry));
+            }
+        }
+        return map;
+    }
+
+    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;
+    }
+}
@@ -0,0 +1,207 @@
+package fun.bm.lophine.utils.concurrent;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+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<>();
+
+    public OptimizedConcurrentTable() {
+        super();
+    }
+
+    public OptimizedConcurrentTable(boolean flagX, boolean flagY, boolean flagZ) {
+        super(flagX, flagY, flagZ);
+    }
+
+    @Override
+    public void put(X x, Y y, Z z) {
+        if (flagX) {
+            List<X> datas = getX(y, z);
+            for (X x1 : datas) {
+                if (!x1.equals(x)) {
+                    remove(x1, y, z);
+                }
+            }
+        }
+        if (flagY) {
+            List<Y> datas = getY(x, z);
+            for (Y y1 : datas) {
+                if (!y1.equals(y)) {
+                    remove(x, y1, z);
+                }
+            }
+        }
+        if (flagZ) {
+            List<Z> datas = getZ(x, y);
+            for (Z z1 : datas) {
+                if (!z1.equals(z)) {
+                    remove(x, y, z1);
+                }
+            }
+        }
+        super.put(x, y, z, true);
+        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 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 Map<X, Y> getXY(Z z) {
+        return buildMapFromIndex(zxIndex.get(z), Function.identity(), Function.identity());
+    }
+
+    @Override
+    public Map<Y, Z> getYZ(X x) {
+        return buildMapFromIndex(xyIndex.get(x), Function.identity(), Function.identity());
+    }
+
+    @Override
+    public Map<X, Z> getXZ(Y y) {
+        return reverseMapFromIndex(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, S> Map<R, S> buildMapFromIndex(ConcurrentHashMap<K, Set<V>> indexMap, java.util.function.Function<K, R> keyMapper, java.util.function.Function<V, S> valueMapper) {
+        Map<R, S> result = new HashMap<>();
+        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.put(keyMapper.apply(key), valueMapper.apply(value));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private <K, V> Map<V, K> reverseMapFromIndex(ConcurrentHashMap<K, Set<V>> indexMap) {
+        Map<V, K> result = new HashMap<>();
+        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.put(value, key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
@@ -0,0 +1,25 @@
+package fun.bm.lophine.utils.concurrent;
+
+public class TableEntry<X, Y, Z> {
+    private final X x;
+    private final Y y;
+    private final 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;
+    }
+}