Updated Upstream (Folia)

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  # Enable version updates for github actions
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/build_1.21.4.yml

@@ -41,7 +41,7 @@ jobs:
         uses: "actions/upload-artifact@v4"
         with:
           name: "${{ env.project_id_b }} CI Artifacts"
-          path: "luminol-server/build/libs/*.jar"
+          path: "luminol-server/build/libs/*-paperclip.jar"
       - name: SetENV
         if: github.event_name != 'pull_request'
         run: sh scripts/SetENV.sh
@@ -58,7 +58,6 @@ jobs:
             ${{ env.commit_msg }}
           artifacts: |
             ${{ env.jar_dir }}
-            ${{ env.jar_dir_bundler }}
           generateReleaseNotes: true
           prerelease: ${{ env.pre }}
           makeLatest: ${{ env.make_latest }}

gradle.properties

@@ -2,7 +2,7 @@ group = me.earthme.luminol
 version=1.21.4-R0.1-SNAPSHOT
 mcVersion=1.21.4
 
-foliaRef=d3969cdc419b84e2d94c13854d4eb94ae2e0b7be
+foliaRef=29867414449cede8010bac42dc9bf31dd21eb278
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

luminol-server/minecraft-patches/features/0022-Revert-RegionizedTaskQueue-referent-counter-changes.patch

