Fix membar can not be stored

.github/FUNDING.yml

@@ -11,4 +11,4 @@ issuehunt: # Replace with a single IssueHunt username
 lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
 polar: # Replace with a single Polar username
 buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
-custom: https://afdian.net/a/Luminol
+custom: https://afdian.com/a/Luminol

.github/workflows/build_1.20.6.yml

@@ -59,6 +59,7 @@ jobs:
           token: "${{ secrets.GITHUB_TOKEN }}"
       - name: Push to API
         if: "!contains(github.event.commits[0].message, '[release skip]')"
+        continue-on-error: true
         env:
           secret_v2: ${{ secrets.API_KEY }}
           tag: ${{ env.tag }}

patches/api/0004-FoliaPR-Add-TPS-From-Region.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 30 Jul 2024 17:58:25 +0800
+Subject: [PATCH] FoliaPR Add TPS From Region
+
+
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 15049641b8123abf03edcbb49257fb4f3db0a5ec..0492d5738a7168b68b60dcbb24a09946a640a1a1 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -2397,6 +2397,28 @@ public final class Bukkit {
+     }
+     // Paper end
+ 
++    // Folia start
++    /**
++     * Gets the current location TPS.
++     *
++     * @param location the location for which to get the TPS
++     * @return current location TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
++     */
++    public double @Nullable [] getTPS(Location location) {
++        return server.getTPS(location);
++    }
++
++    /**
++     * Gets the current chunk TPS.
++     *
++     * @param chunk the chunk for which to get the TPS
++     * @return current chunk TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
++     */
++    public double @Nullable [] getTPS(Chunk chunk){
++        return server.getTPS(chunk);
++    }
++    // Folia end
++
+     /**
+      * Get the advancement specified by this key.
+      *
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index 1f51f80e8516cfac7ed4078ed96e535389a31f25..d5c89a7a63239e6403f1fa1429d8f5a9802883b1 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -2050,6 +2050,24 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+     double getAverageTickTime();
+     // Paper end
+ 
++    // Folia start
++    /**
++     * Gets the current location TPS.
++     *
++     * @param location the location for which to get the TPS
++     * @return current location TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
++     */
++    public double @Nullable [] getTPS(Location location);
++
++    /**
++     * Gets the current chunk TPS.
++     *
++     * @param chunk the chunk for which to get the TPS
++     * @return current chunk TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
++     */
++    public double @Nullable [] getTPS(Chunk chunk);
++    // Folia end
++
+     // Paper start
+     /**
+      * Gets the active {@link org.bukkit.command.CommandMap}

patches/server/0010-Add-a-simple-membar.patch

@@ -306,7 +306,7 @@ index 0000000000000000000000000000000000000000..a33a45194273cc1b4e4157a5449c7994
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 09bde51d3da062c5788151c15c448eaf2a02ea1b..dcdfc70e6c9b021b941a667f288ea09e3c1935e2 100644
+index 0c9b1289f445b7951a8c92c6d9effb0a7fb8ba01..b82ed9280f96bacbb87ae77a6afd5d82d8863b58 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -851,6 +851,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
@@ -318,7 +318,7 @@ index 09bde51d3da062c5788151c15c448eaf2a02ea1b..dcdfc70e6c9b021b941a667f288ea09e
          //Util.shutdownExecutors(); // Paper - moved into super
          SkullBlockEntity.clear();
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index db32beabfa7ba17b1c46d36fa1dc27bc20e06feb..25bdaec097572ee58432516ae5983f4841587046 100644
+index a8f2eddba3ac3b7c551d39e260e096067e8bdc0f..92e9860b146b6e3e1dc593bfd5bfddab3318761d 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 @@ -303,6 +303,7 @@ public class ServerPlayer extends Player {
@@ -329,3 +329,27 @@ index db32beabfa7ba17b1c46d36fa1dc27bc20e06feb..25bdaec097572ee58432516ae5983f48
  
      public io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances getViewDistances() {
          return this.viewDistances.get();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 28583ad8117167400faf3ca0dc4bc9f3f44dbedb..730887465bf9ca380ef692b4c2d4a28bc6caaaa9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2373,6 +2373,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+             //Luminol start - Tpsbar
+             getHandle().isTpsBarVisible = data.getBoolean("tpsbarVisible");
+             //Luminol end
++            //Luminol start - Membar
++            getHandle().isMemBarVisible = data.getBoolean("membarVisible");
++            //Luminol end
+         }
+     }
+ 
+@@ -2397,6 +2400,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         //Luminol start - Tpsbar
+         data.putBoolean("tpsbarVisible",handle.isTpsBarVisible);
+         //Luminol end
++        //Luminol start - Membar
++        data.putBoolean("membarVisible",handle.isMemBarVisible);
++        //Luminol end
+         // Paper start - persist for use in offline save data
+         if (!nbttagcompound.contains("Paper")) {
+             nbttagcompound.put("Paper", new CompoundTag());

patches/server/0014-Add-config-to-verify-signature-only-in-online-mode.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Stabrinai <wujiaxin752@outlook.com>
 Date: Sun, 30 Jun 2024 20:46:42 +0800
-Subject: [PATCH] Verify signature only in online-mode
+Subject: [PATCH] Add config to verify signature only in online-mode
 
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/PublickeyVerifyConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/PublickeyVerifyConfig.java

patches/server/0018-Try-fixing-folia-off-region-POI-accessing-issue.patch

@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..7812a71f05dd32646037afd22cdabf72
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java b/src/main/java/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
-index aac1df9e2c0652bc6348af0404deba7465f82d42..e9173c3fe6489bba6dfb90c71bba2e23aa838af6 100644
+index aac1df9e2c0652bc6348af0404deba7465f82d42..4dcf71e9f861596bd02902d0851ffa57ff9e4170 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/GoToPotentialJobSite.java
 @@ -49,10 +49,17 @@ public class GoToPotentialJobSite extends Behavior<Villager> {
@@ -51,7 +51,7 @@ index aac1df9e2c0652bc6348af0404deba7465f82d42..e9173c3fe6489bba6dfb90c71bba2e23
 -
 +                };
 +                if (!io.papermc.paper.util.TickThread.isTickThreadFor(serverLevel2, blockPos) && me.earthme.luminol.config.modules.fixes.FoliaPOIAccessOffRegionFixConfig.enabled)
-+                    io.papermc.paper.threadedregions.RegionizedServer.getInstance().taskQueue.queueTickTaskQueue(serverLevel, blockPos.getX() >> 4, blockPos.getZ() >> 4, scheduledRelease);
++                    io.papermc.paper.threadedregions.RegionizedServer.getInstance().taskQueue.queueTickTaskQueue(serverLevel2, blockPos.getX() >> 4, blockPos.getZ() >> 4, scheduledRelease);
 +                else
 +                    scheduledRelease.run();
 +                //Luminol end

patches/server/0020-Added-linear-region-format-from-LinearPurpur.patch

@@ -127,7 +127,7 @@ index 0000000000000000000000000000000000000000..e0adfc6422f8db2c2bb81cbe8257f049
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index ac0312d5d496ee5599ff6b002196d98b42385309..e60c8fd49d01a5acb1054b8eebc85612b8192884 100644
+index 14114e868d3547f2f2d4149312742d5e995e8959..6ead4f65a07defbb7778365ce92d891528dc67aa 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -923,7 +923,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

patches/server/0026-Pufferfish-Make-EntityCollisionContext-a-live-repres.patch

@@ -0,0 +1,99 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 19:53:42 +0800
+Subject: [PATCH] Pufferfish Make EntityCollisionContext a live representation
+
+
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java b/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java
+index 88a4a72bb390947dc17e5da09a99b2d1b3ac4621..284c76ddb9724b44bb2e93f590685c728e843e6d 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java
+@@ -17,50 +17,69 @@ public class EntityCollisionContext implements CollisionContext {
+             return defaultValue;
+         }
+     };
+-    private final boolean descending;
+-    private final double entityBottom;
+-    private final ItemStack heldItem;
+-    private final Predicate<FluidState> canStandOnFluid;
++    // Pufferfish start - remove these and pray no plugin uses them
++    // private final boolean descending;
++    // private final double entityBottom;
++    // private final ItemStack heldItem;
++    // private final Predicate<FluidState> canStandOnFluid;
++    // Pufferfish end
+     @Nullable
+     private final Entity entity;
+ 
+     protected EntityCollisionContext(boolean descending, double minY, ItemStack heldItem, Predicate<FluidState> walkOnFluidPredicate, @Nullable Entity entity) {
+-        this.descending = descending;
+-        this.entityBottom = minY;
+-        this.heldItem = heldItem;
+-        this.canStandOnFluid = walkOnFluidPredicate;
++        // Pufferfish start - remove these
++        // this.descending = descending;
++        // this.entityBottom = minY;
++        // this.heldItem = heldItem;
++        // this.canStandOnFluid = walkOnFluidPredicate;
++        // Pufferfish end
+         this.entity = entity;
+     }
+ 
+     @Deprecated
+     protected EntityCollisionContext(Entity entity) {
+-        this(
+-            entity.isDescending(),
+-            entity.getY(),
+-            entity instanceof LivingEntity ? ((LivingEntity)entity).getMainHandItem() : ItemStack.EMPTY,
+-            entity instanceof LivingEntity ? ((LivingEntity)entity)::canStandOnFluid : fluidState -> false,
+-            entity
+-        );
++        // Pufferfish start - remove this
++        // this(
++        //     entity.isDescending(),
++        //     entity.getY(),
++        //     entity instanceof LivingEntity ? ((LivingEntity)entity).getMainHandItem() : ItemStack.EMPTY,
++        //     entity instanceof LivingEntity ? ((LivingEntity)entity)::canStandOnFluid : fluidState -> false,
++        //     entity
++        // );
++        // Pufferfish end
++        this.entity = entity;
+     }
+ 
+     @Override
+     public boolean isHoldingItem(Item item) {
+-        return this.heldItem.is(item);
++        // Pufferfish start
++        Entity entity = this.entity;
++        if (entity instanceof LivingEntity livingEntity) {
++            return livingEntity.getMainHandItem().is(item);
++        }
++        return ItemStack.EMPTY.is(item);
++        // Pufferfish end
+     }
+ 
+     @Override
+     public boolean canStandOnFluid(FluidState stateAbove, FluidState state) {
+-        return this.canStandOnFluid.test(state) && !stateAbove.getType().isSame(state.getType());
++        // Pufferfish start
++        Entity entity = this.entity;
++        if (entity instanceof LivingEntity livingEntity) {
++            return livingEntity.canStandOnFluid(state) && !stateAbove.getType().isSame(state.getType());
++        }
++        return false;
++        // Pufferfish end
+     }
+ 
+     @Override
+     public boolean isDescending() {
+-        return this.descending;
++        return this.entity != null && this.entity.isDescending(); // Pufferfish
+     }
+ 
+     @Override
+     public boolean isAbove(VoxelShape shape, BlockPos pos, boolean defaultValue) {
+-        return this.entityBottom > (double)pos.getY() + shape.max(Direction.Axis.Y) - 1.0E-5F;
++        return (this.entity == null ? -Double.MAX_VALUE : entity.getY()) > (double)pos.getY() + shape.max(Direction.Axis.Y) - 1.0E-5F; // Pufferfish
+     }
+ 
+     @Nullable

patches/server/0029-Pufferfish-Use-aging-cache-for-biome-temperatures.patch

@@ -0,0 +1,178 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 19:53:42 +0800
+Subject: [PATCH] Pufferfish Use aging cache for biome temperatures
+
+
+diff --git a/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java b/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a7f297ebb569f7c1f205e967ca485be70013a714
+--- /dev/null
++++ b/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java
+@@ -0,0 +1,119 @@
++package gg.airplane.structs;
++
++import it.unimi.dsi.fastutil.HashCommon;
++
++/**
++ * A replacement for the cache used in Biome.
++ */
++public class Long2FloatAgingCache {
++
++    private static class AgingEntry {
++        private long data;
++        private float value;
++        private int uses = 0;
++        private int age = 0;
++
++        private AgingEntry(long data, float value) {
++            this.data = data;
++            this.value = value;
++        }
++
++        public void replace(long data, float flag) {
++            this.data = data;
++            this.value = flag;
++        }
++
++        public int getValue() {
++            return this.uses - (this.age >> 1); // age isn't as important as uses
++        }
++
++        public void incrementUses() {
++            this.uses = this.uses + 1 & Integer.MAX_VALUE;
++        }
++
++        public void incrementAge() {
++            this.age = this.age + 1 & Integer.MAX_VALUE;
++        }
++    }
++
++    private final AgingEntry[] entries;
++    private final int mask;
++    private final int maxDistance; // the most amount of entries to check for a value
++
++    public Long2FloatAgingCache(int size) {
++        int arraySize = HashCommon.nextPowerOfTwo(size);
++        this.entries = new AgingEntry[arraySize];
++        this.mask = arraySize - 1;
++        this.maxDistance = Math.min(arraySize, 4);
++    }
++
++    public float getValue(long data) {
++        AgingEntry curr;
++        int pos;
++
++        if ((curr = this.entries[pos = HashCommon.mix(HashCommon.long2int(data)) & this.mask]) == null) {
++            return Float.NaN;
++        } else if (data == curr.data) {
++            curr.incrementUses();
++            return curr.value;
++        }
++
++        int checked = 1; // start at 1 because we already checked the first spot above
++
++        while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) {
++            if (data == curr.data) {
++                curr.incrementUses();
++                return curr.value;
++            } else if (++checked >= this.maxDistance) {
++                break;
++            }
++        }
++
++        return Float.NaN;
++    }
++
++    public void putValue(long data, float value) {
++        AgingEntry curr;
++        int pos;
++
++        if ((curr = this.entries[pos = HashCommon.mix(HashCommon.long2int(data)) & this.mask]) == null) {
++            this.entries[pos] = new AgingEntry(data, value); // add
++            return;
++        } else if (data == curr.data) {
++            curr.incrementUses();
++            return;
++        }
++
++        int checked = 1; // start at 1 because we already checked the first spot above
++
++        while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) {
++            if (data == curr.data) {
++                curr.incrementUses();
++                return;
++            } else if (++checked >= this.maxDistance) {
++                this.forceAdd(data, value);
++                return;
++            }
++        }
++
++        this.entries[pos] = new AgingEntry(data, value); // add
++    }
++
++    private void forceAdd(long data, float value) {
++        int expectedPos = HashCommon.mix(HashCommon.long2int(data)) & this.mask;
++        AgingEntry entryToRemove = this.entries[expectedPos];
++
++        for (int i = expectedPos + 1; i < expectedPos + this.maxDistance; i++) {
++            int pos = i & this.mask;
++            AgingEntry entry = this.entries[pos];
++            if (entry.getValue() < entryToRemove.getValue()) {
++                entryToRemove = entry;
++            }
++
++            entry.incrementAge(); // use this as a mechanism to age the other entries
++        }
++
++        // remove the least used/oldest entry
++        entryToRemove.replace(data, value);
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/level/biome/Biome.java b/src/main/java/net/minecraft/world/level/biome/Biome.java
+index 15f82c9a1ce1fef2e951d1b3c7a65e64b82061ea..f9fbfb63f19decb3b15284306d7edda072e609af 100644
+--- a/src/main/java/net/minecraft/world/level/biome/Biome.java
++++ b/src/main/java/net/minecraft/world/level/biome/Biome.java
+@@ -63,13 +63,18 @@ public final class Biome {
+     private final BiomeGenerationSettings generationSettings;
+     private final MobSpawnSettings mobSettings;
+     private final BiomeSpecialEffects specialEffects;
+-    private final ThreadLocal<Long2FloatLinkedOpenHashMap> temperatureCache = ThreadLocal.withInitial(() -> Util.make(() -> {
++    // Pufferfish start - use our cache
++    private final ThreadLocal<gg.airplane.structs.Long2FloatAgingCache> temperatureCache = ThreadLocal.withInitial(() -> Util.make(() -> {
++            /*
+             Long2FloatLinkedOpenHashMap long2FloatLinkedOpenHashMap = new Long2FloatLinkedOpenHashMap(1024, 0.25F) {
+                 protected void rehash(int i) {
+                 }
+             };
+             long2FloatLinkedOpenHashMap.defaultReturnValue(Float.NaN);
+             return long2FloatLinkedOpenHashMap;
++             */
++            return new gg.airplane.structs.Long2FloatAgingCache(TEMPERATURE_CACHE_SIZE);
++            // Pufferfish end
+         }));
+ 
+     Biome(Biome.ClimateSettings weather, BiomeSpecialEffects effects, BiomeGenerationSettings generationSettings, MobSpawnSettings spawnSettings) {
+@@ -112,17 +117,15 @@ public final class Biome {
+     @Deprecated
+     public float getTemperature(BlockPos blockPos) {
+         long l = blockPos.asLong();
+-        Long2FloatLinkedOpenHashMap long2FloatLinkedOpenHashMap = this.temperatureCache.get();
+-        float f = long2FloatLinkedOpenHashMap.get(l);
++        // Pufferfish start
++        gg.airplane.structs.Long2FloatAgingCache cache = this.temperatureCache.get();
++        float f = cache.getValue(l);
+         if (!Float.isNaN(f)) {
+             return f;
+         } else {
+             float g = this.getHeightAdjustedTemperature(blockPos);
+-            if (long2FloatLinkedOpenHashMap.size() == 1024) {
+-                long2FloatLinkedOpenHashMap.removeFirstFloat();
+-            }
+-
+-            long2FloatLinkedOpenHashMap.put(l, g);
++            cache.putValue(l, g);
++            // Pufferfish end
+             return g;
+         }
+     }

patches/server/0035-Pufferfish-Skip-cloning-loot-parameters.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 20:12:08 +0800
+Subject: [PATCH] Pufferfish Skip cloning loot parameters
+
+
+diff --git a/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java b/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java
+index 37a0002bbe6539648db5219bb373e0404ae48dc0..ca0571d232e102c4b177a1ea44b96f5f0f440211 100644
+--- a/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java
++++ b/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java
+@@ -21,8 +21,10 @@ public class LootParams {
+ 
+     public LootParams(ServerLevel world, Map<LootContextParam<?>, Object> parameters, Map<ResourceLocation, LootParams.DynamicDrop> dynamicDrops, float luck) {
+         this.level = world;
+-        this.params = parameters;
+-        this.dynamicDrops = dynamicDrops;
++        // Pufferfish start - use unmodifiable maps instead of immutable ones to skip the copy
++        this.params = java.util.Collections.unmodifiableMap(parameters);
++        this.dynamicDrops = java.util.Collections.unmodifiableMap(dynamicDrops);
++        // Pufferfish end
+         this.luck = luck;
+     }
+ 

patches/server/0037-Pufferfish-Reduce-projectile-chunk-loading.patch

@@ -33,10 +33,10 @@ index 0000000000000000000000000000000000000000..12683ec5a5102e45b6171fea0b833ba5
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-index a8d2f7a9d0bcb6db0b38ac30b098d59951053b47..77eee09a301a838f21834319d4962eba1c8dcbed 100644
+index a8d2f7a9d0bcb6db0b38ac30b098d59951053b47..829b63c8a7574d6aefe95b7d190dccc4c6ecf1ba 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-@@ -46,6 +46,36 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+@@ -46,6 +46,38 @@ public abstract class Projectile extends Entity implements TraceableEntity {
          super(type, world);
      }
  
@@ -47,23 +47,25 @@ index a8d2f7a9d0bcb6db0b38ac30b098d59951053b47..77eee09a301a838f21834319d4962eba
 +    private int loadedLifetime = 0;
 +    @Override
 +    public void setPos(double x, double y, double z) {
-+        long currentTick = io.papermc.paper.threadedregions.TickRegionScheduler.getCurrentRegion().getData().getCurrentTick();
-+        if (loadedTick != currentTick) {
-+            loadedTick = currentTick;
-+            loadedThisTick = 0;
-+        }
-+        int previousX = Mth.floor(this.getX()) >> 4, previousZ = Mth.floor(this.getZ()) >> 4;
-+        int newX = Mth.floor(x) >> 4, newZ = Mth.floor(z) >> 4;
-+        if (previousX != newX || previousZ != newZ) {
-+            boolean isLoaded = ((net.minecraft.server.level.ServerChunkCache) this.level().getChunkSource()).getChunkAtIfLoadedMainThread(newX, newZ) != null;
-+            if (!isLoaded) {
-+                if (Projectile.loadedThisTick > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerTick) {
-+                    if (++this.loadedLifetime > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerProjectile) {
-+                        this.discard();
++        if (io.papermc.paper.util.TickThread.isTickThreadFor(this) && io.papermc.paper.threadedregions.TickRegionScheduler.getCurrentRegion() != null){
++            long currentTick = io.papermc.paper.threadedregions.TickRegionScheduler.getCurrentRegion().getData().getCurrentTick();
++            if (loadedTick != currentTick) {
++                loadedTick = currentTick;
++                loadedThisTick = 0;
++            }
++            int previousX = Mth.floor(this.getX()) >> 4, previousZ = Mth.floor(this.getZ()) >> 4;
++            int newX = Mth.floor(x) >> 4, newZ = Mth.floor(z) >> 4;
++            if ((previousX != newX || previousZ != newZ) && io.papermc.paper.util.TickThread.isTickThreadFor(((ServerLevel) this.level()), newX, newZ)) {
++                boolean isLoaded = ((net.minecraft.server.level.ServerChunkCache) this.level().getChunkSource()).getChunkAtIfLoadedMainThread(newX, newZ) != null;
++                if (!isLoaded) {
++                    if (Projectile.loadedThisTick > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerTick) {
++                        if (++this.loadedLifetime > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerProjectile) {
++                            this.discard();
++                        }
++                        return;
 +                    }
-+                    return;
++                    Projectile.loadedThisTick++;
 +                }
-+                Projectile.loadedThisTick++;
 +            }
 +        }
 +        super.setPos(x, y, z);

patches/server/0042-Pufferfish-Simpler-ShapelessRecipes-comparison-for-V.patch

@@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 19:53:42 +0800
+Subject: [PATCH] Pufferfish Simpler ShapelessRecipes comparison for Vanilla
+
+
+diff --git a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
+index 3554109bcc4651ca93b6275c914e57e007e2204e..60c7a9520335de8e2638572100affcfdd776c5a3 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
++++ b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
+@@ -27,8 +27,13 @@ public class ShapelessRecipe extends io.papermc.paper.inventory.recipe.RecipeBoo
+     final CraftingBookCategory category;
+     final ItemStack result;
+     final NonNullList<Ingredient> ingredients;
++    private final boolean isBukkit; // Pufferfish
+ 
++    // Pufferfish start
+     public ShapelessRecipe(String group, CraftingBookCategory category, ItemStack result, NonNullList<Ingredient> ingredients) {
++        this(group, category, result, ingredients, false);
++    }
++    public ShapelessRecipe(String group, CraftingBookCategory category, ItemStack result, NonNullList<Ingredient> ingredients, boolean isBukkit) { this.isBukkit = isBukkit; // Pufferfish end
+         this.group = group;
+         this.category = category;
+         this.result = result;
+@@ -78,6 +83,28 @@ public class ShapelessRecipe extends io.papermc.paper.inventory.recipe.RecipeBoo
+     }
+ 
+     public boolean matches(CraftingContainer inventory, Level world) {
++        // Pufferfish start
++        if (!this.isBukkit) {
++            java.util.List<Ingredient> ingredients = com.google.common.collect.Lists.newArrayList(this.ingredients.toArray(new Ingredient[0]));
++
++            inventory: for (int index = 0; index < inventory.getContainerSize(); index++) {
++                ItemStack itemStack = inventory.getItem(index);
++
++                if (!itemStack.isEmpty()) {
++                    for (int i = 0; i < ingredients.size(); i++) {
++                        if (ingredients.get(i).test(itemStack)) {
++                            ingredients.remove(i);
++                            continue inventory;
++                        }
++                    }
++                    return false;
++                }
++            }
++
++            return ingredients.isEmpty();
++        }
++        // Pufferfish end
++
+         StackedContents autorecipestackmanager = new StackedContents();
+         autorecipestackmanager.initialize(this); // Paper - better exact choice recipes
+         int i = 0;
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java
+index 96d772eb02f79f8c478f5e6f065e387aa7665b18..c5ce412f321b8b4f31cc042893659e213b081f29 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java
+@@ -45,6 +45,6 @@ public class CraftShapelessRecipe extends ShapelessRecipe implements CraftRecipe
+             data.set(i, this.toNMS(ingred.get(i), true));
+         }
+ 
+-        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.ShapelessRecipe(this.getGroup(), CraftRecipe.getCategory(this.getCategory()), CraftItemStack.asNMSCopy(this.getResult()), data)));
++        MinecraftServer.getServer().getRecipeManager().addRecipe(new RecipeHolder<>(CraftNamespacedKey.toMinecraft(this.getKey()), new net.minecraft.world.item.crafting.ShapelessRecipe(this.getGroup(), CraftRecipe.getCategory(this.getCategory()), CraftItemStack.asNMSCopy(this.getResult()), data, true))); // Pufferfish
+     }
+ }

patches/server/0054-Added-chunkhot-to-tpsbar.patch

@@ -1,72 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <novau233@163.com>
-Date: Tue, 30 Apr 2024 14:02:39 +0000
-Subject: [PATCH] Added chunkhot to tpsbar
-
-
-diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
-index aafb2f5052c7c8e5971a47308253badb3027093c..9fe7ac7ba83bbcc9a2a851a5cace47641323f4d2 100644
---- a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
-+++ b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
-@@ -12,11 +12,13 @@ public class TpsBarConfig implements IConfigModule {
-     @ConfigInfo(baseName = "enabled")
-     public static boolean tpsbarEnabled = false;
-     @ConfigInfo(baseName = "format")
--    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
-+    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms ChunkHot<yellow>:</yellow> <chunkhot>";
-     @ConfigInfo(baseName = "tps_color_list")
-     public static List<String> tpsColors = List.of("GREEN","YELLOW","RED","PURPLE");
-     @ConfigInfo(baseName = "ping_color_list")
-     public static List<String> pingColors = List.of("GREEN","YELLOW","RED","PURPLE");
-+    @ConfigInfo(baseName = "chunkhot_color_list")
-+    public static List<String> chunkHotColors = List.of("GREEN","YELLOW","RED","PURPLE");
-     @ConfigInfo(baseName = "update_interval_ticks")
-     public static int updateInterval = 15;
- 
-diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
-index 3f1478dde900d671c4bfa43df80f629519cd602e..7abde30d420ff66026d1dee017c41bc23df22b26 100644
---- a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
-+++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
-@@ -139,7 +139,8 @@ public class GlobalServerTpsBar {
-                 TpsBarConfig.tpsBarFormat,
-                 Placeholder.component("tps",getTpsComponent(tps)),
-                 Placeholder.component("mspt",getMsptComponent(mspt)),
--                Placeholder.component("ping",getPingComponent(player.getPing()))
-+                Placeholder.component("ping",getPingComponent(player.getPing())),
-+                Placeholder.component("chunkhot",getChunkHotComponent(player.getNearbyChunkHot()))
-         ));
-         bar.color(barColorFromTps(tps));
-         bar.progress((float) Math.min((float)1,Math.max(mspt / 50,0)));
-@@ -181,6 +182,32 @@ public class GlobalServerTpsBar {
-         return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", mspt)));
-     }
- 
-+    private static @NotNull Component getChunkHotComponent(long chunkHot){
-+        final BossBar.Color colorBukkit = barColorFromChunkHot(chunkHot);
-+        final String colorString = colorBukkit.name();
-+
-+        final String content = "<%s><text></%s>";
-+        final String replaced = String.format(content,colorString,colorString);
-+
-+        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(chunkHot)));
-+    }
-+
-+    private static BossBar.Color barColorFromChunkHot(long chunkHot){
-+        if (chunkHot == -1){
-+            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(3));
-+        }
-+
-+        if (chunkHot <= 300000L){
-+            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(0));
-+        }
-+
-+        if (chunkHot <= 500000L){
-+            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(1));
-+        }
-+
-+        return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(2));
-+    }
-+
-     private static BossBar.Color barColorFromMspt(double mspt){
-         if (mspt == -1){
-             return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));

patches/server/0055-SparklyPaper-Skip-MapItem-update-if-the-map-does-not.patch

@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 20:06:27 +0800
+Subject: [PATCH] SparklyPaper Skip "MapItem#update()" if the map does not have
+ the CraftMapRenderer present
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/MapItemUpdateSkipConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/MapItemUpdateSkipConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6235ff18455a21695bdc2d65367558d3936a45c5
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/MapItemUpdateSkipConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class MapItemUpdateSkipConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "skip_map_item_updates_if_no_bukkit_render";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/item/MapItem.java b/src/main/java/net/minecraft/world/item/MapItem.java
+index 957396b145b1d1adf265f8b9aaeba052758f007a..6d0f67882885373b4772b9f747e68e490dd8797e 100644
+--- a/src/main/java/net/minecraft/world/item/MapItem.java
++++ b/src/main/java/net/minecraft/world/item/MapItem.java
+@@ -281,7 +281,7 @@ public class MapItem extends ComplexItem {
+                     mapItemSavedData.tickCarriedBy(player, stack);
+                 }
+ 
+-                if (!mapItemSavedData.locked && (selected || entity instanceof Player && ((Player)entity).getOffhandItem() == stack)) {
++                if (!mapItemSavedData.locked && (!me.earthme.luminol.config.modules.optimizations.MapItemUpdateSkipConfig.enabled || mapItemSavedData.mapView.getRenderers().stream().anyMatch(mapRenderer -> mapRenderer.getClass() == org.bukkit.craftbukkit.map.CraftMapRenderer.class)) && (selected || entity instanceof Player && ((Player)entity).getOffhandItem() == stack)) { // SparklyPaper - don't update maps if they don't have the CraftMapRenderer in the render list
+                     this.update(world, entity, mapItemSavedData);
+                 }
+                 } // Folia - region threading

patches/server/0056-SparklyPaper-Skip-distanceToSqr-call-in-ServerEntity.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 20:12:08 +0800
+Subject: [PATCH] SparklyPaper Skip "distanceToSqr" call in
+ "ServerEntity#sendChanges" if the delta movement hasn't changed
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index a2279262c93408c11f5d2290b48fd794975e8cfe..17cf318b89b8ecc12331714defa23c6dcf0305b4 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -215,12 +215,14 @@ public class ServerEntity {
+ 
+                 if ((this.trackDelta || this.entity.hasImpulse || this.entity instanceof LivingEntity && ((LivingEntity) this.entity).isFallFlying()) && this.tickCount > 0) {
+                     Vec3 vec3d1 = this.entity.getDeltaMovement();
++                    if (vec3d1 != this.ap) { // SparklyPaper start - skip distanceToSqr call in ServerEntity#sendChanges if the delta movement hasn't changed
+                     double d0 = vec3d1.distanceToSqr(this.ap);
+ 
+                     if (d0 > 1.0E-7D || d0 > 0.0D && vec3d1.lengthSqr() == 0.0D) {
+                         this.ap = vec3d1;
+                         this.broadcast.accept(new ClientboundSetEntityMotionPacket(this.entity.getId(), this.ap));
+                     }
++                    } // SparklyPaper end
+                 }
+ 
+                 if (packet1 != null) {

patches/server/0058-KioCG-Chunk-API-and-display-of-chunkhot-in-tpsbar.patch

@@ -1,9 +1,8 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <novau233@163.com>
 Date: Sat, 27 Apr 2024 12:36:55 +0000
-Subject: [PATCH] KioCG Chunk API
+Subject: [PATCH] KioCG Chunk API and display of chunkhot in tpsbar
 
-TODO: Add back missing method in CraftPhotographer.java
 
 diff --git a/src/main/java/com/kiocg/ChunkHot.java b/src/main/java/com/kiocg/ChunkHot.java
 new file mode 100644
@@ -101,6 +100,72 @@ index 0000000000000000000000000000000000000000..53b4397997bc9b9b9d88e48304b37a25
 +        return total / ((long) TIMES_LENGTH * 20L);
 +    }
 +}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
+index aafb2f5052c7c8e5971a47308253badb3027093c..9fe7ac7ba83bbcc9a2a851a5cace47641323f4d2 100644
+--- a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
+@@ -12,11 +12,13 @@ public class TpsBarConfig implements IConfigModule {
+     @ConfigInfo(baseName = "enabled")
+     public static boolean tpsbarEnabled = false;
+     @ConfigInfo(baseName = "format")
+-    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
++    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms ChunkHot<yellow>:</yellow> <chunkhot>";
+     @ConfigInfo(baseName = "tps_color_list")
+     public static List<String> tpsColors = List.of("GREEN","YELLOW","RED","PURPLE");
+     @ConfigInfo(baseName = "ping_color_list")
+     public static List<String> pingColors = List.of("GREEN","YELLOW","RED","PURPLE");
++    @ConfigInfo(baseName = "chunkhot_color_list")
++    public static List<String> chunkHotColors = List.of("GREEN","YELLOW","RED","PURPLE");
+     @ConfigInfo(baseName = "update_interval_ticks")
+     public static int updateInterval = 15;
+ 
+diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
+index 3f1478dde900d671c4bfa43df80f629519cd602e..7abde30d420ff66026d1dee017c41bc23df22b26 100644
+--- a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
++++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
+@@ -139,7 +139,8 @@ public class GlobalServerTpsBar {
+                 TpsBarConfig.tpsBarFormat,
+                 Placeholder.component("tps",getTpsComponent(tps)),
+                 Placeholder.component("mspt",getMsptComponent(mspt)),
+-                Placeholder.component("ping",getPingComponent(player.getPing()))
++                Placeholder.component("ping",getPingComponent(player.getPing())),
++                Placeholder.component("chunkhot",getChunkHotComponent(player.getNearbyChunkHot()))
+         ));
+         bar.color(barColorFromTps(tps));
+         bar.progress((float) Math.min((float)1,Math.max(mspt / 50,0)));
+@@ -181,6 +182,32 @@ public class GlobalServerTpsBar {
+         return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", mspt)));
+     }
+ 
++    private static @NotNull Component getChunkHotComponent(long chunkHot){
++        final BossBar.Color colorBukkit = barColorFromChunkHot(chunkHot);
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(chunkHot)));
++    }
++
++    private static BossBar.Color barColorFromChunkHot(long chunkHot){
++        if (chunkHot == -1){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(3));
++        }
++
++        if (chunkHot <= 300000L){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(0));
++        }
++
++        if (chunkHot <= 500000L){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(2));
++    }
++
+     private static BossBar.Color barColorFromMspt(double mspt){
+         if (mspt == -1){
+             return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
 index 6ead4f65a07defbb7778365ce92d891528dc67aa..87664187c073685573cb93bf51ba84ef26e6bd8c 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -242,10 +307,10 @@ index ee972fa1a2bc023ed18eaceae21c8c8244754e6a..0fe6afb51246701309c88febeb61aaf7
 +    // KioCG end
  }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 94a5ac99de0b51de426b9929e82d16e12290267e..56216f11320c1c12aa3f850d3764dbfd89d333e1 100644
+index 99978531e19eb9d5a14354b7e518d609e2389b5a..3baaf0eb1ab26ec269161f9c5f35bfc743e9d98e 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -6042,4 +6042,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -6025,4 +6025,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          return ((net.minecraft.server.level.ServerChunkCache) level.getChunkSource()).isPositionTicking(this);
      }
      // Paper end - Expose entity id counter
