Update Luminol

gradle.properties

@@ -2,14 +2,14 @@ group=fun.bm.lophine
 mcVersion=26.1.2
 apiVersion=26.1.2
 channel=STABLE
-clipVersion=3.0.17
-weightVersion=2.0.12
+clipVersion=3.0.18
+weightVersion=2.0.15
 # true for release, false for skip release, pre for pre-release
 release=true
 # true for push to repo, false for skip push repo, auto for detect by release value
 pushRepo=auto
 
-luminolRef=80b2a6c27bd06f252c7c797867f8d8cb77391063
+luminolRef=b672b2fbed8d0f1f7de84dfcf373482dd2e5ee51
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

lophine-server/minecraft-patches/features/0001-Server-I18n.patch

@@ -26,10 +26,10 @@ index 49c7f8194be8222e329fc3215a6aa6db0b221b11..c6c968d28e0d14a4c50e66bdd5176a00
              loadFromJson(stream, output);
          } catch (JsonParseException | IOException var7) {
 diff --git a/net/minecraft/server/Main.java b/net/minecraft/server/Main.java
-index 5b46b224bb0fea3a7e0f721ce9770657ffe0c71d..44d594da98615a8bbfb2560e0a63d2e7aab3cc7e 100644
+index 143ad4e342b184aa02b6fbbe81508e244eebc7a2..89be42b8519522398920eb424c894fd2ab8c9666 100644
 --- a/net/minecraft/server/Main.java
 +++ b/net/minecraft/server/Main.java
-@@ -154,6 +154,8 @@ public class Main {
+@@ -155,6 +155,8 @@ public class Main {
                  return;
              }
  

lophine-server/paper-patches/features/0004-Leaves-Leaves-Base-Protocol-Core.patch

@@ -8,7 +8,7 @@ As a part of : Leaves (https://github.com/LeavesMC/Leaves/blob/3e7f4a313ff0d2469
 Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 63176a938619615646f864054380752d400e1ad4..6c97fe9934e53160ed5631e37499544a614afbdc 100644
+index ba0779211405b8b83f7c7e7b1c55b3e4846029a3..5f685b07878443bfe5f63147a0728df0708d79ad 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -483,6 +483,7 @@ public final class CraftServer implements Server {

lophine-server/paper-patches/features/0006-Leaves-Leaves-Fakeplayer.patch

@@ -53,7 +53,7 @@ index 5339ff469a38d35e72ea7227503a84395462f84a..d75b4ecb24f2ea42afc82ac255775d8f
          if (nmsEntity.level() != this.getHandle().getLevel()) {
              throw new IllegalArgumentException(entity + " wasn't created with this world, you must create the entity with the world you want to add it to.");
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 6c97fe9934e53160ed5631e37499544a614afbdc..60362385861f7bac2773692344aea2986dec2f6d 100644
+index 5f685b07878443bfe5f63147a0728df0708d79ad..0eb89fc127738e02e8d4d49418b83baaffe00cbd 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -303,6 +303,7 @@ public final class CraftServer implements Server {
@@ -81,7 +81,7 @@ index 6c97fe9934e53160ed5631e37499544a614afbdc..60362385861f7bac2773692344aea298
              return false;
          }
  
-@@ -3106,6 +3108,13 @@ public final class CraftServer implements Server {
+@@ -3113,6 +3115,13 @@ public final class CraftServer implements Server {
      }
      // Leaves end - Feature API
  

lophine-server/paper-patches/features/0007-Leaves-Replay-Mod-API.patch

@@ -21,7 +21,7 @@ index e1f456b31ffda9370b63e51f343847d6f9f62263..8a0f85241cc1530aacccc8b6ea24b9de
          }
          // Leaves end - skip bot
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 60362385861f7bac2773692344aea2986dec2f6d..0aacbb75751addf46b40f2dc916b7282a635ed11 100644
+index 0eb89fc127738e02e8d4d49418b83baaffe00cbd..53e49df883ec0fab984f2329d044d12ed6b1edff 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -304,6 +304,7 @@ public final class CraftServer implements Server {
@@ -41,7 +41,7 @@ index 60362385861f7bac2773692344aea2986dec2f6d..0aacbb75751addf46b40f2dc916b7282
              @Override
              public CraftPlayer apply(ServerPlayer player) {
                  return player.getBukkitEntity();
-@@ -3179,4 +3180,11 @@ public final class CraftServer implements Server {
+@@ -3186,4 +3187,11 @@ public final class CraftServer implements Server {
          }
      }
      // Folia end - region TPS API

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

@@ -3,34 +3,34 @@ 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 interface AbstractConcurrentTable<X, Y, Z> {
+    void put(X x, Y y, Z z);
 
-    public abstract void remove(X x, Y y, Z z);
+    void remove(X x, Y y, Z z);
 
-    public abstract List<Z> getZ(X x, Y y);
+    List<Z> getZ(X x, Y y);
 
-    public abstract List<Y> getY(X x, Z z);
+    List<Y> getY(X x, Z z);
 
-    public abstract List<X> getX(Y y, Z z);
+    List<X> getX(Y y, Z z);
 
-    public abstract Map<X, Y> getXY(Z z);
+    Map<X, Y> getXY(Z z);
 
-    public abstract Map<Y, Z> getYZ(X x);
+    Map<Y, Z> getYZ(X x);
 
-    public abstract Map<X, Z> getXZ(Y y);
+    Map<X, Z> getXZ(Y y);
 
-    public abstract List<X> getAllX();
+    List<X> getAllX();
 
-    public abstract List<Y> getAllY();
+    List<Y> getAllY();
 
-    public abstract List<Z> getAllZ();
+    List<Z> getAllZ();
 
-    public abstract void clearXY(Z z);
+    void clearXY(Z z);
 
-    public abstract void clearYZ(X x);
+    void clearYZ(X x);
 
-    public abstract void clearXZ(Y y);
+    void clearXZ(Y y);
 
-    public abstract void clearAll();
+    void clearAll();
 }

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

@@ -7,7 +7,7 @@ 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> {
+public class ConcurrentTable<X, Y, Z> implements AbstractConcurrentTable<X, Y, Z> {
     protected final ConcurrentLinkedDeque<TableEntry<X, Y, Z>> data = new ConcurrentLinkedDeque<>();
     protected final boolean flagX;
     protected final boolean flagY;
@@ -60,88 +60,88 @@ public class ConcurrentTable<X, Y, Z> extends AbstractConcurrentTable<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));
+        data.removeIf(entry -> entry.x().equals(x) && entry.y().equals(y) && entry.z().equals(z));
     }
 
     @Override
     public List<Z> getZ(X x, Y y) {
         return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getY().equals(y),
-                TableEntry::getZ
+                entry -> entry.x().equals(x) && entry.y().equals(y),
+                TableEntry::z
         );
     }
 
     @Override
     public List<Y> getY(X x, Z z) {
         return filterAndCollect(
-                entry -> entry.getX().equals(x) && entry.getZ().equals(z),
-                TableEntry::getY
+                entry -> entry.x().equals(x) && entry.z().equals(z),
+                TableEntry::y
         );
     }
 
     @Override
     public List<X> getX(Y y, Z z) {
         return filterAndCollect(
-                entry -> entry.getY().equals(y) && entry.getZ().equals(z),
-                TableEntry::getX
+                entry -> entry.y().equals(y) && entry.z().equals(z),
+                TableEntry::x
         );
     }
 
     @Override
     public Map<X, Y> getXY(Z z) {
         return filterAndMap(
-                entry -> entry.getZ().equals(z),
-                TableEntry::getX,
-                TableEntry::getY
+                entry -> entry.z().equals(z),
+                TableEntry::x,
+                TableEntry::y
         );
     }
 
     @Override
     public Map<Y, Z> getYZ(X x) {
         return filterAndMap(
-                entry -> entry.getX().equals(x),
-                TableEntry::getY,
-                TableEntry::getZ
+                entry -> entry.x().equals(x),
+                TableEntry::y,
+                TableEntry::z
         );
     }
 
     @Override
     public Map<X, Z> getXZ(Y y) {
         return filterAndMap(
-                entry -> entry.getY().equals(y),
-                TableEntry::getX,
-                TableEntry::getZ
+                entry -> entry.y().equals(y),
+                TableEntry::x,
+                TableEntry::z
         );
     }
 
     @Override
     public List<X> getAllX() {
-        return collectAll(TableEntry::getX);
+        return collectAll(TableEntry::x);
     }
 
     @Override
     public List<Y> getAllY() {
-        return collectAll(TableEntry::getY);
+        return collectAll(TableEntry::y);
     }
 
     @Override
     public List<Z> getAllZ() {
-        return collectAll(TableEntry::getZ);
+        return collectAll(TableEntry::z);
     }
 
     @Override
     public void clearXY(Z z) {
-        data.removeIf(entry -> entry.getZ().equals(z));
+        data.removeIf(entry -> entry.z().equals(z));
     }
 
     @Override
     public void clearYZ(X x) {
-        data.removeIf(entry -> entry.getX().equals(x));
+        data.removeIf(entry -> entry.x().equals(x));
     }
 
     @Override
     public void clearXZ(Y y) {
-        data.removeIf(entry -> entry.getY().equals(y));
+        data.removeIf(entry -> entry.y().equals(y));
     }
 
     @Override

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

@@ -76,9 +76,9 @@ public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z>
         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());
+                removeFromIndex(xyIndex, entry.x(), entry.y(), entry.z());
+                removeFromIndex(yzIndex, entry.y(), entry.z(), entry.x());
+                removeFromIndex(zxIndex, entry.z(), entry.x(), entry.y());
             }
             return shouldRemove;
         });
@@ -86,9 +86,9 @@ public class OptimizedConcurrentTable<X, Y, Z> extends ConcurrentTable<X, Y, Z>
 
     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))) {
+                Objects.equals(entry.x(), x) &&
+                        Objects.equals(entry.y(), y) &&
+                        Objects.equals(entry.z(), z))) {
             return false;
         }
         put(x, y, z);

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

@@ -1,25 +1,4 @@
 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;
-    }
+public record TableEntry<X, Y, Z>(X x, Y y, Z z) {
 }