@@ -0,0 +1,381 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Thu, 20 Mar 2025 23:12:30 +0800
+Subject: [PATCH] Revert RegionizedTaskQueue referent counter changes
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedTaskQueue.java b/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
+index 745ab870310733b569681f5280895bb9798620a4..9b8d06c77aa71acbe25151d82777e5dfa4e4a5f7 100644
+--- a/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
++++ b/io/papermc/paper/threadedregions/RegionizedTaskQueue.java
+@@ -24,7 +24,7 @@ public final class RegionizedTaskQueue {
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final ServerLevel world, final int chunkX, final int chunkZ,
+                                                                final Runnable run) {
+-        return this.createChunkTask(world, chunkX, chunkZ, run, Priority.NORMAL);
++        return new PrioritisedQueue.ChunkBasedPriorityTask(world.taskQueueRegionData, chunkX, chunkZ, true, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final ServerLevel world, final int chunkX, final int chunkZ,
+@@ -34,7 +34,7 @@ public final class RegionizedTaskQueue {
+ 
+     public PrioritisedExecutor.PrioritisedTask createTickTaskQueue(final ServerLevel world, final int chunkX, final int chunkZ,
+                                                                    final Runnable run) {
+-        return this.createTickTaskQueue(world, chunkX, chunkZ, run, Priority.NORMAL);
++        return new PrioritisedQueue.ChunkBasedPriorityTask(world.taskQueueRegionData, chunkX, chunkZ, false, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createTickTaskQueue(final ServerLevel world, final int chunkX, final int chunkZ,
+@@ -73,7 +73,7 @@ public final class RegionizedTaskQueue {
+     public static final class WorldRegionTaskData {
+         private final ServerLevel world;
+         private final MultiThreadedQueue<Runnable> globalChunkTask = new MultiThreadedQueue<>();
+-        private final ConcurrentLong2ReferenceChainedHashTable<ReferenceCountData> referenceCounters = new ConcurrentLong2ReferenceChainedHashTable<>();
++        private final ConcurrentLong2ReferenceChainedHashTable<AtomicLong> referenceCounters = new ConcurrentLong2ReferenceChainedHashTable<>();
+ 
+         public WorldRegionTaskData(final ServerLevel world) {
+             this.world = world;
+@@ -99,7 +99,7 @@ public final class RegionizedTaskQueue {
+         private PrioritisedQueue getQueue(final boolean synchronise, final int chunkX, final int chunkZ, final boolean isChunkTask) {
+             final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser = this.world.regioniser;
+             final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region
+-                = synchronise ? regioniser.getRegionAtSynchronised(chunkX, chunkZ) : regioniser.getRegionAtUnsynchronised(chunkX, chunkZ);
++                    = synchronise ? regioniser.getRegionAtSynchronised(chunkX, chunkZ) : regioniser.getRegionAtUnsynchronised(chunkX, chunkZ);
+             if (region == null) {
+                 return null;
+             }
+@@ -109,13 +109,13 @@ public final class RegionizedTaskQueue {
+ 
+         private void removeTicket(final long coord) {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.removeTicketAtLevel(
+-                TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
++                    TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
+             );
+         }
+ 
+         private void addTicket(final long coord) {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.addTicketAtLevel(
+-                TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
++                    TASK_QUEUE_TICKET, coord, ChunkHolderManager.MAX_TICKET_LEVEL, Unit.INSTANCE
+             );
+         }
+ 
+@@ -123,95 +123,96 @@ public final class RegionizedTaskQueue {
+             this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.processTicketUpdates(CoordinateUtils.getChunkX(coord), CoordinateUtils.getChunkZ(coord));
+         }
+ 
+-        // note: only call on acquired referenceCountData
+-        private void ensureTicketAdded(final long coord, final ReferenceCountData referenceCountData) {
+-            if (!referenceCountData.addedTicket) {
+-                // fine if multiple threads do this, no removeTicket may be called for this coord due to reference count inc
+-                this.addTicket(coord);
+-                this.processTicketUpdates(coord);
+-                referenceCountData.addedTicket = true;
++        private void decrementReference(final AtomicLong reference, final long coord) {
++            final long val = reference.decrementAndGet();
++            if (val == 0L) {
++                final int chunkX = CoordinateUtils.getChunkX(coord);
++                final int chunkZ = CoordinateUtils.getChunkZ(coord);
++                final ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock.Node ticketLock = this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.lock(chunkX, chunkZ);
++                try {
++                    if (this.referenceCounters.remove(coord, reference) == reference) {
++                        WorldRegionTaskData.this.removeTicket(coord);
++                    } // else: race condition, something replaced our reference - not our issue anymore
++                } finally {
++                    this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.unlock(ticketLock);
++                }
++            } else if (val < 0L) {
++                throw new IllegalStateException("Reference count < 0: " + val);
+             }
+         }
+ 
+-        private void decrementReference(final ReferenceCountData referenceCountData, final long coord) {
+-            if (!referenceCountData.decreaseReferenceCount()) {
+-                return;
+-            } // else: need to remove ticket
+-
+-            // note: it is possible that another thread increments and then removes the reference before we can, so
+-            //       use ifPresent
+-            this.referenceCounters.computeIfPresent(coord, (final long keyInMap, final ReferenceCountData valueInMap) -> {
+-                if (valueInMap.referenceCount.get() != 0L) {
+-                    return valueInMap;
+-                }
+-
+-                // note: valueInMap may not be referenceCountData
+-
+-                // possible to invoke this outside of the compute call, but not required and requires additional logic
+-                WorldRegionTaskData.this.removeTicket(keyInMap);
++        private AtomicLong incrementReference(final long coord) {
++            final AtomicLong ret = this.referenceCounters.get(coord);
++            if (ret != null) {
++                // try to fast acquire counter
++                int failures = 0;
++                for (long curr = ret.get();;) {
++                    if (curr == 0L) {
++                        // failed to fast acquire as reference expired
++                        break;
++                    }
+ 
+-                return null;
+-            });
+-        }
++                    for (int i = 0; i < failures; ++i) {
++                        ConcurrentUtil.backoff();
++                    }
+ 
+-        private ReferenceCountData incrementReference(final long coord) {
+-            ReferenceCountData referenceCountData = this.referenceCounters.get(coord);
++                    if (curr == (curr = ret.compareAndExchange(curr, curr + 1L))) {
++                        return ret;
++                    }
+ 
+-            if (referenceCountData != null && referenceCountData.addCount()) {
+-                this.ensureTicketAdded(coord, referenceCountData);
+-                return referenceCountData;
++                    ++failures;
++                }
+             }
+ 
+-            referenceCountData = this.referenceCounters.compute(coord, (final long keyInMap, final ReferenceCountData valueInMap) -> {
++            // slow acquire
++            final int chunkX = CoordinateUtils.getChunkX(coord);
++            final int chunkZ = CoordinateUtils.getChunkZ(coord);
++            final ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock.Node ticketLock = this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.lock(chunkX, chunkZ);
++            final AtomicLong ret2;
++            final boolean processTicketUpdates;
++            try {
++                final AtomicLong replace = new AtomicLong(1L);
++                final AtomicLong valueInMap = this.referenceCounters.putIfAbsent(coord, replace);
+                 if (valueInMap == null) {
+-                    // sets reference count to 1
+-                    return new ReferenceCountData();
+-                }
+-                // OK if we add from 0, the remove call will use compute() and catch this race condition
+-                valueInMap.referenceCount.getAndIncrement();
+-
+-                return valueInMap;
+-            });
+-
+-            this.ensureTicketAdded(coord, referenceCountData);
+-
+-            return referenceCountData;
+-        }
+-    }
+-
+-    private static final class ReferenceCountData {
+-
+-        public final AtomicLong referenceCount = new AtomicLong(1L);
+-        public volatile boolean addedTicket;
++                    // replaced, we should usually be here
++                    this.addTicket(coord);
++                    ret2 = replace;
++                    processTicketUpdates = true;
++                } else {
++                    processTicketUpdates = false;
++                    int failures = 0;
++                    for (long curr = valueInMap.get();;) {
++                        if (curr == 0L) {
++                            // don't need to add ticket here, since ticket is only removed during the lock
++                            // we just need to replace the value in the map so that the thread removing fails and doesn't
++                            // remove the ticket (see decrementReference)
++                            this.referenceCounters.put(coord, replace);
++                            ret2 = replace;
++                            break;
++                        }
+ 
+-        // returns false if reference count is 0, otherwise increments ref count
+-        public boolean addCount() {
+-            int failures = 0;
+-            for (long curr = this.referenceCount.get();;) {
+-                for (int i = 0; i < failures; ++i) {
+-                    Thread.onSpinWait();
+-                }
++                        for (int i = 0; i < failures; ++i) {
++                            ConcurrentUtil.backoff();
++                        }
+ 
+-                if (curr == 0L) {
+-                    return false;
+-                }
++                        if (curr == (curr = valueInMap.compareAndExchange(curr, curr + 1L))) {
++                            // acquired
++                            ret2 = valueInMap;
++                            break;
++                        }
+ 
+-                if (curr == (curr = this.referenceCount.compareAndExchange(curr, curr + 1L))) {
+-                    return true;
++                        ++failures;
++                    }
+                 }
+-
+-                ++failures;
++            } finally {
++                this.world.moonrise$getChunkTaskScheduler().chunkHolderManager.ticketLockArea.unlock(ticketLock);
+             }
+-        }
+ 
+-        // returns true if new reference count is 0
+-        public boolean decreaseReferenceCount() {
+-            final long res = this.referenceCount.decrementAndGet();
+-            if (res >= 0L) {
+-                return res == 0L;
+-            } else {
+-                throw new IllegalStateException("Negative reference count");
++            if (processTicketUpdates) {
++                this.processTicketUpdates(coord);
+             }
++
++            return ret2;
+         }
+     }
+ 
+@@ -240,10 +241,10 @@ public final class RegionizedTaskQueue {
+         void split(final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser,
+                    final Long2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> into) {
+             this.tickTaskQueue.split(
+-                false, regioniser, into
++                    false, regioniser, into
+             );
+             this.chunkQueue.split(
+-                true, regioniser, into
++                    true, regioniser, into
+             );
+         }
+ 
+@@ -340,7 +341,7 @@ public final class RegionizedTaskQueue {
+                           final ThreadedRegionizer<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> regioniser,
+                           final Long2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> into) {
+             final Reference2ReferenceOpenHashMap<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>, ArrayDeque<ChunkBasedPriorityTask>[]>
+-                split = new Reference2ReferenceOpenHashMap<>();
++                    split = new Reference2ReferenceOpenHashMap<>();
+             final int shift = regioniser.sectionChunkShift;
+             synchronized (this) {
+                 this.isDestroyed = true;
+@@ -356,7 +357,7 @@ public final class RegionizedTaskQueue {
+                         final int sectionZ = task.chunkZ >> shift;
+                         final long sectionKey = CoordinateUtils.getChunkKey(sectionX, sectionZ);
+                         final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>
+-                            region = into.get(sectionKey);
++                                region = into.get(sectionKey);
+                         if (region == null) {
+                             throw new IllegalStateException();
+                         }
+@@ -378,7 +379,7 @@ public final class RegionizedTaskQueue {
+                      iterator = split.reference2ReferenceEntrySet().fastIterator();
+                      iterator.hasNext();) {
+                     final Reference2ReferenceMap.Entry<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>, ArrayDeque<ChunkBasedPriorityTask>[]>
+-                        entry = iterator.next();
++                            entry = iterator.next();
+                     final RegionTaskQueueData taskQueueData = entry.getKey().getData().getTaskQueueData();
+                     mergeInto(isChunkData ? taskQueueData.chunkQueue : taskQueueData.tickTaskQueue, entry.getValue());
+                 }
+@@ -408,7 +409,7 @@ public final class RegionizedTaskQueue {
+             final ArrayDeque<ChunkBasedPriorityTask>[] queues = this.queues;
+             final int max = Priority.IDLE.priority;
+             ChunkBasedPriorityTask task = null;
+-            ReferenceCountData referenceCounter = null;
++            AtomicLong referenceCounter = null;
+             synchronized (this) {
+                 if (this.isDestroyed) {
+                     throw new IllegalStateException("Attempting to poll from dead queue");
+@@ -440,10 +441,9 @@ public final class RegionizedTaskQueue {
+ 
+         private static final class ChunkBasedPriorityTask implements PrioritisedExecutor.PrioritisedTask {
+ 
+-            private static final ReferenceCountData REFERENCE_COUNTER_NOT_SET = new ReferenceCountData();
+-            static {
+-                REFERENCE_COUNTER_NOT_SET.referenceCount.set((long)Integer.MIN_VALUE);
+-            }
++            private static final AtomicLong REFERENCE_COUNTER_NOT_SET = new AtomicLong(-1L);
++
++
+ 
+             private final WorldRegionTaskData world;
+             private final int chunkX;
+@@ -451,8 +451,8 @@ public final class RegionizedTaskQueue {
+             private final long sectionLowerLeftCoord; // chunk coordinate
+             private final boolean isChunkTask;
+ 
+-            private volatile ReferenceCountData referenceCounter;
+-            private static final VarHandle REFERENCE_COUNTER_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "referenceCounter", ReferenceCountData.class);
++            private volatile AtomicLong referenceCounter;
++            private static final VarHandle REFERENCE_COUNTER_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "referenceCounter", AtomicLong.class);
+             private Runnable run;
+             private volatile Priority priority;
+             private static final VarHandle PRIORITY_HANDLE = ConcurrentUtil.getVarHandle(ChunkBasedPriorityTask.class, "priority", Priority.class);
+@@ -489,16 +489,16 @@ public final class RegionizedTaskQueue {
+                 return (Priority)PRIORITY_HANDLE.compareAndExchange(this, expect, update);
+             }
+ 
+-            private void setReferenceCounterPlain(final ReferenceCountData value) {
++            private void setReferenceCounterPlain(final AtomicLong value) {
+                 REFERENCE_COUNTER_HANDLE.set(this, value);
+             }
+ 
+-            private ReferenceCountData getReferenceCounterVolatile() {
+-                return (ReferenceCountData)REFERENCE_COUNTER_HANDLE.get(this);
++            private AtomicLong getReferenceCounterVolatile() {
++                return (AtomicLong)REFERENCE_COUNTER_HANDLE.get(this);
+             }
+ 
+-            private ReferenceCountData compareAndExchangeReferenceCounter(final ReferenceCountData expect, final ReferenceCountData update) {
+-                return (ReferenceCountData)REFERENCE_COUNTER_HANDLE.compareAndExchange(this, expect, update);
++            private AtomicLong compareAndExchangeReferenceCounter(final AtomicLong expect, final AtomicLong update) {
++                return (AtomicLong)REFERENCE_COUNTER_HANDLE.compareAndExchange(this, expect, update);
+             }
+ 
+             private void executeInternal() {
+@@ -515,7 +515,7 @@ public final class RegionizedTaskQueue {
+ 
+             private boolean tryComplete(final boolean cancel) {
+                 int failures = 0;
+-                for (ReferenceCountData curr = this.getReferenceCounterVolatile();;) {
++                for (AtomicLong curr = this.getReferenceCounterVolatile();;) {
+                     if (curr == null) {
+                         return false;
+                     }
+@@ -564,7 +564,7 @@ public final class RegionizedTaskQueue {
+                     return false;
+                 }
+ 
+-                final ReferenceCountData referenceCounter = this.world.incrementReference(this.sectionLowerLeftCoord);
++                final AtomicLong referenceCounter = this.world.incrementReference(this.sectionLowerLeftCoord);
+                 if (this.compareAndExchangeReferenceCounter(REFERENCE_COUNTER_NOT_SET, referenceCounter) != REFERENCE_COUNTER_NOT_SET) {
+                     // we don't expect race conditions here, so it is OK if we have to needlessly reference count
+                     this.world.decrementReference(referenceCounter, this.sectionLowerLeftCoord);
+@@ -614,7 +614,7 @@ public final class RegionizedTaskQueue {
+                 }
+             }
+ 
+-            private ReferenceCountData trySetCompleting(final int minPriority) {
++            private AtomicLong trySetCompleting(final int minPriority) {
+                 // first, try to set priority to EXECUTING
+                 for (Priority curr = this.getPriorityVolatile();;) {
+                     if (curr.isLowerPriority(minPriority)) {
+@@ -626,7 +626,7 @@ public final class RegionizedTaskQueue {
+                     } // else: continue
+                 }
+ 
+-                for (ReferenceCountData curr = this.getReferenceCounterVolatile();;) {
++                for (AtomicLong curr = this.getReferenceCounterVolatile();;) {
+                     if (curr == null) {
+                         // something acquired before us
+                         return null;
+@@ -639,7 +639,6 @@ public final class RegionizedTaskQueue {
+                     if (curr != (curr = this.compareAndExchangeReferenceCounter(curr, null))) {
+                         continue;
+                     }
+-
+                     return curr;
+                 }
+             }
+@@ -647,7 +646,7 @@ public final class RegionizedTaskQueue {
+             private void updatePriorityInQueue() {
+                 boolean synchronise = false;
+                 for (;;) {
+-                    final ReferenceCountData referenceCount = this.getReferenceCounterVolatile();
++                    final AtomicLong referenceCount = this.getReferenceCounterVolatile();
+                     if (referenceCount == REFERENCE_COUNTER_NOT_SET || referenceCount == null) {
+                         // cancelled or not queued
+                         return;

luminol-server/paper-patches/features/0004-Add-tpsbar-with-chunkhot-membar-and-region-bar.patch

@@ -22,10 +22,10 @@ index de8b9048c8395c05b8688bc9d984b8ad680f15b3..f42692cd4f0154705c3d5b030d281cfc
 +    // KioCG end
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8dff0a04937 100644
+index ac878520dc4aaa0e6a1ce8de0982d60a8397bc15..af20bc3b9cfb056beca0a341e209a4cc5e869da3 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2404,6 +2404,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2401,6 +2401,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
                  handle.expToDrop = data.getInt("expToDrop");
                  handle.keepLevel = data.getBoolean("keepLevel");
              }
@@ -41,7 +41,7 @@ index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8df
          }
      }
  
-@@ -2425,6 +2434,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2422,6 +2431,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
          data.putLong("lastPlayed", System.currentTimeMillis());
          data.putString("lastKnownName", handle.getScoreboardName());
  
@@ -57,9 +57,9 @@ index c9afcd46f6a1b74b82ed68f1df6188369cf53a73..7cb95021f547c94eae7cef0bf5b2d8df
          // Paper start - persist for use in offline save data
          if (!nbttagcompound.contains("Paper")) {
              nbttagcompound.put("Paper", new CompoundTag());
-@@ -3618,4 +3636,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     public void setDeathScreenScore(final int score) {
-         getHandle().setScore(score);
+@@ -3631,4 +3649,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void setSimplifyContainerDesyncCheck(final boolean simplifyContainerDesyncCheck) {
+         this.simplifyContainerDesyncCheck = simplifyContainerDesyncCheck;
      }
 +
 +    // KioCG start - ChunkHot

luminol-server/paper-patches/features/0007-SparklyPaper-Optimize-canSee-checks.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] SparklyPaper Optimize canSee checks
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 7cb95021f547c94eae7cef0bf5b2d8dff0a04937..b80795605a61cb0d7aa9fa7eec960d9a13d8c030 100644
+index af20bc3b9cfb056beca0a341e209a4cc5e869da3..91dd18a874ea83bed83983ecfa52decce2b163a5 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -214,7 +214,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -210,7 +210,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
      private boolean hasPlayedBefore = false;
      private final ConversationTracker conversationTracker = new ConversationTracker();
      private final Set<String> channels = new HashSet<String>();
@@ -17,7 +17,7 @@ index 7cb95021f547c94eae7cef0bf5b2d8dff0a04937..b80795605a61cb0d7aa9fa7eec960d9a
      private final Set<UUID> unlistedEntities = new HashSet<>(); // Paper - Add Listing API for Player
      private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
      private int hash = 0;
-@@ -2268,9 +2268,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2265,9 +2265,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
  
      @Override
      public boolean canSee(org.bukkit.entity.Entity entity) {

scripts/SetENV.sh

@@ -11,13 +11,10 @@ grdversion=$(prop version)
 preVersion=$(prop preVersion)
 release_tag="$mcversion-$commitid"
 jarName="$project_id-$mcversion-paperclip.jar"
-jarName_bundler="$project_id-$mcversion-bundler.jar"
 jarName_dir="luminol-server/build/libs/$jarName"
-jarName_bundler_dir="luminol-server/build/libs/$jarName_bundler"
 make_latest=$([ $preVersion = "true" ] && echo "false" || echo "true")
 
 mv luminol-server/build/libs/$project_id-paperclip-$grdversion-mojmap.jar $jarName_dir
-mv luminol-server/build/libs/$project_id-bundler-$grdversion-mojmap.jar $jarName_bundler_dir
 
 echo "project_id=$project_id" >> $GITHUB_ENV
 echo "project_id_b=$project_id_b" >> $GITHUB_ENV
@@ -28,5 +25,4 @@ echo "pre=$preVersion" >> $GITHUB_ENV
 echo "tag=$release_tag" >> $GITHUB_ENV
 echo "jar=$jarName" >> $GITHUB_ENV
 echo "jar_dir=$jarName_dir" >> $GITHUB_ENV
-echo "jar_dir_bundler=$jarName_bundler_dir" >> $GITHUB_ENV
 echo "make_latest=$make_latest" >> $GITHUB_ENV