@@ -335,10 +400,10 @@ index b0f2e614c90137c526de865bd64469f09b95c964..3d8b55afaced6fbac3bc957ffdc33682
 +    // KioCG end
  }
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-index 77eee09a301a838f21834319d4962eba1c8dcbed..cd133931de618e5d8ed5062f8ebfde9d8a9e799c 100644
+index 829b63c8a7574d6aefe95b7d190dccc4c6ecf1ba..d9018cc8a1e69efd23d6a0d35a24b75dd0220d20 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-@@ -400,4 +400,11 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+@@ -402,4 +402,11 @@ public abstract class Projectile extends Entity implements TraceableEntity {
      public float getPickRadius() {
          return this.isPickable() ? 1.0F : 0.0F;
      }
@@ -419,10 +484,10 @@ index 92f1ea81b5e90529905d9c508aca18c31443ff6a..3b972bf05d9ee79f2cdfc9b5a81692c2
 +    // 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 a3d4dc232d011c262d85028351191ac2b8547398..a3aca277422d623c6998bbbe5d9574cd1e10f544 100644
+index 2e2c8d6fa55f3b58fb6e48de0c36b22d51b09653..6c8eb658145ad0a15f6e734e0902916ba32e77bb 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -3554,4 +3554,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -3560,4 +3560,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
      public void setSendViewDistance(final int viewDistance) {
          this.getHandle().setSendViewDistance(viewDistance);
      }

patches/server/0059-Leaf-Skip-event-if-no-listeners.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 29 Jul 2024 20:05:34 +0800
+Subject: [PATCH] Leaf Skip event if no listeners
+
+
+diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+index 7ce9ebba8ce304d1f3f21d4f15ee5f3560d7700b..9180f23529a31b6b0a5b38bb7cda3e32d487f691 100644
+--- a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
++++ b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+@@ -36,15 +36,17 @@ class PaperEventManager {
+ 
+     // SimplePluginManager
+     public void callEvent(@NotNull Event event) {
++        // Leaf start - Skip event if no listeners
++        RegisteredListener[] listeners = event.getHandlers().getRegisteredListeners();
++        if (listeners.length == 0) return;
++        // Leaf end - Skip event if no listeners
++
+         if (event.isAsynchronous() && this.server.isPrimaryThread()) {
+             throw new IllegalStateException(event.getEventName() + " may only be triggered asynchronously.");
+         } else if (!event.isAsynchronous() && !this.server.isPrimaryThread() && !this.server.isStopping()) {
+             throw new IllegalStateException(event.getEventName() + " may only be triggered synchronously.");
+         }
+ 
+-        HandlerList handlers = event.getHandlers();
+-        RegisteredListener[] listeners = handlers.getRegisteredListeners();
+-
+         for (RegisteredListener registration : listeners) {
+             if (!registration.getPlugin().isEnabled()) {
+                 continue;

patches/server/0061-Fix-MC-2025.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Fix-MC-2025
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 99978531e19eb9d5a14354b7e518d609e2389b5a..94a5ac99de0b51de426b9929e82d16e12290267e 100644
+index 3baaf0eb1ab26ec269161f9c5f35bfc743e9d98e..56216f11320c1c12aa3f850d3764dbfd89d333e1 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
 @@ -2607,6 +2607,16 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess

patches/server/0062-FoliaPR-Add-TPS-From-Region.patch

@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 30 Jul 2024 17:58:22 +0800
+Subject: [PATCH] FoliaPR Add TPS From Region
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index af077ce30c01c5d1870b99617b339393f8907d36..6332d5713d1ac3e86d4922633f38d6db1a0f6406 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -3133,6 +3133,42 @@ public final class CraftServer implements Server {
+         };
+     }
+ 
++    // Folia start
++    @Override
++    public double[] getTPS(org.bukkit.Location location) {
++        final int x = location.blockX() >> 4;
++        final int z = location.blockZ() >> 4;
++        final ServerLevel world = ((CraftWorld) location.getWorld()).getHandle();
++        return getTPSFromRegion(world, x, z);
++    }
++
++    @Override
++    public double[] getTPS(org.bukkit.Chunk chunk) {
++        final int x = chunk.getX();
++        final int z = chunk.getZ();
++        final ServerLevel world = ((CraftWorld) chunk.getWorld()).getHandle();
++        return getTPSFromRegion(world, x, z);
++    }
++
++    private double[] getTPSFromRegion(ServerLevel world, int x, int z) {
++        io.papermc.paper.threadedregions.ThreadedRegionizer.ThreadedRegion<io.papermc.paper.threadedregions.TickRegions.TickRegionData, io.papermc.paper.threadedregions.TickRegions.TickRegionSectionData>
++            region = world.regioniser.getRegionAtSynchronised(x, z);
++        if (region == null) {
++            return null;
++        } else {
++            io.papermc.paper.threadedregions.TickRegions.TickRegionData regionData = region.getData();
++            final long currTime = System.nanoTime();
++            return new double[] {
++                regionData.getRegionSchedulingHandle().getTickReport5s(currTime).tpsData().segmentAll().average(),
++                regionData.getRegionSchedulingHandle().getTickReport15s(currTime).tpsData().segmentAll().average(),
++                regionData.getRegionSchedulingHandle().getTickReport1m(currTime).tpsData().segmentAll().average(),
++                regionData.getRegionSchedulingHandle().getTickReport5m(currTime).tpsData().segmentAll().average(),
++                regionData.getRegionSchedulingHandle().getTickReport15m(currTime).tpsData().segmentAll().average(),
++            };
++        }
++    }
++    // Folia end
++
+     // Paper start - adventure sounds
+     @Override
+     public void playSound(final net.kyori.adventure.sound.Sound sound) {