all patches applied \o/

2026-02-20 18:07:43 +01:00 · 2024-12-03 21:14:29 -08:00
parent 3744c42c80
commit 2951510ea1
44 changed files with 59 additions and 59 deletions
--- a/patches/server/0251-Add-more-logger-output-for-invalid-movement-kicks.patch
+++ b/patches/server/0251-Add-more-logger-output-for-invalid-movement-kicks.patch
@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Wed, 27 Jul 2022 00:42:39 -0500
+Subject: [PATCH] Add more logger output for invalid movement kicks
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 3c98be45587f3f6ca6cdc53834ef7dae4962f58d..f8438bc2af43ee8883db75503deac10e1e34686e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -756,6 +756,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
+         if (packet.getId() == this.awaitingTeleport) {
+             if (this.awaitingPositionFromClient == null) {
+                ServerGamePacketListenerImpl.LOGGER.warn("Disconnected on accept teleport packet. Was not expecting position data from client at this time"); // Purpur
+                 this.disconnect((Component) Component.translatable("multiplayer.disconnect.invalid_player_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PLAYER_MOVEMENT); // Paper - kick event cause
+                 return;
+             }
+@@ -1425,7 +1426,15 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     @Override
+     public void handleMovePlayer(ServerboundMovePlayerPacket packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
+-        if (ServerGamePacketListenerImpl.containsInvalidValues(packet.getX(0.0D), packet.getY(0.0D), packet.getZ(0.0D), packet.getYRot(0.0F), packet.getXRot(0.0F))) {
+        // Purpur start
+        boolean invalidX = Double.isNaN(packet.getX(0.0D));
+        boolean invalidY = Double.isNaN(packet.getY(0.0D));
+        boolean invalidZ = Double.isNaN(packet.getZ(0.0D));
+        boolean invalidYaw = !Floats.isFinite(packet.getYRot(0.0F));
+        boolean invalidPitch = !Floats.isFinite(packet.getXRot(0.0F));
+        if (invalidX || invalidY || invalidZ || invalidYaw || invalidPitch) {
+            ServerGamePacketListenerImpl.LOGGER.warn(String.format("Disconnected on move player packet. Invalid data: x=%b, y=%b, z=%b, yaw=%b, pitch=%b", invalidX, invalidY, invalidZ, invalidYaw, invalidPitch)); // Purpur
+        // Purpur end
+             this.disconnect((Component) Component.translatable("multiplayer.disconnect.invalid_player_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PLAYER_MOVEMENT); // Paper - kick event cause
+         } else {
+             ServerLevel worldserver = this.player.serverLevel();
--- a/patches/server/0252-Add-Bee-API.patch
+++ b/patches/server/0252-Add-Bee-API.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SageSphinx63920 <sage@sagesphinx63920.dev>
+Date: Mon, 25 Jul 2022 19:33:49 +0200
+Subject: [PATCH] Add Bee API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+index 5ca5f128e5614146e76935e6d674e0699c65dfdb..884527c8326c6df3656a4d3a2f5f2847f95b0f63 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+@@ -988,6 +988,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+                 if (optional.isPresent()) {
+                     Bee.this.savedFlowerPos = (BlockPos) optional.get();
+                     Bee.this.navigation.moveTo((double) Bee.this.savedFlowerPos.getX() + 0.5D, (double) Bee.this.savedFlowerPos.getY() + 0.5D, (double) Bee.this.savedFlowerPos.getZ() + 0.5D, 1.2000000476837158D);
+                    new org.purpurmc.purpur.event.entity.BeeFoundFlowerEvent((org.bukkit.entity.Bee) Bee.this.getBukkitEntity(), io.papermc.paper.util.MCUtil.toLocation(Bee.this.level(), Bee.this.savedFlowerPos)).callEvent(); // Purpur
+                     return true;
+                 } else {
+                     Bee.this.remainingCooldownBeforeLocatingNewFlower = Mth.nextInt(Bee.this.random, 20, 60);
+@@ -1031,6 +1032,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+             this.pollinating = false;
+             Bee.this.navigation.stop();
+             Bee.this.remainingCooldownBeforeLocatingNewFlower = 200;
+            new org.purpurmc.purpur.event.entity.BeeStopPollinatingEvent((org.bukkit.entity.Bee) Bee.this.getBukkitEntity(), Bee.this.savedFlowerPos == null ? null : io.papermc.paper.util.MCUtil.toLocation(Bee.this.level(), Bee.this.savedFlowerPos), Bee.this.hasNectar()).callEvent(); // Purpur
+         }
+ 
+         @Override
+@@ -1080,6 +1082,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+                                 this.setWantedPos();
+                             }
+ 
+                        if (this.successfulPollinatingTicks == 0) new org.purpurmc.purpur.event.entity.BeeStartedPollinatingEvent((org.bukkit.entity.Bee) Bee.this.getBukkitEntity(), io.papermc.paper.util.MCUtil.toLocation(Bee.this.level(), Bee.this.savedFlowerPos)).callEvent(); // Purpur
+                             ++this.successfulPollinatingTicks;
+                             if (Bee.this.random.nextFloat() < 0.05F && this.successfulPollinatingTicks > this.lastSoundPlayedTick + 60) {
+                                 this.lastSoundPlayedTick = this.successfulPollinatingTicks;
--- a/patches/server/0253-Debug-Marker-API.patch
+++ b/patches/server/0253-Debug-Marker-API.patch
@@ -0,0 +1,148 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: YouHaveTrouble <youhavetrouble@youhavetrouble.me>
+Date: Sat, 23 Jul 2022 14:40:38 +0200
+Subject: [PATCH] Debug Marker API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 268ab3f175ece52e7da6dfa50573089f49685d68..6b0308d081af880a79c369306e8ad69757bcd6de 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1643,6 +1643,42 @@ public final class CraftServer implements Server {
+         net.minecraft.world.item.ItemStack itemStack = net.minecraft.world.item.ItemStack.fromBukkitCopy(new ItemStack(material));
+         MinecraftServer.getServer().fuelValues().values.keySet().removeIf(itemStack::is);
+     }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration) {
+        sendBlockHighlight(location, duration, "", 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, int argb) {
+        sendBlockHighlight(location, duration, "", argb);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text) {
+        sendBlockHighlight(location, duration, text, 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, int argb) {
+        this.worlds.forEach((name, world) -> world.sendBlockHighlight(location, duration, text, argb));
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, org.bukkit.Color color, int transparency) {
+        sendBlockHighlight(location, duration, "", color, transparency);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, org.bukkit.Color color, int transparency) {
+        if (transparency < 0 || transparency > 255) throw new IllegalArgumentException("transparency is outside of 0-255 range");
+        sendBlockHighlight(location, duration, text, transparency << 24 | color.asRGB());
+    }
+
+    @Override
+    public void clearBlockHighlights() {
+        this.worlds.forEach((name, world) -> clearBlockHighlights());
+    }
+     // Purpur End
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 5d0f4395617bcd59aad7cea221f6009d08dc0913..41077511328a31f39639af1d02e7a3041992676d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -2388,6 +2388,42 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     public float getLocalDifficultyAt(Location location) {
+         return getHandle().getCurrentDifficultyAt(io.papermc.paper.util.MCUtil.toBlockPosition(location)).getEffectiveDifficulty();
+     }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration) {
+        sendBlockHighlight(location, duration, "", 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, int argb) {
+        sendBlockHighlight(location, duration, "", argb);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text) {
+        sendBlockHighlight(location, duration, text, 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, int argb) {
+        net.minecraft.network.protocol.game.DebugPackets.sendGameTestAddMarker(getHandle(), io.papermc.paper.util.MCUtil.toBlockPosition(location), text, argb, duration);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, org.bukkit.Color color, int transparency) {
+        sendBlockHighlight(location, duration, "", color, transparency);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, org.bukkit.Color color, int transparency) {
+        if (transparency < 0 || transparency > 255) throw new IllegalArgumentException("transparency is outside of 0-255 range");
+        sendBlockHighlight(location, duration, text, transparency << 24 | color.asRGB());
+    }
+
+    @Override
+    public void clearBlockHighlights() {
+        net.minecraft.network.protocol.game.DebugPackets.sendGameTestClearPacket(getHandle());
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 3c76dd383ec0ba19eea19d12902833dc410f96c0..f63b02573b3d42ae8743f591aff2282ece927e31 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3614,5 +3614,43 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void resetIdleTimer() {
+         getHandle().resetLastActionTime();
+     }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration) {
+        sendBlockHighlight(location, duration, "", 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, int argb) {
+        sendBlockHighlight(location, duration, "", argb);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text) {
+        sendBlockHighlight(location, duration, text, 0x6400FF00);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, int argb) {
+        if (this.getHandle().connection == null) return;
+        this.getHandle().connection.send(new net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket(new net.minecraft.network.protocol.common.custom.GameTestAddMarkerDebugPayload(io.papermc.paper.util.MCUtil.toBlockPosition(location), argb, text, duration)));
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, org.bukkit.Color color, int transparency) {
+        sendBlockHighlight(location, duration, "", color, transparency);
+    }
+
+    @Override
+    public void sendBlockHighlight(Location location, int duration, String text, org.bukkit.Color color, int transparency) {
+        if (transparency < 0 || transparency > 255) throw new IllegalArgumentException("transparency is outside of 0-255 range");
+        sendBlockHighlight(location, duration, text, transparency << 24 | color.asRGB());
+    }
+
+    @Override
+    public void clearBlockHighlights() {
+        if (this.getHandle().connection == null) return;
+        this.getHandle().connection.send(new net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket(new net.minecraft.network.protocol.common.custom.GameTestClearMarkersDebugPayload()));
+    }
+     // Purpur end
+ }
--- a/patches/server/0254-mob-spawning-option-to-ignore-creative-players.patch
+++ b/patches/server/0254-mob-spawning-option-to-ignore-creative-players.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Fri, 26 Aug 2022 22:44:41 -0700
+Subject: [PATCH] mob spawning option to ignore creative players
+
+
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index c1b76a1ebc1eea7ab70cf61d8175a31794dd122a..dc15c15951e4ca30b8341d24f813259a77f41c77 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -280,7 +280,7 @@ public final class NaturalSpawner {
+                             blockposition_mutableblockposition.set(l, i, i1);
+                             double d0 = (double) l + 0.5D;
+                             double d1 = (double) i1 + 0.5D;
+-                            Player entityhuman = world.getNearestPlayer(d0, (double) i, d1, -1.0D, false);
+                            Player entityhuman = world.getNearestPlayer(d0, (double) i, d1, -1.0D, world.purpurConfig.mobSpawningIgnoreCreativePlayers); // Purpur
+ 
+                             if (entityhuman != null) {
+                                 double d2 = entityhuman.distanceToSqr(d0, (double) i, d1);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 47b29febec2af1f3a8ef7b9afc6a4982df08eb47..e94c9fb93191d880b7cbd1b293a8da5c1074aba4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -378,6 +378,7 @@ public class PurpurWorldConfig {
+     public boolean phantomSpawning;
+     public boolean villagerTraderSpawning;
+     public boolean villageSiegeSpawning;
+    public boolean mobSpawningIgnoreCreativePlayers = false;
+     private void mobSpawnerSettings() {
+         // values of "default" or null will default to true only if the world environment is normal (aka overworld)
+         Predicate<Boolean> predicate = (bool) -> (bool != null && bool) || (bool == null && environment == World.Environment.NORMAL);
+@@ -386,6 +387,7 @@ public class PurpurWorldConfig {
+         phantomSpawning = getBoolean("gameplay-mechanics.mob-spawning.phantoms", predicate);
+         villagerTraderSpawning = getBoolean("gameplay-mechanics.mob-spawning.wandering-traders", predicate);
+         villageSiegeSpawning = getBoolean("gameplay-mechanics.mob-spawning.village-sieges", predicate);
+        mobSpawningIgnoreCreativePlayers = getBoolean("gameplay-mechanics.mob-spawning.ignore-creative-players", mobSpawningIgnoreCreativePlayers);
+     }
+ 
+     public boolean disableObserverClocks = false;
--- a/patches/server/0255-Add-skeleton-bow-accuracy-option.patch
+++ b/patches/server/0255-Add-skeleton-bow-accuracy-option.patch
@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Fri, 2 Sep 2022 13:04:53 -0500
+Subject: [PATCH] Add skeleton bow accuracy option
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+index f90f3e3ad7c941e3222a8119d9b01d571eef4c1b..0235488faee8078186fbb78038789da0846aca29 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+++ b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+@@ -199,7 +199,7 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
+             }
+ 
+             if (event.getProjectile() == entityarrow.getBukkitEntity()) {
+-                Projectile.spawnProjectileUsingShoot(entityarrow, worldserver, itemstack1, d0, d1 + d3 * 0.20000000298023224D, d2, 1.6F, (float) (14 - worldserver.getDifficulty().getId() * 4));
+                Projectile.spawnProjectileUsingShoot(entityarrow, worldserver, itemstack1, d0, d1 + d3 * 0.20000000298023224D, d2, 1.6F, this.level().purpurConfig.skeletonBowAccuracyMap.getOrDefault(this.level().getDifficulty().getId(), (float) (14 - this.level().getDifficulty().getId() * 4))); // Purpur
+             }
+             // CraftBukkit end
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index e94c9fb93191d880b7cbd1b293a8da5c1074aba4..b38c114e063c3f49cdf19f9c489ee92bcb7006ed 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2600,6 +2600,8 @@ public class PurpurWorldConfig {
+     public boolean skeletonAlwaysDropExp = false;
+     public double skeletonHeadVisibilityPercent = 0.5D;
+     public int skeletonFeedWitherRoses = 0;
+    public String skeletonBowAccuracy = "14 - difficulty * 4";
+    public Map<Integer, Float> skeletonBowAccuracyMap = new HashMap<>();
+     private void skeletonSettings() {
+         skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable);
+         skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater);
+@@ -2615,6 +2617,18 @@ public class PurpurWorldConfig {
+         skeletonAlwaysDropExp = getBoolean("mobs.skeleton.always-drop-exp", skeletonAlwaysDropExp);
+         skeletonHeadVisibilityPercent = getDouble("mobs.skeleton.head-visibility-percent", skeletonHeadVisibilityPercent);
+         skeletonFeedWitherRoses = getInt("mobs.skeleton.feed-wither-roses", skeletonFeedWitherRoses);
+        final String defaultSkeletonBowAccuracy = skeletonBowAccuracy;
+        skeletonBowAccuracy = getString("mobs.skeleton.bow-accuracy", skeletonBowAccuracy);
+        for (int i = 1; i < 4; i++) {
+            final float divergence;
+            try {
+                divergence = ((Number) Entity.scriptEngine.eval("let difficulty = " + i + "; " + skeletonBowAccuracy)).floatValue();
+            } catch (javax.script.ScriptException e) {
+                e.printStackTrace();
+                break;
+            }
+            skeletonBowAccuracyMap.put(i, divergence);
+        }
+     }
+ 
+     public boolean skeletonHorseRidable = false;
--- a/patches/server/0256-Add-death-screen-API.patch
+++ b/patches/server/0256-Add-death-screen-API.patch
@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Fri, 23 Sep 2022 18:41:05 -0700
+Subject: [PATCH] Add death screen API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index f63b02573b3d42ae8743f591aff2282ece927e31..8e0136c55e37d1f2732c555eb7c6129eb2b84c19 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3652,5 +3652,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         if (this.getHandle().connection == null) return;
+         this.getHandle().connection.send(new net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket(new net.minecraft.network.protocol.common.custom.GameTestClearMarkersDebugPayload()));
+     }
+
+    @Override
+    public void sendDeathScreen(net.kyori.adventure.text.Component message) {
+        if (this.getHandle().connection == null) return;
+        this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundPlayerCombatKillPacket(getEntityId(), io.papermc.paper.adventure.PaperAdventure.asVanilla(message)));
+    }
+     // Purpur end
+ }
--- a/patches/server/0257-Make-pufferfish-config-relocatable.patch
+++ b/patches/server/0257-Make-pufferfish-config-relocatable.patch
@@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Sun, 12 Jun 2022 09:18:57 -0500
+Subject: [PATCH] Make pufferfish config relocatable
+
+
+diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
+index 3175d421e39bf1315cf699f2df7c63a6535bb5b9..411c81a88b8a008b2aaf0ca62fb7ffa1dd9e32a4 100644
+--- a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
+++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
+@@ -25,6 +25,7 @@ public class PufferfishConfig {
+ 	
+ 	private static final YamlFile config = new YamlFile();
+ 	private static int updates = 0;
+	public static File pufferfishFile; // Purpur
+ 	
+ 	private static ConfigurationSection convertToBukkit(org.simpleyaml.configuration.ConfigurationSection section) {
+ 		ConfigurationSection newSection = new MemoryConfiguration();
+@@ -47,7 +48,7 @@ public class PufferfishConfig {
+ 	}
+ 	
+ 	public static void load() throws IOException {
+-		File configFile = new File("pufferfish.yml");
+		File configFile = pufferfishFile; // Purpur
+ 		
+ 		if (configFile.exists()) {
+ 			try {
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 8eb51119d60979f85bc98a9413d318522c732693..08a81a45371fd273fb35956bef3bb7947bb4c5b6 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -245,6 +245,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark
+         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics(); // Paper - start metrics
+         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // Paper - load version history now
+        gg.pufferfish.pufferfish.PufferfishConfig.pufferfishFile = (java.io.File) options.valueOf("pufferfish-settings"); // Purpur
+         gg.pufferfish.pufferfish.PufferfishConfig.load(); // Pufferfish
+         gg.pufferfish.pufferfish.PufferfishCommand.init(); // Pufferfish
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index 628f7f784c830189c5718a20ce43a9352e400c33..c471a8c81ba067abcb22956ad1a30b5a9b64fc87 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -182,6 +182,12 @@ public class Main {
+                     .ofType(File.class)
+                     .defaultsTo(new File("purpur.yml"))
+                     .describedAs("Yml file");
+
+                acceptsAll(asList("pufferfish", "pufferfish-settings"), "File for pufferfish settings")
+                        .withRequiredArg()
+                        .ofType(File.class)
+                        .defaultsTo(new File("pufferfish.yml"))
+                        .describedAs("Yml file");
+                 // Purpur end
+ 
+                 // Paper start
--- a/patches/server/0258-Implement-ram-and-rambar-commands.patch
+++ b/patches/server/0258-Implement-ram-and-rambar-commands.patch
@@ -0,0 +1,360 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Mon, 26 Sep 2022 07:43:30 -0500
+Subject: [PATCH] Implement ram and rambar commands
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index eedb3707523b47ab79db326f6d7382cca60c5393..db455a0fc7e1fc004215b718ff470bd2f74eae1b 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -261,6 +261,8 @@ public class Commands {
+             org.purpurmc.purpur.command.UptimeCommand.register(this.dispatcher); // Purpur
+             org.purpurmc.purpur.command.TPSBarCommand.register(this.dispatcher); // Purpur
+             org.purpurmc.purpur.command.CompassCommand.register(this.dispatcher); // Purpur
+            org.purpurmc.purpur.command.RamBarCommand.register(this.dispatcher); // Purpur
+            org.purpurmc.purpur.command.RamCommand.register(this.dispatcher); // Purpur
+         }
+ 
+         if (environment.includeIntegrated) {
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 7e785394de3db56e5d0fd8bea5edf5df9fa129fa..8264adc43edfebc2c260c2b915186c20ec3637cc 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -330,6 +330,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
+     public boolean purpurClient = false; // Purpur
+     private boolean tpsBar = false; // Purpur
+     private boolean compassBar = false; // Purpur
+    private boolean ramBar = false; // Purpur
+ 
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+@@ -694,6 +695,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
+ 
+         if (nbt.contains("Purpur.TPSBar")) { this.tpsBar = nbt.getBoolean("Purpur.TPSBar"); } // Purpur
+         if (nbt.contains("Purpur.CompassBar")) { this.compassBar = nbt.getBoolean("Purpur.CompassBar"); } // Purpur
+        if (nbt.contains("Purpur.RamBar")) { this.ramBar = nbt.getBoolean("Purpur.RamBar"); } // Purpur
+     }
+ 
+     @Override
+@@ -746,6 +748,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
+         }
+ 
+         this.saveEnderPearls(nbt);
+        nbt.putBoolean("Purpur.RamBar", this.ramBar); // Purpur
+         nbt.putBoolean("Purpur.TPSBar", this.tpsBar); // Purpur
+         nbt.putBoolean("Purpur.CompassBar", this.compassBar); // Purpur
+     }
+@@ -3457,5 +3460,13 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
+     public void compassBar(boolean compassBar) {
+         this.compassBar = compassBar;
+     }
+
+    public boolean ramBar() {
+        return this.ramBar;
+    }
+
+    public void ramBar(boolean ramBar) {
+        this.ramBar = ramBar;
+    }
+     // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 32e44e47cc6b5e6ed6e13f41dd8b4ba29459d7f0..7164788c20483a78a92ccdcf480bd95651d84825 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -185,6 +185,8 @@ public class PurpurConfig {
+     public static String creditsCommandOutput = "<green>%s has been shown the end credits";
+     public static String demoCommandOutput = "<green>%s has been shown the demo screen";
+     public static String pingCommandOutput = "<green>%s's ping is %sms";
+    public static String ramCommandOutput = "<green>Ram Usage: <used>/<xmx> (<percent>)";
+    public static String rambarCommandOutput = "<green>Rambar toggled <onoff> for <target>";
+     public static String tpsbarCommandOutput = "<green>Tpsbar toggled <onoff> for <target>";
+     public static String dontRunWithScissors = "<red><italic>Don't run with scissors!";
+     public static String uptimeCommandOutput = "<green>Server uptime is <uptime>";
+@@ -202,6 +204,8 @@ public class PurpurConfig {
+         creditsCommandOutput = getString("settings.messages.credits-command-output", creditsCommandOutput);
+         demoCommandOutput = getString("settings.messages.demo-command-output", demoCommandOutput);
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+        ramCommandOutput = getString("settings.messages.ram-command-output", ramCommandOutput);
+        rambarCommandOutput = getString("settings.messages.rambar-command-output", rambarCommandOutput);
+         tpsbarCommandOutput = getString("settings.messages.tpsbar-command-output", tpsbarCommandOutput);
+         dontRunWithScissors = getString("settings.messages.dont-run-with-scissors", dontRunWithScissors);
+         uptimeCommandOutput = getString("settings.messages.uptime-command-output", uptimeCommandOutput);
+@@ -250,6 +254,15 @@ public class PurpurConfig {
+         disableGiveCommandDrops = getBoolean("settings.disable-give-dropping", disableGiveCommandDrops);
+     }
+ 
+    public static String commandRamBarTitle = "<gray>Ram<yellow>:</yellow> <used>/<xmx> (<percent>)";
+    public static BossBar.Overlay commandRamBarProgressOverlay = BossBar.Overlay.NOTCHED_20;
+    public static BossBar.Color commandRamBarProgressColorGood = BossBar.Color.GREEN;
+    public static BossBar.Color commandRamBarProgressColorMedium = BossBar.Color.YELLOW;
+    public static BossBar.Color commandRamBarProgressColorLow = BossBar.Color.RED;
+    public static String commandRamBarTextColorGood = "<gradient:#55ff55:#00aa00><text></gradient>";
+    public static String commandRamBarTextColorMedium = "<gradient:#ffff55:#ffaa00><text></gradient>";
+    public static String commandRamBarTextColorLow = "<gradient:#ff5555:#aa0000><text></gradient>";
+    public static int commandRamBarTickInterval = 20;
+     public static String commandTPSBarTitle = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
+     public static BossBar.Overlay commandTPSBarProgressOverlay = BossBar.Overlay.NOTCHED_20;
+     public static TPSBarTask.FillMode commandTPSBarProgressFillMode = TPSBarTask.FillMode.MSPT;
+@@ -277,6 +290,16 @@ public class PurpurConfig {
+     public static String uptimeSecond = "%02d second";
+     public static String uptimeSeconds = "%02d seconds";
+     private static void commandSettings() {
+        commandRamBarTitle = getString("settings.command.rambar.title", commandRamBarTitle);
+        commandRamBarProgressOverlay = BossBar.Overlay.valueOf(getString("settings.command.rambar.overlay", commandRamBarProgressOverlay.name()));
+        commandRamBarProgressColorGood = BossBar.Color.valueOf(getString("settings.command.rambar.progress-color.good", commandRamBarProgressColorGood.name()));
+        commandRamBarProgressColorMedium = BossBar.Color.valueOf(getString("settings.command.rambar.progress-color.medium", commandRamBarProgressColorMedium.name()));
+        commandRamBarProgressColorLow = BossBar.Color.valueOf(getString("settings.command.rambar.progress-color.low", commandRamBarProgressColorLow.name()));
+        commandRamBarTextColorGood = getString("settings.command.rambar.text-color.good", commandRamBarTextColorGood);
+        commandRamBarTextColorMedium = getString("settings.command.rambar.text-color.medium", commandRamBarTextColorMedium);
+        commandRamBarTextColorLow = getString("settings.command.rambar.text-color.low", commandRamBarTextColorLow);
+        commandRamBarTickInterval = getInt("settings.command.rambar.tick-interval", commandRamBarTickInterval);
+
+         commandTPSBarTitle = getString("settings.command.tpsbar.title", commandTPSBarTitle);
+         commandTPSBarProgressOverlay = BossBar.Overlay.valueOf(getString("settings.command.tpsbar.overlay", commandTPSBarProgressOverlay.name()));
+         commandTPSBarProgressFillMode = TPSBarTask.FillMode.valueOf(getString("settings.command.tpsbar.fill-mode", commandTPSBarProgressFillMode.name()));
+diff --git a/src/main/java/org/purpurmc/purpur/command/RamBarCommand.java b/src/main/java/org/purpurmc/purpur/command/RamBarCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2852c07adb080c34905f5d1b19efed8ea47eecc6
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/command/RamBarCommand.java
+@@ -0,0 +1,44 @@
+package org.purpurmc.purpur.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.server.level.ServerPlayer;
+import org.purpurmc.purpur.PurpurConfig;
+import org.purpurmc.purpur.task.RamBarTask;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class RamBarCommand {
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(Commands.literal("rambar")
+                .requires(listener -> listener.hasPermission(2, "bukkit.command.rambar"))
+                .executes(context -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
+                .then(Commands.argument("targets", EntityArgument.players())
+                        .requires(listener -> listener.hasPermission(2, "bukkit.command.rambar.other"))
+                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
+                )
+        );
+    }
+
+    private static int execute(CommandSourceStack sender, Collection<ServerPlayer> targets) {
+        for (ServerPlayer player : targets) {
+            boolean result = RamBarTask.instance().togglePlayer(player.getBukkitEntity());
+            player.ramBar(result);
+
+            Component output = MiniMessage.miniMessage().deserialize(PurpurConfig.rambarCommandOutput,
+                    Placeholder.component("onoff", Component.translatable(result ? "options.on" : "options.off")
+                            .color(result ? NamedTextColor.GREEN : NamedTextColor.RED)),
+                    Placeholder.parsed("target", player.getGameProfile().getName()));
+
+            sender.sendSuccess(output, false);
+        }
+        return targets.size();
+    }
+}
+diff --git a/src/main/java/org/purpurmc/purpur/command/RamCommand.java b/src/main/java/org/purpurmc/purpur/command/RamCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..992f8dfc628c7485e335191e1308cdfd4eedfbe8
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/command/RamCommand.java
+@@ -0,0 +1,30 @@
+package org.purpurmc.purpur.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import io.papermc.paper.adventure.PaperAdventure;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import org.purpurmc.purpur.PurpurConfig;
+import org.purpurmc.purpur.task.RamBarTask;
+
+public class RamCommand {
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(Commands.literal("ram")
+                .requires(listener -> listener.hasPermission(2, "bukkit.command.ram"))
+                .executes(context -> {
+                    CommandSourceStack sender = context.getSource();
+                    RamBarTask ramBar = RamBarTask.instance();
+                    sender.sendSuccess(() -> PaperAdventure.asVanilla(MiniMessage.miniMessage().deserialize(PurpurConfig.ramCommandOutput,
+                            Placeholder.component("allocated", ramBar.format(ramBar.getAllocated())),
+                            Placeholder.component("used", ramBar.format(ramBar.getUsed())),
+                            Placeholder.component("xmx", ramBar.format(ramBar.getXmx())),
+                            Placeholder.component("xms", ramBar.format(ramBar.getXms())),
+                            Placeholder.unparsed("percent", ((int) (ramBar.getPercent() * 100)) + "%")
+                    )), false);
+                    return 1;
+                })
+        );
+    }
+}
+diff --git a/src/main/java/org/purpurmc/purpur/task/BossBarTask.java b/src/main/java/org/purpurmc/purpur/task/BossBarTask.java
+index 65c1bac3daf781c66442350ba08c43b21d2f1637..3c3d4cd52db93b97a40321030a70ebc282c9636b 100644
+--- a/src/main/java/org/purpurmc/purpur/task/BossBarTask.java
+++ b/src/main/java/org/purpurmc/purpur/task/BossBarTask.java
+@@ -89,17 +89,22 @@ public abstract class BossBarTask extends BukkitRunnable {
+     }
+ 
+     public static void startAll() {
+        RamBarTask.instance().start();
+         TPSBarTask.instance().start();
+         CompassTask.instance().start();
+     }
+ 
+     public static void stopAll() {
+        RamBarTask.instance().stop();
+         TPSBarTask.instance().stop();
+         CompassTask.instance().stop();
+     }
+ 
+     public static void addToAll(ServerPlayer player) {
+         Player bukkit = player.getBukkitEntity();
+        if (player.ramBar()) {
+            RamBarTask.instance().addPlayer(bukkit);
+        }
+         if (player.tpsBar()) {
+             TPSBarTask.instance().addPlayer(bukkit);
+         }
+@@ -109,6 +114,7 @@ public abstract class BossBarTask extends BukkitRunnable {
+     }
+ 
+     public static void removeFromAll(Player player) {
+        RamBarTask.instance().removePlayer(player);
+         TPSBarTask.instance().removePlayer(player);
+         CompassTask.instance().removePlayer(player);
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/task/RamBarTask.java b/src/main/java/org/purpurmc/purpur/task/RamBarTask.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8e98c0ae73e2c40002a72b5d0d246ffa0c3ab38f
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/task/RamBarTask.java
+@@ -0,0 +1,117 @@
+package org.purpurmc.purpur.task;
+
+import net.kyori.adventure.bossbar.BossBar;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import org.bukkit.entity.Player;
+import org.purpurmc.purpur.PurpurConfig;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+
+public class RamBarTask extends BossBarTask {
+    private static RamBarTask instance;
+    private long allocated = 0L;
+    private long used = 0L;
+    private long xmx = 0L;
+    private long xms = 0L;
+    private float percent = 0F;
+    private int tick = 0;
+
+    public static RamBarTask instance() {
+        if (instance == null) {
+            instance = new RamBarTask();
+        }
+        return instance;
+    }
+
+    @Override
+    BossBar createBossBar() {
+        return BossBar.bossBar(Component.text(""), 0.0F, instance().getBossBarColor(), PurpurConfig.commandRamBarProgressOverlay);
+    }
+
+    @Override
+    void updateBossBar(BossBar bossbar, Player player) {
+        bossbar.progress(getBossBarProgress());
+        bossbar.color(getBossBarColor());
+        bossbar.name(MiniMessage.miniMessage().deserialize(PurpurConfig.commandRamBarTitle,
+                Placeholder.component("allocated", format(this.allocated)),
+                Placeholder.component("used", format(this.used)),
+                Placeholder.component("xmx", format(this.xmx)),
+                Placeholder.component("xms", format(this.xms)),
+                Placeholder.unparsed("percent", ((int) (this.percent * 100)) + "%")
+        ));
+    }
+
+    @Override
+    public void run() {
+        if (++this.tick < PurpurConfig.commandRamBarTickInterval) {
+            return;
+        }
+        this.tick = 0;
+
+        MemoryUsage heap = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+
+        this.allocated = heap.getCommitted();
+        this.used = heap.getUsed();
+        this.xmx = heap.getMax();
+        this.xms = heap.getInit();
+        this.percent = Math.max(Math.min((float) this.used / this.xmx, 1.0F), 0.0F);
+
+        super.run();
+    }
+
+    private float getBossBarProgress() {
+        return this.percent;
+    }
+
+    private BossBar.Color getBossBarColor() {
+        if (this.percent < 0.5F) {
+            return PurpurConfig.commandRamBarProgressColorGood;
+        } else if (this.percent < 0.75F) {
+            return PurpurConfig.commandRamBarProgressColorMedium;
+        } else {
+            return PurpurConfig.commandRamBarProgressColorLow;
+        }
+    }
+
+    public Component format(long v) {
+        String color;
+        if (this.percent < 0.60F) {
+            color = PurpurConfig.commandRamBarTextColorGood;
+        } else if (this.percent < 0.85F) {
+            color = PurpurConfig.commandRamBarTextColorMedium;
+        } else {
+            color = PurpurConfig.commandRamBarTextColorLow;
+        }
+        String value;
+        if (v < 1024) {
+            value = v + "B";
+        } else {
+            int z = (63 - Long.numberOfLeadingZeros(v)) / 10;
+            value = String.format("%.1f%s", (double) v / (1L << (z * 10)), "BKMGTPE".charAt(z));
+        }
+        return MiniMessage.miniMessage().deserialize(color, Placeholder.unparsed("text", value));
+    }
+
+    public long getAllocated() {
+        return this.allocated;
+    }
+
+    public long getUsed() {
+        return this.used;
+    }
+
+    public long getXmx() {
+        return this.xmx;
+    }
+
+    public long getXms() {
+        return this.xms;
+    }
+
+    public float getPercent() {
+        return this.percent;
+    }
+}
--- a/patches/server/0259-Configurable-block-blast-resistance.patch
+++ b/patches/server/0259-Configurable-block-blast-resistance.patch
@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sat, 1 Oct 2022 13:29:17 -0700
+Subject: [PATCH] Configurable block blast resistance
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 6376b8b3ff444f4cab93e2bb5d2becc77c33c118..c8ae6e4cd74549f753ec04def5d882de1ab72308 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -91,7 +91,7 @@ public abstract class BlockBehaviour implements FeatureElement {
+ 
+     protected static final Direction[] UPDATE_SHAPE_ORDER = new Direction[]{Direction.WEST, Direction.EAST, Direction.NORTH, Direction.SOUTH, Direction.DOWN, Direction.UP};
+     public final boolean hasCollision;
+-    protected final float explosionResistance;
+    public float explosionResistance; // Purpur - protected final -> public
+     protected final boolean isRandomlyTicking;
+     protected final SoundType soundType;
+     protected final float friction;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 7164788c20483a78a92ccdcf480bd95651d84825..a282e1a0c832174a70c7b317f547c5d250fe37ad 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -498,4 +498,19 @@ public class PurpurConfig {
+         String setPattern = getString("settings.username-valid-characters", defaultPattern);
+         usernameValidCharactersPattern = java.util.regex.Pattern.compile(setPattern == null || setPattern.isBlank() ? defaultPattern : setPattern);
+     }
+
+    private static void blastResistanceSettings() {
+        getMap("settings.blast-resistance-overrides", Collections.emptyMap()).forEach((blockId, value) -> {
+            Block block = BuiltInRegistries.BLOCK.getValue(ResourceLocation.parse(blockId));
+            if (block == Blocks.AIR) {
+                log(Level.SEVERE, "Invalid block for `settings.blast-resistance-overrides`: " + blockId);
+                return;
+            }
+            if (!(value instanceof Number blastResistance)) {
+                log(Level.SEVERE, "Invalid blast resistance for `settings.blast-resistance-overrides." + blockId + "`: " + value);
+                return;
+            }
+            block.explosionResistance = blastResistance.floatValue();
+        });
+    }
+ }
--- a/patches/server/0260-Configurable-block-fall-damage-modifiers.patch
+++ b/patches/server/0260-Configurable-block-fall-damage-modifiers.patch
@@ -0,0 +1,110 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sat, 1 Oct 2022 18:06:52 -0700
+Subject: [PATCH] Configurable block fall damage modifiers
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/BedBlock.java b/src/main/java/net/minecraft/world/level/block/BedBlock.java
+index db79ef24ea01db5f619ab29700d3d391438fb742..54836f2a1e4cc9046ba29fb71ea237b358c9cb7d 100644
+--- a/src/main/java/net/minecraft/world/level/block/BedBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BedBlock.java
+@@ -183,7 +183,7 @@ public class BedBlock extends HorizontalDirectionalBlock implements EntityBlock
+ 
+     @Override
+     public void fallOn(Level world, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+-        super.fallOn(world, state, pos, entity, fallDistance * 0.5F);
+        super.fallOn(world, state, pos, entity, fallDistance); // Purpur
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/Block.java b/src/main/java/net/minecraft/world/level/block/Block.java
+index b0fbadd0d6ec3e34e36c9f33ed89a3c315dc4289..91e68335d7007e3c1fe13eec0060db01c5f659ac 100644
+--- a/src/main/java/net/minecraft/world/level/block/Block.java
+++ b/src/main/java/net/minecraft/world/level/block/Block.java
+@@ -88,6 +88,10 @@ public class Block extends BlockBehaviour implements ItemLike {
+     public static final int UPDATE_LIMIT = 512;
+     protected final StateDefinition<Block, BlockState> stateDefinition;
+     private BlockState defaultBlockState;
+    // Purpur start
+    public float fallDamageMultiplier = 1.0F;
+    public float fallDistanceMultiplier = 1.0F;
+    // Purpur end
+     // Paper start - Protect Bedrock and End Portal/Frames from being destroyed
+     public final boolean isDestroyable() {
+         return io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowPermanentBlockBreakExploits ||
+@@ -473,7 +477,7 @@ public class Block extends BlockBehaviour implements ItemLike {
+     }
+ 
+     public void fallOn(Level world, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+-        entity.causeFallDamage(fallDistance, 1.0F, entity.damageSources().fall());
+        entity.causeFallDamage(fallDistance * fallDistanceMultiplier, fallDamageMultiplier, entity.damageSources().fall()); // Purpur
+     }
+ 
+     public void updateEntityMovementAfterFallOn(BlockGetter world, Entity entity) {
+diff --git a/src/main/java/net/minecraft/world/level/block/HayBlock.java b/src/main/java/net/minecraft/world/level/block/HayBlock.java
+index ef364aa171a48482a45bc18cfe730ec20c3f7be6..74971d90506aa253d5ee821b5390fb2551a3a393 100644
+--- a/src/main/java/net/minecraft/world/level/block/HayBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/HayBlock.java
+@@ -23,6 +23,6 @@ public class HayBlock extends RotatedPillarBlock {
+ 
+     @Override
+     public void fallOn(Level world, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+-        entity.causeFallDamage(fallDistance, 0.2F, world.damageSources().fall());
+        super.fallOn(world, state, pos, entity, fallDistance); // Purpur
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index a282e1a0c832174a70c7b317f547c5d250fe37ad..1d4fb426bfba5f572785c5a904d01be8edf23f24 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -513,4 +513,50 @@ public class PurpurConfig {
+             block.explosionResistance = blastResistance.floatValue();
+         });
+     }
+    private static void blockFallMultiplierSettings() {
+        getMap("settings.block-fall-multipliers", Map.ofEntries(
+                Map.entry("minecraft:hay_block", Map.of("damage", 0.2F)),
+                Map.entry("minecraft:white_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:light_gray_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:gray_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:black_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:brown_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:pink_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:red_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:orange_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:yellow_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:green_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:lime_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:cyan_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:light_blue_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:blue_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:purple_bed", Map.of("distance", 0.5F)),
+                Map.entry("minecraft:magenta_bed", Map.of("distance", 0.5F))
+        )).forEach((blockId, value) -> {
+            Block block = BuiltInRegistries.BLOCK.getValue(ResourceLocation.parse(blockId));
+            if (block == Blocks.AIR) {
+                log(Level.SEVERE, "Invalid block for `settings.block-fall-multipliers`: " + blockId);
+                return;
+            }
+            if (!(value instanceof Map<?, ?> map)) {
+                log(Level.SEVERE, "Invalid fall multiplier for `settings.block-fall-multipliers." + blockId + "`: " + value
+                        + ", expected a map with keys `damage` and `distance` to floats.");
+                return;
+            }
+            Object rawFallDamageMultiplier = map.get("damage");
+            if (rawFallDamageMultiplier == null) rawFallDamageMultiplier = 1F;
+            if (!(rawFallDamageMultiplier instanceof Number fallDamageMultiplier)) {
+                log(Level.SEVERE, "Invalid multiplier for `settings.block-fall-multipliers." + blockId + ".damage`: " + map.get("damage"));
+                return;
+            }
+            Object rawFallDistanceMultiplier = map.get("distance");
+            if (rawFallDistanceMultiplier == null) rawFallDistanceMultiplier = 1F;
+            if (!(rawFallDistanceMultiplier instanceof Number fallDistanceMultiplier)) {
+                log(Level.SEVERE, "Invalid multiplier for `settings.block-fall-multipliers." + blockId + ".distance`: " + map.get("distance"));
+                return;
+            }
+            block.fallDamageMultiplier = fallDamageMultiplier.floatValue();
+            block.fallDistanceMultiplier = fallDistanceMultiplier.floatValue();
+        });
+    }
+ }
--- a/patches/server/0261-Language-API.patch
+++ b/patches/server/0261-Language-API.patch
@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sat, 1 Oct 2022 17:08:43 -0700
+Subject: [PATCH] Language API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 6b0308d081af880a79c369306e8ad69757bcd6de..81922bf93f8a96e6cf05944ca98a82cc5945a6c6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -426,6 +426,20 @@ public final class CraftServer implements Server {
+         this.paperPluginManager = new io.papermc.paper.plugin.manager.PaperPluginManagerImpl(this, this.commandMap, pluginManager);
+         this.pluginManager.paperPluginManager = this.paperPluginManager;
+          // Paper end
+        // Purpur start
+        org.purpurmc.purpur.language.Language.setLanguage(new org.purpurmc.purpur.language.Language() {
+            private net.minecraft.locale.Language language = net.minecraft.locale.Language.getInstance();
+            @Override
+            public boolean has(@org.jetbrains.annotations.NotNull String key) {
+                return language.has(key);
+            }
+
+            @Override
+            public @org.jetbrains.annotations.NotNull String getOrDefault(@org.jetbrains.annotations.NotNull String key) {
+                return language.getOrDefault(key);
+            }
+        });
+        // Purpur end
+ 
+         CraftRegistry.setMinecraftRegistry(console.registryAccess());
+ 
--- a/patches/server/0262-Milk-Keeps-Beneficial-Effects.patch
+++ b/patches/server/0262-Milk-Keeps-Beneficial-Effects.patch
@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Rhythmic <mc.ADHDMC@gmail.com>
+Date: Thu, 6 Oct 2022 10:41:01 -0700
+Subject: [PATCH] Milk Keeps Beneficial Effects
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 239046ab467f499107d1e30ca183d79661a380f0..33fbe0f7a356dd847e546feffb468b2803c6744b 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1162,6 +1162,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+             while (iterator.hasNext()) {
+                 MobEffectInstance effect = iterator.next();
+                if (cause == EntityPotionEffectEvent.Cause.MILK && !this.level().purpurConfig.milkClearsBeneficialEffects && effect.getEffect().value().isBeneficial()) continue; // Purpur
+                 EntityPotionEffectEvent event = CraftEventFactory.callEntityPotionEffectChangeEvent(this, effect, null, cause, EntityPotionEffectEvent.Action.CLEARED);
+                 if (event.isCancelled()) {
+                     continue;
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+index 37ba31724fb3630c9c7d8040f47be36e037d4e48..42c91e52060fad4a7a598f9e9ef88fd0e0ff8475 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -123,7 +123,7 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+             return this.canDrinkPotion && this.level().isNight() && !entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API
+         }));
+         this.goalSelector.addGoal(0, new UseItemGoal<>(this, new ItemStack(Items.MILK_BUCKET), SoundEvents.WANDERING_TRADER_REAPPEARED, (entityvillagertrader) -> {
+-            return this.canDrinkMilk && this.level().isDay() && entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API
+            return level().purpurConfig.milkClearsBeneficialEffects && this.canDrinkMilk && this.level().isDay() && entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API // Purpur
+         }));
+         this.goalSelector.addGoal(1, new TradeWithPlayerGoal(this));
+         this.goalSelector.addGoal(1, new AvoidEntityGoal<>(this, Zombie.class, 8.0F, 0.5D, 0.5D));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b38c114e063c3f49cdf19f9c489ee92bcb7006ed..446cdd50d4b5d5ed2e58f4bc4fbb13810399754d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -145,6 +145,7 @@ public class PurpurWorldConfig {
+     public boolean persistentTileEntityLore = false;
+     public boolean persistentTileEntityDisplayName = true;
+     public int mobLastHurtByPlayerTime = 100;
+    public boolean milkClearsBeneficialEffects = true;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         alwaysTameInCreative = getBoolean("gameplay-mechanics.always-tame-in-creative", alwaysTameInCreative);
+@@ -178,6 +179,7 @@ public class PurpurWorldConfig {
+         persistentTileEntityLore = getBoolean("gameplay-mechanics.persistent-tileentity-lore", persistentTileEntityLore);
+         persistentTileEntityDisplayName = getBoolean("gameplay-mechanics.persistent-tileentity-display-name", persistentTileEntityDisplayName);
+         mobLastHurtByPlayerTime = getInt("gameplay-mechanics.mob-last-hurt-by-player-time", mobLastHurtByPlayerTime);
+        milkClearsBeneficialEffects = getBoolean("gameplay-mechanics.milk-clears-beneficial-effects", milkClearsBeneficialEffects);
+     }
+ 
+     public int daytimeTicks = 12000;
--- a/patches/server/0263-MC-121706-Fix-mobs-not-looking-up-and-down-when-stra.patch
+++ b/patches/server/0263-MC-121706-Fix-mobs-not-looking-up-and-down-when-stra.patch
@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Krakenied <Krakenied1@gmail.com>
+Date: Sun, 9 Oct 2022 01:50:39 +0200
+Subject: [PATCH] MC-121706 - Fix mobs not looking up and down when strafing
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/RangedBowAttackGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/RangedBowAttackGoal.java
+index 515c1f671cb2c3a7cc23053aedf404bbbe77af3e..42a1e5b9c08a9245dd0ce6d4025e3bb5d60feb62 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/RangedBowAttackGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/RangedBowAttackGoal.java
+@@ -116,9 +116,9 @@ public class RangedBowAttackGoal<T extends Monster & RangedAttackMob> extends Go
+                 }
+ 
+                 this.mob.lookAt(livingEntity, 30.0F, 30.0F);
+-            } else {
+            } //else { // Purpur - fix MC-121706
+                 this.mob.getLookControl().setLookAt(livingEntity, 30.0F, 30.0F);
+-            }
+            //} // Purpur
+ 
+             if (this.mob.isUsingItem()) {
+                 if (!bl && this.seeTime < -60) {
--- a/patches/server/0264-Add-log-suppression-for-LibraryLoader.patch
+++ b/patches/server/0264-Add-log-suppression-for-LibraryLoader.patch
@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Krakenied <Krakenied1@gmail.com>
+Date: Fri, 14 Oct 2022 23:11:16 +0200
+Subject: [PATCH] Add log suppression for LibraryLoader
+
+
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 1d4fb426bfba5f572785c5a904d01be8edf23f24..4e47c24adb808feee415ee3e1c159955a7be5c71 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -471,11 +471,14 @@ public class PurpurConfig {
+     public static boolean loggerSuppressIgnoredAdvancementWarnings = false;
+     public static boolean loggerSuppressUnrecognizedRecipeErrors = false;
+     public static boolean loggerSuppressSetBlockFarChunk = false;
+    public static boolean loggerSuppressLibraryLoader = false;
+     private static void loggerSettings() {
+         loggerSuppressInitLegacyMaterialError = getBoolean("settings.logger.suppress-init-legacy-material-errors", loggerSuppressInitLegacyMaterialError);
+         loggerSuppressIgnoredAdvancementWarnings = getBoolean("settings.logger.suppress-ignored-advancement-warnings", loggerSuppressIgnoredAdvancementWarnings);
+         loggerSuppressUnrecognizedRecipeErrors = getBoolean("settings.logger.suppress-unrecognized-recipe-errors", loggerSuppressUnrecognizedRecipeErrors);
+         loggerSuppressSetBlockFarChunk = getBoolean("settings.logger.suppress-setblock-in-far-chunk-errors", loggerSuppressSetBlockFarChunk);
+        loggerSuppressLibraryLoader = getBoolean("settings.logger.suppress-library-loader", loggerSuppressLibraryLoader);
+        org.bukkit.plugin.java.JavaPluginLoader.SuppressLibraryLoaderLogger = loggerSuppressLibraryLoader;
+     }
+ 
+     public static boolean tpsCatchup = true;
--- a/patches/server/0265-Add-an-option-to-fix-MC-3304-projectile-looting.patch
+++ b/patches/server/0265-Add-an-option-to-fix-MC-3304-projectile-looting.patch
@@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sat, 1 Oct 2022 11:33:15 -0700
+Subject: [PATCH] Add an option to fix MC-3304 (projectile looting)
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+index f4f2581faba3f8686592f3f8ebbcdba3e5d30f7b..2f56d25fe4dce613f078455bd0150c6140df7fff 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -82,6 +82,7 @@ public abstract class AbstractArrow extends Projectile {
+     public ItemStack pickupItemStack;
+     @Nullable
+     public ItemStack firedFromWeapon;
+    public net.minecraft.world.item.enchantment.ItemEnchantments actualEnchantments = net.minecraft.world.item.enchantment.ItemEnchantments.EMPTY; // Purpur - Add an option to fix MC-3304 projectile looting
+ 
+     // Spigot Start
+     @Override
+@@ -638,6 +639,12 @@ public abstract class AbstractArrow extends Projectile {
+         return this.firedFromWeapon;
+     }
+ 
+    // Purpur start - Add an option to fix MC-3304 projectile looting
+    public void setActualEnchantments(net.minecraft.world.item.enchantment.ItemEnchantments actualEnchantments) {
+        this.actualEnchantments = actualEnchantments;
+    }
+    // Purpur end - Add an option to fix MC-3304 projectile looting
+
+     protected SoundEvent getDefaultHitGroundSoundEvent() {
+         return SoundEvents.ARROW_HIT;
+     }
+diff --git a/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java b/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
+index 78ba170a83f8c026bd110eae494c52577182ed61..c2ae50872cead7202246b9cce4db6e0a81e1cf5f 100644
+--- a/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
+++ b/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
+@@ -105,6 +105,8 @@ public abstract class ProjectileWeaponItem extends Item {
+             entityarrow.setCritArrow(true);
+         }
+ 
+        entityarrow.setActualEnchantments(weaponStack.getEnchantments()); // Purpur - Add an option to fix MC-3304 projectile looting
+
+         return entityarrow;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/item/TridentItem.java b/src/main/java/net/minecraft/world/item/TridentItem.java
+index 810082126567eb02bec395065b95b3c3902d4973..be32255c9bd90f7de3f8f5a62d84c7dcf59fa722 100644
+--- a/src/main/java/net/minecraft/world/item/TridentItem.java
+++ b/src/main/java/net/minecraft/world/item/TridentItem.java
+@@ -101,6 +101,9 @@ public class TridentItem extends Item implements ProjectileItem {
+                                 return false;
+                             }
+                             ThrownTrident entitythrowntrident = tridentDelayed.projectile(); // Paper - PlayerLaunchProjectileEvent
+
+                            entitythrowntrident.setActualEnchantments(stack.getEnchantments()); // Purpur - Add an option to fix MC-3304 projectile looting
+
+                             if (event.shouldConsume()) stack.hurtWithoutBreaking(1, entityhuman); // Paper - PlayerLaunchProjectileEvent
+                             entitythrowntrident.pickupItemStack = stack.copy(); // SPIGOT-4511 update since damage call moved
+                             // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/world/level/storage/loot/functions/EnchantedCountIncreaseFunction.java b/src/main/java/net/minecraft/world/level/storage/loot/functions/EnchantedCountIncreaseFunction.java
+index 5f27e1ce23f2ed68e4c8af1986fafce940dbf826..d8cf49cbd82ed12d23fa10a81a88cc4bcf1c0f10 100644
+--- a/src/main/java/net/minecraft/world/level/storage/loot/functions/EnchantedCountIncreaseFunction.java
+++ b/src/main/java/net/minecraft/world/level/storage/loot/functions/EnchantedCountIncreaseFunction.java
+@@ -66,6 +66,11 @@ public class EnchantedCountIncreaseFunction extends LootItemConditionalFunction
+         Entity entity = context.getOptionalParameter(LootContextParams.ATTACKING_ENTITY);
+         if (entity instanceof LivingEntity livingEntity) {
+             int i = EnchantmentHelper.getEnchantmentLevel(this.enchantment, livingEntity);
+            // Purpur start - Add an option to fix MC-3304 projectile looting
+            if (org.purpurmc.purpur.PurpurConfig.fixProjectileLootingTransfer && context.getOptionalParameter(LootContextParams.DIRECT_ATTACKING_ENTITY) instanceof net.minecraft.world.entity.projectile.AbstractArrow arrow) {
+                i = arrow.actualEnchantments.getLevel(this.enchantment);
+            }
+            // Purpur end - Add an option to fix MC-3304 projectile looting
+             if (i == 0) {
+                 return stack;
+             }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 4e47c24adb808feee415ee3e1c159955a7be5c71..b5724a0646f2194591d0c8539b87a850ad1bb5db 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -502,6 +502,11 @@ public class PurpurConfig {
+         usernameValidCharactersPattern = java.util.regex.Pattern.compile(setPattern == null || setPattern.isBlank() ? defaultPattern : setPattern);
+     }
+ 
+    public static boolean fixProjectileLootingTransfer = false;
+    private static void fixProjectileLootingTransfer() {
+        fixProjectileLootingTransfer = getBoolean("settings.fix-projectile-looting-transfer", fixProjectileLootingTransfer);
+    }
+
+     private static void blastResistanceSettings() {
+         getMap("settings.blast-resistance-overrides", Collections.emptyMap()).forEach((blockId, value) -> {
+             Block block = BuiltInRegistries.BLOCK.getValue(ResourceLocation.parse(blockId));
--- a/patches/server/0266-Add-option-to-allow-creeper-to-encircle-target-when-.patch
+++ b/patches/server/0266-Add-option-to-allow-creeper-to-encircle-target-when-.patch
@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jared Seville <Peashooter101@yahoo.com>
+Date: Sat, 15 Oct 2022 16:01:03 -0700
+Subject: [PATCH] Add option to allow creeper to encircle target when fusing.
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+index 137ec75ee803789deb7b1ca93dd9369c9af362b9..ca95d25af3e9a0536868b0c7fd8e7d2ff1154ee3 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+@@ -54,6 +54,14 @@ public class SwellGoal extends Goal {
+             this.creeper.setSwellDir(-1);
+         } else {
+             this.creeper.setSwellDir(1);
+            // Purpur start
+            if (this.creeper.level().purpurConfig.creeperEncircleTarget) {
+                net.minecraft.world.phys.Vec3 relative = this.creeper.position().subtract(this.target.position());
+                relative = relative.yRot((float) Math.PI / 3).normalize().multiply(2, 2, 2);
+                net.minecraft.world.phys.Vec3 destination = this.target.position().add(relative);
+                this.creeper.getNavigation().moveTo(destination.x, destination.y, destination.z, 1);
+            }
+            // Purpur end
+         }
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 446cdd50d4b5d5ed2e58f4bc4fbb13810399754d..342d5111bd3d4b434071f7499467a860a278ee08 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1439,6 +1439,7 @@ public class PurpurWorldConfig {
+     public boolean creeperHealthRadius = false;
+     public boolean creeperAlwaysDropExp = false;
+     public double creeperHeadVisibilityPercent = 0.5D;
+    public boolean creeperEncircleTarget = false;
+     private void creeperSettings() {
+         creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
+         creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
+@@ -1458,6 +1459,7 @@ public class PurpurWorldConfig {
+         creeperHealthRadius = getBoolean("mobs.creeper.health-impacts-explosion", creeperHealthRadius);
+         creeperAlwaysDropExp = getBoolean("mobs.creeper.always-drop-exp", creeperAlwaysDropExp);
+         creeperHeadVisibilityPercent = getDouble("mobs.creeper.head-visibility-percent", creeperHeadVisibilityPercent);
+        creeperEncircleTarget = getBoolean("mobs.creeper.encircle-target", creeperEncircleTarget);
+     }
+ 
+     public boolean dolphinRidable = false;
--- a/patches/server/0267-Fire-Immunity-API.patch
+++ b/patches/server/0267-Fire-Immunity-API.patch
@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Racci <90304606+DaRacci@users.noreply.github.com>
+Date: Fri, 4 Feb 2022 16:10:21 +1100
+Subject: [PATCH] Fire Immunity API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 7435ff1996e0a6db2f98f1218bf7d2b73a3e2b1d..1832f7ef8a14fb60e004cb7b99a0cd0155332349 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -393,6 +393,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public boolean activatedPriorityReset = false; // Pufferfish - DAB
+     public int activatedPriority = gg.pufferfish.pufferfish.PufferfishConfig.maximumActivationPrio; // Pufferfish - DAB (golf score)
+     public final BlockPos.MutableBlockPos cachedBlockPos = new BlockPos.MutableBlockPos(); // Pufferfish - reduce entity allocations
+    public @Nullable Boolean immuneToFire = null; // Purpur - Fire immune API
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -1983,7 +1984,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+ 
+     public boolean fireImmune() {
+-        return this.getType().fireImmune();
+        return this.immuneToFire != null ? immuneToFire : this.getType().fireImmune(); // Purpur - add fire immune API
+     }
+ 
+     public boolean causeFallDamage(float fallDistance, float damageMultiplier, DamageSource damageSource) {
+@@ -2738,6 +2739,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                 nbttagcompound.putBoolean("Paper.FreezeLock", true);
+             }
+             // Paper end
+            // Purpur start
+            if (immuneToFire != null) {
+                nbttagcompound.putBoolean("Purpur.FireImmune", immuneToFire);
+            }
+            // Purpur end
+             return nbttagcompound;
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Saving entity NBT");
+@@ -2888,6 +2894,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                 freezeLocked = nbt.getBoolean("Paper.FreezeLock");
+             }
+             // Paper end
+            // Purpur start
+            if (nbt.contains("Purpur.FireImmune")) {
+                immuneToFire = nbt.getBoolean("Purpur.FireImmune");
+            }
+            // Purpur end
+ 
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Loading entity NBT");
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index d4396ece618c0fec437ed915ce07be3fb5f7dca9..1290c1587fe9e39d9350c1079ab27f3be0c6084f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -88,6 +88,16 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+     }
+ 
+     // Purpur start - API for any mob to burn daylight
+    @Override
+    public boolean isImmuneToFire() {
+        return getHandle().fireImmune();
+    }
+
+    @Override
+    public void setImmuneToFire(Boolean fireImmune) {
+        getHandle().immuneToFire = fireImmune;
+    }
+
+     @Override
+     public boolean isInDaylight() {
+         return getHandle().isSunBurnTick();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+index 01e4395f1669d21c30465aa1366bd2f1ae17678f..5c1cda88080850314dac196dbe71ff12e48a8aca 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+@@ -173,9 +173,14 @@ public class CraftItem extends CraftEntity implements Item {
+         return this.getHandle().immuneToExplosion;
+     }
+ 
+    @Override
+    public void setImmuneToFire(@org.jetbrains.annotations.Nullable Boolean immuneToFire) {
+        this.getHandle().immuneToFire = (immuneToFire != null && immuneToFire);
+    }
+
+     @Override
+     public void setImmuneToFire(boolean immuneToFire) {
+-        item.immuneToFire = immuneToFire;
+        this.setImmuneToFire((Boolean) immuneToFire);
+     }
+ 
+     @Override
--- a/patches/server/0268-Add-option-to-teleport-to-spawn-on-nether-ceiling-da.patch
+++ b/patches/server/0268-Add-option-to-teleport-to-spawn-on-nether-ceiling-da.patch
@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Sun, 13 Nov 2022 05:05:34 -0600
+Subject: [PATCH] Add option to teleport to spawn on nether ceiling damage
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 1832f7ef8a14fb60e004cb7b99a0cd0155332349..da7ffdf85907c92fe6c4c6a5ebe571ef4666fcb8 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1004,6 +1004,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             && this.level.paperConfig().environment.netherCeilingVoidDamageHeight.test(v -> this.getY() >= v)
+             && (!(this instanceof Player player) || !player.getAbilities().invulnerable))) {
+             // Paper end - Configurable nether ceiling damage
+            if (this.level().purpurConfig.teleportOnNetherCeilingDamage && this.level.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER && this instanceof ServerPlayer player) player.teleport(io.papermc.paper.util.MCUtil.toLocation(this.level, this.level.getSharedSpawnPos())); else // Purpur
+             this.onBelowWorld();
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 342d5111bd3d4b434071f7499467a860a278ee08..89e80073eb911e72d0bac5b50119421a91cd3a16 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -418,6 +418,7 @@ public class PurpurWorldConfig {
+     public String playerDeathExpDropEquation = "expLevel * 7";
+     public int playerDeathExpDropMax = 100;
+     public boolean teleportIfOutsideBorder = false;
+    public boolean teleportOnNetherCeilingDamage = false;
+     public boolean totemOfUndyingWorksInInventory = false;
+     public boolean playerFixStuckPortal = false;
+     public boolean creativeOnePunch = false;
+@@ -445,6 +446,7 @@ public class PurpurWorldConfig {
+         playerDeathExpDropEquation = getString("gameplay-mechanics.player.exp-dropped-on-death.equation", playerDeathExpDropEquation);
+         playerDeathExpDropMax = getInt("gameplay-mechanics.player.exp-dropped-on-death.maximum", playerDeathExpDropMax);
+         teleportIfOutsideBorder = getBoolean("gameplay-mechanics.player.teleport-if-outside-border", teleportIfOutsideBorder);
+        teleportOnNetherCeilingDamage = getBoolean("gameplay-mechanics.player.teleport-on-nether-ceiling-damage", teleportOnNetherCeilingDamage);
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+         playerFixStuckPortal = getBoolean("gameplay-mechanics.player.fix-stuck-in-portal", playerFixStuckPortal);
+         creativeOnePunch = getBoolean("gameplay-mechanics.player.one-punch-in-creative", creativeOnePunch);
--- a/patches/server/0269-Added-got-ram-event.patch
+++ b/patches/server/0269-Added-got-ram-event.patch
@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SageSphinx63920 <sage@sagesphinx63920.dev>
+Date: Sat, 29 Oct 2022 00:06:41 +0200
+Subject: [PATCH] Added got ram event
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+index 752f44048ed4f61ce8e2cce67d0680b7837cdd29..d508cb2a61866c8fd7f381f8deb558ed86f7c845 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+@@ -433,6 +433,7 @@ public class Goat extends Animal {
+ 
+     // Paper start - Goat ram API
+     public void ram(net.minecraft.world.entity.LivingEntity entity) {
+        if(!new org.purpurmc.purpur.event.entity.GoatRamEntityEvent((org.bukkit.entity.Goat) getBukkitEntity(), (org.bukkit.entity.LivingEntity) entity.getBukkitLivingEntity()).callEvent()) return; // Purpur
+         Brain<Goat> brain = this.getBrain();
+         brain.setMemory(MemoryModuleType.RAM_TARGET, entity.position());
+         brain.eraseMemory(MemoryModuleType.RAM_COOLDOWN_TICKS);
--- a/patches/server/0270-Log-skipped-entity-s-position.patch
+++ b/patches/server/0270-Log-skipped-entity-s-position.patch
@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Thu, 24 Nov 2022 11:00:37 -0600
+Subject: [PATCH] Log skipped entity's position
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index 2f08747612bd238f12c8d3dccb996118e7c34e33..a3ae5e663a0334eaa8ca6ce89c3088620a849bb9 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -693,6 +693,12 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+             entity.load(nbt);
+         }, () -> {
+             EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.getString("id"));
+            // Purpur start - log skipped entity's position
+            try {
+                ListTag pos = nbt.getList("Pos", 6);
+                EntityType.LOGGER.warn("Location: {} {},{},{}", world.getWorld().getName(), pos.getDouble(0), pos.getDouble(1), pos.getDouble(2));
+            } catch (Throwable ignore) {}
+            // Purpur end
+         });
+     }
+ 
--- a/patches/server/0271-End-Crystal-Cramming.patch
+++ b/patches/server/0271-End-Crystal-Cramming.patch
@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Thu, 15 Dec 2022 11:42:15 -0600
+Subject: [PATCH] End Crystal Cramming
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+index 305c3350116f656c3d0e6134e4d8023eac50f3ad..b1db1e92de3a88a0f0e0fdb42b0bf9732095c8a9 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+@@ -102,6 +102,7 @@ public class EndCrystal extends Entity {
+                 }
+             }
+             // Paper end - Fix invulnerable end crystals
+            if (this.level().purpurConfig.endCrystalCramming > 0 && this.level().getEntitiesOfClass(EndCrystal.class, getBoundingBox()).size() > this.level().purpurConfig.endCrystalCramming) this.hurt(this.damageSources().cramming(), 6.0F); // Purpur
+         }
+ 
+     // Purpur start
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 89e80073eb911e72d0bac5b50119421a91cd3a16..991d13948d90039a4a344b51317b52f882b34e5f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -915,6 +915,7 @@ public class PurpurWorldConfig {
+     public double basedEndCrystalExplosionPower = 6.0D;
+     public boolean basedEndCrystalExplosionFire = false;
+     public net.minecraft.world.level.Level.ExplosionInteraction basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
+    public int endCrystalCramming = 0;
+     private void endCrystalSettings() {
+         if (PurpurConfig.version < 31) {
+             if ("DESTROY".equals(getString("blocks.end-crystal.baseless.explosion-effect", baselessEndCrystalExplosionEffect.name()))) {
+@@ -942,6 +943,7 @@ public class PurpurWorldConfig {
+             log(Level.SEVERE, "Unknown value for `blocks.end-crystal.base.explosion-effect`! Using default of `BLOCK`");
+             basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
+         }
+        endCrystalCramming = getInt("blocks.end-crystal.cramming-amount", endCrystalCramming);
+     }
+ 
+     public boolean farmlandBypassMobGriefing = false;
--- a/patches/server/0272-Option-to-allow-beacon-effects-when-covered-by-tinte.patch
+++ b/patches/server/0272-Option-to-allow-beacon-effects-when-covered-by-tinte.patch
@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: 12emin34 <macanovic.emin@gmail.com>
+Date: Mon, 26 Dec 2022 19:10:43 +0100
+Subject: [PATCH] Option to allow beacon effects when covered by tinted glass
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+index fbc6b0099af34b0247f6144a9cef020f9ccddeef..2d190b3a6378b8cbadfa65510df1ccfbd5882ef8 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -178,6 +178,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+         int j = pos.getY();
+         int k = pos.getZ();
+         BlockPos blockposition1;
+        boolean isTintedGlass = false;
+ 
+         if (blockEntity.lastCheckY < j) {
+             blockposition1 = pos;
+@@ -211,6 +212,9 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+                     }
+                 }
+             } else {
+                if (world.purpurConfig.beaconAllowEffectsWithTintedGlass && block.equals(Blocks.TINTED_GLASS)) {
+                    isTintedGlass = true;
+                }
+                 if (tileentitybeacon_beaconcolortracker == null || iblockdata1.getLightBlock() >= 15 && !iblockdata1.is(Blocks.BEDROCK)) {
+                     blockEntity.checkingBeamSections.clear();
+                     blockEntity.lastCheckY = l;
+@@ -230,7 +234,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+                 blockEntity.levels = BeaconBlockEntity.updateBase(world, i, j, k);
+             }
+ 
+-            if (blockEntity.levels > 0 && !blockEntity.beamSections.isEmpty()) {
+            if (blockEntity.levels > 0 && (!blockEntity.beamSections.isEmpty() || (world.purpurConfig.beaconAllowEffectsWithTintedGlass && isTintedGlass))) {
+                 BeaconBlockEntity.applyEffects(world, pos, blockEntity.levels, blockEntity.primaryPower, blockEntity.secondaryPower, blockEntity); // Paper - Custom beacon ranges
+                 BeaconBlockEntity.playSound(world, pos, SoundEvents.BEACON_AMBIENT);
+             }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 991d13948d90039a4a344b51317b52f882b34e5f..5fb1b4ca45faaf9d172adb8f3a7879322ae29117 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -814,11 +814,13 @@ public class PurpurWorldConfig {
+     public int beaconLevelTwo = 30;
+     public int beaconLevelThree = 40;
+     public int beaconLevelFour = 50;
+    public boolean beaconAllowEffectsWithTintedGlass = false;
+     private void beaconSettings() {
+         beaconLevelOne = getInt("blocks.beacon.effect-range.level-1", beaconLevelOne);
+         beaconLevelTwo = getInt("blocks.beacon.effect-range.level-2", beaconLevelTwo);
+         beaconLevelThree = getInt("blocks.beacon.effect-range.level-3", beaconLevelThree);
+         beaconLevelFour = getInt("blocks.beacon.effect-range.level-4", beaconLevelFour);
+        beaconAllowEffectsWithTintedGlass = getBoolean("blocks.beacon.allow-effects-with-tinted-glass", beaconAllowEffectsWithTintedGlass);
+     }
+ 
+     public boolean bedExplode = true;
--- a/patches/server/0273-Add-attribute-clamping-and-armor-limit-config.patch
+++ b/patches/server/0273-Add-attribute-clamping-and-armor-limit-config.patch
@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Thu, 27 Oct 2022 23:12:45 -0400
+Subject: [PATCH] Add attribute clamping and armor limit config
+
+
+diff --git a/src/main/java/net/minecraft/world/damagesource/CombatRules.java b/src/main/java/net/minecraft/world/damagesource/CombatRules.java
+index 064c1e33f3feee77837bb57887877ae1ca39548d..ffd009bca3fdbfd0b14df78072ef8d472a57cd65 100644
+--- a/src/main/java/net/minecraft/world/damagesource/CombatRules.java
+++ b/src/main/java/net/minecraft/world/damagesource/CombatRules.java
+@@ -15,7 +15,7 @@ public class CombatRules {
+ 
+     public static float getDamageAfterAbsorb(LivingEntity armorWearer, float damageAmount, DamageSource damageSource, float armor, float armorToughness) {
+         float f = 2.0F + armorToughness / 4.0F;
+-        float g = Mth.clamp(armor - damageAmount / f, armor * 0.2F, 20.0F);
+        float g = Mth.clamp(armor - damageAmount / f, armor * 0.2F, org.purpurmc.purpur.PurpurConfig.limitArmor ? 20F : Float.MAX_VALUE); // Purpur
+         float h = g / 25.0F;
+         ItemStack itemStack = damageSource.getWeaponItem();
+         float i;
+@@ -30,7 +30,7 @@ public class CombatRules {
+     }
+ 
+     public static float getDamageAfterMagicAbsorb(float damageDealt, float protection) {
+-        float f = Mth.clamp(protection, 0.0F, 20.0F);
+        float f = Mth.clamp(protection, 0.0F, org.purpurmc.purpur.PurpurConfig.limitArmor ? 20F : Float.MAX_VALUE); // Purpur
+         return damageDealt * (1.0F - f / 25.0F);
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/RangedAttribute.java b/src/main/java/net/minecraft/world/entity/ai/attributes/RangedAttribute.java
+index f0703302e7dbbda88de8c648d20d87c55ed9b1e0..a913ebabaa5f443afa987b972355a8f8d1723c78 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/attributes/RangedAttribute.java
+++ b/src/main/java/net/minecraft/world/entity/ai/attributes/RangedAttribute.java
+@@ -29,6 +29,7 @@ public class RangedAttribute extends Attribute {
+ 
+     @Override
+     public double sanitizeValue(double value) {
+        if (!org.purpurmc.purpur.PurpurConfig.clampAttributes) return Double.isNaN(value) ? this.minValue : value; // Purpur
+         return Double.isNaN(value) ? this.minValue : Mth.clamp(value, this.minValue, this.maxValue);
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index b5724a0646f2194591d0c8539b87a850ad1bb5db..334bcf9f24c6b658664424fd960dad6fb9e28c7d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -507,6 +507,16 @@ public class PurpurConfig {
+         fixProjectileLootingTransfer = getBoolean("settings.fix-projectile-looting-transfer", fixProjectileLootingTransfer);
+     }
+ 
+    public static boolean clampAttributes = true;
+    private static void clampAttributes() {
+        clampAttributes = getBoolean("settings.clamp-attributes", clampAttributes);
+    }
+
+    public static boolean limitArmor = true;
+    private static void limitArmor() {
+        limitArmor = getBoolean("settings.limit-armor", limitArmor);
+    }
+
+     private static void blastResistanceSettings() {
+         getMap("settings.blast-resistance-overrides", Collections.emptyMap()).forEach((blockId, value) -> {
+             Block block = BuiltInRegistries.BLOCK.getValue(ResourceLocation.parse(blockId));
--- a/patches/server/0274-Config-to-remove-explosion-radius-clamp.patch
+++ b/patches/server/0274-Config-to-remove-explosion-radius-clamp.patch
@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nico314159 <nicolino.will@gmail.com>
+Date: Mon, 9 Jan 2023 19:45:55 -0500
+Subject: [PATCH] Config to remove explosion radius clamp
+
+
+diff --git a/src/main/java/net/minecraft/world/level/ServerExplosion.java b/src/main/java/net/minecraft/world/level/ServerExplosion.java
+index 685ccfb73bf7125585ef90b6a0f51b2f81daa428..15a3849922664b85fa6bc9101c2af380d57ea0f3 100644
+--- a/src/main/java/net/minecraft/world/level/ServerExplosion.java
+++ b/src/main/java/net/minecraft/world/level/ServerExplosion.java
+@@ -311,7 +311,7 @@ public class ServerExplosion implements Explosion {
+     public ServerExplosion(ServerLevel world, @Nullable Entity entity, @Nullable DamageSource damageSource, @Nullable ExplosionDamageCalculator behavior, Vec3 pos, float power, boolean createFire, Explosion.BlockInteraction destructionType) {
+         this.level = world;
+         this.source = entity;
+-        this.radius = (float) Math.max(power, 0.0); // CraftBukkit - clamp bad values
+        this.radius = (float) (world == null || world.purpurConfig.explosionClampRadius ? Math.max(power, 0.0) : power); // CraftBukkit - clamp bad values // Purpur
+         this.center = pos;
+         this.fire = createFire;
+         this.blockInteraction = destructionType;
+@@ -666,7 +666,7 @@ public class ServerExplosion implements Explosion {
+ 
+     public void explode() {
+         // CraftBukkit start
+-        if (this.radius < 0.1F) {
+        if ((this.level == null || this.level.purpurConfig.explosionClampRadius) && this.radius < 0.1F) { // Purpur
+             return;
+         }
+         // CraftBukkit end
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 5fb1b4ca45faaf9d172adb8f3a7879322ae29117..12ccac3893097d428c3c7f9cfdfc67e78dd9d691 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -225,6 +225,11 @@ public class PurpurWorldConfig {
+         infinityWorksWithoutArrows = getBoolean("gameplay-mechanics.infinity-bow.works-without-arrows", infinityWorksWithoutArrows);
+     }
+ 
+    public boolean explosionClampRadius = true;
+    private void explosionSettings() {
+        explosionClampRadius = getBoolean("gameplay-mechanics.clamp-explosion-radius", explosionClampRadius);
+    }
+
+     public List<Item> itemImmuneToCactus = new ArrayList<>();
+     public List<Item> itemImmuneToExplosion = new ArrayList<>();
+     public List<Item> itemImmuneToFire = new ArrayList<>();
--- a/patches/server/0275-bonemealable-sugarcane-cactus-and-netherwart.patch
+++ b/patches/server/0275-bonemealable-sugarcane-cactus-and-netherwart.patch
@@ -0,0 +1,163 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Thu, 9 Feb 2023 00:28:03 -0800
+Subject: [PATCH] bonemealable sugarcane, cactus, and netherwart
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/CactusBlock.java b/src/main/java/net/minecraft/world/level/block/CactusBlock.java
+index bbfd8f5d404d0add94f0d8ac89a2964692b37e44..9f163ed07f8e6a5370c4c355b4e910f7a49b6bcd 100644
+--- a/src/main/java/net/minecraft/world/level/block/CactusBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/CactusBlock.java
+@@ -24,7 +24,7 @@ import net.minecraft.world.phys.shapes.CollisionContext;
+ import net.minecraft.world.phys.shapes.VoxelShape;
+ import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
+ 
+-public class CactusBlock extends Block {
+public class CactusBlock extends Block implements BonemealableBlock { // Purpur
+ 
+     public static final MapCodec<CactusBlock> CODEC = simpleCodec(CactusBlock::new);
+     public static final IntegerProperty AGE = BlockStateProperties.AGE_15;
+@@ -135,4 +135,34 @@ public class CactusBlock extends Block {
+     protected boolean isPathfindable(BlockState state, PathComputationType type) {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    public boolean isValidBonemealTarget(final LevelReader world, final BlockPos pos, final BlockState state) {
+        if (!((Level) world).purpurConfig.cactusAffectedByBonemeal || !world.isEmptyBlock(pos.above())) return false;
+
+        int cactusHeight = 0;
+        while (world.getBlockState(pos.below(cactusHeight)).is(this)) {
+            cactusHeight++;
+        }
+
+        return cactusHeight < ((Level) world).paperConfig().maxGrowthHeight.cactus;
+    }
+
+    @Override
+    public boolean isBonemealSuccess(Level world, RandomSource random, BlockPos pos, BlockState state) {
+        return true;
+    }
+
+    @Override
+    public void performBonemeal(ServerLevel world, RandomSource random, BlockPos pos, BlockState state) {
+        int cactusHeight = 0;
+        while (world.getBlockState(pos.below(cactusHeight)).is(this)) {
+            cactusHeight++;
+        }
+        for (int i = 0; i <= world.paperConfig().maxGrowthHeight.cactus - cactusHeight; i++) {
+            world.setBlockAndUpdate(pos.above(i), state.setValue(CactusBlock.AGE, 0));
+        }
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/NetherWartBlock.java b/src/main/java/net/minecraft/world/level/block/NetherWartBlock.java
+index b571bca4375ca7caf9b75dbf84009cb0604b66ad..264692baa4a20b66910d8ff379fa72acb99e27f8 100644
+--- a/src/main/java/net/minecraft/world/level/block/NetherWartBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/NetherWartBlock.java
+@@ -16,7 +16,7 @@ import net.minecraft.world.level.block.state.properties.IntegerProperty;
+ import net.minecraft.world.phys.shapes.CollisionContext;
+ import net.minecraft.world.phys.shapes.VoxelShape;
+ 
+-public class NetherWartBlock extends BushBlock {
+public class NetherWartBlock extends BushBlock implements BonemealableBlock { // Purpur
+ 
+     public static final MapCodec<NetherWartBlock> CODEC = simpleCodec(NetherWartBlock::new);
+     public static final int MAX_AGE = 3;
+@@ -78,5 +78,22 @@ public class NetherWartBlock extends BushBlock {
+             super.playerDestroy(world, player, pos, state, blockEntity, itemInHand, includeDrops, dropExp);
+         }
+     }
+
+    @Override
+    public boolean isValidBonemealTarget(final net.minecraft.world.level.LevelReader world, final BlockPos pos, final BlockState state) {
+        return ((net.minecraft.world.level.Level) world).purpurConfig.netherWartAffectedByBonemeal && state.getValue(NetherWartBlock.AGE) < 3;
+    }
+
+    @Override
+    public boolean isBonemealSuccess(net.minecraft.world.level.Level world, RandomSource random, BlockPos pos, BlockState state) {
+        return true;
+    }
+
+    @Override
+    public void performBonemeal(ServerLevel world, RandomSource random, BlockPos pos, BlockState state) {
+        int i = Math.min(3, state.getValue(NetherWartBlock.AGE) + 1);
+        state = state.setValue(NetherWartBlock.AGE, i);
+        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, pos, state, 2); // CraftBukkit
+    }
+     // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/SugarCaneBlock.java b/src/main/java/net/minecraft/world/level/block/SugarCaneBlock.java
+index 547ea09ed84595286c97c128b3b96f6d387ae25f..d0f8a13f27132257ece6dadf736c2dc6b1e5720e 100644
+--- a/src/main/java/net/minecraft/world/level/block/SugarCaneBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SugarCaneBlock.java
+@@ -20,7 +20,7 @@ import net.minecraft.world.level.material.FluidState;
+ import net.minecraft.world.phys.shapes.CollisionContext;
+ import net.minecraft.world.phys.shapes.VoxelShape;
+ 
+-public class SugarCaneBlock extends Block {
+public class SugarCaneBlock extends Block implements BonemealableBlock { // Purpur
+ 
+     public static final MapCodec<SugarCaneBlock> CODEC = simpleCodec(SugarCaneBlock::new);
+     public static final IntegerProperty AGE = BlockStateProperties.AGE_15;
+@@ -113,4 +113,34 @@ public class SugarCaneBlock extends Block {
+     protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+         builder.add(SugarCaneBlock.AGE);
+     }
+
+    // Purpur start
+    @Override
+    public boolean isValidBonemealTarget(final LevelReader world, final BlockPos pos, final BlockState state) {
+        if (!((net.minecraft.world.level.Level) world).purpurConfig.sugarCanAffectedByBonemeal || !world.isEmptyBlock(pos.above())) return false;
+
+        int reedHeight = 0;
+        while (world.getBlockState(pos.below(reedHeight)).is(this)) {
+            reedHeight++;
+        }
+
+        return reedHeight < ((net.minecraft.world.level.Level) world).paperConfig().maxGrowthHeight.reeds;
+    }
+
+    @Override
+    public boolean isBonemealSuccess(net.minecraft.world.level.Level world, RandomSource random, BlockPos pos, BlockState state) {
+        return true;
+    }
+
+    @Override
+    public void performBonemeal(ServerLevel world, RandomSource random, BlockPos pos, BlockState state) {
+        int reedHeight = 0;
+        while (world.getBlockState(pos.below(reedHeight)).is(this)) {
+            reedHeight++;
+        }
+        for (int i = 0; i <= world.paperConfig().maxGrowthHeight.reeds - reedHeight; i++) {
+            world.setBlockAndUpdate(pos.above(i), state.setValue(SugarCaneBlock.AGE, 0));
+        }
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 12ccac3893097d428c3c7f9cfdfc67e78dd9d691..4ef5aaa033f6ba5a4260345df12426954b8d6fbe 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -868,8 +868,20 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean cactusBreaksFromSolidNeighbors = true;
+    public boolean cactusAffectedByBonemeal = false;
+     private void cactusSettings() {
+         cactusBreaksFromSolidNeighbors = getBoolean("blocks.cactus.breaks-from-solid-neighbors", cactusBreaksFromSolidNeighbors);
+        cactusAffectedByBonemeal = getBoolean("blocks.cactus.affected-by-bonemeal", cactusAffectedByBonemeal);
+    }
+
+    public boolean sugarCanAffectedByBonemeal = false;
+    private void sugarCaneSettings() {
+        sugarCanAffectedByBonemeal = getBoolean("blocks.sugar_cane.affected-by-bonemeal", sugarCanAffectedByBonemeal);
+    }
+
+    public boolean netherWartAffectedByBonemeal = false;
+    private void netherWartSettings() {
+        netherWartAffectedByBonemeal = getBoolean("blocks.nether_wart.affected-by-bonemeal", netherWartAffectedByBonemeal);
+     }
+ 
+     public boolean campFireLitWhenPlaced = true;
--- a/patches/server/0276-Add-PreExplodeEvents.patch
+++ b/patches/server/0276-Add-PreExplodeEvents.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SageSphinx63920 <sage@sagesphinx63920.dev>
+Date: Mon, 26 Dec 2022 23:42:37 +0100
+Subject: [PATCH] Add PreExplodeEvents
+
+
+diff --git a/src/main/java/net/minecraft/world/level/ServerExplosion.java b/src/main/java/net/minecraft/world/level/ServerExplosion.java
+index 15a3849922664b85fa6bc9101c2af380d57ea0f3..e2763ee67530074d8ec78fbff694eb84f5373de0 100644
+--- a/src/main/java/net/minecraft/world/level/ServerExplosion.java
+++ b/src/main/java/net/minecraft/world/level/ServerExplosion.java
+@@ -670,6 +670,23 @@ public class ServerExplosion implements Explosion {
+             return;
+         }
+         // CraftBukkit end
+        // Purpur start - add PreExplodeEvents
+        if (this.source != null) {
+            Location location = new Location(this.level.getWorld(), this.center.x, this.center.y, this.center.z);
+            if(!new org.purpurmc.purpur.event.entity.PreEntityExplodeEvent(this.source.getBukkitEntity(), location, this.blockInteraction == Explosion.BlockInteraction.DESTROY_WITH_DECAY ? 1.0F / this.radius : 1.0F, org.bukkit.craftbukkit.CraftExplosionResult.toBukkit(getBlockInteraction())).callEvent()) {
+                this.wasCanceled = true;
+                return;
+            }
+        } else {
+            Location location = new Location(this.level.getWorld(), this.center.x, this.center.y, this.center.z);
+            org.bukkit.block.Block block = location.getBlock();
+            org.bukkit.block.BlockState blockState = (this.damageSource.getDirectBlockState() != null) ? this.damageSource.getDirectBlockState() : block.getState();
+            if(!new org.purpurmc.purpur.event.PreBlockExplodeEvent(location.getBlock(), this.blockInteraction == Explosion.BlockInteraction.DESTROY_WITH_DECAY ? 1.0F / this.radius : 1.0F, blockState, org.bukkit.craftbukkit.CraftExplosionResult.toBukkit(getBlockInteraction())).callEvent()) {
+                this.wasCanceled = true;
+                return;
+            }
+        }
+        // Purpur end
+         // Paper start - collision optimisations
+         this.blockCache = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>();
+         this.chunkPosCache = new long[CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH];
--- a/patches/server/0277-Improve-output-of-plugins-command.patch
+++ b/patches/server/0277-Improve-output-of-plugins-command.patch
@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Parker Hawke <hawkeboyz2@hotmail.com>
+Date: Sat, 27 Jun 2020 18:43:37 -0400
+Subject: [PATCH] Improve output of plugins command
+
+Co-authored-by: Oharass <oharass@bk.ru>
+Co-authored-by: granny <granny@purpurmc.org>
+
+diff --git a/src/main/java/io/papermc/paper/command/PaperPluginsCommand.java b/src/main/java/io/papermc/paper/command/PaperPluginsCommand.java
+index f0fce4113fb07c64adbec029d177c236cbdcbae8..865dc183276720d54d31d2a54d1bb5c845e80598 100644
+--- a/src/main/java/io/papermc/paper/command/PaperPluginsCommand.java
+++ b/src/main/java/io/papermc/paper/command/PaperPluginsCommand.java
+@@ -78,10 +78,10 @@ public class PaperPluginsCommand extends BukkitCommand {
+         this.setAliases(Arrays.asList("pl"));
+     }
+ 
+-    private static <T> List<Component> formatProviders(TreeMap<String, PluginProvider<T>> plugins) {
+    private static <T> List<Component> formatProviders(TreeMap<String, PluginProvider<T>> plugins, @NotNull CommandSender sender) { // Purpur
+         List<Component> components = new ArrayList<>(plugins.size());
+         for (PluginProvider<T> entry : plugins.values()) {
+-            components.add(formatProvider(entry));
+            components.add(formatProvider(entry, sender)); // Purpur
+         }
+ 
+         boolean isFirst = true;
+@@ -109,7 +109,7 @@ public class PaperPluginsCommand extends BukkitCommand {
+         return formattedSublists;
+     }
+ 
+-    private static Component formatProvider(PluginProvider<?> provider) {
+    private static Component formatProvider(PluginProvider<?> provider, @NotNull CommandSender sender) { // Purpur
+         TextComponent.Builder builder = Component.text();
+         if (provider instanceof SpigotPluginProvider spigotPluginProvider && CraftMagicNumbers.isLegacy(spigotPluginProvider.getMeta())) {
+             builder.append(LEGACY_PLUGIN_STAR);
+@@ -117,13 +117,65 @@ public class PaperPluginsCommand extends BukkitCommand {
+ 
+         String name = provider.getMeta().getName();
+         Component pluginName = Component.text(name, fromStatus(provider))
+-            .clickEvent(ClickEvent.runCommand("/version " + name));
+        // Purpur start
+            .clickEvent(ClickEvent.suggestCommand("/version " + name));
+
+        if (sender instanceof org.bukkit.entity.Player && sender.hasPermission("bukkit.command.version")) {
+            // Event components
+            String description = provider.getMeta().getDescription();
+            TextComponent.Builder hover = Component.text();
+            hover.append(Component.text("Version: ", NamedTextColor.WHITE)).append(Component.text(provider.getMeta().getVersion(), NamedTextColor.GREEN));
+
+            if (description != null) {
+                hover.append(Component.newline())
+                        .append(Component.text("Description: ", NamedTextColor.WHITE))
+                        .append(Component.text(description, NamedTextColor.GREEN));
+            }
+
+            if (provider.getMeta().getWebsite() != null) {
+                hover.append(Component.newline())
+                        .append(Component.text("Website: ", NamedTextColor.WHITE))
+                        .append(Component.text(provider.getMeta().getWebsite(), NamedTextColor.GREEN));
+            }
+
+            if (!provider.getMeta().getAuthors().isEmpty()) {
+                hover.append(Component.newline());
+                if (provider.getMeta().getAuthors().size() == 1) {
+                    hover.append(Component.text("Author: "));
+                } else {
+                    hover.append(Component.text("Authors: "));
+                }
+
+                hover.append(getAuthors(provider.getMeta()));
+            }
+
+            pluginName.hoverEvent(hover.build());
+        }
+        // Purpur end
+ 
+         builder.append(pluginName);
+ 
+         return builder.build();
+     }
+ 
+    // Purpur start
+    @NotNull
+    private static TextComponent getAuthors(@NotNull final PluginMeta pluginMeta) {
+        TextComponent.Builder builder = Component.text();
+        List<String> authors = pluginMeta.getAuthors();
+
+        for (int i = 0; i < authors.size(); i++) {
+            if (i > 0) {
+                builder.append(Component.text(i < authors.size() - 1 ? ", " : " and ", NamedTextColor.WHITE));
+            }
+
+            builder.append(Component.text(authors.get(i), NamedTextColor.GREEN));
+        }
+
+        return builder.build();
+    }
+    // Purpur end
+
+     private static Component asPlainComponents(String strings) {
+         net.kyori.adventure.text.TextComponent.Builder builder = Component.text();
+         for (String string : strings.split("\n")) {
+@@ -182,24 +234,24 @@ public class PaperPluginsCommand extends BukkitCommand {
+             }
+         }
+ 
+-        Component infoMessage = Component.text("Server Plugins (%s):".formatted(paperPlugins.size() + spigotPlugins.size()), NamedTextColor.WHITE);
+        //Component infoMessage = Component.text("Server Plugins (%s):".formatted(paperPlugins.size() + spigotPlugins.size()), NamedTextColor.WHITE);
+             //.append(INFO_ICON_START.hoverEvent(SERVER_PLUGIN_INFO)); TODO: Add docs
+ 
+-        sender.sendMessage(infoMessage);
+        //sender.sendMessage(infoMessage); // Purpur
+ 
+-        if (!paperPlugins.isEmpty()) {
+-            sender.sendMessage(PAPER_HEADER);
+-        }
+        //if (!paperPlugins.isEmpty()) { // Purpur
+            sender.sendMessage(PAPER_HEADER.append(Component.text(" (%s):".formatted(paperPlugins.size())))); // Purpur
+        //} // Purpur
+ 
+-        for (Component component : formatProviders(paperPlugins)) {
+        for (Component component : formatProviders(paperPlugins, sender)) { // Purpur
+             sender.sendMessage(component);
+         }
+ 
+-        if (!spigotPlugins.isEmpty()) {
+-            sender.sendMessage(BUKKIT_HEADER);
+-        }
+        //if (!spigotPlugins.isEmpty()) { // Purpur
+            sender.sendMessage(BUKKIT_HEADER.append(Component.text(" (%s):".formatted(spigotPlugins.size())))); // Purpur
+        //} // Purpur
+         
+-        for (Component component : formatProviders(spigotPlugins)) {
+        for (Component component : formatProviders(spigotPlugins, sender)) { // Purpur
+             sender.sendMessage(component);
+         }
+ 
--- a/patches/server/0278-Make-GUI-Great-Again.patch
+++ b/patches/server/0278-Make-GUI-Great-Again.patch
@@ -0,0 +1,421 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 16 Jan 2020 14:59:16 -0600
+Subject: [PATCH] Make GUI Great Again
+
+
+diff --git a/src/log4jPlugins/java/org/purpurmc/purpur/gui/HighlightErrorConverter.java b/src/log4jPlugins/java/org/purpurmc/purpur/gui/HighlightErrorConverter.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..15a226e3854d731f7724025ea3459c8ace07630c
+--- /dev/null
+++ b/src/log4jPlugins/java/org/purpurmc/purpur/gui/HighlightErrorConverter.java
+@@ -0,0 +1,85 @@
+package org.purpurmc.purpur.gui.util;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+import org.apache.logging.log4j.core.pattern.ConverterKeys;
+import org.apache.logging.log4j.core.pattern.LogEventPatternConverter;
+import org.apache.logging.log4j.core.pattern.PatternConverter;
+import org.apache.logging.log4j.core.pattern.PatternFormatter;
+import org.apache.logging.log4j.core.pattern.PatternParser;
+import org.apache.logging.log4j.util.PerformanceSensitive;
+
+import java.util.List;
+
+@Plugin(name = "highlightGUIError", category = PatternConverter.CATEGORY)
+@ConverterKeys({"highlightGUIError"})
+@PerformanceSensitive("allocation")
+public final class HighlightErrorConverter extends LogEventPatternConverter {
+    private static final String ERROR = "\u00A74\u00A7l"; // Bold Red
+    private static final String WARN = "\u00A7e\u00A7l"; // Bold Yellow
+
+    private final List<PatternFormatter> formatters;
+
+    private HighlightErrorConverter(List<PatternFormatter> formatters) {
+        super("highlightGUIError", null);
+        this.formatters = formatters;
+    }
+
+    @Override
+    public void format(LogEvent event, StringBuilder toAppendTo) {
+        Level level = event.getLevel();
+        if (level.isMoreSpecificThan(Level.ERROR)) {
+            format(ERROR, event, toAppendTo);
+            return;
+        } else if (level.isMoreSpecificThan(Level.WARN)) {
+            format(WARN, event, toAppendTo);
+            return;
+        }
+        for (PatternFormatter formatter : formatters) {
+            formatter.format(event, toAppendTo);
+        }
+    }
+
+    private void format(String style, LogEvent event, StringBuilder toAppendTo) {
+        int start = toAppendTo.length();
+        toAppendTo.append(style);
+        int end = toAppendTo.length();
+
+        for (PatternFormatter formatter : formatters) {
+            formatter.format(event, toAppendTo);
+        }
+
+        if (toAppendTo.length() == end) {
+            toAppendTo.setLength(start);
+        }
+    }
+
+    @Override
+    public boolean handlesThrowable() {
+        for (final PatternFormatter formatter : formatters) {
+            if (formatter.handlesThrowable()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static HighlightErrorConverter newInstance(Configuration config, String[] options) {
+        if (options.length != 1) {
+            LOGGER.error("Incorrect number of options on highlightGUIError. Expected 1 received " + options.length);
+            return null;
+        }
+
+        if (options[0] == null) {
+            LOGGER.error("No pattern supplied on highlightGUIError");
+            return null;
+        }
+
+        PatternParser parser = PatternLayout.createPatternParser(config);
+        List<PatternFormatter> formatters = parser.parse(options[0]);
+        return new HighlightErrorConverter(formatters);
+    }
+}
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 08a81a45371fd273fb35956bef3bb7947bb4c5b6..7a442fb4cf78bcb1268359ee41a6de138edb76b6 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -111,6 +111,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+                     return;
+                 }
+                 // Paper start - Use TerminalConsoleAppender
+                if (DedicatedServer.this.gui == null || System.console() != null) // Purpur - has no GUI or has console (did not double-click)
+                 new com.destroystokyo.paper.console.PaperConsole(DedicatedServer.this).start();
+                 /*
+                 jline.console.ConsoleReader bufferedreader = DedicatedServer.this.reader;
+diff --git a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+index 759062d219ff490a3cb19e710c4d18e3e08288e0..8f74c2ec5252b6265549589310d742337c91cb2c 100644
+--- a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+++ b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+@@ -43,6 +43,11 @@ public class MinecraftServerGui extends JComponent {
+     private Thread logAppenderThread;
+     private final Collection<Runnable> finalizers = Lists.newArrayList();
+     final AtomicBoolean isClosing = new AtomicBoolean();
+    // Purpur start
+    private final CommandHistory history = new CommandHistory();
+    private String currentCommand = "";
+    private int historyIndex = 0;
+    // Purpur end
+ 
+     public static MinecraftServerGui showFrameFor(final DedicatedServer server) {
+         try {
+@@ -51,7 +56,7 @@ public class MinecraftServerGui extends JComponent {
+             ;
+         }
+ 
+-        final JFrame jframe = new JFrame("Minecraft server");
+        final JFrame jframe = new JFrame("Purpur Minecraft server"); // Purpur
+         final MinecraftServerGui servergui = new MinecraftServerGui(server);
+ 
+         jframe.setDefaultCloseOperation(2);
+@@ -59,7 +64,7 @@ public class MinecraftServerGui extends JComponent {
+         jframe.pack();
+         jframe.setLocationRelativeTo((Component) null);
+         jframe.setVisible(true);
+-        jframe.setName("Minecraft server"); // Paper - Improve ServerGUI
+        jframe.setName("Purpur Minecraft server"); // Paper - Improve ServerGUI // Purpur
+ 
+         // Paper start - Improve ServerGUI
+         try {
+@@ -71,7 +76,7 @@ public class MinecraftServerGui extends JComponent {
+         jframe.addWindowListener(new WindowAdapter() {
+             public void windowClosing(WindowEvent windowevent) {
+                 if (!servergui.isClosing.getAndSet(true)) {
+-                    jframe.setTitle("Minecraft server - shutting down!");
+                    jframe.setTitle("Purpur Minecraft server - shutting down!"); // Purpur
+                     server.halt(true);
+                     servergui.runFinalizers();
+                 }
+@@ -159,7 +164,7 @@ public class MinecraftServerGui extends JComponent {
+ 
+     private JComponent buildChatPanel() {
+         JPanel jpanel = new JPanel(new BorderLayout());
+-        JTextArea jtextarea = new JTextArea();
+        org.purpurmc.purpur.gui.JColorTextPane jtextarea = new org.purpurmc.purpur.gui.JColorTextPane(); // Purpur
+         JScrollPane jscrollpane = new JScrollPane(jtextarea, 22, 30);
+ 
+         jtextarea.setEditable(false);
+@@ -171,10 +176,43 @@ public class MinecraftServerGui extends JComponent {
+ 
+             if (!s.isEmpty()) {
+                 this.server.handleConsoleInput(s, this.server.createCommandSourceStack());
+                // Purpur start
+                history.add(s);
+                historyIndex = -1;
+                // Purpur end
+             }
+ 
+             jtextfield.setText("");
+         });
+        // Purpur start
+        jtextfield.getInputMap().put(javax.swing.KeyStroke.getKeyStroke("UP"), "up");
+        jtextfield.getInputMap().put(javax.swing.KeyStroke.getKeyStroke("DOWN"), "down");
+        jtextfield.getActionMap().put("up", new javax.swing.AbstractAction() {
+            @Override
+            public void actionPerformed(java.awt.event.ActionEvent actionEvent) {
+                if (historyIndex < 0) {
+                    currentCommand = jtextfield.getText();
+                }
+                if (historyIndex < history.size() - 1) {
+                    jtextfield.setText(history.get(++historyIndex));
+                }
+            }
+        });
+        jtextfield.getActionMap().put("down", new javax.swing.AbstractAction() {
+            @Override
+            public void actionPerformed(java.awt.event.ActionEvent actionEvent) {
+                if (historyIndex >= 0) {
+                    if (historyIndex == 0) {
+                        --historyIndex;
+                        jtextfield.setText(currentCommand);
+                    } else {
+                        --historyIndex;
+                        jtextfield.setText(history.get(historyIndex));
+                    }
+                }
+            }
+        });
+        // Purpur end
+         jtextarea.addFocusListener(new FocusAdapter() { // CraftBukkit - decompile error
+             public void focusGained(FocusEvent focusevent) {}
+         });
+@@ -210,7 +248,7 @@ public class MinecraftServerGui extends JComponent {
+     }
+ 
+     private static final java.util.regex.Pattern ANSI = java.util.regex.Pattern.compile("\\e\\[[\\d;]*[^\\d;]"); // CraftBukkit // Paper
+-    public void print(JTextArea textArea, JScrollPane scrollPane, String message) {
+    public void print(org.purpurmc.purpur.gui.JColorTextPane textArea, JScrollPane scrollPane, String message) { // Purpur
+         if (!SwingUtilities.isEventDispatchThread()) {
+             SwingUtilities.invokeLater(() -> {
+                 this.print(textArea, scrollPane, message);
+@@ -224,11 +262,14 @@ public class MinecraftServerGui extends JComponent {
+                 flag = (double) jscrollbar.getValue() + jscrollbar.getSize().getHeight() + (double) (MinecraftServerGui.MONOSPACED.getSize() * 4) > (double) jscrollbar.getMaximum();
+             }
+ 
+            /* // Purpur
+             try {
+                 document.insertString(document.getLength(), MinecraftServerGui.ANSI.matcher(message).replaceAll(""), (AttributeSet) null); // CraftBukkit
+             } catch (BadLocationException badlocationexception) {
+                 ;
+             }
+            */ // Purpur
+            textArea.append(message); // Purpur
+ 
+             if (flag) {
+                 jscrollbar.setValue(Integer.MAX_VALUE);
+@@ -236,4 +277,16 @@ public class MinecraftServerGui extends JComponent {
+ 
+         }
+     }
+
+    // Purpur start
+    public static class CommandHistory extends java.util.LinkedList<String> {
+        @Override
+        public boolean add(String command) {
+            if (size() > 1000) {
+                remove();
+            }
+            return super.offerFirst(command);
+        }
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/gui/GUIColor.java b/src/main/java/org/purpurmc/purpur/gui/GUIColor.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..550222758bf0e7deff26a6e813a860b7be365e87
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/gui/GUIColor.java
+@@ -0,0 +1,58 @@
+package org.purpurmc.purpur.gui;
+
+import net.md_5.bungee.api.ChatColor;
+
+import java.awt.Color;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum GUIColor {
+    BLACK(ChatColor.BLACK, new Color(0x000000)),
+    DARK_BLUE(ChatColor.DARK_BLUE, new Color(0x0000AA)),
+    DARK_GREEN(ChatColor.DARK_GREEN, new Color(0x00AA00)),
+    DARK_AQUA(ChatColor.DARK_AQUA, new Color(0x009999)),
+    DARK_RED(ChatColor.DARK_RED, new Color(0xAA0000)),
+    DARK_PURPLE(ChatColor.DARK_PURPLE, new Color(0xAA00AA)),
+    GOLD(ChatColor.GOLD, new Color(0xBB8800)),
+    GRAY(ChatColor.GRAY, new Color(0x888888)),
+    DARK_GRAY(ChatColor.DARK_GRAY, new Color(0x444444)),
+    BLUE(ChatColor.BLUE, new Color(0x5555FF)),
+    GREEN(ChatColor.GREEN, new Color(0x55FF55)),
+    AQUA(ChatColor.AQUA, new Color(0x55DDDD)),
+    RED(ChatColor.RED, new Color(0xFF5555)),
+    LIGHT_PURPLE(ChatColor.LIGHT_PURPLE, new Color(0xFF55FF)),
+    YELLOW(ChatColor.YELLOW, new Color(0xFFBB00)),
+    WHITE(ChatColor.WHITE, new Color(0xBBBBBB));
+
+    private final ChatColor chat;
+    private final Color color;
+
+    private static final Map<ChatColor, GUIColor> BY_CHAT = new HashMap<>();
+
+    GUIColor(ChatColor chat, Color color) {
+        this.chat = chat;
+        this.color = color;
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+    public ChatColor getChatColor() {
+        return chat;
+    }
+
+    public String getCode() {
+        return chat.toString();
+    }
+
+    public static GUIColor getColor(ChatColor chat) {
+        return BY_CHAT.get(chat);
+    }
+
+    static {
+        for (GUIColor color : values()) {
+            BY_CHAT.put(color.chat, color);
+        }
+    }
+}
+diff --git a/src/main/java/org/purpurmc/purpur/gui/JColorTextPane.java b/src/main/java/org/purpurmc/purpur/gui/JColorTextPane.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d75fb5e77eff27d86135ed7d605dbc250b660f7d
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/gui/JColorTextPane.java
+@@ -0,0 +1,83 @@
+package org.purpurmc.purpur.gui;
+
+import com.google.common.collect.Sets;
+import javax.swing.UIManager;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.chat.TextComponent;
+
+import javax.swing.JTextPane;
+import javax.swing.Timer;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.StyleContext;
+import java.util.Set;
+
+public class JColorTextPane extends JTextPane {
+    private static final GUIColor DEFAULT_COLOR;
+    static {
+        DEFAULT_COLOR = UIManager.getSystemLookAndFeelClassName().equals("com.sun.java.swing.plaf.gtk.GTKLookAndFeel")
+            ? GUIColor.WHITE : GUIColor.BLACK;
+    }
+
+
+    public void append(String msg) {
+        // TODO: update to use adventure instead
+        BaseComponent[] components = TextComponent.fromLegacyText(DEFAULT_COLOR.getCode() + msg, DEFAULT_COLOR.getChatColor());
+        for (BaseComponent component : components) {
+            String text = component.toPlainText();
+            if (text == null || text.isEmpty()) {
+                continue;
+            }
+
+            GUIColor guiColor = GUIColor.getColor(component.getColor());
+
+            StyleContext context = StyleContext.getDefaultStyleContext();
+            AttributeSet attr = context.addAttribute(SimpleAttributeSet.EMPTY, StyleConstants.Foreground, guiColor.getColor());
+            attr = context.addAttribute(attr, StyleConstants.CharacterConstants.Bold, component.isBold() || guiColor != DEFAULT_COLOR);
+            attr = context.addAttribute(attr, StyleConstants.CharacterConstants.Italic, component.isItalic());
+            attr = context.addAttribute(attr, StyleConstants.CharacterConstants.Underline, component.isUnderlined());
+            attr = context.addAttribute(attr, StyleConstants.CharacterConstants.StrikeThrough, component.isStrikethrough());
+            //attr = context.addAttribute(attr, StyleConstants.CharacterConstants.Blink, component.isObfuscated()); // no such thing as Blink, sadly
+
+            try {
+                int pos = getDocument().getLength();
+                getDocument().insertString(pos, text, attr);
+
+                if (component.isObfuscated()) {
+                    // dirty hack to blink some text
+                    Blink blink = new Blink(pos, text.length(), attr, context.addAttribute(attr, StyleConstants.Foreground, getBackground()));
+                    BLINKS.add(blink);
+                }
+            } catch (BadLocationException ignore) {
+            }
+        }
+    }
+
+    private static final Set<Blink> BLINKS = Sets.newHashSet();
+    private static boolean SYNC_BLINK;
+
+    static {
+        new Timer(500, e -> {
+            SYNC_BLINK = !SYNC_BLINK;
+            BLINKS.forEach(Blink::blink);
+        }).start();
+    }
+
+    public class Blink {
+        private final int start, length;
+        private final AttributeSet attr1, attr2;
+
+        private Blink(int start, int length, AttributeSet attr1, AttributeSet attr2) {
+            this.start = start;
+            this.length = length;
+            this.attr1 = attr1;
+            this.attr2 = attr2;
+        }
+
+        private void blink() {
+            getStyledDocument().setCharacterAttributes(start, length, SYNC_BLINK ? attr1 : attr2, true);
+        }
+    }
+}
+diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
+index d2a75850af9c6ad2aca66a5f994f1b587d73eac4..a056aa167887abef9e6d531a9edd2cda433567d2 100644
+--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
+@@ -2,7 +2,16 @@
+ <Configuration status="WARN" shutdownHook="disable">
+     <Appenders>
+         <Queue name="ServerGuiConsole">
+-            <PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg{nolookups}%n" />
+            <!-- Purpur start - copied from TerminalConsole -->
+            <PatternLayout>
+                <LoggerNamePatternSelector defaultPattern="%highlightGUIError{[%d{HH:mm:ss} %level]: [%logger] %stripAnsi{%msg}%n%xEx{full}}">
+                    <!-- Log root, Minecraft, Mojang and Bukkit loggers without prefix -->
+                    <!-- Disable prefix for various plugins that bypass the plugin logger -->
+                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang.,com.sk89q.,ru.tehkode.,Minecraft.AWE"
+                                  pattern="%highlightGUIError{[%d{HH:mm:ss} %level]: %stripAnsi{%msg}%n%xEx{full}}" />
+                </LoggerNamePatternSelector>
+            </PatternLayout>
+            <!-- Purpur end -->
+         </Queue>
+         <TerminalConsole name="TerminalConsole">
+             <PatternLayout>
--- a/patches/server/0279-Stored-Bee-API.patch
+++ b/patches/server/0279-Stored-Bee-API.patch
@@ -0,0 +1,253 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: EOT3000 <egor.tolstenkov@outlook.com>
+Date: Sat, 10 Jun 2023 20:27:12 -0400
+Subject: [PATCH] Stored Bee API
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+index 7f0e37e23ff4c64355fdc822c0ac683959b8588a..6fa25cac9d88808a590281bf90f619fa2f167d4a 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+@@ -147,11 +147,33 @@ public class BeehiveBlockEntity extends BlockEntity {
+         return list;
+     }
+ 
+    // Purpur start
+    public List<Entity> releaseBee(BlockState iblockdata, BeehiveBlockEntity.BeeData data, BeehiveBlockEntity.BeeReleaseStatus tileentitybeehive_releasestatus, boolean force) {
+        List<Entity> list = Lists.newArrayList();
+
+        BeehiveBlockEntity.releaseOccupant(this.level, this.worldPosition, iblockdata, data.occupant, list, tileentitybeehive_releasestatus, this.savedFlowerPos, force);
+
+        if (!list.isEmpty()) {
+            stored.remove(data);
+
+            super.setChanged();
+        }
+
+        return list;
+    }
+    // Purpur end
+
+     @VisibleForDebug
+     public int getOccupantCount() {
+         return this.stored.size();
+     }
+ 
+    // Purpur start
+    public List<BeeData> getStored() {
+        return stored;
+    }
+    // Purpur end
+
+     // Paper start - Add EntityBlockStorage clearEntities
+     public void clearBees() {
+         this.stored.clear();
+@@ -467,9 +489,9 @@ public class BeehiveBlockEntity extends BlockEntity {
+         }
+     }
+ 
+-    private static class BeeData {
+    public static class BeeData { // Purpur - change from private to public
+ 
+-        private final BeehiveBlockEntity.Occupant occupant;
+        public final BeehiveBlockEntity.Occupant occupant; // Purpur - make public
+         private int exitTickCounter; // Paper - Fix bees aging inside hives; separate counter for checking if bee should exit to reduce exit attempts
+         private int ticksInHive;
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
+index 1a2a05160ba51d9c75f1ae6ae61d944d81428722..3beb26ad2ef0fded49a8da8c5dec64f9508c1995 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
+@@ -16,8 +16,15 @@ import org.bukkit.entity.Bee;
+ 
+ public class CraftBeehive extends CraftBlockEntityState<BeehiveBlockEntity> implements Beehive {
+ 
+    private final List<org.purpurmc.purpur.entity.StoredEntity<Bee>> storage = new ArrayList<>(); // Purpur
+
+     public CraftBeehive(World world, BeehiveBlockEntity tileEntity) {
+         super(world, tileEntity);
+        // Purpur start - load bees to be able to modify them individually
+        for(BeehiveBlockEntity.BeeData data : tileEntity.getStored()) {
+            storage.add(new org.purpurmc.purpur.entity.PurpurStoredBee(data, this));
+        }
+        // Purpur end
+     }
+ 
+     protected CraftBeehive(CraftBeehive state, Location location) {
+@@ -75,15 +82,54 @@ public class CraftBeehive extends CraftBlockEntityState<BeehiveBlockEntity> impl
+                 bees.add((Bee) bee.getBukkitEntity());
+             }
+         }
+-
+        storage.clear(); // Purpur
+         return bees;
+     }
+ 
+    // Purpur start
+    @Override
+    public Bee releaseEntity(org.purpurmc.purpur.entity.StoredEntity<Bee> entity) {
+        ensureNoWorldGeneration();
+
+        if(!getEntities().contains(entity)) {
+            return null;
+        }
+
+        if(isPlaced()) {
+            BeehiveBlockEntity beehive = ((BeehiveBlockEntity) this.getTileEntityFromWorld());
+            BeehiveBlockEntity.BeeData data = ((org.purpurmc.purpur.entity.PurpurStoredBee) entity).getHandle();
+
+            List<Entity> list = beehive.releaseBee(getHandle(), data, BeeReleaseStatus.BEE_RELEASED, true);
+
+            if (list.size() == 1) {
+                storage.remove(entity);
+
+                return (Bee) list.get(0).getBukkitEntity();
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public List<org.purpurmc.purpur.entity.StoredEntity<Bee>> getEntities() {
+        return new ArrayList<>(storage);
+    }
+    // Purpur end
+
+     @Override
+     public void addEntity(Bee entity) {
+         Preconditions.checkArgument(entity != null, "Entity must not be null");
+ 
+-        this.getSnapshot().addOccupant(((CraftBee) entity).getHandle());
+        int length = this.getSnapshot().getStored().size();  // Purpur
+        getSnapshot().addOccupant(((CraftBee) entity).getHandle());
+
+        // Purpur start - check if new bee was added, and if yes, add to stored bees
+        List<BeehiveBlockEntity.BeeData> storedBeeData = this.getSnapshot().getStored();
+        if(length < storedBeeData.size()) {
+            storage.add(new org.purpurmc.purpur.entity.PurpurStoredBee(storedBeeData.getLast(), this));
+        }
+        // Purpur end
+     }
+ 
+     @Override
+@@ -100,6 +146,7 @@ public class CraftBeehive extends CraftBlockEntityState<BeehiveBlockEntity> impl
+     @Override
+     public void clearEntities() {
+         getSnapshot().clearBees();
+        storage.clear(); // Purpur
+     }
+     // Paper end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/entity/PurpurStoredBee.java b/src/main/java/org/purpurmc/purpur/entity/PurpurStoredBee.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7608bf0981fa0d37031e51e57e4086cb5ec4c88b
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/entity/PurpurStoredBee.java
+@@ -0,0 +1,106 @@
+package org.purpurmc.purpur.entity;
+
+import io.papermc.paper.adventure.PaperAdventure;
+import net.kyori.adventure.text.Component;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.item.component.CustomData;
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import org.bukkit.block.EntityBlockStorage;
+import org.bukkit.craftbukkit.persistence.CraftPersistentDataContainer;
+import org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry;
+import org.bukkit.entity.Bee;
+import org.bukkit.entity.EntityType;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Locale;
+
+public class PurpurStoredBee implements StoredEntity<Bee> {
+    private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
+
+    private final EntityBlockStorage<Bee> blockStorage;
+    private final BeehiveBlockEntity.BeeData handle;
+    private final CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(PurpurStoredBee.DATA_TYPE_REGISTRY);
+
+    private Component customName;
+
+    public PurpurStoredBee(BeehiveBlockEntity.BeeData data, EntityBlockStorage<Bee> blockStorage) {
+        this.handle = data;
+        this.blockStorage = blockStorage;
+
+        CompoundTag customData = handle.occupant.entityData().copyTag();
+        this.customName = customData.contains("CustomName")
+                ? PaperAdventure.asAdventure(net.minecraft.network.chat.Component.Serializer.fromJson(customData.getString("CustomName"), MinecraftServer.getDefaultRegistryAccess()))
+                : null;
+
+        if(customData.contains("BukkitValues", Tag.TAG_COMPOUND)) {
+            this.persistentDataContainer.putAll(customData.getCompound("BukkitValues"));
+        }
+    }
+
+    public BeehiveBlockEntity.BeeData getHandle() {
+        return handle;
+    }
+
+    @Override
+    public @Nullable Component customName() {
+        return customName;
+    }
+
+    @Override
+    public void customName(@Nullable Component customName) {
+        this.customName = customName;
+    }
+
+    @Override
+    public @Nullable String getCustomName() {
+        return PaperAdventure.asPlain(customName, Locale.US);
+    }
+
+    @Override
+    public void setCustomName(@Nullable String name) {
+        customName(name != null ? Component.text(name) : null);
+    }
+
+    @Override
+    public @NotNull PersistentDataContainer getPersistentDataContainer() {
+        return persistentDataContainer;
+    }
+
+    @Override
+    public boolean hasBeenReleased() {
+        return !blockStorage.getEntities().contains(this);
+    }
+
+    @Override
+    public @Nullable Bee release() {
+        return blockStorage.releaseEntity(this);
+    }
+
+    @Override
+    public @Nullable EntityBlockStorage<Bee> getBlockStorage() {
+        if(hasBeenReleased()) {
+            return null;
+        }
+
+        return blockStorage;
+    }
+
+    @Override
+    public @NotNull EntityType getType() {
+        return EntityType.BEE;
+    }
+
+    @Override
+    public void update() {
+        handle.occupant.entityData().copyTag().put("BukkitValues", this.persistentDataContainer.toTagCompound());
+        if(customName == null) {
+            handle.occupant.entityData().copyTag().remove("CustomName");
+        } else {
+            handle.occupant.entityData().copyTag().putString("CustomName", net.minecraft.network.chat.Component.Serializer.toJson(PaperAdventure.asVanilla(customName), MinecraftServer.getDefaultRegistryAccess()));
+        }
+    }
+}
--- a/patches/server/0280-Shears-can-defuse-TNT.patch
+++ b/patches/server/0280-Shears-can-defuse-TNT.patch
@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrFishCakes <FinlayOxby@outlook.com>
+Date: Sun, 2 Jul 2023 00:50:14 +0100
+Subject: [PATCH] Shears can defuse TNT
+
+Shears can now defuse TNT. Each world can have a configured chance for the TNT to be defused when right clicking with a set of shears and damage dealt to the shears accordingly. If the TNT is defused then it will drop the TNT item instead and the entity removed from the world no longer existing. All the interaction is handled within the net.minecraft.world.entity.item.PrimedTnt class similar to how it is handled for when sheep are sheared.
+
+By default the option is disabled to avoid breaking any possible vanilla mechanics.
+
+diff --git a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+index 809f5e847e2f5bb594c130cebd2cb897ea768d82..6f1e21d6c104d71fe4fc3376ed2f2273a5f3d3cc 100644
+--- a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+++ b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+@@ -249,4 +249,31 @@ public class PrimedTnt extends Entity implements TraceableEntity {
+         return !level().paperConfig().fixes.preventTntFromMovingInWater && super.isPushedByFluid();
+     }
+     // Paper end - Option to prevent TNT from moving in water
+    // Purpur start - Shears can defuse TNT
+    @Override
+    public net.minecraft.world.InteractionResult interact(net.minecraft.world.entity.player.Player player, net.minecraft.world.InteractionHand hand) {
+        Level world = this.level();
+
+        if (world instanceof ServerLevel serverWorld && level().purpurConfig.shearsCanDefuseTnt) {
+            final net.minecraft.world.item.ItemStack inHand = player.getItemInHand(hand);
+
+            if (!inHand.is(net.minecraft.world.item.Items.SHEARS) || !player.getBukkitEntity().hasPermission("purpur.tnt.defuse") ||
+                    serverWorld.random.nextFloat() > serverWorld.purpurConfig.shearsCanDefuseTntChance) return net.minecraft.world.InteractionResult.PASS;
+
+            net.minecraft.world.entity.item.ItemEntity tntItem = new net.minecraft.world.entity.item.ItemEntity(serverWorld, getX(), getY(), getZ(),
+                    new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Items.TNT));
+            tntItem.setPickUpDelay(10);
+
+            inHand.hurtAndBreak(1, player, LivingEntity.getSlotForHand(hand));
+            serverWorld.addFreshEntity(tntItem, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.CUSTOM);
+
+            this.playSound(net.minecraft.sounds.SoundEvents.SHEEP_SHEAR);
+
+            this.kill(serverWorld);
+            return net.minecraft.world.InteractionResult.SUCCESS;
+        }
+
+        return super.interact(player, hand);
+    }
+    // Purpur end - Shears can defuse TNT
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 4ef5aaa033f6ba5a4260345df12426954b8d6fbe..f8c49f69297fac41f65c3d37ba0e1020fa3f0736 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -3414,4 +3414,11 @@ public class PurpurWorldConfig {
+         cauldronDripstoneWaterFillChance = (float) getDouble("blocks.cauldron.fill-chances.dripstone-water", cauldronDripstoneWaterFillChance);
+         cauldronDripstoneLavaFillChance = (float) getDouble("blocks.cauldron.fill-chances.dripstone-lava", cauldronDripstoneLavaFillChance);
+     }
+
+    public float shearsCanDefuseTntChance = 0.00F;
+    public boolean shearsCanDefuseTnt = false;
+    private void shearsCanDefuseTntSettings() {
+        shearsCanDefuseTntChance = (float) getDouble("gameplay-mechanics.item.shears.defuse-tnt-chance", 0.00D);
+        shearsCanDefuseTnt = shearsCanDefuseTntChance > 0.00F;
+    }
+ }
--- a/patches/server/0281-Explorer-Map-API.patch
+++ b/patches/server/0281-Explorer-Map-API.patch
@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Wed, 5 Jul 2023 12:48:15 -0500
+Subject: [PATCH] Explorer Map API
+
+
+diff --git a/src/main/java/net/minecraft/world/item/MapItem.java b/src/main/java/net/minecraft/world/item/MapItem.java
+index 8ff50a4c7461bbd9f469d503f6b5ee482d2463d7..5c0a46c11003b6e154195a8ef299416cc73eae33 100644
+--- a/src/main/java/net/minecraft/world/item/MapItem.java
+++ b/src/main/java/net/minecraft/world/item/MapItem.java
+@@ -194,6 +194,7 @@ public class MapItem extends Item {
+     public static void renderBiomePreviewMap(ServerLevel world, ItemStack map) {
+         MapItemSavedData mapItemSavedData = getSavedData(map, world);
+         if (mapItemSavedData != null) {
+            mapItemSavedData.isExplorerMap = true; // Purpur
+             if (world.dimension() == mapItemSavedData.dimension) {
+                 int i = 1 << mapItemSavedData.scale;
+                 int j = mapItemSavedData.centerX;
+diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
+index ae321b3b8d98e42ef07fd1f0f738c1a2b428f6db..26da9e7c25ef6a89482838010d8ed6bcf8c87511 100644
+--- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
+++ b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
+@@ -81,6 +81,7 @@ public class MapItemSavedData extends SavedData {
+     private final Map<String, MapFrame> frameMarkers = Maps.newHashMap();
+     private int trackedDecorationCount;
+     private org.bukkit.craftbukkit.map.RenderData vanillaRender = new org.bukkit.craftbukkit.map.RenderData(); // Paper
+    public boolean isExplorerMap; // Purpur
+ 
+     // CraftBukkit start
+     public final CraftMapView mapView;
+diff --git a/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java b/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java
+index cf0920e5f84b35647882fb963e9972af4e8427e0..e30c851acf49a425cd4fd409a6d5bbb2ff836e0e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java
+++ b/src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java
+@@ -49,4 +49,10 @@ public class CraftMapRenderer extends MapRenderer {
+         }
+     }
+ 
+    // Purpur - start
+    @Override
+    public boolean isExplorerMap() {
+        return this.worldMap.isExplorerMap;
+    }
+    // Purpur - end
+ }
--- a/patches/server/0282-Option-Ocelot-Spawn-Under-Sea-Level.patch
+++ b/patches/server/0282-Option-Ocelot-Spawn-Under-Sea-Level.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 21 Jul 2023 11:04:47 -0500
+Subject: [PATCH] Option Ocelot Spawn Under Sea Level
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+index 14634de26c218a3d26afd3e7e6ca89c1a0595178..dee59cb4b87845c940ee089aa932aa69dd2539d6 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+@@ -284,7 +284,7 @@ public class Ocelot extends Animal {
+         if (world.isUnobstructed(this) && !world.containsAnyLiquid(this.getBoundingBox())) {
+             BlockPos blockposition = this.blockPosition();
+ 
+-            if (blockposition.getY() < world.getSeaLevel()) {
+            if (!level().purpurConfig.ocelotSpawnUnderSeaLevel && blockposition.getY() < world.getSeaLevel()) {
+                 return false;
+             }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f8c49f69297fac41f65c3d37ba0e1020fa3f0736..29c934fa57da481730d80601bf86a90d5b8def09 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2150,6 +2150,7 @@ public class PurpurWorldConfig {
+     public int ocelotBreedingTicks = 6000;
+     public boolean ocelotTakeDamageFromWater = false;
+     public boolean ocelotAlwaysDropExp = false;
+    public boolean ocelotSpawnUnderSeaLevel = false;
+     private void ocelotSettings() {
+         ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable);
+         ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater);
+@@ -2164,6 +2165,7 @@ public class PurpurWorldConfig {
+         ocelotBreedingTicks = getInt("mobs.ocelot.breeding-delay-ticks", ocelotBreedingTicks);
+         ocelotTakeDamageFromWater = getBoolean("mobs.ocelot.takes-damage-from-water", ocelotTakeDamageFromWater);
+         ocelotAlwaysDropExp = getBoolean("mobs.ocelot.always-drop-exp", ocelotAlwaysDropExp);
+        ocelotSpawnUnderSeaLevel = getBoolean("mobs.ocelot.spawn-below-sea-level", ocelotSpawnUnderSeaLevel);
+     }
+ 
+     public boolean pandaRidable = false;
--- a/patches/server/0283-add-an-option-for-piglins-to-ignore-gold-trimmed-arm.patch
+++ b/patches/server/0283-add-an-option-for-piglins-to-ignore-gold-trimmed-arm.patch
@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <contact@granny.dev>
+Date: Sun, 13 Aug 2023 06:26:08 -0700
+Subject: [PATCH] add an option for piglins to ignore gold-trimmed armor
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+index e283b1296c1e831376bfe9491cbf02ed4b3fffe4..27a6de70530c2a1cbe2f77a7fb493038121710ea 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+++ b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+@@ -605,11 +605,18 @@ public class PiglinAi {
+             }
+ 
+             itemstack = (ItemStack) iterator.next();
+-        } while (!itemstack.is(ItemTags.PIGLIN_SAFE_ARMOR));
+        } while (!itemstack.is(ItemTags.PIGLIN_SAFE_ARMOR) && (!entity.level().purpurConfig.piglinIgnoresArmorWithGoldTrim || !isWearingGoldTrim(itemstack.getItem()))); // Purpur
+ 
+         return true;
+     }
+ 
+    // Purpur start
+    private static boolean isWearingGoldTrim(Item itemstack) {
+        net.minecraft.world.item.equipment.trim.ArmorTrim armorTrim = itemstack.components().get(net.minecraft.core.component.DataComponents.TRIM);
+        return armorTrim != null && armorTrim.material().is(net.minecraft.world.item.equipment.trim.TrimMaterials.GOLD);
+    }
+    // Purpur end
+
+     private static void stopWalking(Piglin piglin) {
+         piglin.getBrain().eraseMemory(MemoryModuleType.WALK_TARGET);
+         piglin.getNavigation().stop();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 29c934fa57da481730d80601bf86a90d5b8def09..a040f13bd39bd9e0b24ac9be4a95a093930977d1 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2327,6 +2327,7 @@ public class PurpurWorldConfig {
+     public int piglinPortalSpawnModifier = 2000;
+     public boolean piglinAlwaysDropExp = false;
+     public double piglinHeadVisibilityPercent = 0.5D;
+    public boolean piglinIgnoresArmorWithGoldTrim = false;
+     private void piglinSettings() {
+         piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable);
+         piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater);
+@@ -2343,6 +2344,7 @@ public class PurpurWorldConfig {
+         piglinPortalSpawnModifier = getInt("mobs.piglin.portal-spawn-modifier", piglinPortalSpawnModifier);
+         piglinAlwaysDropExp = getBoolean("mobs.piglin.always-drop-exp", piglinAlwaysDropExp);
+         piglinHeadVisibilityPercent = getDouble("mobs.piglin.head-visibility-percent", piglinHeadVisibilityPercent);
+        piglinIgnoresArmorWithGoldTrim = getBoolean("mobs.piglin.ignores-armor-with-gold-trim", piglinIgnoresArmorWithGoldTrim);
+     }
+ 
+     public boolean piglinBruteRidable = false;
--- a/patches/server/0284-Add-option-for-always-showing-item-in-player-death-m.patch
+++ b/patches/server/0284-Add-option-for-always-showing-item-in-player-death-m.patch
@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Tue, 22 Aug 2023 22:18:26 -0700
+Subject: [PATCH] Add option for always showing item in player death messages
+
+
+diff --git a/src/main/java/net/minecraft/world/damagesource/CombatTracker.java b/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
+index 357a79d72a2de02a019595e457fe432bf409e516..4fb025a63628eb60509d90b680922a0220104bcb 100644
+--- a/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
+++ b/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
+@@ -54,7 +54,7 @@ public class CombatTracker {
+ 
+     private Component getMessageForAssistedFall(Entity attacker, Component attackerDisplayName, String itemDeathTranslationKey, String deathTranslationKey) {
+         ItemStack itemStack = attacker instanceof LivingEntity livingEntity ? livingEntity.getMainHandItem() : ItemStack.EMPTY;
+-        return !itemStack.isEmpty() && itemStack.has(DataComponents.CUSTOM_NAME)
+        return !itemStack.isEmpty() && (org.purpurmc.purpur.PurpurConfig.playerDeathsAlwaysShowItem || itemStack.has(DataComponents.CUSTOM_NAME)) // Purpur
+             ? Component.translatable(itemDeathTranslationKey, this.mob.getDisplayName(), attackerDisplayName, itemStack.getDisplayName())
+             : Component.translatable(deathTranslationKey, this.mob.getDisplayName(), attackerDisplayName);
+     }
+diff --git a/src/main/java/net/minecraft/world/damagesource/DamageSource.java b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+index d95d122601dd47a27e8d82a13b071919c360fe68..4a96d914f8aa6f0c5f13fc85369a311f25835ac2 100644
+--- a/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+++ b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+@@ -218,7 +218,7 @@ public class DamageSource {
+ 
+             ItemStack itemstack1 = itemstack;
+ 
+-            return !itemstack1.isEmpty() && itemstack1.has(DataComponents.CUSTOM_NAME) ? Component.translatable(s + ".item", killed.getDisplayName(), ichatbasecomponent, itemstack1.getDisplayName()) : Component.translatable(s, killed.getDisplayName(), ichatbasecomponent);
+            return !itemstack1.isEmpty() && (org.purpurmc.purpur.PurpurConfig.playerDeathsAlwaysShowItem || itemstack1.has(DataComponents.CUSTOM_NAME)) ? Component.translatable(s + ".item", killed.getDisplayName(), ichatbasecomponent, itemstack1.getDisplayName()) : Component.translatable(s, killed.getDisplayName(), ichatbasecomponent);
+         }
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 334bcf9f24c6b658664424fd960dad6fb9e28c7d..e2b2eb66907f3a35792a59d68509abda1dd34ccb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -577,4 +577,9 @@ public class PurpurConfig {
+             block.fallDistanceMultiplier = fallDistanceMultiplier.floatValue();
+         });
+     }
+
+    public static boolean playerDeathsAlwaysShowItem = false;
+    private static void playerDeathsAlwaysShowItem() {
+        playerDeathsAlwaysShowItem = getBoolean("settings.player-deaths-always-show-item", playerDeathsAlwaysShowItem);
+    }
+ }
--- a/patches/server/0285-place-end-crystal-on-any-block.patch
+++ b/patches/server/0285-place-end-crystal-on-any-block.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <contact@granny.dev>
+Date: Wed, 23 Aug 2023 01:39:14 -0700
+Subject: [PATCH] place end crystal on any block
+
+
+diff --git a/src/main/java/net/minecraft/world/item/EndCrystalItem.java b/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+index 2bee342e59e600426c8681a3ce641a12f22790be..e75930f26604b772a141a93c6f4b77828abc4503 100644
+--- a/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+++ b/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+@@ -27,7 +27,7 @@ public class EndCrystalItem extends Item {
+         BlockPos blockposition = context.getClickedPos();
+         BlockState iblockdata = world.getBlockState(blockposition);
+ 
+-        if (!iblockdata.is(Blocks.OBSIDIAN) && !iblockdata.is(Blocks.BEDROCK)) {
+        if (!world.purpurConfig.endCrystalPlaceAnywhere && !iblockdata.is(Blocks.OBSIDIAN) && !iblockdata.is(Blocks.BEDROCK)) {
+             return InteractionResult.FAIL;
+         } else {
+             BlockPos blockposition1 = blockposition.above(); final BlockPos aboveBlockPosition = blockposition1; // Paper - OBFHELPER
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a040f13bd39bd9e0b24ac9be4a95a093930977d1..c9ad3129146f5f29f1a1d0afbbc911d92bb4e8fb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -935,6 +935,7 @@ public class PurpurWorldConfig {
+     public boolean basedEndCrystalExplosionFire = false;
+     public net.minecraft.world.level.Level.ExplosionInteraction basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
+     public int endCrystalCramming = 0;
+    public boolean endCrystalPlaceAnywhere = false;
+     private void endCrystalSettings() {
+         if (PurpurConfig.version < 31) {
+             if ("DESTROY".equals(getString("blocks.end-crystal.baseless.explosion-effect", baselessEndCrystalExplosionEffect.name()))) {
+@@ -963,6 +964,7 @@ public class PurpurWorldConfig {
+             basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
+         }
+         endCrystalCramming = getInt("blocks.end-crystal.cramming-amount", endCrystalCramming);
+        endCrystalPlaceAnywhere = getBoolean("gameplay-mechanics.item.end-crystal.place-anywhere", endCrystalPlaceAnywhere);
+     }
+ 
+     public boolean farmlandBypassMobGriefing = false;
--- a/patches/server/0286-Add-option-to-disable-the-copper-oxidation-proximity.patch
+++ b/patches/server/0286-Add-option-to-disable-the-copper-oxidation-proximity.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Meln Cat <melncatuwu@gmail.com>
+Date: Mon, 9 Oct 2023 12:21:49 -0700
+Subject: [PATCH] Add option to disable the copper oxidation proximity penalty
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/ChangeOverTimeBlock.java b/src/main/java/net/minecraft/world/level/block/ChangeOverTimeBlock.java
+index daae7fd6e0148cfba8e359d990748a0c83a3376e..0e06b1bcd906e92c083dc74d56d6d0a2a36f62a7 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChangeOverTimeBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ChangeOverTimeBlock.java
+@@ -67,7 +67,7 @@ public interface ChangeOverTimeBlock<T extends Enum<T>> {
+         }
+ 
+         float f = (float) (k + 1) / (float) (k + j + 1);
+-        float f1 = f * f * this.getChanceModifier();
+        float f1 = world.purpurConfig.disableOxidationProximityPenalty ? this.getChanceModifier() : f * f * this.getChanceModifier(); // Purpur
+ 
+         return random.nextFloat() < f1 ? this.getNext(state) : Optional.empty();
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index c9ad3129146f5f29f1a1d0afbbc911d92bb4e8fb..9b3e2d1ab8ad0b388a0bd3947feea43e602b8781 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -146,6 +146,7 @@ public class PurpurWorldConfig {
+     public boolean persistentTileEntityDisplayName = true;
+     public int mobLastHurtByPlayerTime = 100;
+     public boolean milkClearsBeneficialEffects = true;
+    public boolean disableOxidationProximityPenalty = false;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         alwaysTameInCreative = getBoolean("gameplay-mechanics.always-tame-in-creative", alwaysTameInCreative);
+@@ -180,6 +181,7 @@ public class PurpurWorldConfig {
+         persistentTileEntityDisplayName = getBoolean("gameplay-mechanics.persistent-tileentity-display-name", persistentTileEntityDisplayName);
+         mobLastHurtByPlayerTime = getInt("gameplay-mechanics.mob-last-hurt-by-player-time", mobLastHurtByPlayerTime);
+         milkClearsBeneficialEffects = getBoolean("gameplay-mechanics.milk-clears-beneficial-effects", milkClearsBeneficialEffects);
+        disableOxidationProximityPenalty = getBoolean("gameplay-mechanics.disable-oxidation-proximity-penalty", disableOxidationProximityPenalty);
+     }
+ 
+     public int daytimeTicks = 12000;
--- a/patches/server/0287-register-minecraft-debug-commands.patch
+++ b/patches/server/0287-register-minecraft-debug-commands.patch
@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <contact@granny.dev>
+Date: Sun, 18 Feb 2024 16:28:32 -0800
+Subject: [PATCH] register minecraft debug commands
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index db455a0fc7e1fc004215b718ff470bd2f74eae1b..8d82425ccbc30b3f4a59767ca72bf37311ddeda0 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -226,8 +226,8 @@ public class Commands {
+             JfrCommand.register(this.dispatcher);
+         }
+ 
+-        if (SharedConstants.IS_RUNNING_IN_IDE) {
+-            TestCommand.register(this.dispatcher);
+        if (org.purpurmc.purpur.PurpurConfig.registerMinecraftDebugCommands || SharedConstants.IS_RUNNING_IN_IDE) { // Purpur
+            if (!org.purpurmc.purpur.PurpurConfig.registerMinecraftDebugCommands) TestCommand.register(this.dispatcher); // Purpur
+             RaidCommand.register(this.dispatcher, commandRegistryAccess);
+             DebugPathCommand.register(this.dispatcher);
+             DebugMobSpawningCommand.register(this.dispatcher);
+diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
+index 978c0d7296f400fe2ebda89e4f61386e6e87fe0c..a880f4e5cf712654649ad043e58e073e9a87c0fe 100644
+--- a/src/main/java/net/minecraft/server/Main.java
+++ b/src/main/java/net/minecraft/server/Main.java
+@@ -125,6 +125,7 @@ public class Main {
+             // Purpur start - load config files early
+             org.bukkit.configuration.file.YamlConfiguration purpurConfiguration = io.papermc.paper.configuration.PaperConfigurations.loadLegacyConfigFile((File) optionset.valueOf("purpur-settings"));
+             org.purpurmc.purpur.PurpurConfig.clampEnchantLevels = purpurConfiguration.getBoolean("settings.enchantment.clamp-levels", true);
+            org.purpurmc.purpur.PurpurConfig.registerMinecraftDebugCommands = purpurConfiguration.getBoolean("settings.register-minecraft-debug-commands");
+             // Purpur end - load config files early
+ 
+             io.papermc.paper.plugin.PluginInitializerManager.load(optionset); // Paper
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index e2b2eb66907f3a35792a59d68509abda1dd34ccb..8ceec24eeb4b441bcc37e75d4b6a778cc6184f31 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -582,4 +582,9 @@ public class PurpurConfig {
+     private static void playerDeathsAlwaysShowItem() {
+         playerDeathsAlwaysShowItem = getBoolean("settings.player-deaths-always-show-item", playerDeathsAlwaysShowItem);
+     }
+
+    public static boolean registerMinecraftDebugCommands = false;
+    private static void registerMinecraftDebugCommands() {
+        registerMinecraftDebugCommands = getBoolean("settings.register-minecraft-debug-commands", registerMinecraftDebugCommands);
+    }
+ }
--- a/patches/server/0288-Configurable-villager-search-radius.patch
+++ b/patches/server/0288-Configurable-villager-search-radius.patch
@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Pantera <zeruskr@gmail.com>
+Date: Fri, 26 Jan 2024 15:57:24 +0900
+Subject: [PATCH] Configurable-villager-search-radius
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+index 0d177e828c2b338ce93c58aaef04df326e1eb0b2..273ba657926ce72a7c82861e880a82bf7f322a0b 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+@@ -86,7 +86,7 @@ public class AcquirePoi {
+                                     };
+                                     // Paper start - optimise POI access
+                                     final java.util.List<Pair<Holder<PoiType>, BlockPos>> poiposes = new java.util.ArrayList<>();
+-                                    io.papermc.paper.util.PoiAccess.findNearestPoiPositions(poiManager, poiPredicate, predicate2, entity.blockPosition(), 48, 48*48, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes);
+                                    io.papermc.paper.util.PoiAccess.findNearestPoiPositions(poiManager, poiPredicate, predicate2, entity.blockPosition(), world.purpurConfig.villagerAcquirePoiSearchRadius, world.purpurConfig.villagerAcquirePoiSearchRadius*world.purpurConfig.villagerAcquirePoiSearchRadius, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes);
+                                     final Set<Pair<Holder<PoiType>, BlockPos>> set = new java.util.HashSet<>(poiposes.size());
+                                     for (final Pair<Holder<PoiType>, BlockPos> poiPose : poiposes) {
+                                         if (worldPosBiPredicate.test(world, poiPose.getSecond())) {
+diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
+index 92731b6b593289e9f583c9b705b219e81fcd8e73..9104d7010bda6f9f73b478c11490ef9c53f76da2 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
+++ b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
+@@ -56,7 +56,7 @@ public class NearestBedSensor extends Sensor<Mob> {
+             // Paper start - optimise POI access
+             java.util.List<Pair<Holder<PoiType>, BlockPos>> poiposes = new java.util.ArrayList<>();
+             // don't ask me why it's unbounded. ask mojang.
+-            io.papermc.paper.util.PoiAccess.findAnyPoiPositions(poiManager, type -> type.is(PoiTypes.HOME), predicate, entity.blockPosition(), 48, PoiManager.Occupancy.ANY, false, Integer.MAX_VALUE, poiposes);
+            io.papermc.paper.util.PoiAccess.findAnyPoiPositions(poiManager, type -> type.is(PoiTypes.HOME), predicate, entity.blockPosition(), world.purpurConfig.villagerNearestBedSensorSearchRadius, PoiManager.Occupancy.ANY, false, Integer.MAX_VALUE, poiposes); // Purpur
+             Path path = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes));
+             // Paper end - optimise POI access
+             if (path != null && path.canReach()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9b3e2d1ab8ad0b388a0bd3947feea43e602b8781..d396a9fee2326620a0222ff91dba63f187907525 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -3004,6 +3004,8 @@ public class PurpurWorldConfig {
+     public boolean villagerDisplayTradeItem = true;
+     public int villagerSpawnIronGolemRadius = 0;
+     public int villagerSpawnIronGolemLimit = 0;
+    public int villagerAcquirePoiSearchRadius = 48;
+    public int villagerNearestBedSensorSearchRadius = 48;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -3042,6 +3044,8 @@ public class PurpurWorldConfig {
+         villagerDisplayTradeItem = getBoolean("mobs.villager.display-trade-item", villagerDisplayTradeItem);
+         villagerSpawnIronGolemRadius = getInt("mobs.villager.spawn-iron-golem.radius", villagerSpawnIronGolemRadius);
+         villagerSpawnIronGolemLimit = getInt("mobs.villager.spawn-iron-golem.limit", villagerSpawnIronGolemLimit);
+        villagerAcquirePoiSearchRadius = getInt("mobs.villager.search-radius.acquire-poi", villagerAcquirePoiSearchRadius);
+        villagerNearestBedSensorSearchRadius = getInt("mobs.villager.search-radius.nearest-bed-sensor", villagerNearestBedSensorSearchRadius);
+     }
+ 
+     public boolean vindicatorRidable = false;
--- a/patches/server/0289-option-to-make-ravagers-afraid-of-rabbits.patch
+++ b/patches/server/0289-option-to-make-ravagers-afraid-of-rabbits.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Tue, 7 May 2024 04:59:57 -0700
+Subject: [PATCH] option to make ravagers afraid of rabbits
+
+https://github.com/PurpurMC/Purpur/discussions/713
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+index 5688f6ff0c1d9d1fbca548dcff8d8dfa5b42b8fd..17aaa3f376ce6183911739536206f9f701e452b5 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+@@ -119,6 +119,7 @@ public class Ravager extends Raider {
+         super.registerGoals();
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+        if (level().purpurConfig.ravagerAvoidRabbits) this.goalSelector.addGoal(3, new net.minecraft.world.entity.ai.goal.AvoidEntityGoal<>(this, net.minecraft.world.entity.animal.Rabbit.class, 6.0F, 1.0D, 1.2D)); // Purpur
+         this.goalSelector.addGoal(4, new MeleeAttackGoal(this, 1.0D, true));
+         this.goalSelector.addGoal(5, new WaterAvoidingRandomStrollGoal(this, 0.4D));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d396a9fee2326620a0222ff91dba63f187907525..57ddb4e6a464567cc67e09ce06218cc25af4ddf9 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2485,6 +2485,7 @@ public class PurpurWorldConfig {
+     public boolean ravagerTakeDamageFromWater = false;
+     public List<Block> ravagerGriefableBlocks = new ArrayList<>();
+     public boolean ravagerAlwaysDropExp = false;
+    public boolean ravagerAvoidRabbits = false;
+     private void ravagerSettings() {
+         ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable);
+         ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater);
+@@ -2516,6 +2517,7 @@ public class PurpurWorldConfig {
+             }
+         });
+         ravagerAlwaysDropExp = getBoolean("mobs.ravager.always-drop-exp", ravagerAlwaysDropExp);
+        ravagerAvoidRabbits = getBoolean("mobs.ravager.avoid-rabbits", ravagerAvoidRabbits);
+     }
+ 
+     public boolean salmonRidable = false;
--- a/patches/server/0290-config-for-startup-commands.patch
+++ b/patches/server/0290-config-for-startup-commands.patch
@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Sun, 5 May 2024 02:27:52 -0700
+Subject: [PATCH] config for startup commands
+
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 74d4bb12d70cbfd8365337c8fbcdbdfe6d70e970..0819adb34541e5a774f07616957c785b3d6cd8ea 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1294,6 +1294,17 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 }
+             }
+             // Purpur end
+
+            // Purpur start
+            if (!Boolean.getBoolean("Purpur.IReallyDontWantStartupCommands") && !org.purpurmc.purpur.PurpurConfig.startupCommands.isEmpty()) {
+                LOGGER.info("Purpur: Running startup commands specified in purpur.yml.");
+                for (final String startupCommand : org.purpurmc.purpur.PurpurConfig.startupCommands) {
+                    LOGGER.info("Purpur: Running the following command: \"{}\"", startupCommand);
+                    ((DedicatedServer) this).handleConsoleInput(startupCommand, this.createCommandSourceStack());
+                }
+            }
+            // Purpur end
+
+             while (this.running) {
+                 long i;
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 8ceec24eeb4b441bcc37e75d4b6a778cc6184f31..ed54fc4104ac5e38490bc5390f8351eb5a9c039d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -587,4 +587,16 @@ public class PurpurConfig {
+     private static void registerMinecraftDebugCommands() {
+         registerMinecraftDebugCommands = getBoolean("settings.register-minecraft-debug-commands", registerMinecraftDebugCommands);
+     }
+
+    public static List<String> startupCommands = new ArrayList<>();
+    private static void startupCommands() {
+        startupCommands.clear();
+        getList("settings.startup-commands", new ArrayList<String>()).forEach(line -> {
+            String command = line.toString();
+            if (command.startsWith("/")) {
+                command = command.substring(1);
+            }
+            startupCommands.add(command);
+        });
+    }
+ }
--- a/patches/server/0291-Config-to-reverse-bubble-column-flow.patch
+++ b/patches/server/0291-Config-to-reverse-bubble-column-flow.patch
@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Sat, 8 Jun 2024 22:06:47 -0700
+Subject: [PATCH] Config to reverse bubble column flow
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java b/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java
+index 385da0585f409ee453f10d45f5837cdc09adc21b..c65016cba376a41c267fb4b6499ec0a263851558 100644
+--- a/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java
+@@ -123,10 +123,10 @@ public class BubbleColumnBlock extends Block implements BucketPickup {
+         if (state.is(Blocks.BUBBLE_COLUMN)) {
+             return state;
+         } else if (state.is(Blocks.SOUL_SAND)) {
+-            return Blocks.BUBBLE_COLUMN.defaultBlockState().setValue(DRAG_DOWN, Boolean.valueOf(false));
+            return Blocks.BUBBLE_COLUMN.defaultBlockState().setValue(DRAG_DOWN, Boolean.valueOf(org.purpurmc.purpur.PurpurConfig.soulSandBlockReverseBubbleColumnFlow)); // Purpur
+         } else {
+             return state.is(Blocks.MAGMA_BLOCK)
+-                ? Blocks.BUBBLE_COLUMN.defaultBlockState().setValue(DRAG_DOWN, Boolean.valueOf(true))
+                ? Blocks.BUBBLE_COLUMN.defaultBlockState().setValue(DRAG_DOWN, Boolean.valueOf(!org.purpurmc.purpur.PurpurConfig.magmaBlockReverseBubbleColumnFlow)) // Purpur
+                 : Blocks.WATER.defaultBlockState();
+         }
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index ed54fc4104ac5e38490bc5390f8351eb5a9c039d..95cd1156766895546ef5574b33a60806bff08fa2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -344,6 +344,8 @@ public class PurpurConfig {
+     public static int kelpMaxGrowthAge = 25;
+     public static int twistingVinesMaxGrowthAge = 25;
+     public static int weepingVinesMaxGrowthAge = 25;
+    public static boolean magmaBlockReverseBubbleColumnFlow = false;
+    public static boolean soulSandBlockReverseBubbleColumnFlow = false;
+     private static void blockSettings() {
+         if (version < 3) {
+             boolean oldValue = getBoolean("settings.barrel.packed-barrels", true);
+@@ -417,6 +419,8 @@ public class PurpurConfig {
+             log(Level.WARNING, "blocks.weeping_vines.max-growth-age is set to above maximum allowed value of 25");
+             log(Level.WARNING, "Using value of 25 to prevent issues");
+         }
+        magmaBlockReverseBubbleColumnFlow = getBoolean("settings.blocks.magma-block.reverse-bubble-column-flow", magmaBlockReverseBubbleColumnFlow);
+        soulSandBlockReverseBubbleColumnFlow = getBoolean("settings.blocks.soul-sand.reverse-bubble-column-flow", soulSandBlockReverseBubbleColumnFlow);
+     }
+ 
+     public static boolean allowInapplicableEnchants = false;
--- a/patches/server/0292-Adopt-MaterialRerouting.patch
+++ b/patches/server/0292-Adopt-MaterialRerouting.patch
@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <granny@purpurmc.org>
+Date: Thu, 13 Jun 2024 16:00:30 -0700
+Subject: [PATCH] Adopt MaterialRerouting
+
+Adopts the purpur-api to the material rerouting infrastructure introduced
+by upstream's upstream.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+index db8d8e2a07296d62c3097f02b03319e2e1ba9394..e5c30847297e056782084d81fb9300f98d4a8f75 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+++ b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+@@ -708,4 +708,32 @@ public class MaterialRerouting {
+         meta.setCanPlaceOn(materials);
+     }
+     // Paper end
+    // Purpur start
+    // Method added post 1.13, no-op (https://github.com/PurpurMC/Purpur/pull/570)
+    public static void addFuel(Server server, Material material, int burnTime) {
+        server.addFuel(material, burnTime);
+    }
+
+    // Method added post 1.13, no-op (https://github.com/PurpurMC/Purpur/pull/570)
+    public static void removeFuel(Server server, Material material) {
+        server.removeFuel(material);
+    }
+
+    // Method added post 1.13, no-op (https://github.com/PurpurMC/Purpur/pull/570)
+    @RerouteStatic("org/bukkit/Bukkit")
+    public static void addFuel(Material material, int burnTime) {
+        Bukkit.addFuel(material, burnTime);
+    }
+
+    // Method added post 1.13, no-op (https://github.com/PurpurMC/Purpur/pull/570)
+    @RerouteStatic("org/bukkit/Bukkit")
+    public static void removeFuel(Material material) {
+        Bukkit.removeFuel(material);
+    }
+
+    // Method added post 1.13, no-op (https://github.com/PurpurMC/Purpur/commit/607d909efba516893072b782c0393c53d048210e)
+    public static BlockData getBlockData(ItemStack itemStack, Material material) {
+        return itemStack.getBlockData(MaterialRerouting.transformToBlockType(material));
+    }
+    // Purpur end
+ }
--- a/patches/server/0293-Fire-EntityTeleportHinderedEvent-when-attempting-to-.patch
+++ b/patches/server/0293-Fire-EntityTeleportHinderedEvent-when-attempting-to-.patch
@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Villagers654 <110007851+Villagers654@users.noreply.github.com>
+Date: Mon, 22 Jul 2024 21:03:09 -0400
+Subject: [PATCH] Fire EntityTeleportHinderedEvent when attempting to teleport
+ a player with passengers
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 8e0136c55e37d1f2732c555eb7c6129eb2b84c19..22abd7c837fe35423bd0c9e94107d47156d09266 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1462,6 +1462,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+ 
+         if (entity.isVehicle() && !ignorePassengers) { // Paper - Teleport API
+            if (!new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, cause).callEvent()) // Purpur start
+             return false;
+         }
+ 
--- a/patches/server/0294-ItemStack-convenience-methods.patch
+++ b/patches/server/0294-ItemStack-convenience-methods.patch
@@ -0,0 +1,296 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: granny <contact@granny.dev>
+Date: Thu, 3 Oct 2024 18:33:14 -0700
+Subject: [PATCH] ItemStack convenience methods
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index 78975412da0f0c2b802bfce6d30d56b26d8023e2..4ec6a07796023aab2f8f84f131f48108c235c852 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -658,4 +658,285 @@ public final class CraftItemStack extends ItemStack {
+     }
+ 
+     // Paper end - data component API
+
+    // Purpur start
+    @Override
+    public String getDisplayName() {
+        return getItemMeta().getDisplayName();
+    }
+
+    @Override
+    public void setDisplayName(String name) {
+        ItemMeta itemMeta = getItemMeta();
+        itemMeta.setDisplayName(name);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public boolean hasDisplayName() {
+        return hasItemMeta() && getItemMeta().hasDisplayName();
+    }
+
+    @Override
+    public String getLocalizedName() {
+        return getItemMeta().getLocalizedName();
+    }
+
+    @Override
+    public void setLocalizedName(String name) {
+        ItemMeta itemMeta = getItemMeta();
+        itemMeta.setLocalizedName(name);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public boolean hasLocalizedName() {
+        return hasItemMeta() && getItemMeta().hasLocalizedName();
+    }
+
+    @Override
+    public boolean hasLore() {
+        return hasItemMeta() && getItemMeta().hasLore();
+    }
+
+    @Override
+    public boolean hasEnchant(Enchantment ench) {
+        return hasItemMeta() && getItemMeta().hasEnchant(ench);
+    }
+
+    @Override
+    public int getEnchantLevel(Enchantment ench) {
+        return getItemMeta().getEnchantLevel(ench);
+    }
+
+    @Override
+    public Map<Enchantment, Integer> getEnchants() {
+        return getItemMeta().getEnchants();
+    }
+
+    @Override
+    public boolean addEnchant(Enchantment ench, int level, boolean ignoreLevelRestriction) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.addEnchant(ench, level, ignoreLevelRestriction);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public boolean removeEnchant(Enchantment ench) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.removeEnchant(ench);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public boolean hasEnchants() {
+        return hasItemMeta() && getItemMeta().hasEnchants();
+    }
+
+    @Override
+    public boolean hasConflictingEnchant(Enchantment ench) {
+        return hasItemMeta() && getItemMeta().hasConflictingEnchant(ench);
+    }
+
+    @Override
+    public void setCustomModelData(Integer data) {
+        ItemMeta itemMeta = getItemMeta();
+        itemMeta.setCustomModelData(data);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public int getCustomModelData() {
+        return getItemMeta().getCustomModelData();
+    }
+
+    @Override
+    public boolean hasCustomModelData() {
+        return hasItemMeta() && getItemMeta().hasCustomModelData();
+    }
+
+    @Override
+    public boolean hasBlockData() {
+        return hasItemMeta() && ((org.bukkit.inventory.meta.BlockDataMeta) getItemMeta()).hasBlockData();
+    }
+
+    @Override
+    public org.bukkit.block.data.BlockData getBlockData(Material material) {
+        return ((org.bukkit.inventory.meta.BlockDataMeta) getItemMeta()).getBlockData(material);
+    }
+
+    @Override
+    public void setBlockData(org.bukkit.block.data.BlockData blockData) {
+        ItemMeta itemMeta = getItemMeta();
+        ((org.bukkit.inventory.meta.BlockDataMeta) itemMeta).setBlockData(blockData);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public int getRepairCost() {
+        return ((org.bukkit.inventory.meta.Repairable) getItemMeta()).getRepairCost();
+    }
+
+    @Override
+    public void setRepairCost(int cost) {
+        ItemMeta itemMeta = getItemMeta();
+        ((org.bukkit.inventory.meta.Repairable) itemMeta).setRepairCost(cost);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public boolean hasRepairCost() {
+        return hasItemMeta() && ((org.bukkit.inventory.meta.Repairable) getItemMeta()).hasRepairCost();
+    }
+
+    @Override
+    public boolean isUnbreakable() {
+        return hasItemMeta() && getItemMeta().isUnbreakable();
+    }
+
+    @Override
+    public void setUnbreakable(boolean unbreakable) {
+        ItemMeta itemMeta = getItemMeta();
+        itemMeta.setUnbreakable(unbreakable);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public boolean hasAttributeModifiers() {
+        return hasItemMeta() && getItemMeta().hasAttributeModifiers();
+    }
+
+    @Override
+    public com.google.common.collect.Multimap<org.bukkit.attribute.Attribute, org.bukkit.attribute.AttributeModifier> getAttributeModifiers() {
+        return getItemMeta().getAttributeModifiers();
+    }
+
+    @Override
+    public com.google.common.collect.Multimap<org.bukkit.attribute.Attribute, org.bukkit.attribute.AttributeModifier> getAttributeModifiers(org.bukkit.inventory.EquipmentSlot slot) {
+        return getItemMeta().getAttributeModifiers(slot);
+    }
+
+    @Override
+    public java.util.Collection<org.bukkit.attribute.AttributeModifier> getAttributeModifiers(org.bukkit.attribute.Attribute attribute) {
+        return getItemMeta().getAttributeModifiers(attribute);
+    }
+
+    @Override
+    public boolean addAttributeModifier(org.bukkit.attribute.Attribute attribute, org.bukkit.attribute.AttributeModifier modifier) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.addAttributeModifier(attribute, modifier);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public void setAttributeModifiers(com.google.common.collect.Multimap<org.bukkit.attribute.Attribute, org.bukkit.attribute.AttributeModifier> attributeModifiers) {
+        ItemMeta itemMeta = getItemMeta();
+        itemMeta.setAttributeModifiers(attributeModifiers);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public boolean removeAttributeModifier(org.bukkit.attribute.Attribute attribute) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.removeAttributeModifier(attribute);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public boolean removeAttributeModifier(org.bukkit.inventory.EquipmentSlot slot) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.removeAttributeModifier(slot);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public boolean removeAttributeModifier(org.bukkit.attribute.Attribute attribute, org.bukkit.attribute.AttributeModifier modifier) {
+        ItemMeta itemMeta = getItemMeta();
+        boolean result = itemMeta.removeAttributeModifier(attribute, modifier);
+        setItemMeta(itemMeta);
+        return result;
+    }
+
+    @Override
+    public boolean hasDamage() {
+        return hasItemMeta() && ((org.bukkit.inventory.meta.Damageable) getItemMeta()).hasDamage();
+    }
+
+    @Override
+    public int getDamage() {
+        return ((org.bukkit.inventory.meta.Damageable) getItemMeta()).getDamage();
+    }
+
+    @Override
+    public void setDamage(int damage) {
+        ItemMeta itemMeta = getItemMeta();
+        ((org.bukkit.inventory.meta.Damageable) itemMeta).setDamage(damage);
+        setItemMeta(itemMeta);
+    }
+
+    @Override
+    public void repair() {
+        repair(1);
+    }
+
+    @Override
+    public boolean damage() {
+        return damage(1);
+    }
+
+    @Override
+    public void repair(int amount) {
+        damage(-amount);
+    }
+
+    @Override
+    public boolean damage(int amount) {
+        return damage(amount, false);
+    }
+
+    @Override
+    public boolean damage(int amount, boolean ignoreUnbreaking) {
+        org.bukkit.inventory.meta.Damageable damageable = (org.bukkit.inventory.meta.Damageable) getItemMeta();
+        if (amount > 0) {
+            int unbreaking = getEnchantLevel(Enchantment.UNBREAKING);
+            int reduce = 0;
+            for (int i = 0; unbreaking > 0 && i < amount; ++i) {
+                if (reduceDamage(java.util.concurrent.ThreadLocalRandom.current(), unbreaking)) {
+                    ++reduce;
+                }
+            }
+            amount -= reduce;
+            if (amount <= 0) {
+                return isBroke(damageable.getDamage());
+            }
+        }
+        int damage = damageable.getDamage() + amount;
+        damageable.setDamage(damage);
+        setItemMeta((ItemMeta) damageable);
+        return isBroke(damage);
+    }
+
+    private boolean isBroke(int damage) {
+        if (damage > getType().getMaxDurability()) {
+            if (getAmount() > 0) {
+                // ensure it "breaks"
+                setAmount(0);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private boolean reduceDamage(java.util.Random random, int unbreaking) {
+        if (getType().isArmor()) {
+            return random.nextFloat() < 0.6F;
+        }
+        return random.nextInt(unbreaking + 1) > 0;
+    }
+    // Purpur end
+ }