60/103 minecraft source files applied

purpur-server/minecraft-patches/rejected/net/minecraft/commands/CommandSourceStack.java.patch

@@ -0,0 +1,61 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/commands/CommandSourceStack.java b/net/minecraft/commands/CommandSourceStack.java
+index 566304106fd4f1c677a56e7c66282d1570e7b974..21d135189a4d67605e0dfb991283d48268ce5d5c 100644
+--- a/net/minecraft/commands/CommandSourceStack.java
++++ b/net/minecraft/commands/CommandSourceStack.java
+@@ -430,6 +430,19 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
+     }
+     // CraftBukkit end
+ 
++    // Purpur start - Gamemode extra permissions
++    public boolean testPermission(net.minecraft.server.permissions.Permission permission, String bukkitPermission) {
++        if (hasPermission(permission, bukkitPermission)) {
++            return true;
++        }
++        net.kyori.adventure.text.Component permissionMessage = getLevel().getServer().server.permissionMessage();
++        if (!permissionMessage.equals(net.kyori.adventure.text.Component.empty())) {
++            sendFailure(io.papermc.paper.adventure.PaperAdventure.asVanilla(permissionMessage.replaceText(net.kyori.adventure.text.TextReplacementConfig.builder().matchLiteral("<permission>").replacement(bukkitPermission).build())));
++        }
++        return false;
++    }
++    // Purpur end - Gamemode extra permissions
++
+     public Vec3 getPosition() {
+         return this.worldPosition;
+     }
+@@ -513,6 +526,30 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
+         }
+     }
+ 
++    // Purpur start - Purpur config files
++    public void sendSuccess(@Nullable String message) {
++        sendSuccess(message, false);
++    }
++
++    public void sendSuccess(@Nullable String message, boolean broadcastToOps) {
++        if (message == null) {
++            return;
++        }
++        sendSuccess(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(message), broadcastToOps);
++    }
++
++    public void sendSuccess(net.kyori.adventure.text.@Nullable Component message) {
++        sendSuccess(message, false);
++    }
++
++    public void sendSuccess(net.kyori.adventure.text.@Nullable Component message, boolean broadcastToOps) {
++        if (message == null) {
++            return;
++        }
++        sendSuccess(() -> io.papermc.paper.adventure.PaperAdventure.asVanilla(message), broadcastToOps);
++    }
++    // Purpur end - Purpur config files
++
+     public void sendSuccess(Supplier<Component> messageSupplier, boolean allowLogging) {
+         boolean flag = this.source.acceptsSuccess() && !this.silent;
+         boolean flag1 = allowLogging && this.source.shouldInformAdmins() && !this.silent;

purpur-server/minecraft-patches/rejected/net/minecraft/commands/Commands.java.patch

@@ -0,0 +1,56 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
+index 668eb52d71d77f75c24d4840be9a6c49d96dfc34..83148f756ecc77ae45abffbd1d7cbfacf6c99e7f 100644
+--- a/net/minecraft/commands/Commands.java
++++ b/net/minecraft/commands/Commands.java
+@@ -265,11 +265,11 @@ public class Commands {
+             JfrCommand.register(this.dispatcher);
+         }
+ 
+-        if (SharedConstants.DEBUG_CHASE_COMMAND) {
++        if (org.purpurmc.purpur.PurpurConfig.registerMinecraftDisabledCommands || SharedConstants.DEBUG_CHASE_COMMAND) { // Purpur - register disabled minecraft commands
+             ChaseCommand.register(this.dispatcher);
+         }
+ 
+-        if (SharedConstants.DEBUG_DEV_COMMANDS || SharedConstants.IS_RUNNING_IN_IDE) {
++        if (org.purpurmc.purpur.PurpurConfig.registerMinecraftDebugCommands || SharedConstants.DEBUG_DEV_COMMANDS || SharedConstants.IS_RUNNING_IN_IDE) {  // Purpur - register minecraft debug commands
+             RaidCommand.register(this.dispatcher, context);
+             DebugPathCommand.register(this.dispatcher);
+             DebugMobSpawningCommand.register(this.dispatcher);
+@@ -297,6 +297,14 @@ public class Commands {
+             StopCommand.register(this.dispatcher);
+             TransferCommand.register(this.dispatcher);
+             WhitelistCommand.register(this.dispatcher);
++            org.purpurmc.purpur.command.CreditsCommand.register(this.dispatcher); // Purpur - Add credits command
++            org.purpurmc.purpur.command.DemoCommand.register(this.dispatcher); // Purpur - Add demo command
++            org.purpurmc.purpur.command.PingCommand.register(this.dispatcher); // Purpur - Add ping command
++            org.purpurmc.purpur.command.UptimeCommand.register(this.dispatcher); // Purpur - Add uptime command
++            org.purpurmc.purpur.command.TPSBarCommand.register(this.dispatcher); // Purpur - Implement TPSBar
++            org.purpurmc.purpur.command.CompassCommand.register(this.dispatcher); // Purpur - Add compass command
++            org.purpurmc.purpur.command.RamBarCommand.register(this.dispatcher); // Purpur - Add rambar command
++            org.purpurmc.purpur.command.RamCommand.register(this.dispatcher); // Purpur - Add ram command
+         }
+ 
+         if (selection.includeIntegrated) {
+@@ -522,6 +530,7 @@ public class Commands {
+     private void runSync(ServerPlayer player, java.util.Collection<String> bukkit, RootCommandNode<CommandSourceStack> rootCommandNode) {
+         // Paper end - Perf: Async command map building
+         new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendCommandsEvent<CommandSourceStack>(player.getBukkitEntity(), (RootCommandNode) rootCommandNode, true).callEvent(); // Paper - Brigadier API
++        if (org.bukkit.event.player.PlayerCommandSendEvent.getHandlerList().getRegisteredListeners().length > 0) { // Purpur - Skip events if there's no listeners
+         org.bukkit.event.player.PlayerCommandSendEvent event = new org.bukkit.event.player.PlayerCommandSendEvent(player.getBukkitEntity(), new java.util.LinkedHashSet<>(bukkit));
+         event.getPlayer().getServer().getPluginManager().callEvent(event);
+ 
+@@ -532,6 +541,8 @@ public class Commands {
+             }
+         }
+         // CraftBukkit end
++        } // Purpur - Skip events if there's no listeners
++
+         player.connection.send(new ClientboundCommandsPacket(rootCommandNode, COMMAND_NODE_INSPECTOR));
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/commands/arguments/selector/EntitySelector.java.patch

@@ -0,0 +1,53 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/commands/arguments/selector/EntitySelector.java b/net/minecraft/commands/arguments/selector/EntitySelector.java
+index af71e0e1eb1c93745f3e4954ecc8fbd2ad4808a3..fbab3e2f4e3a9cdc1c148fc794036c5655368666 100644
+--- a/net/minecraft/commands/arguments/selector/EntitySelector.java
++++ b/net/minecraft/commands/arguments/selector/EntitySelector.java
+@@ -190,26 +190,27 @@ public class EntitySelector {
+         this.checkPermissions(source);
+         if (this.playerName != null) {
+             ServerPlayer playerByName = source.getServer().getPlayerList().getPlayerByName(this.playerName);
+-            return playerByName == null ? List.of() : List.of(playerByName);
++            return playerByName == null || !canSee(source, playerByName) ? List.of() : List.of(playerByName); // Purpur - Hide hidden players from entity selector
+         } else if (this.entityUUID != null) {
+             ServerPlayer playerByName = source.getServer().getPlayerList().getPlayer(this.entityUUID);
+-            return playerByName == null ? List.of() : List.of(playerByName);
++            return playerByName == null || !canSee(source, playerByName) ? List.of() : List.of(playerByName); // Purpur - Hide hidden players from entity selector
+         } else {
+             Vec3 vec3 = this.position.apply(source.getPosition());
+             AABB absoluteAabb = this.getAbsoluteAabb(vec3);
+             Predicate<Entity> predicate = this.getPredicate(vec3, absoluteAabb, null);
+             if (this.currentEntity) {
+-                return source.getEntity() instanceof ServerPlayer serverPlayer && predicate.test(serverPlayer) ? List.of(serverPlayer) : List.of();
++                return source.getEntity() instanceof ServerPlayer serverPlayer && predicate.test(serverPlayer) && canSee(source, serverPlayer) ? List.of(serverPlayer) : List.of(); // Purpur - Hide hidden players from entity selector
+             } else {
+                 int resultLimit = this.getResultLimit();
+                 List<ServerPlayer> players;
+                 if (this.isWorldLimited()) {
+                     players = source.getLevel().getPlayers(predicate, resultLimit);
++                    players.removeIf(entityplayer3 -> !canSee(source, entityplayer3)); // Purpur - Hide hidden players from entity selector
+                 } else {
+                     players = new ObjectArrayList<>();
+ 
+                     for (ServerPlayer serverPlayer1 : source.getServer().getPlayerList().getPlayers()) {
+-                        if (predicate.test(serverPlayer1)) {
++                        if (predicate.test(serverPlayer1) && canSee(source, serverPlayer1)) { // Purpur - Hide hidden players from entity selector
+                             players.add(serverPlayer1);
+                             if (players.size() >= resultLimit) {
+                                 return players;
+@@ -267,4 +268,10 @@ public class EntitySelector {
+     public static Component joinNames(List<? extends Entity> names) {
+         return ComponentUtils.formatList(names, Entity::getDisplayName);
+     }
++
++    // Purpur start - Hide hidden players from entity selector
++    private boolean canSee(CommandSourceStack sender, ServerPlayer target) {
++        return !org.purpurmc.purpur.PurpurConfig.hideHiddenPlayersFromEntitySelector || !(sender.getEntity() instanceof ServerPlayer player) || player.getBukkitEntity().canSee(target.getBukkitEntity());
++    }
++    // Purpur end - Hide hidden players from entity selector
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/core/BlockPos.java.patch

@@ -0,0 +1,23 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/core/BlockPos.java b/net/minecraft/core/BlockPos.java
+index e87473fcb36e18d960ef3e4082995785d64b9c0f..e4dee5426e186d44d4d929967c65710848ace11d 100644
+--- a/net/minecraft/core/BlockPos.java
++++ b/net/minecraft/core/BlockPos.java
+@@ -61,6 +61,12 @@ public class BlockPos extends Vec3i {
+     public static final int MAX_HORIZONTAL_COORDINATE = 33554431;
+     // Paper end - Optimize Bit Operations by inlining
+ 
++    // Purpur start - Ridables
++    public BlockPos(net.minecraft.world.entity.Entity entity) {
++        super(entity.getBlockX(), entity.getBlockY(), entity.getBlockZ());
++    }
++    // Purpur end - Ridables
++
+     public BlockPos(int x, int y, int z) {
+         super(x, y, z);
+     }

purpur-server/minecraft-patches/rejected/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java b/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
+index e2d169b45f1dba6559ca337b07a110f79d3db504..727d04a442053f6d0c4df3e744554e2866fa38cd 100644
+--- a/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
++++ b/net/minecraft/core/dispenser/EquipmentDispenseItemBehavior.java
+@@ -32,7 +32,7 @@ public class EquipmentDispenseItemBehavior extends DefaultDispenseItemBehavior {
+             return false;
+         } else {
+             LivingEntity livingEntity = entitiesOfClass.getFirst();
+-            EquipmentSlot equipmentSlotForItem = livingEntity.getEquipmentSlotForItem(item);
++            EquipmentSlot equipmentSlotForItem = blockSource.level().purpurConfig.dispenserApplyCursedArmor ? livingEntity.getEquipmentSlotForItem(item) : livingEntity.getEquipmentSlotForDispenserItem(item); if (equipmentSlotForItem == null) return false; // Purpur - Dispenser curse of binding protection
+             ItemStack itemStack = item.copyWithCount(1); // Paper - shrink below and single item in event
+             // CraftBukkit start
+             net.minecraft.world.level.Level world = blockSource.level();

purpur-server/minecraft-patches/rejected/net/minecraft/gametest/framework/TestCommand.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/gametest/framework/TestCommand.java b/net/minecraft/gametest/framework/TestCommand.java
+index 4a06b20b60f67a2d383dbd09b3bad713155dc81e..63e0294f5624643b6d37983f523bf2434cbe47e2 100644
+--- a/net/minecraft/gametest/framework/TestCommand.java
++++ b/net/minecraft/gametest/framework/TestCommand.java
+@@ -443,7 +443,7 @@ public class TestCommand {
+                             )
+                     )
+             );
+-        if (SharedConstants.IS_RUNNING_IN_IDE) {
++        if (org.purpurmc.purpur.PurpurConfig.registerMinecraftDebugCommands || SharedConstants.IS_RUNNING_IN_IDE) { // Purpur - register minecraft debug commands
+             literalArgumentBuilder = literalArgumentBuilder.then(
+                     Commands.literal("export")
+                         .then(

purpur-server/minecraft-patches/rejected/net/minecraft/server/Main.java.patch

@@ -0,0 +1,24 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/Main.java b/net/minecraft/server/Main.java
+index 9216e85e74bb0121c72665f155b07cf9a37f430a..31ce71305260f082729780d4e8fb4dba557f9883 100644
+--- a/net/minecraft/server/Main.java
++++ b/net/minecraft/server/Main.java
+@@ -105,6 +105,13 @@ public class Main {
+                 JvmProfiler.INSTANCE.start(Environment.SERVER);
+             }
+ 
++            // Purpur start - Add toggle for enchant level clamping - 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 - register minecraft debug commands
++            org.purpurmc.purpur.PurpurConfig.registerMinecraftDisabledCommands = purpurConfiguration.getBoolean("settings.register-minecraft-disabled-commands"); // Purpur - register disabled minecraft commands
++            // Purpur end - Add toggle for enchant level clamping - load config files early
++
+             io.papermc.paper.plugin.PluginInitializerManager.load(optionSet); // Paper
+             Bootstrap.bootStrap();
+             Bootstrap.validate();

purpur-server/minecraft-patches/rejected/net/minecraft/server/MinecraftServer.java.patch

@@ -0,0 +1,114 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index ca2caace6aab0dfcb0ab7a0fd28e66555c62fdc5..7a54f6bc2a364c1d3ac1ed58b33ecf720a305840 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -290,6 +290,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public joptsimple.OptionSet options;
+     public org.bukkit.command.ConsoleCommandSender console;
+     public static int currentTick; // Paper - improve tick loop
++    public static final long startTimeMillis = System.currentTimeMillis(); // Purpur - Add uptime command
+     public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
+     public int autosavePeriod;
+     // Paper - don't store the vanilla dispatcher
+@@ -306,6 +307,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public boolean isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
+     private final Set<String> pluginsBlockingSleep = new java.util.HashSet<>(); // Paper - API to allow/disallow tick sleeping
+     public static final long SERVER_INIT = System.nanoTime(); // Paper - Lag compensation
++    public boolean lagging = false; // Purpur - Lagging threshold
++    protected boolean upnp = false; // Purpur - UPnP Port Forwarding
+     // Paper start - improve tick loop
+     public final ca.spottedleaf.moonrise.common.time.TickData tickTimes1s  = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(1L));
+     public final ca.spottedleaf.moonrise.common.time.TickData tickTimes5s  = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(5L));
+@@ -375,6 +378,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public double[] computeTPS() {
+         final long interval = this.tickRateManager().nanosecondsPerTick();
+         return new double[] {
++            getTPS(this.tickTimes5s, interval), // Purpur - Add 5 second tps average in /tps
+             getTPS(this.tickTimes1m, interval),
+             getTPS(this.tickTimes5m, interval),
+             getTPS(this.tickTimes15m, interval)
+@@ -1014,6 +1018,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+         LOGGER.info("Stopping server");
+         Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Perf: Async command map building; Shutdown and don't bother finishing
++        // Purpur start - UPnP Port Forwarding
++        if (upnp) {
++            if (dev.omega24.upnp4j.UPnP4J.close(this.getPort(), dev.omega24.upnp4j.util.Protocol.TCP)) {
++                LOGGER.info("[UPnP] Port {} closed", this.getPort());
++            } else {
++                LOGGER.error("[UPnP] Failed to close port {}", this.getPort());
++            }
++        }
++        // Purpur end - UPnP Port Forwarding
+         // CraftBukkit start
+         if (this.server != null) {
+             this.server.spark.disable(); // Paper - spark
+@@ -1107,6 +1120,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.safeShutdown(waitForShutdown, false);
+     }
+     public void safeShutdown(boolean waitForShutdown, boolean isRestarting) {
++        org.purpurmc.purpur.task.BossBarTask.stopAll(); // Purpur - Implement TPSBar
++        org.purpurmc.purpur.task.BeehiveTask.instance().unregister(); // Purpur - Give bee counts in beehives to Purpur clients
+         this.isRestarting = isRestarting;
+         this.hasLoggedStop = true; // Paper - Debugging
+         if (isDebugging()) io.papermc.paper.util.TraceUtil.dumpTraceForThread("Server stopped"); // Paper - Debugging
+@@ -1284,11 +1299,21 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             }
+             // Paper end - Add onboarding message for initial server start
+             // Paper start - Improve outdated version checking
+-            if (System.getProperty("paper.disableStartupVersionCheck") == null && io.papermc.paper.configuration.GlobalConfiguration.get().updateChecker.enabled) {
++            if (false && System.getProperty("paper.disableStartupVersionCheck") == null && io.papermc.paper.configuration.GlobalConfiguration.get().updateChecker.enabled) { // Purpur - disable paper startup check
+                 CompletableFuture.runAsync(com.destroystokyo.paper.PaperVersionFetcher::getUpdateStatusStartupMessage, io.papermc.paper.util.MCUtil.ASYNC_EXECUTOR);
+             }
+             // Paper end - Improve outdated version checking
+ 
++            // Purpur start - config for startup commands
++            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);
++                    ((net.minecraft.server.dedicated.DedicatedServer) this).handleConsoleInput(startupCommand, this.createCommandSourceStack());
++                }
++            }
++            // Purpur end - config for startup commands
++
+             while (this.running) {
+                 final long tickStart = System.nanoTime(); // Paper - improve tick loop
+                 long l; // Paper - improve tick loop - diff on change, expect this to be tick interval
+@@ -1302,9 +1327,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                     final long ticksBehind = Math.max(1L, this.tickSchedule.getPeriodsAhead(l, tickStart));
+                     final long catchup = (long)Math.max(
+                         1,
+-                        5 //ConfigHolder.getConfig().tickLoop.catchupTicks.getOrDefault(MoonriseConfig.TickLoop.DEFAULT_CATCHUP_TICKS).intValue()
++                        org.purpurmc.purpur.PurpurConfig.tpsCatchup ? 5 : 1 //ConfigHolder.getConfig().tickLoop.catchupTicks.getOrDefault(MoonriseConfig.TickLoop.DEFAULT_CATCHUP_TICKS).intValue() // Purpur - Configurable TPS Catchup
+                     );
+ 
++                    lagging = getTPS()[0] < org.purpurmc.purpur.PurpurConfig.laggingThreshold; // Purpur - Lagging threshold
++
+                     // adjust ticksBehind so that it is not greater-than catchup
+                     if (ticksBehind > catchup) {
+                         final long difference = ticksBehind - catchup;
+@@ -1785,7 +1812,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             long worldTime = level.getGameTime();
+             final ClientboundSetTimePacket worldPacket = new ClientboundSetTimePacket(worldTime, dayTime, doDaylight);
+             for (Player entityhuman : level.players()) {
+-                if (!(entityhuman instanceof ServerPlayer) || (tickCount + entityhuman.getId()) % 20 != 0) {
++                if (!(entityhuman instanceof ServerPlayer) || (!level.isForceTime() && (tickCount + entityhuman.getId()) % 20 != 0)) { // Purpur - Configurable daylight cycle
+                     continue;
+                 }
+                 ServerPlayer entityplayer = (ServerPlayer) entityhuman;
+@@ -1952,7 +1979,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     @DontObfuscate
+     public String getServerModName() {
+-        return io.papermc.paper.ServerBuildInfo.buildInfo().brandName(); // Paper
++        return org.purpurmc.purpur.PurpurConfig.serverModName; // Paper // Purpur - Configurable server mod name
+     }
+ 
+     public SystemReport fillSystemReport(SystemReport systemReport) {

purpur-server/minecraft-patches/rejected/net/minecraft/server/PlayerAdvancements.java.patch

@@ -0,0 +1,26 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/PlayerAdvancements.java b/net/minecraft/server/PlayerAdvancements.java
+index 98004b77b7f40d315f41be82105df6d4b9000e33..9612e9dd36010ffcc0e038301233d90b3ed7aeed 100644
+--- a/net/minecraft/server/PlayerAdvancements.java
++++ b/net/minecraft/server/PlayerAdvancements.java
+@@ -146,6 +146,7 @@ public class PlayerAdvancements {
+             AdvancementHolder advancementHolder = advancementManager.get(path);
+             if (advancementHolder == null) {
+                 if (!path.getNamespace().equals(Identifier.DEFAULT_NAMESPACE)) return; // CraftBukkit
++                if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressIgnoredAdvancementWarnings) // Purpur - Logger settings (suppressing pointless logs)
+                 LOGGER.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", path, this.playerSavePath);
+             } else {
+                 this.startProgress(advancementHolder, progress);
+@@ -193,6 +194,7 @@ public class PlayerAdvancements {
+                 advancement.value().display().ifPresent(displayInfo -> {
+                     // Paper start - Add Adventure message to PlayerAdvancementDoneEvent
+                     if (event.message() != null && this.player.level().getGameRules().get(GameRules.SHOW_ADVANCEMENT_MESSAGES)) {
++                        if (org.purpurmc.purpur.PurpurConfig.advancementOnlyBroadcastToAffectedPlayer) this.player.sendMessage(message); else // Purpur - Configurable broadcast settings
+                         this.playerList.broadcastSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.message()), false);
+                         // Paper end
+                     }

purpur-server/minecraft-patches/rejected/net/minecraft/server/commands/EnchantCommand.java.patch

@@ -0,0 +1,28 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/commands/EnchantCommand.java b/net/minecraft/server/commands/EnchantCommand.java
+index 21548995eb278236946b6e495d27f6261e24f7a2..1735a87a974028779cc64cbeb39ff2eeb16034b1 100644
+--- a/net/minecraft/server/commands/EnchantCommand.java
++++ b/net/minecraft/server/commands/EnchantCommand.java
+@@ -70,7 +70,7 @@ public class EnchantCommand {
+ 
+     private static int enchant(CommandSourceStack source, Collection<? extends Entity> targets, Holder<Enchantment> enchantment, int level) throws CommandSyntaxException {
+         Enchantment enchantment1 = enchantment.value();
+-        if (level > enchantment1.getMaxLevel()) {
++        if (!org.purpurmc.purpur.PurpurConfig.allowUnsafeEnchantCommand && level > enchantment1.getMaxLevel()) { // Purpur - Config to allow unsafe enchants
+             throw ERROR_LEVEL_TOO_HIGH.create(level, enchantment1.getMaxLevel());
+         } else {
+             int i = 0;
+@@ -80,7 +80,7 @@ public class EnchantCommand {
+                     ItemStack mainHandItem = livingEntity.getMainHandItem();
+                     if (!mainHandItem.isEmpty()) {
+                         if (enchantment1.canEnchant(mainHandItem)
+-                            && EnchantmentHelper.isEnchantmentCompatible(EnchantmentHelper.getEnchantmentsForCrafting(mainHandItem).keySet(), enchantment)) {
++                            && EnchantmentHelper.isEnchantmentCompatible(EnchantmentHelper.getEnchantmentsForCrafting(mainHandItem).keySet(), enchantment) || (org.purpurmc.purpur.PurpurConfig.allowUnsafeEnchantCommand && !mainHandItem.hasEnchantment(enchantment))) { // Purpur - Config to allow unsafe enchants
+                             mainHandItem.enchant(enchantment, level);
+                             i++;
+                         } else if (targets.size() == 1) {

purpur-server/minecraft-patches/rejected/net/minecraft/server/commands/GameModeCommand.java.patch

@@ -0,0 +1,29 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/commands/GameModeCommand.java b/net/minecraft/server/commands/GameModeCommand.java
+index 503447fbb54bed493f1d867c75ef3f344fe7b81b..a601df223c685f435241cd193a912898e60bab03 100644
+--- a/net/minecraft/server/commands/GameModeCommand.java
++++ b/net/minecraft/server/commands/GameModeCommand.java
+@@ -53,6 +53,18 @@ public class GameModeCommand {
+     }
+ 
+     private static int setMode(CommandContext<CommandSourceStack> context, Collection<ServerPlayer> players, GameType gameType) {
++        // Purpur start - Gamemode extra permissions
++        if (org.purpurmc.purpur.PurpurConfig.commandGamemodeRequiresPermission) {
++            String gamemode = gameType.getName();
++            CommandSourceStack sender = context.getSource();
++            if (!sender.testPermission(Permissions.COMMANDS_GAMEMASTER, "minecraft.command.gamemode." + gamemode)) {
++                return 0;
++            }
++            if (sender.getEntity() instanceof ServerPlayer player && (players.size() > 1 || !players.contains(player)) && !sender.testPermission(Permissions.COMMANDS_GAMEMASTER, "minecraft.command.gamemode." + gamemode + ".other")) {
++                return 0;
++            }
++        }
++        // Purpur end - Gamemode extra permissions
+         int i = 0;
+ 
+         for (ServerPlayer serverPlayer : players) {

purpur-server/minecraft-patches/rejected/net/minecraft/server/commands/GiveCommand.java.patch

@@ -0,0 +1,18 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/commands/GiveCommand.java b/net/minecraft/server/commands/GiveCommand.java
+index 0fc63717af24ca37497db8ea5a2395548d9d8491..2f8fd2240d603346e751a5f7afb91121065423d6 100644
+--- a/net/minecraft/server/commands/GiveCommand.java
++++ b/net/minecraft/server/commands/GiveCommand.java
+@@ -68,6 +68,7 @@ public class GiveCommand {
+                     i1 -= min;
+                     ItemStack itemStack1 = item.createItemStack(min, false);
+                     boolean flag = serverPlayer.getInventory().add(itemStack1);
++                    if (org.purpurmc.purpur.PurpurConfig.disableGiveCommandDrops) continue; // Purpur - add config option for toggling give command dropping
+                     if (flag && itemStack1.isEmpty()) {
+                         ItemEntity itemEntity = serverPlayer.drop(itemStack, false, false, false, null); // Paper - do not fire PlayerDropItemEvent for /give command
+                         if (itemEntity != null) {

purpur-server/minecraft-patches/rejected/net/minecraft/server/gui/MinecraftServerGui.java.patch

@@ -0,0 +1,144 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/gui/MinecraftServerGui.java b/net/minecraft/server/gui/MinecraftServerGui.java
+index f262a7c5ae4e7d56f16f5c0f4f145a2e428abbe4..614c7d9f673c926562acc8fa3b3788623900db41 100644
+--- a/net/minecraft/server/gui/MinecraftServerGui.java
++++ b/net/minecraft/server/gui/MinecraftServerGui.java
+@@ -39,6 +39,11 @@ public class MinecraftServerGui extends JComponent {
+     private Thread logAppenderThread;
+     private final Collection<Runnable> finalizers = Lists.newArrayList();
+     final AtomicBoolean isClosing = new AtomicBoolean();
++    // Purpur start - GUI Improvements
++    private final CommandHistory history = new CommandHistory();
++    private String currentCommand = "";
++    private int historyIndex = 0;
++    // Purpur end - GUI Improvements
+ 
+     public static MinecraftServerGui showFrameFor(final DedicatedServer server) {
+         try {
+@@ -46,7 +51,7 @@ public class MinecraftServerGui extends JComponent {
+         } catch (Exception var3) {
+         }
+ 
+-        final JFrame jFrame = new JFrame("Minecraft server");
++        final JFrame jFrame = new JFrame("Purpur Minecraft server"); // Purpur - Improve GUI
+         final MinecraftServerGui minecraftServerGui = new MinecraftServerGui(server);
+         jFrame.setDefaultCloseOperation(2);
+         jFrame.add(minecraftServerGui);
+@@ -54,7 +59,7 @@ public class MinecraftServerGui extends JComponent {
+         jFrame.setLocationRelativeTo(null);
+         jFrame.setVisible(true);
+         // Paper start - Improve ServerGUI
+-        jFrame.setName("Minecraft server");
++        jFrame.setName("Purpur Minecraft server"); // Purpur - Improve GUI
+         try {
+             jFrame.setIconImage(javax.imageio.ImageIO.read(java.util.Objects.requireNonNull(MinecraftServerGui.class.getClassLoader().getResourceAsStream("logo.png"))));
+         } catch (java.io.IOException ignore) {
+@@ -64,7 +69,7 @@ public class MinecraftServerGui extends JComponent {
+             @Override
+             public void windowClosing(WindowEvent event) {
+                 if (!minecraftServerGui.isClosing.getAndSet(true)) {
+-                    jFrame.setTitle("Minecraft server - shutting down!");
++                    jFrame.setTitle("Purpur Minecraft server - shutting down!"); // Purpur - Improve GUI
+                     server.halt(true);
+                     minecraftServerGui.runFinalizers();
+                 }
+@@ -112,7 +117,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 - GUI Improvements
+         JScrollPane jScrollPane = new JScrollPane(jTextArea, 22, 30);
+         jTextArea.setEditable(false);
+         jTextArea.setFont(MONOSPACED);
+@@ -121,10 +126,43 @@ public class MinecraftServerGui extends JComponent {
+             String trimmed = jTextField.getText().trim();
+             if (!trimmed.isEmpty()) {
+                 this.server.handleConsoleInput(trimmed, this.server.createCommandSourceStack());
++                // Purpur start - GUI Improvements
++                history.add(trimmed);
++                historyIndex = -1;
++                // Purpur end - GUI Improvements
+             }
+ 
+             jTextField.setText("");
+         });
++        // Purpur start - GUI Improvements
++        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 - GUI Improvements
+         jTextArea.addFocusListener(new FocusAdapter() {
+             @Override
+             public void focusGained(FocusEvent event) {
+@@ -159,7 +197,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 line) {
++    public void print(org.purpurmc.purpur.gui.JColorTextPane textArea, JScrollPane scrollPane, String line) { // Purpur - GUI Improvements
+         if (!SwingUtilities.isEventDispatchThread()) {
+             SwingUtilities.invokeLater(() -> this.print(textArea, scrollPane, line));
+         } else {
+@@ -170,10 +208,11 @@ public class MinecraftServerGui extends JComponent {
+                 flag = verticalScrollBar.getValue() + verticalScrollBar.getSize().getHeight() + MONOSPACED.getSize() * 4 > verticalScrollBar.getMaximum();
+             }
+ 
+-            try {
++            /*try { // Purpur - GUI Improvements
+                 document.insertString(document.getLength(), MinecraftServerGui.ANSI.matcher(line).replaceAll(""), null); // CraftBukkit
+             } catch (BadLocationException var8) {
+-            }
++            }*/ // Purpur - GUI Improvements
++            textArea.append(line); // Purpur - GUI Improvements
+ 
+             if (flag) {
+                 verticalScrollBar.setValue(Integer.MAX_VALUE);
+@@ -181,6 +220,18 @@ public class MinecraftServerGui extends JComponent {
+         }
+     }
+ 
++    // Purpur start - GUI Improvements
++    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 - GUI Improvements
++
+     // Paper start - Add onboarding message for initial server start
+     private JComponent buildOnboardingPanel() {
+         String onboardingLink = "https://docs.papermc.io/paper/next-steps";

purpur-server/minecraft-patches/rejected/net/minecraft/server/level/ServerLevel.java.patch

@@ -0,0 +1,224 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index dc65503a2d785d64d37b76b0303f51cf66d9769a..5130c0067f01eec31c69b9e71d904f932943b922 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -218,6 +218,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     private final StructureManager structureManager;
+     private final StructureCheck structureCheck;
+     private final boolean tickTime;
++    private double preciseTime; // Purpur - Configurable daylight cycle
++    private boolean forceTime; // Purpur - Configurable daylight cycle
+     private final RandomSequences randomSequences;
+     final LevelDebugSynchronizers debugSynchronizers = new LevelDebugSynchronizers(this);
+ 
+@@ -622,8 +624,25 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         // CraftBukkit end
+         this.tickTime = tickTime;
+         this.server = server;
+-        this.customSpawners = customSpawners;
++        this.customSpawners = new ArrayList<>(); // Purpur - Allow toggling special MobSpawners per world
+         this.serverLevelData = serverLevelData;
++        // Purpur start - Allow toggling special MobSpawners per world
++        if (purpurConfig.phantomSpawning) {
++            this.customSpawners.add(new net.minecraft.world.level.levelgen.PhantomSpawner());
++        }
++        if (purpurConfig.patrolSpawning) {
++            this.customSpawners.add(new net.minecraft.world.level.levelgen.PatrolSpawner());
++        }
++        if (purpurConfig.catSpawning) {
++            this.customSpawners.add(new net.minecraft.world.entity.npc.CatSpawner());
++        }
++        if (purpurConfig.villageSiegeSpawning) {
++            this.customSpawners.add(new net.minecraft.world.entity.ai.village.VillageSiege());
++        }
++        if (purpurConfig.villagerTraderSpawning) {
++            this.customSpawners.add(new net.minecraft.world.entity.npc.wanderingtrader.WanderingTraderSpawner(serverLevelData));
++        }
++        // Purpur end - Allow toggling special MobSpawners per world
+         ChunkGenerator chunkGenerator = levelStem.generator();
+         // CraftBukkit start
+         this.serverLevelData.setWorld(this);
+@@ -709,6 +728,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         this.chunkDataController = new ca.spottedleaf.moonrise.patches.chunk_system.io.datacontroller.ChunkDataController((ServerLevel)(Object)this, this.chunkTaskScheduler);
+         // Paper end - rewrite chunk system
+         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
++        this.preciseTime = this.serverLevelData.getDayTime(); // Purpur - Configurable daylight cycle
+     }
+ 
+     // Paper start
+@@ -760,7 +780,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         }
+ 
+         int i = this.getGameRules().get(GameRules.PLAYERS_SLEEPING_PERCENTAGE);
+-        if (this.sleepStatus.areEnoughSleeping(i) && this.sleepStatus.areEnoughDeepSleeping(i, this.players)) {
++        if (this.purpurConfig.playersSkipNight && this.sleepStatus.areEnoughSleeping(i) && this.sleepStatus.areEnoughDeepSleeping(i, this.players)) { // Purpur - Config for skipping night
+             // Paper start - create time skip event - move up calculations
+             final long newDayTime = this.levelData.getDayTime() + 24000L;
+             org.bukkit.event.world.TimeSkipEvent event = new org.bukkit.event.world.TimeSkipEvent(
+@@ -895,6 +915,13 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             this.serverLevelData.getScheduledEvents().tick(this.server, l);
+             Profiler.get().pop();
+             if (this.getGameRules().get(GameRules.ADVANCE_TIME)) {
++                // Purpur start - Configurable daylight cycle
++                int incrementTicks = isBrightOutside() ? this.purpurConfig.daytimeTicks : this.purpurConfig.nighttimeTicks;
++                if (incrementTicks != 12000) {
++                    this.preciseTime += 12000 / (double) incrementTicks;
++                    this.setDayTime(this.preciseTime);
++                } else
++                // Purpur end - Configurable daylight cycle
+                 this.setDayTime(this.levelData.getDayTime() + 1L);
+             }
+         }
+@@ -902,6 +929,20 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
+     public void setDayTime(long time) {
+         this.serverLevelData.setDayTime(time);
++        // Purpur start - Configurable daylight cycle
++        this.preciseTime = time;
++        this.forceTime = false;
++    }
++    public void setDayTime(double i) {
++        this.serverLevelData.setDayTime((long) i);
++        this.forceTime = true;
++        // Purpur end - Configurable daylight cycle
++    }
++
++    // Purpur start - Configurable daylight cycle
++    public boolean isForceTime() {
++        return this.forceTime;
++    // Purpur end - Configurable daylight cycle
+     }
+ 
+     public long getDayCount() {
+@@ -1010,9 +1051,17 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                     && this.random.nextDouble() < currentDifficultyAt.getEffectiveDifficulty() * this.paperConfig().entities.spawning.skeletonHorseThunderSpawnChance.or(0.01) // Paper - Configurable spawn chances for skeleton horses
+                     && !this.getBlockState(blockPos.below()).is(BlockTags.LIGHTNING_RODS);
+                 if (flag) {
+-                    SkeletonHorse skeletonHorse = EntityType.SKELETON_HORSE.create(this, EntitySpawnReason.EVENT);
++                    // Purpur start - Special mobs naturally spawn
++                    net.minecraft.world.entity.animal.equine.AbstractHorse skeletonHorse;
++                    if (purpurConfig.zombieHorseSpawnChance > 0D && random.nextDouble() <= purpurConfig.zombieHorseSpawnChance) {
++                        skeletonHorse = EntityType.ZOMBIE_HORSE.create(this, EntitySpawnReason.EVENT);
++                    } else {
++                        skeletonHorse = EntityType.SKELETON_HORSE.create(this, EntitySpawnReason.EVENT);
++                        if (skeletonHorse != null) ((SkeletonHorse) skeletonHorse).setTrap(true);
++                    }
++                    // Purpur end - Special mobs naturally spawn
+                     if (skeletonHorse != null) {
+-                        skeletonHorse.setTrap(true);
++                        //skeletonHorse.setTrap(true); // Purpur - Special mobs naturally spawn - moved up
+                         skeletonHorse.setAge(0);
+                         skeletonHorse.setPos(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+                         this.addFreshEntity(skeletonHorse, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit
+@@ -1047,9 +1096,35 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                 if (blockState.is(Blocks.SNOW)) {
+                     int layersValue = blockState.getValue(SnowLayerBlock.LAYERS);
+                     if (layersValue < Math.min(i, 8)) {
++                        // Purpur start - Smooth snow accumulation
++                        boolean canSnow = true;
++                        // Ensure snow doesn't get more than N layers taller than its neighbors
++                        // We only need to check blocks that are taller than the minimum step height
++                        if (org.purpurmc.purpur.PurpurConfig.smoothSnowAccumulationStep > 0 && layersValue >= org.purpurmc.purpur.PurpurConfig.smoothSnowAccumulationStep) {
++                            int layersValueMin = layersValue - org.purpurmc.purpur.PurpurConfig.smoothSnowAccumulationStep;
++                            for (Direction direction : Direction.Plane.HORIZONTAL) {
++                                BlockPos blockPosNeighbor = heightmapPos.relative(direction);
++                                BlockState blockStateNeighbor = this.getBlockState(blockPosNeighbor);
++                                if (blockStateNeighbor.is(Blocks.SNOW)) {
++                                    // Special check for snow layers, if neighbors are too short, don't accumulate
++                                    int layersValueNeighbor = blockStateNeighbor.getValue(SnowLayerBlock.LAYERS);
++                                    if (layersValueNeighbor <= layersValueMin) {
++                                        canSnow = false;
++                                        break;
++                                    }
++                                } else if (!Block.isFaceFull(blockStateNeighbor.getCollisionShape(this, blockPosNeighbor), direction.getOpposite())) {
++                                    // Since our layer is tall enough already, if we have a non-full neighbor block, don't accumulate
++                                    canSnow = false;
++                                    break;
++                                }
++                            }
++                        }
++                        if (canSnow) {
++                        // Purpur end - Smooth snow accumulation
+                         BlockState blockState1 = blockState.setValue(SnowLayerBlock.LAYERS, layersValue + 1);
+                         Block.pushEntitiesUp(blockState, blockState1, this, heightmapPos);
+                         org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, heightmapPos, blockState1, Block.UPDATE_ALL, null); // CraftBukkit
++                        } // Purpur - Smooth snow accumulation
+                     }
+                 } else {
+                     org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, heightmapPos, Blocks.SNOW.defaultBlockState(), Block.UPDATE_ALL, null); // CraftBukkit
+@@ -1070,7 +1145,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                 poiType -> poiType.is(PoiTypes.LIGHTNING_ROD),
+                 blockPos -> blockPos.getY() == this.getHeight(Heightmap.Types.WORLD_SURFACE, blockPos.getX(), blockPos.getZ()) - 1,
+                 pos,
+-                128,
++                org.purpurmc.purpur.PurpurConfig.lightningRodRange, // Purpur - Make lightning rod range configurable
+                 PoiManager.Occupancy.ANY
+             );
+         return optional.map(blockPos -> blockPos.above(1));
+@@ -1119,8 +1194,26 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                 int i = this.getGameRules().get(GameRules.PLAYERS_SLEEPING_PERCENTAGE);
+                 Component component;
+                 if (this.sleepStatus.areEnoughSleeping(i)) {
++                    // Purpur start - Customizable sleeping actionbar messages
++                    if (org.purpurmc.purpur.PurpurConfig.sleepSkippingNight.isBlank()) {
++                        return;
++                    }
++                    if (!org.purpurmc.purpur.PurpurConfig.sleepSkippingNight.equalsIgnoreCase("default")) {
++                        component = io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.purpurmc.purpur.PurpurConfig.sleepSkippingNight));
++                    } else
++                    // Purpur end - Customizable sleeping actionbar messages
+                     component = Component.translatable("sleep.skipping_night");
+                 } else {
++                    // Purpur start - Customizable sleeping actionbar messages
++                    if (org.purpurmc.purpur.PurpurConfig.sleepingPlayersPercent.isBlank()) {
++                        return;
++                    }
++                    if (!org.purpurmc.purpur.PurpurConfig.sleepingPlayersPercent.equalsIgnoreCase("default")) {
++                        component = io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.purpurmc.purpur.PurpurConfig.sleepingPlayersPercent,
++                            net.kyori.adventure.text.minimessage.tag.resolver.Placeholder.parsed("count", Integer.toString(this.sleepStatus.amountSleeping())),
++                            net.kyori.adventure.text.minimessage.tag.resolver.Placeholder.parsed("total", Integer.toString(this.sleepStatus.sleepersNeeded(i)))));
++                    } else
++                    // Purpur end - Customizable sleeping actionbar messages
+                     component = Component.translatable("sleep.players_sleeping", this.sleepStatus.amountSleeping(), this.sleepStatus.sleepersNeeded(i));
+                 }
+ 
+@@ -1275,6 +1368,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     @VisibleForTesting
+     public void resetWeatherCycle() {
+         // CraftBukkit start
++        if (this.purpurConfig.rainStopsAfterSleep) // Purpur - Option for if rain and thunder should stop on sleep
+         this.serverLevelData.setRaining(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - Add cause to Weather/ThunderChangeEvents
+         // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
+         // Not that everyone ever manages to get the whole server to sleep at the same time....
+@@ -1282,6 +1376,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             this.serverLevelData.setRainTime(0);
+         }
+         // CraftBukkit end
++        if (this.purpurConfig.thunderStopsAfterSleep) // Purpur - Option for if rain and thunder should stop on sleep
+         this.serverLevelData.setThundering(false, org.bukkit.event.weather.ThunderChangeEvent.Cause.SLEEP); // Paper - Add cause to Weather/ThunderChangeEvents
+         // CraftBukkit start
+         // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
+@@ -1954,7 +2049,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         Explosion.BlockInteraction blockInteraction = switch (explosionInteraction) {
+             case NONE -> Explosion.BlockInteraction.KEEP;
+             case BLOCK -> this.getDestroyType(GameRules.BLOCK_EXPLOSION_DROP_DECAY);
+-            case MOB -> this.getGameRules().get(GameRules.MOB_GRIEFING)
++            case MOB -> ((source instanceof net.minecraft.world.entity.projectile.hurtingprojectile.LargeFireball) ? this.getGameRules().get(GameRules.MOB_GRIEFING, this.purpurConfig.fireballsMobGriefingOverride) : this.getGameRules().get(GameRules.MOB_GRIEFING)) // Purpur - Add mobGriefing override to everything affected
+                 ? this.getDestroyType(GameRules.MOB_EXPLOSION_DROP_DECAY)
+                 : Explosion.BlockInteraction.KEEP;
+             case TNT -> this.getDestroyType(GameRules.TNT_EXPLOSION_DROP_DECAY);
+@@ -2846,7 +2941,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             // Spigot start
+             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message
+                 // Paper start - Fix merchant inventory not closing on entity removal
+-                if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) {
++                if (!entity.level().purpurConfig.playerVoidTrading && entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) { // Purpur - Allow void trading
+                     merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED);
+                 }
+                 // Paper end - Fix merchant inventory not closing on entity removal

purpur-server/minecraft-patches/rejected/net/minecraft/server/level/ServerPlayer.java.patch

@@ -0,0 +1,291 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 79c804245c7f41a5a7f062e1c5e01760adde7d84..a16813766ad244c002a752b0c03779c550d39e75 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -433,6 +433,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public boolean isRealPlayer; // Paper
+     public com.destroystokyo.paper.event.entity.@Nullable PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
+     public org.bukkit.event.player.PlayerQuitEvent.@Nullable QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
++    private boolean tpsBar = false; // Purpur - Implement TPSBar
++    private boolean compassBar = false; // Purpur - Add compass command
++    private boolean ramBar = false; // Purpur - Implement rambar commands
+ 
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+@@ -506,6 +509,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         this.respawnConfig = input.read("respawn", ServerPlayer.RespawnConfig.CODEC).orElse(null);
+         this.spawnExtraParticlesOnFall = input.getBooleanOr("spawn_extra_particles_on_fall", false);
+         this.raidOmenPosition = input.read("raid_omen_position", BlockPos.CODEC).orElse(null);
++        this.tpsBar = input.getBooleanOr("Purpur.TPSBar", false); // Purpur - Implement TPSBar
++        this.compassBar = input.getBooleanOr("Purpur.CompassBar", false); // Purpur - Add compass command
++        this.ramBar = input.getBooleanOr("Purpur.RamBar", false); // Purpur - Implement rambar command
+         // Paper start - Expand PlayerGameModeChangeEvent
+         this.loadGameTypes(input);
+     }
+@@ -547,6 +553,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+             output.store("ShoulderEntityRight", CompoundTag.CODEC, this.getShoulderEntityRight());
+         }
+         this.getBukkitEntity().setExtraData(output); // CraftBukkit
++        output.putBoolean("Purpur.TPSBar", this.tpsBar); // Purpur - Implement TPSBar
++        output.putBoolean("Purpur.CompassBar", this.compassBar); // Purpur - Add compass command
++        output.putBoolean("Purpur.RamBar", this.ramBar); // Purpur - Add rambar command
+     }
+ 
+     private void saveParentVehicle(ValueOutput output) {
+@@ -1183,6 +1192,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+             // Paper - moved up to sendClientboundPlayerCombatKillPacket()
+             sendClientboundPlayerCombatKillPacket(event.getShowDeathMessages(), deathScreenMessage); // Paper - Expand PlayerDeathEvent
+             Team team = this.getTeam();
++            if (org.purpurmc.purpur.PurpurConfig.deathMessageOnlyBroadcastToAffectedPlayer) this.sendSystemMessage(deathMessage); else // Purpur - Configurable broadcast settings
+             if (team == null || team.getDeathMessageVisibility() == Team.Visibility.ALWAYS) {
+                 this.server.getPlayerList().broadcastSystemMessage(deathMessage, false);
+             } else if (team.getDeathMessageVisibility() == Team.Visibility.HIDE_FOR_OTHER_TEAMS) {
+@@ -1290,6 +1300,13 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         if (this.isInvulnerableTo(level, damageSource)) {
+             return false;
+         } else {
++            // Purpur start - Add boat fall damage config
++            if (damageSource.is(net.minecraft.tags.DamageTypeTags.IS_FALL)) {
++                if (getRootVehicle() instanceof net.minecraft.world.entity.vehicle.boat.Boat && !level().purpurConfig.boatsDoFallDamage) {
++                    return false;
++                }
++            }
++            // Purpur end - Add boat fall damage config
+             Entity entity = damageSource.getEntity();
+             if (!( // Paper - split the if statement. If below statement is false, hurtServer would not have been evaluated. Return false.
+              !(entity instanceof Player player && !this.canHarmPlayer(player))
+@@ -1544,6 +1561,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+ 
+                 profilerFiller.pop();
+                 profilerFiller.push("placing");
++                this.portalPos = org.bukkit.craftbukkit.util.CraftLocation.toBlockPosition(exit); // Purpur - Fix stuck in portals
+                 this.setServerLevel(level);
+                 this.connection.internalTeleport(PositionMoveRotation.of(teleportTransition), teleportTransition.relatives()); // CraftBukkit - use internal teleport without event
+                 this.connection.resetPosition();
+@@ -1652,7 +1670,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+                                 new AABB(vec3.x() - 8.0, vec3.y() - 5.0, vec3.z() - 8.0, vec3.x() + 8.0, vec3.y() + 5.0, vec3.z() + 8.0),
+                                 monster -> monster.isPreventingPlayerRest(this.level(), this)
+                             );
+-                        if (!entitiesOfClass.isEmpty()) {
++                        if (!this.level().purpurConfig.playerSleepNearMonsters && !entitiesOfClass.isEmpty()) { // Purpur - Config to ignore nearby mobs when sleeping
+                             return Either.left(Player.BedSleepingProblem.NOT_SAFE);
+                         }
+                     }
+@@ -1692,8 +1710,19 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+                         CriteriaTriggers.SLEPT_IN_BED.trigger(this);
+                     });
+                     if (!this.level().canSleepThroughNights()) {
+-                        this.displayClientMessage(Component.translatable("sleep.not_possible"), true);
++                        // Purpur start - Customizable sleeping actionbar messages
++                    Component clientMessage;
++                    if (org.purpurmc.purpur.PurpurConfig.sleepNotPossible.isBlank()) {
++                        clientMessage = null;
++                    } else if (!org.purpurmc.purpur.PurpurConfig.sleepNotPossible.equalsIgnoreCase("default")) {
++                        clientMessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.purpurmc.purpur.PurpurConfig.sleepNotPossible));
++                    } else {
++                        clientMessage = Component.translatable("sleep.not_possible");
+                     }
++                    if (clientMessage != null) {
++                        this.displayClientMessage(clientMessage, true);
++                    }// Purpur end - Customizable sleeping actionbar messages
++                }
+ 
+                     this.level().updateSleepingPlayerList();
+                     return either;
+@@ -1784,6 +1813,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+ 
+     @Override
+     public void openTextEdit(SignBlockEntity signEntity, boolean isFrontText) {
++        if (level().purpurConfig.signAllowColors) this.connection.send(signEntity.getTranslatedUpdatePacket(textFilteringEnabled, isFrontText)); // Purpur - Signs allow color codes
+         this.connection.send(new ClientboundBlockUpdatePacket(this.level(), signEntity.getBlockPos()));
+         this.connection.send(new ClientboundOpenSignEditorPacket(signEntity.getBlockPos(), isFrontText));
+     }
+@@ -2121,6 +2151,26 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         this.lastSentExp = -1; // CraftBukkit - Added to reset
+     }
+ 
++    // Purpur start - Component related conveniences
++    public void sendActionBarMessage(@Nullable String message) {
++        if (message != null && !message.isEmpty()) {
++            sendActionBarMessage(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(message));
++        }
++    }
++
++    public void sendActionBarMessage(net.kyori.adventure.text.@Nullable Component message) {
++        if (message != null) {
++            sendActionBarMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(message));
++        }
++    }
++
++    public void sendActionBarMessage(@Nullable Component message) {
++        if (message != null) {
++            displayClientMessage(message, true);
++        }
++    }
++    // Purpur end - Component related conveniences
++
+     @Override
+     public void displayClientMessage(Component message, boolean overlay) {
+         this.sendSystemMessage(message, overlay);
+@@ -2355,6 +2405,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         );
+     }
+ 
++    // Purpur start - Component related conveniences
++    public void sendMiniMessage(@Nullable String message) {
++        if (message != null && !message.isEmpty()) {
++            this.sendMessage(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(message));
++        }
++    }
++
++    public void sendMessage(net.kyori.adventure.text.@Nullable Component message) {
++        if (message != null) {
++            this.sendSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(message));
++        }
++    }
++    // Purpur end - Component related conveniences
++
+     public void sendSystemMessage(Component message) {
+         this.sendSystemMessage(message, false);
+     }
+@@ -2492,8 +2556,68 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+ 
+     public void resetLastActionTime() {
+         this.lastActionTime = Util.getMillis();
++        this.setAfk(false); // Purpur - AFK API
+     }
+ 
++    // Purpur start - AFK API
++    private boolean isAfk = false;
++
++    @Override
++    public void setAfk(boolean afk) {
++        if (this.isAfk == afk) {
++            return;
++        }
++
++        String msg = afk ? org.purpurmc.purpur.PurpurConfig.afkBroadcastAway : org.purpurmc.purpur.PurpurConfig.afkBroadcastBack;
++
++        org.purpurmc.purpur.event.PlayerAFKEvent event = new org.purpurmc.purpur.event.PlayerAFKEvent(this.getBukkitEntity(), afk, this.level().purpurConfig.idleTimeoutKick, msg, !org.bukkit.Bukkit.isPrimaryThread());
++        if (!event.callEvent() || event.shouldKick()) {
++            return;
++        }
++
++        this.isAfk = afk;
++
++        if (!afk) {
++            resetLastActionTime();
++        }
++
++        msg = event.getBroadcastMsg();
++        if (msg != null && !msg.isEmpty()) {
++            String playerName = this.getGameProfile().name();
++            if (org.purpurmc.purpur.PurpurConfig.afkBroadcastUseDisplayName) {
++                net.kyori.adventure.text.Component playerDisplayNameComponent = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(this.getBukkitEntity().getDisplayName());
++                playerName = net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer.plainText().serialize(playerDisplayNameComponent);
++            }
++            server.getPlayerList().broadcastMiniMessage(String.format(msg, playerName), false);
++        }
++
++        if (this.level().purpurConfig.idleTimeoutUpdateTabList) {
++            String scoreboardName = getScoreboardName();
++            String playerListName = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().serialize(getBukkitEntity().playerListName());
++            String[] split = playerListName.split(scoreboardName);
++            String prefix = (split.length > 0 ? split[0] : "").replace(org.purpurmc.purpur.PurpurConfig.afkTabListPrefix, "");
++            String suffix = (split.length > 1 ? split[1] : "").replace(org.purpurmc.purpur.PurpurConfig.afkTabListSuffix, "");
++            if (afk) {
++                getBukkitEntity().setPlayerListName(org.purpurmc.purpur.PurpurConfig.afkTabListPrefix + prefix + scoreboardName + suffix + org.purpurmc.purpur.PurpurConfig.afkTabListSuffix, true);
++            } else {
++                getBukkitEntity().setPlayerListName(prefix + scoreboardName + suffix, true);
++            }
++        }
++
++        ((ServerLevel) this.level()).updateSleepingPlayerList();
++    }
++
++    @Override
++    public boolean isAfk() {
++        return this.isAfk;
++    }
++
++    @Override
++    public boolean canBeCollidedWith(Entity entity) {
++        return !this.isAfk() && super.canBeCollidedWith(entity);
++    }
++    // Purpur end - AFK API
++
+     public ServerStatsCounter getStats() {
+         return this.stats;
+     }
+@@ -3126,4 +3250,65 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         return (org.bukkit.craftbukkit.entity.CraftPlayer) super.getBukkitEntity();
+     }
+     // CraftBukkit end
++
++    // Purpur start - Add option to teleport to spawn if outside world border
++    public void teleport(org.bukkit.Location to) {
++        this.ejectPassengers();
++        this.stopRiding(true);
++
++        if (this.isSleeping()) {
++            this.stopSleepInBed(true, false);
++        }
++
++        if (this.containerMenu != this.inventoryMenu) {
++            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.TELEPORT);
++        }
++
++        ServerLevel toLevel = ((org.bukkit.craftbukkit.CraftWorld) to.getWorld()).getHandle();
++        if (this.level() == toLevel) {
++            this.connection.internalTeleport(to);
++        } else {
++            this.teleport(new TeleportTransition(
++                toLevel,
++                org.bukkit.craftbukkit.util.CraftLocation.toVec3(to),
++                Vec3.ZERO,
++                to.getYaw(),
++                to.getPitch(),
++                net.minecraft.world.entity.Relative.ALL,
++                TeleportTransition.DO_NOTHING,
++                org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.UNKNOWN
++            ));
++        }
++    }
++    // Purpur end - Add option to teleport to spawn if outside world border
++
++    // Purpur start - Implement TPSBar
++    public boolean tpsBar() {
++        return this.tpsBar;
++    }
++
++    public void tpsBar(boolean tpsBar) {
++        this.tpsBar = tpsBar;
++    }
++    // Purpur end - Implement TPSBar
++
++    // Purpur start - Add compass command
++    public boolean compassBar() {
++        return this.compassBar;
++    }
++
++    public void compassBar(boolean compassBar) {
++        this.compassBar = compassBar;
++    }
++    // Purpur end - Add compass command
++
++    // Purpur start - Add rambar command
++    public boolean ramBar() {
++        return this.ramBar;
++    }
++
++    public void ramBar(boolean ramBar) {
++        this.ramBar = ramBar;
++    }
++    // Purpur end - Add rambar command
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/server/level/ServerPlayerGameMode.java.patch

@@ -0,0 +1,54 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/level/ServerPlayerGameMode.java b/net/minecraft/server/level/ServerPlayerGameMode.java
+index 84d19d79e77cec6a5d64f59fbcce703e467b2407..9b9cdb23a55b82efbeea3ba68b8144c15791dff0 100644
+--- a/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -365,6 +365,7 @@ public class ServerPlayerGameMode {
+                 }
+                 return false;
+             }
++            if (this.player.level().purpurConfig.slabHalfBreak && this.player.isShiftKeyDown() && blockState.getBlock() instanceof net.minecraft.world.level.block.SlabBlock && ((net.minecraft.world.level.block.SlabBlock) blockState.getBlock()).halfBreak(blockState, pos, this.player)) return true; // Purpur - Break individual slabs when sneaking
+         }
+         // CraftBukkit end
+ 
+@@ -490,6 +491,7 @@ public class ServerPlayerGameMode {
+     public InteractionHand interactHand;
+     public ItemStack interactItemStack;
+     public InteractionResult useItemOn(ServerPlayer player, Level level, ItemStack stack, InteractionHand hand, BlockHitResult hitResult) {
++        if (shiftClickMended(stack)) return InteractionResult.SUCCESS; // Purpur - Shift right click to use exp for mending
+         BlockPos blockPos = hitResult.getBlockPos();
+         BlockState blockState = level.getBlockState(blockPos);
+         boolean cancelledBlock = false;
+@@ -538,7 +540,7 @@ public class ServerPlayerGameMode {
+             boolean flag = !player.getMainHandItem().isEmpty() || !player.getOffhandItem().isEmpty();
+             boolean flag1 = player.isSecondaryUseActive() && flag;
+             ItemStack itemStack = stack.copy();
+-            if (!flag1) {
++            if (!flag1 || (player.level().purpurConfig.composterBulkProcess && blockState.is(net.minecraft.world.level.block.Blocks.COMPOSTER))) { // Purpur - Sneak to bulk process composter
+                 InteractionResult interactionResult = blockState.useItemOn(player.getItemInHand(hand), level, player, hand, hitResult);
+                 if (interactionResult.consumesAction()) {
+                     CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger(player, blockPos, itemStack);
+@@ -584,4 +586,18 @@ public class ServerPlayerGameMode {
+     public void setLevel(ServerLevel level) {
+         this.level = level;
+     }
++
++    // Purpur start - Shift right click to use exp for mending
++    public boolean shiftClickMended(ItemStack itemstack) {
++        if (this.player.level().purpurConfig.shiftRightClickRepairsMendingPoints > 0 && this.player.isShiftKeyDown() && this.player.getBukkitEntity().hasPermission("purpur.mending_shift_click")) {
++            int points = Math.min(this.player.totalExperience, this.player.level().purpurConfig.shiftRightClickRepairsMendingPoints);
++            if (points > 0 && itemstack.isDamaged() && net.minecraft.world.item.enchantment.EnchantmentHelper.getItemEnchantmentLevel(net.minecraft.world.item.enchantment.Enchantments.MENDING, itemstack) > 0) {
++                this.player.giveExperiencePoints(itemstack.getDamageValue() == 1 ? -2 : -points);
++                this.player.level().addFreshEntity(new net.minecraft.world.entity.ExperienceOrb(this.player.level(), this.player.getX(), this.player.getY(), this.player.getZ(), itemstack.getDamageValue() == 1 ? 1 : points, org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN, this.player, this.player));
++                return true;
++            }
++        }
++        return false;
++    }
++    // Purpur end - Shift right click to use exp for mending
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/server/network/ServerCommonPacketListenerImpl.java.patch

@@ -0,0 +1,90 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index b8a4b4cc02a2fc6b70f4b840796eed501aad6239..02c6733ce1de543dab3bf558148879039e501257 100644
+--- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -40,10 +40,11 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+     public final Connection connection; // Paper
+     private final boolean transferred;
+     //private long keepAliveTime; // Paper - improve keepalives
+-    //private boolean keepAlivePending; // Paper - improve keepalives
++    private boolean keepAlivePending; // Paper - improve keepalives // Purpur - Alternative Keepalive Handling
+     //private long keepAliveChallenge; // Paper - improve keepalives
+     private long closedListenerTime;
+     private boolean closed = false;
++    private it.unimi.dsi.fastutil.longs.LongList keepAlives = new it.unimi.dsi.fastutil.longs.LongArrayList(); // Purpur - Alternative Keepalive Handling
+     private volatile int latency; // Paper - improve keepalives - make volatile
+     private final io.papermc.paper.util.KeepAlive keepAlive; // Paper - improve keepalives
+     private volatile boolean suspendFlushingOnServerThread = false;
+@@ -54,6 +55,10 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+     public final java.util.Map<java.util.UUID, net.kyori.adventure.resource.ResourcePackCallback> packCallbacks = new java.util.concurrent.ConcurrentHashMap<>(); // Paper - adventure resource pack callbacks
+     private static final long KEEPALIVE_LIMIT = Long.getLong("paper.playerconnection.keepalive", 30) * 1000; // Paper - provide property to set keepalive limit
+     protected static final net.minecraft.resources.Identifier MINECRAFT_BRAND = net.minecraft.resources.Identifier.withDefaultNamespace("brand"); // Paper - Brand support
++    // Purpur start - Purpur client support
++    protected static final net.minecraft.resources.Identifier PURPUR_CLIENT = net.minecraft.resources.Identifier.fromNamespaceAndPath("purpur", "client");
++    public boolean purpurClient;
++    // Purpur end - Purpur client support
+     // Paper start - retain certain values
+     public @Nullable String playerBrand;
+     public final java.util.Set<String> pluginMessagerChannels;
+@@ -105,6 +110,18 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         // Paper start - improve keepalives
+         long now = System.nanoTime();
+         io.papermc.paper.util.KeepAlive.PendingKeepAlive pending = this.keepAlive.pendingKeepAlives.peek();
++        // Purpur start - Alternative Keepalive Handling
++        if (org.purpurmc.purpur.PurpurConfig.useAlternateKeepAlive) {
++            if (this.keepAlivePending && !keepAlives.isEmpty() && keepAlives.contains(packet.getId())) {
++                int ping = (int) (Util.getMillis() - packet.getId());
++                int updatedLatency = (this.latency * 3 + ping) / 4;
++                this.latency = updatedLatency;
++                this.keepAlivePending = false;
++                keepAlives.clear(); // we got a valid response, lets roll with it and forget the rest
++            }
++            return;
++        } else
++        // Purpur end - Alternative Keepalive Handling
+         if (pending != null && pending.challengeId() == packet.getId()) {
+             this.keepAlive.pendingKeepAlives.remove(pending);
+ 
+@@ -179,6 +196,12 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+                 return;
+             }
+ 
++            // Purpur start - Purpur client support
++            if (identifier.equals(PURPUR_CLIENT)) {
++                this.purpurClient = true;
++            }
++            // Purpur end - Purpur client support
++
+             if (identifier.equals(MINECRAFT_BRAND)) {
+                 this.playerBrand = new net.minecraft.network.FriendlyByteBuf(io.netty.buffer.Unpooled.wrappedBuffer(data)).readUtf(256);
+             }
+@@ -264,6 +287,23 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         Profiler.get().push("keepAlive");
+         long millis = Util.getMillis();
+         // Paper start - improve keepalives
++        // Purpur start - Alternative Keepalive Handling
++        if (org.purpurmc.purpur.PurpurConfig.useAlternateKeepAlive) {
++            if (this.checkIfClosed(millis) && !this.processedDisconnect) {
++                long currTime = System.nanoTime();
++                if ((currTime - this.keepAlive.lastKeepAliveTx) >= java.util.concurrent.TimeUnit.SECONDS.toNanos(1L)) { // 1 second
++                    this.keepAlive.lastKeepAliveTx = currTime;
++                    if (this.keepAlivePending && !this.processedDisconnect && keepAlives.size() * 1000L >= KEEPALIVE_LIMIT) {
++                        this.disconnect(TIMEOUT_DISCONNECTION_MESSAGE, io.papermc.paper.connection.DisconnectionReason.TIMEOUT);
++                    } else if (this.checkIfClosed(millis)) {
++                        this.keepAlivePending = true;
++                        this.keepAlives.add(millis); // currentTime is ID
++                        this.send(new ClientboundKeepAlivePacket(millis));
++                    }
++                }
++            }
++        } else
++        // Purpur end - Alternative Keepalive Handling
+         if (this.checkIfClosed(millis) && !this.processedDisconnect) {
+             long currTime = System.nanoTime();
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/server/network/ServerGamePacketListenerImpl.java.patch

@@ -0,0 +1,241 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index e158d614abed8d16e80192c0c9abd8537c92b9dc..74f8f1c8a3d688fadcbc266bac126e13d9d93dc5 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -346,6 +346,20 @@ public class ServerGamePacketListenerImpl
+     }
+     // Paper end - configuration phase API
+ 
++    // Purpur start - AFK API
++    private final com.google.common.cache.LoadingCache<org.bukkit.craftbukkit.entity.CraftPlayer, Boolean> kickPermissionCache = com.google.common.cache.CacheBuilder.newBuilder()
++        .maximumSize(1000)
++        .expireAfterWrite(1, java.util.concurrent.TimeUnit.MINUTES)
++        .build(
++            new com.google.common.cache.CacheLoader<>() {
++                @Override
++                public Boolean load(org.bukkit.craftbukkit.entity.CraftPlayer player) {
++                    return player.hasPermission("purpur.bypassIdleKick");
++                }
++            }
++        );
++    // Purpur end - AFK API
++    
+     @Override
+     public void tick() {
+         if (this.isDisconnected()) return; // Paper
+@@ -364,6 +378,12 @@ public class ServerGamePacketListenerImpl
+                 && this.server.playerIdleTimeout() > 0
+                 && Util.getMillis() - this.player.getLastActionTime() > TimeUnit.MINUTES.toMillis(this.server.playerIdleTimeout())
+                 && !this.player.wonGame) {
++                // Purpur start - AFK API
++                this.player.setAfk(true);
++                if (!this.player.level().purpurConfig.idleTimeoutKick || (!Boolean.parseBoolean(System.getenv("PURPUR_FORCE_IDLE_KICK")) && kickPermissionCache.getUnchecked(this.player.getBukkitEntity()))) {
++                    return;
++                }
++                // Purpur end - AFK API
+                 this.disconnect(Component.translatable("multiplayer.disconnect.idling"), org.bukkit.event.player.PlayerKickEvent.Cause.IDLING); // Paper - kick event cause
+             }
+         }
+@@ -683,6 +703,8 @@ public class ServerGamePacketListenerImpl
+                     this.lastYaw = to.getYaw();
+                     this.lastPitch = to.getPitch();
+ 
++                    if (!to.getWorld().getUID().equals(from.getWorld().getUID()) || to.getBlockX() != from.getBlockX() || to.getBlockY() != from.getBlockY() || to.getBlockZ() != from.getBlockZ() || to.getYaw() != from.getYaw() || to.getPitch() != from.getPitch()) this.player.resetLastActionTime(); // Purpur - AFK API
++
+                     Location oldTo = to.clone();
+                     PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
+                     this.cserver.getPluginManager().callEvent(event);
+@@ -762,6 +784,7 @@ public class ServerGamePacketListenerImpl
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.level());
+         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 - Add more logger output for invalid movement kicks
+                 this.disconnect(Component.translatable("multiplayer.disconnect.invalid_player_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PLAYER_MOVEMENT); // Paper - kick event cause
+                 return;
+             }
+@@ -1302,6 +1325,10 @@ public class ServerGamePacketListenerImpl
+             final int maxBookPageSize = pageMax.intValue();
+             final double multiplier = Math.clamp(io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.totalMultiplier, 0.3D, 1D);
+             long byteAllowed = maxBookPageSize;
++            // Purpur start - PlayerBookTooLargeEvent
++            int slot = packet.slot();
++            ItemStack itemstack = Inventory.isHotbarSlot(slot) || slot == Inventory.SLOT_OFFHAND ? this.player.getInventory().getItem(slot) : ItemStack.EMPTY;
++            // Purpur end - PlayerBookTooLargeEvent
+             for (final String page : pageList) {
+                 final int byteLength = page.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
+                 byteTotal += byteLength;
+@@ -1326,7 +1353,8 @@ public class ServerGamePacketListenerImpl
+             }
+ 
+             if (byteTotal > byteAllowed) {
+-                ServerGamePacketListenerImpl.LOGGER.warn("{} tried to send a book too large. Book size: {} - Allowed: {} - Pages: {}", this.player.getScoreboardName(), byteTotal, byteAllowed, pageList.size());
++                ServerGamePacketListenerImpl.LOGGER.warn("{} tried to send too large of a book. Book size: {} - Allowed: {} - Pages: {}", this.player.getScoreboardName(), byteTotal, byteAllowed, pageList.size());
++                org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent event = new org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent(player.getBukkitEntity(), itemstack.asBukkitCopy()); if (event.shouldKickPlayer()) // Purpur - PlayerBookTooLargeEvent
+                 this.disconnectAsync(Component.literal("Book too large!"), org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // Paper - kick event cause // Paper - add proper async disconnect
+                 return;
+             }
+@@ -1345,31 +1373,45 @@ public class ServerGamePacketListenerImpl
+             Optional<String> optional = packet.title();
+             optional.ifPresent(list::add);
+             list.addAll(packet.pages());
++            // Purpur start - Allow color codes in books
++            boolean hasEditPerm = getCraftPlayer().hasPermission("purpur.book.color.edit");
++            boolean hasSignPerm = hasEditPerm || getCraftPlayer().hasPermission("purpur.book.color.sign");
++            // Purpur end - Allow color codes in books
+             Consumer<List<FilteredText>> consumer = optional.isPresent()
+-                ? texts -> this.signBook(texts.get(0), texts.subList(1, texts.size()), slot)
+-                : list1 -> this.updateBookContents(list1, slot);
++                ? texts -> this.signBook(texts.get(0), texts.subList(1, texts.size()), slot, hasSignPerm) // Purpur - Allow color codes in books
++                : list1 -> this.updateBookContents(list1, slot, hasEditPerm); // Purpur - Allow color codes in books
+             this.filterTextPacket(list).thenAcceptAsync(consumer, this.server);
+         }
+     }
+ 
+     private void updateBookContents(List<FilteredText> pages, int index) {
++    // Purpur start - Allow color codes in books
++        updateBookContents(pages, index, false);
++    }
++    private void updateBookContents(List<FilteredText> pages, int index, boolean hasPerm) {
++    // Purpur end - Allow color codes in books
+         // CraftBukkit start
+         ItemStack handItem = this.player.getInventory().getItem(index);
+         ItemStack item = handItem.copy();
+         // CraftBukkit end
+         if (item.has(DataComponents.WRITABLE_BOOK_CONTENT)) {
+-            List<Filterable<String>> list = pages.stream().map(this::filterableFromOutgoing).toList();
++            List<Filterable<String>> list = pages.stream().map(filteredText -> filterableFromOutgoing(filteredText).map(s -> color(s, hasPerm))).toList(); // Purpur - Allow color codes in books
+             item.set(DataComponents.WRITABLE_BOOK_CONTENT, new WritableBookContent(list));
+             this.player.getInventory().setItem(index, CraftEventFactory.handleEditBookEvent(this.player, index, handItem, item)); // CraftBukkit // Paper - Don't ignore result (see other callsite for handleEditBookEvent)
+         }
+     }
+ 
+     private void signBook(FilteredText title, List<FilteredText> pages, int index) {
++        // Purpur start - Allow color codes in books
++        signBook(title, pages, index, false);
++    }
++    private void signBook(FilteredText title, List<FilteredText> pages, int index, boolean hasPerm) {
++        // Purpur end - Allow color codes in books
+         ItemStack item = this.player.getInventory().getItem(index);
+         if (item.has(DataComponents.WRITABLE_BOOK_CONTENT)) {
+             ItemStack itemStack = item.transmuteCopy(Items.WRITTEN_BOOK);
+             itemStack.remove(DataComponents.WRITABLE_BOOK_CONTENT);
+-            List<Filterable<Component>> list = pages.stream().map(filteredText -> this.filterableFromOutgoing(filteredText).<Component>map(Component::literal)).toList();
++            List<Filterable<Component>> list = pages.stream().map((filteredText) -> this.filterableFromOutgoing(filteredText).map(s -> hexColor(s, hasPerm))).toList(); // Purpur - Allow color codes in books
+             itemStack.set(
+                 DataComponents.WRITTEN_BOOK_CONTENT, new WrittenBookContent(this.filterableFromOutgoing(title), this.player.getPlainTextName(), 0, list, true)
+             );
+@@ -1382,6 +1424,16 @@ public class ServerGamePacketListenerImpl
+         return this.player.isTextFilteringEnabled() ? Filterable.passThrough(filteredText.filteredOrEmpty()) : Filterable.from(filteredText);
+     }
+ 
++    // Purpur start - Allow color codes in books
++    private Component hexColor(String str, boolean hasPerm) {
++        return hasPerm ? PaperAdventure.asVanilla(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().deserialize(str)) : Component.literal(str);
++    }
++
++    private String color(String str, boolean hasPerm) {
++        return hasPerm ? org.bukkit.ChatColor.color(str, false) : str;
++    }
++    // Purpur end - Allow color codes in books
++
+     @Override
+     public void handleEntityTagQuery(ServerboundEntityTagQueryPacket packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.level());
+@@ -1421,7 +1473,15 @@ public class ServerGamePacketListenerImpl
+     @Override
+     public void handleMovePlayer(ServerboundMovePlayerPacket packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.level());
+-        if (containsInvalidValues(packet.getX(0.0), packet.getY(0.0), packet.getZ(0.0), packet.getYRot(0.0F), packet.getXRot(0.0F))) {
++        // Purpur start - Add more logger output for invalid movement kicks
++        boolean invalidX = Double.isNaN(packet.getX(0.0));
++        boolean invalidY = Double.isNaN(packet.getY(0.0));
++        boolean invalidZ = Double.isNaN(packet.getZ(0.0));
++        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 end - Add more logger output for invalid movement kicks
+             this.disconnect(Component.translatable("multiplayer.disconnect.invalid_player_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PLAYER_MOVEMENT); // Paper - kick event cause
+         } else {
+             ServerLevel serverLevel = this.player.level();
+@@ -1604,7 +1664,7 @@ public class ServerGamePacketListenerImpl
+                                         movedWrongly = true;
+                                         if (event.getLogWarning())
+                                      // Paper end
+-                                    LOGGER.warn("{} moved wrongly!", this.player.getPlainTextName());
++                                    LOGGER.warn("{} moved wrongly!, ({})", this.player.getPlainTextName(), verticalDelta); // Purpur - AFK API
+                                     } // Paper
+                                 }
+ 
+@@ -1669,6 +1729,8 @@ public class ServerGamePacketListenerImpl
+                                         this.lastYaw = to.getYaw();
+                                         this.lastPitch = to.getPitch();
+ 
++                                        if (!to.getWorld().getUID().equals(from.getWorld().getUID()) || to.getBlockX() != from.getBlockX() || to.getBlockY() != from.getBlockY() || to.getBlockZ() != from.getBlockZ() || to.getYaw() != from.getYaw() || to.getPitch() != from.getPitch()) this.player.resetLastActionTime(); // Purpur - AFK API
++
+                                         Location oldTo = to.clone();
+                                         PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
+                                         this.cserver.getPluginManager().callEvent(event);
+@@ -1724,6 +1786,13 @@ public class ServerGamePacketListenerImpl
+                                         this.player.tryResetCurrentImpulseContext();
+                                     }
+ 
++                                    // Purpur start - Dont run with scissors!
++                                    if (this.player.level().purpurConfig.dontRunWithScissors && this.player.isSprinting() && !(this.player.level().purpurConfig.ignoreScissorsInWater && this.player.isInWater()) && !(this.player.level().purpurConfig.ignoreScissorsInLava && this.player.isInLava()) && (isScissors(this.player.getItemInHand(InteractionHand.MAIN_HAND)) || isScissors(this.player.getItemInHand(InteractionHand.OFF_HAND))) && (int) (Math.random() * 10) == 0) {
++                                        this.player.hurtServer(this.player.level(), this.player.damageSources().scissors(), (float) this.player.level().purpurConfig.scissorsRunningDamage);
++                                        if (!org.purpurmc.purpur.PurpurConfig.dontRunWithScissors.isBlank()) this.player.sendActionBarMessage(org.purpurmc.purpur.PurpurConfig.dontRunWithScissors);
++                                    }
++                                    // Purpur end - Dont run with scissors!
++
+                                     this.player.checkMovementStatistics(this.player.getX() - x, this.player.getY() - y, this.player.getZ() - z);
+                                     this.lastGoodX = this.player.getX();
+                                     this.lastGoodY = this.player.getY();
+@@ -1741,6 +1810,17 @@ public class ServerGamePacketListenerImpl
+         }
+     }
+ 
++    // Purpur start - Dont run with scissors!
++    public boolean isScissors(ItemStack stack) {
++        if (!stack.is(Items.SHEARS)) return false;
++
++        Identifier itemModelReference = stack.get(net.minecraft.core.component.DataComponents.ITEM_MODEL);
++        if (itemModelReference != null && itemModelReference.equals(this.player.level().purpurConfig.dontRunWithScissorsItemModelReference)) return true;
++
++        return stack.getOrDefault(DataComponents.CUSTOM_MODEL_DATA, net.minecraft.world.item.component.CustomModelData.EMPTY).equals(net.minecraft.world.item.component.CustomModelData.EMPTY);
++    }
++    // Purpur end - Dont run with scissors!
++
+     private boolean shouldCheckPlayerMovement(boolean isElytraMovement) {
+         if (this.isSingleplayerOwner()) {
+             return false;
+@@ -2169,6 +2249,7 @@ public class ServerGamePacketListenerImpl
+ 
+                 boolean cancelled;
+                 if (hitResult == null || hitResult.getType() != HitResult.Type.BLOCK) {
++                    if (this.player.gameMode.shiftClickMended(itemInHand)) return; // Purpur - Shift right click to use exp for mending
+                     org.bukkit.event.player.PlayerInteractEvent event = CraftEventFactory.callPlayerInteractEvent(this.player, Action.RIGHT_CLICK_AIR, itemInHand, hand);
+                     cancelled = event.useItemInHand() == Event.Result.DENY;
+                 } else {
+@@ -2821,6 +2902,7 @@ public class ServerGamePacketListenerImpl
+ 
+                 AABB boundingBox = target.getBoundingBox();
+                 if (packet.isWithinRange(this.player, boundingBox, io.papermc.paper.configuration.GlobalConfiguration.get().misc.clientInteractionLeniencyDistance.or(3.0))) { // Paper - configurable lenience value for interact range
++                    if (target instanceof net.minecraft.world.entity.Mob mob) mob.ticksSinceLastInteraction = 0; // Purpur - Entity lifespan
+                     packet.dispatch(
+                         new ServerboundInteractPacket.Handler() {
+                             private void performInteraction(InteractionHand hand, ServerGamePacketListenerImpl.EntityInteraction entityInteraction, PlayerInteractEntityEvent event) { // CraftBukkit
+@@ -3581,7 +3663,7 @@ public class ServerGamePacketListenerImpl
+     @Override
+     public void handleChangeGameMode(ServerboundChangeGameModePacket packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.level());
+-        if (!GameModeCommand.PERMISSION_CHECK.check(this.player.permissions())) {
++        if (!GameModeCommand.PERMISSION_CHECK.check(this.player.permissions()) && !player.getBukkitEntity().hasPermission("purpur.debug.f3n")) { // Purpur - Add permission for F3+N debug
+             LOGGER.warn(
+                 "Player {} tried to change game mode to {} without required permissions",
+                 this.player.getGameProfile().name(),

purpur-server/minecraft-patches/rejected/net/minecraft/server/network/ServerLoginPacketListenerImpl.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index 51a29ab542136e67741be10bbc5c6377715a207c..e16bb386ae500bc290970f8cba33c5999cf0a58d 100644
+--- a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -278,7 +278,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+                         ServerLoginPacketListenerImpl.LOGGER.warn("Failed to verify username but will let them in anyway!");
+                         ServerLoginPacketListenerImpl.this.startClientVerification(ServerLoginPacketListenerImpl.this.createOfflineProfile(string1)); // Spigot
+                     } else {
+-                        ServerLoginPacketListenerImpl.this.disconnect(Component.translatable("multiplayer.disconnect.unverified_username"));
++                        ServerLoginPacketListenerImpl.this.disconnect(org.purpurmc.purpur.PurpurConfig.unverifiedUsername.equals("default") ? Component.translatable("multiplayer.disconnect.unverified_username") : io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.purpurmc.purpur.PurpurConfig.unverifiedUsername))); // Purpur - Config for unverified username message
+                         ServerLoginPacketListenerImpl.LOGGER.error("Username '{}' tried to join with an invalid session", string1);
+                     }
+                 } catch (AuthenticationUnavailableException var4) {

purpur-server/minecraft-patches/rejected/net/minecraft/server/players/PlayerList.java.patch

@@ -0,0 +1,64 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 989ac565c47a70c7947cb7315d0f5c2cfecd0363..646e16b3d69b5516e8f7c401828fec731378979c 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -311,6 +311,7 @@ public abstract class PlayerList {
+             scoreboard.addPlayerToTeam(player.getScoreboardName(), collideRuleTeam);
+         }
+         // Paper end - Configurable player collision
++        org.purpurmc.purpur.task.BossBarTask.addToAll(player); // Purpur - Implement TPSBar
+         // CraftBukkit start - moved down
+         LOGGER.info(
+             "{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", // CraftBukkit - add world name
+@@ -431,6 +432,7 @@ public abstract class PlayerList {
+     }
+     public net.kyori.adventure.text.@Nullable Component remove(ServerPlayer player, net.kyori.adventure.text.Component leaveMessage) {
+         // Paper end - Fix kick event leave message not being sent
++        org.purpurmc.purpur.task.BossBarTask.removeFromAll(player.getBukkitEntity()); // Purpur - Implement TPSBar
+         ServerLevel serverLevel = player.level();
+         player.awardStat(Stats.LEAVE_GAME);
+         // CraftBukkit start - Quitting must be before we do final save of data, in case plugins need to modify it
+@@ -770,6 +772,20 @@ public abstract class PlayerList {
+         }
+     }
+ 
++    // Purpur start - Component related conveniences
++    public void broadcastMiniMessage(@Nullable String message, boolean overlay) {
++        if (message != null && !message.isEmpty()) {
++            this.broadcastMessage(net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(message), overlay);
++        }
++    }
++
++    public void broadcastMessage(net.kyori.adventure.text.@Nullable Component message, boolean overlay) {
++        if (message != null) {
++            this.broadcastSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(message), overlay);
++        }
++    }
++    // Purpur end - Component related conveniences
++
+     public void broadcastAll(Packet<?> packet, ResourceKey<Level> dimension) {
+         for (ServerPlayer serverPlayer : this.players) {
+             if (serverPlayer.level().dimension() == dimension) {
+@@ -863,6 +879,7 @@ public abstract class PlayerList {
+                 case ADMINS -> EntityEvent.PERMISSION_LEVEL_ADMINS;
+                 case OWNERS -> EntityEvent.PERMISSION_LEVEL_OWNERS;
+             };
++            if (b < EntityEvent.PERMISSION_LEVEL_OWNERS && player.getBukkitEntity().hasPermission("purpur.debug.f3n")) b = EntityEvent.PERMISSION_LEVEL_OWNERS; // Purpur - Add permission for F3+N debug
+             player.connection.send(new ClientboundEntityEventPacket(player, b));
+         }
+ 
+@@ -874,7 +891,7 @@ public abstract class PlayerList {
+ 
+     // Paper start - whitelist verify event / login event
+     public LoginResult canBypassFullServerLogin(final NameAndId nameAndId, final LoginResult currentResult) {
+-        final boolean shouldKick = this.players.size() >= this.getMaxPlayers() && !this.canBypassPlayerLimit(nameAndId);
++        final boolean shouldKick = this.players.size() >= this.getMaxPlayers() && !(/*player.hasPermission("purpur.joinfullserver") || */this.canBypassPlayerLimit(nameAndId)); // Purpur - Allow player join full server by permission TODO: this hasn't worked for a while, so comment it out until we can reliably check perms of the player joining
+         final io.papermc.paper.event.player.PlayerServerFullCheckEvent fullCheckEvent = new io.papermc.paper.event.player.PlayerServerFullCheckEvent(
+             new com.destroystokyo.paper.profile.CraftPlayerProfile(nameAndId),
+             io.papermc.paper.adventure.PaperAdventure.asAdventure(currentResult.message),

purpur-server/minecraft-patches/rejected/net/minecraft/server/players/SleepStatus.java.patch

@@ -0,0 +1,28 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/server/players/SleepStatus.java b/net/minecraft/server/players/SleepStatus.java
+index 2a7ae521654ad5c9f392baa5562e64bb71b13097..3a3e6992563236141db687084aeec9684437a7db 100644
+--- a/net/minecraft/server/players/SleepStatus.java
++++ b/net/minecraft/server/players/SleepStatus.java
+@@ -15,7 +15,7 @@ public class SleepStatus {
+ 
+     public boolean areEnoughDeepSleeping(int requiredSleepPercentage, List<ServerPlayer> sleepingPlayers) {
+         // CraftBukkit start
+-        int i = (int) sleepingPlayers.stream().filter(player -> player.isSleepingLongEnough() || player.fauxSleeping).count();
++        int i = (int) sleepingPlayers.stream().filter(player -> player.isSleepingLongEnough() || player.fauxSleeping || (player.level().purpurConfig.idleTimeoutCountAsSleeping && player.isAfk())).count(); // Purpur - AFK API
+         boolean anyDeepSleep = sleepingPlayers.stream().anyMatch(Player::isSleepingLongEnough);
+         return anyDeepSleep && i >= this.sleepersNeeded(requiredSleepPercentage);
+         // CraftBukkit end
+@@ -43,7 +43,7 @@ public class SleepStatus {
+         for (ServerPlayer serverPlayer : players) {
+             if (!serverPlayer.isSpectator()) {
+                 this.activePlayers++;
+-                if (serverPlayer.isSleeping() || serverPlayer.fauxSleeping) { // CraftBukkit
++                if (serverPlayer.isSleeping() || serverPlayer.fauxSleeping || (serverPlayer.level().purpurConfig.idleTimeoutCountAsSleeping && serverPlayer.isAfk())) { // CraftBukkit // Purpur - AFK API
+                     this.sleepingPlayers++;
+                 }
+                 // CraftBukkit start

purpur-server/minecraft-patches/rejected/net/minecraft/stats/ServerRecipeBook.java.patch

@@ -0,0 +1,18 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/stats/ServerRecipeBook.java b/net/minecraft/stats/ServerRecipeBook.java
+index 736a52c23da313bec6b25a9d1abf08816462403c..2f4f90bf428deb682fe9ec8c1218ae31ebaeea7c 100644
+--- a/net/minecraft/stats/ServerRecipeBook.java
++++ b/net/minecraft/stats/ServerRecipeBook.java
+@@ -106,6 +106,7 @@ public class ServerRecipeBook extends RecipeBook {
+     private void loadRecipes(List<ResourceKey<Recipe<?>>> recipes, Consumer<ResourceKey<Recipe<?>>> output, Predicate<ResourceKey<Recipe<?>>> isRecognized) {
+         for (ResourceKey<Recipe<?>> resourceKey : recipes) {
+             if (!isRecognized.test(resourceKey)) {
++                if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressUnrecognizedRecipeErrors) // Purpur - Logger settings (suppressing pointless logs)
+                 LOGGER.error("Tried to load unrecognized recipe: {} removed now.", resourceKey);
+             } else {
+                 output.accept(resourceKey);

purpur-server/minecraft-patches/rejected/net/minecraft/world/damagesource/CombatRules.java.patch

@@ -0,0 +1,28 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/damagesource/CombatRules.java b/net/minecraft/world/damagesource/CombatRules.java
+index 5f8637dfe4703cb78f486fe49d2e81518cf48715..d27215349f63e73198d23e107a6b634ddef8f7ca 100644
+--- a/net/minecraft/world/damagesource/CombatRules.java
++++ b/net/minecraft/world/damagesource/CombatRules.java
+@@ -15,7 +15,7 @@ public class CombatRules {
+ 
+     public static float getDamageAfterAbsorb(LivingEntity entity, float damageAmount, DamageSource damageSource, float armorValue, float armorToughness) {
+         float f = 2.0F + armorToughness / 4.0F;
+-        float f1 = Mth.clamp(armorValue - damageAmount / f, armorValue * 0.2F, 20.0F);
++        float f1 = Mth.clamp(armorValue - damageAmount / f, armorValue * 0.2F, org.purpurmc.purpur.PurpurConfig.limitArmor ? 20F : Float.MAX_VALUE); // Purpur - Add attribute clamping and armor limit config
+         float f2 = f1 / 25.0F;
+         ItemStack weaponItem = damageSource.getWeaponItem();
+         float f3;
+@@ -30,7 +30,7 @@ public class CombatRules {
+     }
+ 
+     public static float getDamageAfterMagicAbsorb(float damageAmount, float enchantModifiers) {
+-        float f = Mth.clamp(enchantModifiers, 0.0F, 20.0F);
++        float f = Mth.clamp(enchantModifiers, 0.0F, org.purpurmc.purpur.PurpurConfig.limitArmor ? 20F : Float.MAX_VALUE); // Purpur - Add attribute clamping and armor limit config
+         return damageAmount * (1.0F - f / 25.0F);
+     }
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/damagesource/CombatTracker.java.patch

@@ -0,0 +1,35 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/damagesource/CombatTracker.java b/net/minecraft/world/damagesource/CombatTracker.java
+index ffdfb4c4e3d6496ebdba6e4bad7146a9cbdcf5ec..30d0807d7adf46a6cd23b81b979e06f943a2bca1 100644
+--- a/net/minecraft/world/damagesource/CombatTracker.java
++++ b/net/minecraft/world/damagesource/CombatTracker.java
+@@ -64,7 +64,7 @@ public class CombatTracker {
+ 
+     private Component getMessageForAssistedFall(Entity entity, Component entityDisplayName, String hasWeaponTranslationKey, String noWeaponTranslationKey) {
+         ItemStack itemStack = entity 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 - always show item in player death messages
+             ? Component.translatable(hasWeaponTranslationKey, this.mob.getDisplayName(), entityDisplayName, itemStack.getDisplayName())
+             : Component.translatable(noWeaponTranslationKey, this.mob.getDisplayName(), entityDisplayName);
+     }
+@@ -107,6 +107,15 @@ public class CombatTracker {
+                 Component component = ComponentUtils.wrapInSquareBrackets(Component.translatable(string + ".link")).withStyle(INTENTIONAL_GAME_DESIGN_STYLE);
+                 return Component.translatable(string + ".message", this.mob.getDisplayName(), component);
+             } else {
++                // Purpur start - Dont run with scissors!
++                if (damageSource.isScissors()) {
++                    return damageSource.getLocalizedDeathMessage(org.purpurmc.purpur.PurpurConfig.deathMsgRunWithScissors, this.mob);
++                // Purpur start - Stonecutter damage
++                } else if (damageSource.isStonecutter()) {
++                    return damageSource.getLocalizedDeathMessage(org.purpurmc.purpur.PurpurConfig.deathMsgStonecutter, this.mob);
++                // Purpur end - Stonecutter damage
++                }
++                // Purpur end - Dont run with scissors!
+                 return damageSource.getLocalizedDeathMessage(this.mob);
+             }
+         }

purpur-server/minecraft-patches/rejected/net/minecraft/world/damagesource/DamageSource.java.patch

@@ -0,0 +1,82 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/damagesource/DamageSource.java b/net/minecraft/world/damagesource/DamageSource.java
+index 4df37fcd42b8edf789ee8e99d61ee1fa6471288b..67318e32fa58a89ba9321a36627af07697aacea4 100644
+--- a/net/minecraft/world/damagesource/DamageSource.java
++++ b/net/minecraft/world/damagesource/DamageSource.java
+@@ -24,6 +24,8 @@ public class DamageSource {
+     private org.bukkit.block.@Nullable Block eventBlockDamager; // Relevant block set. damageSourcePosition is only used for bad respawn point explosion or custom damage
+     private org.bukkit.block.@Nullable BlockState fromBlockSnapshot; // Captured block snapshot when the eventBlockDamager is not relevant (e.g. for bad respawn point explosions the block is already removed)
+     private boolean critical; // Supports arrows and sweeping damage
++    private boolean scissors = false; // Purpur - Dont run with scissors!
++    private boolean stonecutter = false; // Purpur - Stonecutter damage
+ 
+     public DamageSource knownCause(final org.bukkit.event.entity.EntityDamageEvent.DamageCause cause) {
+         final DamageSource damageSource = this.copy();
+@@ -35,6 +37,30 @@ public class DamageSource {
+         return this.knownCause;
+     }
+ 
++    // Purpur start - Dont run with scissors!
++    public DamageSource scissors() {
++        this.knownCause(org.bukkit.event.entity.EntityDamageEvent.DamageCause.SUICIDE);
++        this.scissors = true;
++        return this;
++    }
++
++    public boolean isScissors() {
++        return this.scissors;
++    }
++    // Purpur end - Dont run with scissors!
++
++    // Purpur start -  - Stonecutter damage
++    public DamageSource stonecutter() {
++        this.knownCause(org.bukkit.event.entity.EntityDamageEvent.DamageCause.CONTACT);
++        this.stonecutter = true;
++        return this;
++    }
++
++    public boolean isStonecutter() {
++        return this.stonecutter;
++    }
++    // Purpur end - Stonecutter damage
++
+     @Nullable
+     public Entity eventEntityDamager() {
+         return this.eventEntityDamager;
+@@ -94,6 +120,8 @@ public class DamageSource {
+         damageSource.eventBlockDamager = this.eventBlockDamager;
+         damageSource.fromBlockSnapshot = this.fromBlockSnapshot;
+         damageSource.critical = this.critical;
++        damageSource.scissors = this.isScissors(); // Purpur - Dont run with scissors!
++        damageSource.stonecutter = this.isStonecutter(); // Purpur - Stonecutter damage
+         return damageSource;
+     }
+     // CraftBukkit end
+@@ -157,12 +185,21 @@ public class DamageSource {
+         } else {
+             Component component = this.causingEntity == null ? this.directEntity.getDisplayName() : this.causingEntity.getDisplayName();
+             ItemStack itemStack = this.causingEntity instanceof LivingEntity livingEntity1 ? livingEntity1.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 - always show item in player death messages
+                 ? Component.translatable(string + ".item", livingEntity.getDisplayName(), component, itemStack.getDisplayName())
+                 : Component.translatable(string, livingEntity.getDisplayName(), component);
+         }
+     }
+ 
++    // Purpur start - Component related conveniences
++    public Component getLocalizedDeathMessage(String str, LivingEntity entity) {
++        net.kyori.adventure.text.Component name = io.papermc.paper.adventure.PaperAdventure.asAdventure(entity.getDisplayName());
++        net.kyori.adventure.text.minimessage.tag.resolver.TagResolver template = net.kyori.adventure.text.minimessage.tag.resolver.Placeholder.component("player", name);
++        net.kyori.adventure.text.Component component = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(str, template);
++        return io.papermc.paper.adventure.PaperAdventure.asVanilla(component);
++    }
++    // Purpur end - Component related conveniences
++
+     public String getMsgId() {
+         return this.type().msgId();
+     }

purpur-server/minecraft-patches/rejected/net/minecraft/world/effect/HungerMobEffect.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/effect/HungerMobEffect.java b/net/minecraft/world/effect/HungerMobEffect.java
+index 0890694ae96b6cd60079c34066e7a6e288f038e8..6c0e6bd2a171edc57dec71af178764454de73313 100644
+--- a/net/minecraft/world/effect/HungerMobEffect.java
++++ b/net/minecraft/world/effect/HungerMobEffect.java
+@@ -12,7 +12,7 @@ class HungerMobEffect extends MobEffect {
+     @Override
+     public boolean applyEffectTick(ServerLevel level, LivingEntity entity, int amplifier) {
+         if (entity instanceof Player player) {
+-            player.causeFoodExhaustion(0.005F * (amplifier + 1), org.bukkit.event.entity.EntityExhaustionEvent.ExhaustionReason.HUNGER_EFFECT); // CraftBukkit - EntityExhaustionEvent
++            player.causeFoodExhaustion(entity.level().purpurConfig.humanHungerExhaustionAmount * (amplifier + 1), org.bukkit.event.entity.EntityExhaustionEvent.ExhaustionReason.HUNGER_EFFECT); // CraftBukkit - EntityExhaustionEvent // Purpur - Config MobEffect by world
+         }
+ 
+         return true;

purpur-server/minecraft-patches/rejected/net/minecraft/world/effect/PoisonMobEffect.java.patch

@@ -0,0 +1,21 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/effect/PoisonMobEffect.java b/net/minecraft/world/effect/PoisonMobEffect.java
+index 75327fd96858fd508ea63a6983e5cbc655a8800f..73cfc61ac3f8e33e6b9f4fd08a292266c0adb535 100644
+--- a/net/minecraft/world/effect/PoisonMobEffect.java
++++ b/net/minecraft/world/effect/PoisonMobEffect.java
+@@ -12,8 +12,8 @@ public class PoisonMobEffect extends MobEffect {
+ 
+     @Override
+     public boolean applyEffectTick(ServerLevel level, LivingEntity entity, int amplifier) {
+-        if (entity.getHealth() > 1.0F) {
+-            entity.hurtServer(level, entity.damageSources().magic().knownCause(org.bukkit.event.entity.EntityDamageEvent.DamageCause.POISON), 1.0F); // CraftBukkit
++        if (entity.getHealth() > entity.level().purpurConfig.entityMinimalHealthPoison) { // Purpur
++            entity.hurtServer(level, entity.damageSources().magic().knownCause(org.bukkit.event.entity.EntityDamageEvent.DamageCause.POISON), entity.level().purpurConfig.entityPoisonDegenerationAmount); // CraftBukkit // Purpur - Config MobEffect by world
+         }
+ 
+         return true;

purpur-server/minecraft-patches/rejected/net/minecraft/world/effect/RegenerationMobEffect.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/effect/RegenerationMobEffect.java b/net/minecraft/world/effect/RegenerationMobEffect.java
+index 76cffa4d4d18d6c04749d941dbdf5eb60aed4095..81481267a1577721dcc405f39a4c350bd59ac9a2 100644
+--- a/net/minecraft/world/effect/RegenerationMobEffect.java
++++ b/net/minecraft/world/effect/RegenerationMobEffect.java
+@@ -11,7 +11,7 @@ class RegenerationMobEffect extends MobEffect {
+     @Override
+     public boolean applyEffectTick(ServerLevel level, LivingEntity entity, int amplifier) {
+         if (entity.getHealth() < entity.getMaxHealth()) {
+-            entity.heal(1.0F, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.MAGIC_REGEN); // CraftBukkit
++            entity.heal(entity.level().purpurConfig.entityHealthRegenAmount, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.MAGIC_REGEN); // CraftBukkit // Purpur - Config MobEffect by world
+         }
+ 
+         return true;

purpur-server/minecraft-patches/rejected/net/minecraft/world/effect/WitherMobEffect.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/effect/WitherMobEffect.java b/net/minecraft/world/effect/WitherMobEffect.java
+index 1fc9e1ad541c46124183a401b2a7d99aea69cecf..881271f0bc77a8a8a7d31daad9a8188bebaca67b 100644
+--- a/net/minecraft/world/effect/WitherMobEffect.java
++++ b/net/minecraft/world/effect/WitherMobEffect.java
+@@ -12,7 +12,7 @@ public class WitherMobEffect extends MobEffect {
+ 
+     @Override
+     public boolean applyEffectTick(ServerLevel level, LivingEntity entity, int amplifier) {
+-        entity.hurtServer(level, entity.damageSources().wither(), 1.0F);
++        entity.hurtServer(level, entity.damageSources().wither(), entity.level().purpurConfig.entityWitherDegenerationAmount); // Purpur - Config MobEffect by world
+         return true;
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/Entity.java.patch

@@ -0,0 +1,178 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 118ba985eff209ff97dd2c8b2749a75113f5ce43..5efb94bf1029fdbbd48937c1f3925421d6daacfd 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -153,6 +153,7 @@ import org.jspecify.annotations.Nullable;
+ import org.slf4j.Logger;
+ 
+ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Nameable, ItemOwner, SlotProvider, EntityAccess, ScoreHolder, DataComponentGetter, ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity, ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerEntity { // Paper - rewrite chunk system // Paper - optimise entity tracker
++    public static javax.script.ScriptEngine scriptEngine = new javax.script.ScriptEngineManager().getEngineByName("rhino"); // Purpur - Configurable entity base attributes
+     // CraftBukkit start
+     private static final int CURRENT_LEVEL = 2;
+     static boolean isLevelAtLeast(ValueInput input, int level) {
+@@ -282,8 +283,9 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     public double xOld;
+     public double yOld;
+     public double zOld;
++    public float maxUpStep; // Purpur - Add option to set armorstand step height
+     public boolean noPhysics;
+-    public final RandomSource random = SHARED_RANDOM; // Paper - Share random for entities to make them more random
++    public final RandomSource random; // Paper - Share random for entities to make them more random // Add toggle for RNG manipulation
+     public int tickCount;
+     private int remainingFireTicks;
+     public boolean wasTouchingWater;
+@@ -316,8 +318,8 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     public @Nullable PortalProcessor portalProcess;
+     public int portalCooldown;
+     private boolean invulnerable;
+-    protected UUID uuid = Mth.createInsecureUUID(this.random);
+-    protected String stringUUID = this.uuid.toString();
++    protected UUID uuid; // Purpur - Add toggle for RNG manipulation
++    protected String stringUUID; // Purpur - Add toggle for RNG manipulation
+     private boolean hasGlowingTag;
+     private final Set<String> tags = new io.papermc.paper.util.SizeLimitedSet<>(new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(), MAX_ENTITY_TAG_COUNT); // Paper - fully limit tag size - replace set impl
+     private final double[] pistonDeltas = new double[]{0.0, 0.0, 0.0};
+@@ -373,6 +375,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     public long activatedTick = Integer.MIN_VALUE;
+     public boolean isTemporarilyActive;
+     public long activatedImmunityTick = Integer.MIN_VALUE;
++    public @Nullable Boolean immuneToFire = null; // Purpur - Fire immune API
+ 
+     public void inactiveTick() {
+     }
+@@ -535,10 +538,22 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     }
+     // Paper end - optimise entity tracker
+ 
++    // Purpur start - Add canSaveToDisk to Entity
++    public boolean canSaveToDisk() {
++        return true;
++    }
++    // Purpur end - Add canSaveToDisk to Entity
++
+     public Entity(EntityType<?> type, Level level) {
+         this.type = type;
+         this.level = level;
+         this.dimensions = type.getDimensions();
++        this.maxAirTicks = level == null ? Entity.TOTAL_AIR_SUPPLY : this.level.purpurConfig.drowningAirTicks; // Purpur - Drowning Settings
++        // Purpur start - Add toggle for RNG manipulation
++        this.random = level == null || level.purpurConfig.entitySharedRandom ? SHARED_RANDOM : RandomSource.create();
++        this.uuid = Mth.createInsecureUUID(this.random);
++        this.stringUUID = this.uuid.toString();
++        // Purpur end - Add toggle for RNG manipulation
+         this.position = Vec3.ZERO;
+         this.blockPosition = BlockPos.ZERO;
+         this.chunkPosition = ChunkPos.ZERO;
+@@ -931,6 +946,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+             && 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(org.bukkit.craftbukkit.util.CraftLocation.toBukkit(this.level.levelData.getRespawnData().pos(), this.level)); else // Purpur - Add option to teleport to spawn on nether ceiling damage
+             this.onBelowWorld();
+         }
+     }
+@@ -1960,7 +1976,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     }
+ 
+     public boolean fireImmune() {
+-        return this.getType().fireImmune();
++        return this.immuneToFire != null ? immuneToFire : this.getType().fireImmune(); // Purpur - add fire immune API
+     }
+ 
+     public boolean causeFallDamage(double fallDistance, float damageMultiplier, DamageSource damageSource) {
+@@ -2572,7 +2588,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+                 output.putBoolean("Bukkit.invisible", this.persistentInvisibility);
+             }
+             // SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
+-            if (this.maxAirTicks != this.getDefaultMaxAirSupply()) {
++            if (this.maxAirTicks != this.getDefaultMaxAirSupply() && this.getDefaultMaxAirSupply() != this.level().purpurConfig.drowningAirTicks) { // Purpur - Drowning Settings
+                 output.putInt("Bukkit.MaxAirSupply", this.getMaxAirSupply());
+             }
+             output.putInt("Spigot.ticksLived", this.totalEntityAge); // Paper
+@@ -2659,6 +2675,11 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+                 output.putBoolean("Paper.FreezeLock", true);
+             }
+             // Paper end
++            // Purpur start - Fire immune API
++            if (immuneToFire != null) {
++                output.putBoolean("Purpur.FireImmune", immuneToFire);
++            }
++            // Purpur end - Fire immune API
+         } catch (Throwable var7) {
+             CrashReport crashReport = CrashReport.forThrowable(var7, "Saving entity NBT");
+             CrashReportCategory crashReportCategory = crashReport.addCategory("Entity being saved");
+@@ -2779,6 +2800,9 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+             }
+             freezeLocked = input.getBooleanOr("Paper.FreezeLock", false);
+             // Paper end
++
++            immuneToFire = input.read("Purpur.FireImmune", com.mojang.serialization.Codec.BOOL).orElse(null); // Purpur - Fire immune API
++
+         } catch (Throwable var7) {
+             CrashReport crashReport = CrashReport.forThrowable(var7, "Loading entity NBT");
+             CrashReportCategory crashReportCategory = crashReport.addCategory("Entity being loaded");
+@@ -3042,6 +3066,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+             if (this.isAlive() && this instanceof Leashable leashable2) {
+                 if (leashable2.getLeashHolder() == player) {
+                     if (!this.level().isClientSide()) {
++                        if (hand == InteractionHand.OFF_HAND && (level().purpurConfig.villagerCanBeLeashed || level().purpurConfig.wanderingTraderCanBeLeashed) && this instanceof net.minecraft.world.entity.npc.villager.AbstractVillager) return InteractionResult.CONSUME; // Purpur - Allow leashing villagers
+                         // Paper start - EntityUnleashEvent
+                         if (!org.bukkit.craftbukkit.event.CraftEventFactory.handlePlayerUnleashEntityEvent(
+                             leashable2, player, hand, !player.hasInfiniteMaterials(), true
+@@ -3472,15 +3497,18 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+         return Vec3.directionFromRotation(this.getRotationVector());
+     }
+ 
++    public BlockPos portalPos = BlockPos.ZERO; // Purpur - Fix stuck in portals
+     public void setAsInsidePortal(Portal portal, BlockPos pos) {
+         if (this.isOnPortalCooldown()) {
++            if (!(level().purpurConfig.playerFixStuckPortal && this instanceof Player && !pos.equals(this.portalPos))) // Purpur - Fix stuck in portals
+             this.setPortalCooldown();
+-        } else {
++        } else if (this.level.purpurConfig.entitiesCanUsePortals || this instanceof ServerPlayer) { // Purpur - Entities can use portals
+             if (this.portalProcess == null || !this.portalProcess.isSamePortal(portal)) {
+                 this.portalProcess = new PortalProcessor(portal, pos.immutable());
+             } else if (!this.portalProcess.isInsidePortalThisTick()) {
+                 this.portalProcess.updateEntryPosition(pos.immutable());
+                 this.portalProcess.setAsInsidePortalThisTick(true);
++                this.portalPos = BlockPos.ZERO; // Purpur - Fix stuck in portals
+             }
+         }
+     }
+@@ -4220,7 +4248,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     }
+ 
+     public boolean canUsePortal(boolean allowPassengers) {
+-        return (allowPassengers || !this.isPassenger()) && this.isAlive();
++        return (allowPassengers || !this.isPassenger()) && this.isAlive() && (this.level.purpurConfig.entitiesCanUsePortals || this instanceof ServerPlayer); // Purpur - Entities can use portals
+     }
+ 
+     public boolean canTeleport(Level fromLevel, Level toLevel) {
+@@ -4739,6 +4767,12 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+         return Mth.lerp(partialTick, this.yRotO, this.yRot);
+     }
+ 
++    // Purpur start - Stop squids floating on top of water
++    public AABB getAxisForFluidCheck() {
++        return this.getBoundingBox().deflate(0.001D);
++    }
++    // Purpur end - Stop squids floating on top of water
++
+     // Paper start - optimise collisions
+     public boolean updateFluidHeightAndDoFluidPushing(final TagKey<Fluid> fluid, final double flowScale) {
+         if (this.touchingUnloadedChunk()) {
+@@ -5159,7 +5193,7 @@ public abstract class Entity implements SyncedDataHolder, DebugValueSource, Name
+     }
+ 
+     public float maxUpStep() {
+-        return 0.0F;
++        return maxUpStep; // Purpur - Add option to set armorstand step height
+     }
+ 
+     public void onExplosionHit(@Nullable Entity entity) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/EntityType.java.patch

@@ -0,0 +1,52 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/EntityType.java b/net/minecraft/world/entity/EntityType.java
+index a3cba4a65687c61fefbfcf3c35625ceed2e50bfb..f0731609fbfb06ea23baba2a8b3694003a470b7d 100644
+--- a/net/minecraft/world/entity/EntityType.java
++++ b/net/minecraft/world/entity/EntityType.java
+@@ -1240,6 +1240,16 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+         return register(vanillaEntityId(key), builder);
+     }
+ 
++    // Purpur start - PlayerSetSpawnerTypeWithEggEvent
++    public static EntityType<?> getFromBukkitType(org.bukkit.entity.EntityType bukkitType) {
++        return getFromKey(Identifier.parse(bukkitType.getKey().toString()));
++    }
++
++    public static EntityType<?> getFromKey(Identifier location) {
++        return BuiltInRegistries.ENTITY_TYPE.getValue(location);
++    }
++    // Purpur end - PlayerSetSpawnerTypeWithEggEvent
++
+     public static Identifier getKey(EntityType<?> entityType) {
+         return BuiltInRegistries.ENTITY_TYPE.getKey(entityType);
+     }
+@@ -1467,6 +1477,16 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+         return this.category;
+     }
+ 
++    // Purpur start - PlayerSetSpawnerTypeWithEggEvent
++    public String getName() {
++        return BuiltInRegistries.ENTITY_TYPE.getKey(this).getPath();
++    }
++
++    public String getTranslatedName() {
++        return getDescription().getString();
++    }
++    // Purpur end - PlayerSetSpawnerTypeWithEggEvent
++
+     public String getDescriptionId() {
+         return this.descriptionId;
+     }
+@@ -1528,6 +1548,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+             // Paper start - Add logging for debugging entity tags with invalid ids
+             () -> {
+                 LOGGER.warn("Skipping Entity with id {}", input.getStringOr("id", "[invalid]"));
++                LOGGER.warn("Location: {} {}", level.getWorld().getName(), input.read("Pos", net.minecraft.world.phys.Vec3.CODEC).orElse(net.minecraft.world.phys.Vec3.ZERO)); // Purpur - log skipped entity's position
+                 if ((DEBUG_ENTITIES_WITH_INVALID_IDS || level.getCraftServer().getServer().isDebugging()) && input instanceof TagValueInput tagInput) {
+                     LOGGER.warn("Skipped entity tag: {}", tagInput.input);
+                 }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ExperienceOrb.java.patch

@@ -0,0 +1,28 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ExperienceOrb.java b/net/minecraft/world/entity/ExperienceOrb.java
+index f2ec0bd8cca3c08d558790537e17a8a2f95f1953..c655689cdd2d4e655dfc872edd231dcdfb7c0995 100644
+--- a/net/minecraft/world/entity/ExperienceOrb.java
++++ b/net/minecraft/world/entity/ExperienceOrb.java
+@@ -355,7 +355,7 @@ public class ExperienceOrb extends Entity {
+     public void playerTouch(Player entity) {
+         if (entity instanceof ServerPlayer serverPlayer) {
+             if (entity.takeXpDelay == 0 && new com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent(serverPlayer.getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) this.getBukkitEntity()).callEvent()) { // Paper - PlayerPickupExperienceEvent
+-                entity.takeXpDelay = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerXpCooldownEvent(entity, 2, org.bukkit.event.player.PlayerExpCooldownChangeEvent.ChangeReason.PICKUP_ORB).getNewCooldown(); // CraftBukkit - entity.takeXpDelay = 2;
++                entity.takeXpDelay = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerXpCooldownEvent(entity, this.level().purpurConfig.playerExpPickupDelay, org.bukkit.event.player.PlayerExpCooldownChangeEvent.ChangeReason.PICKUP_ORB).getNewCooldown(); // CraftBukkit - entity.takeXpDelay = 2; // Purpur - Configurable player pickup exp delay
+                 entity.take(this, 1);
+                 int i = this.repairPlayerItems(serverPlayer, this.getValue());
+                 if (i > 0) {
+@@ -371,7 +371,7 @@ public class ExperienceOrb extends Entity {
+     }
+ 
+     private int repairPlayerItems(ServerPlayer player, int value) {
+-        Optional<EnchantedItemInUse> randomItemWith = EnchantmentHelper.getRandomItemWith(
++        Optional<EnchantedItemInUse> randomItemWith = level().purpurConfig.useBetterMending ? EnchantmentHelper.getMostDamagedItemWith(EnchantmentEffectComponents.REPAIR_WITH_XP, player) : EnchantmentHelper.getRandomItemWith( // Purpur - Add option to mend the most damaged equipment first
+             EnchantmentEffectComponents.REPAIR_WITH_XP, player, ItemStack::isDamaged
+         );
+         if (randomItemWith.isPresent()) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/LivingEntity.java.patch

@@ -0,0 +1,195 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index 54f31965213309a2cd228b7211e96ae1b9c219d4..527db90fa6faa6f39a80e64db16e28f1d616ce4d 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -447,6 +447,12 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+                 if (d < 0.0) {
+                     double damagePerBlock = serverLevel1.getWorldBorder().getDamagePerBlock();
+                     if (damagePerBlock > 0.0) {
++                        // Purpur start - Add option to teleport to spawn if outside world border
++                        if (this.level().purpurConfig.teleportIfOutsideBorder && this instanceof ServerPlayer serverPlayer) {
++                            serverPlayer.teleport(org.bukkit.craftbukkit.util.CraftLocation.toBukkit(this.level().levelData.getRespawnData().pos(), this.level()));
++                            return;
++                        }
++                        // Purpur end - Add option to teleport to spawn if outside world border
+                         this.hurtServer(serverLevel1, this.damageSources().outOfBorder(), Math.max(1, Mth.floor(-d * damagePerBlock)));
+                     }
+                 }
+@@ -462,7 +468,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+                     if (this.shouldTakeDrowningDamage()) {
+                         this.setAirSupply(0);
+                         serverLevel1.broadcastEntityEvent(this, EntityEvent.DROWN_PARTICLES);
+-                        this.hurtServer(serverLevel1, this.damageSources().drown(), 2.0F);
++                        this.hurtServer(serverLevel1, this.damageSources().drown(), (float) this.level().purpurConfig.damageFromDrowning); // Purpur - Drowning Settings
+                     }
+                 } else if (this.getAirSupply() < this.getMaxAirSupply() && MobEffectUtil.shouldEffectsRefillAirsupply(this)) {
+                     this.setAirSupply(this.increaseAirSupply(this.getAirSupply()));
+@@ -522,7 +528,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+     }
+ 
+     protected boolean shouldTakeDrowningDamage() {
+-        return this.getAirSupply() <= -20;
++        return this.getAirSupply() <= -this.level().purpurConfig.drowningDamageInterval; // Purpur - Drowning Settings
+     }
+ 
+     @Override
+@@ -1050,15 +1056,33 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+         if (lookingEntity != null) {
+             ItemStack itemBySlot = this.getItemBySlot(EquipmentSlot.HEAD);
+             EntityType<?> type = lookingEntity.getType();
+-            if (type == EntityType.SKELETON && itemBySlot.is(Items.SKELETON_SKULL)
+-                || type == EntityType.ZOMBIE && itemBySlot.is(Items.ZOMBIE_HEAD)
+-                || type == EntityType.PIGLIN && itemBySlot.is(Items.PIGLIN_HEAD)
+-                || type == EntityType.PIGLIN_BRUTE && itemBySlot.is(Items.PIGLIN_HEAD)
+-                || type == EntityType.CREEPER && itemBySlot.is(Items.CREEPER_HEAD)) {
+-                d *= 0.5;
++            // Purpur start - Mob head visibility percent
++            if (type == EntityType.SKELETON && itemBySlot.is(Items.SKELETON_SKULL)) {
++                d *= lookingEntity.level().purpurConfig.skeletonHeadVisibilityPercent;
++            }
++            else if (type == EntityType.ZOMBIE && itemBySlot.is(Items.ZOMBIE_HEAD)) {
++                d *= lookingEntity.level().purpurConfig.zombieHeadVisibilityPercent;
++            }
++            else if ((type == EntityType.PIGLIN || type == EntityType.PIGLIN_BRUTE) && itemBySlot.is(Items.PIGLIN_HEAD)) {
++                d *= lookingEntity.level().purpurConfig.piglinHeadVisibilityPercent;
+             }
++            else if (type == EntityType.CREEPER && itemBySlot.is(Items.CREEPER_HEAD)) {
++                d *= lookingEntity.level().purpurConfig.creeperHeadVisibilityPercent;
++            }
++            // Purpur end - Mob head visibility percent
+         }
+ 
++        // Purpur start - Configurable mob blindness
++        if (lookingEntity instanceof LivingEntity entityliving) {
++            if (entityliving.hasEffect(MobEffects.BLINDNESS)) {
++                int amplifier = entityliving.getEffect(MobEffects.BLINDNESS).getAmplifier();
++                for (int i = 0; i < amplifier; i++) {
++                    d *= this.level().purpurConfig.mobsBlindnessMultiplier;
++                }
++            }
++        }
++        // Purpur end - Configurable mob blindness
++
+         return d;
+     }
+ 
+@@ -1104,6 +1128,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+             Iterator<MobEffectInstance> iterator = this.activeEffects.values().iterator();
+             while (iterator.hasNext()) {
+                 MobEffectInstance effect = iterator.next();
++                if (cause == EntityPotionEffectEvent.Cause.MILK && !this.level().purpurConfig.milkClearsBeneficialEffects && effect.getEffect().value().isBeneficial()) continue; // Purpur - Milk Keeps Beneficial Effects
+                 EntityPotionEffectEvent event = CraftEventFactory.callEntityPotionEffectChangeEvent(this, effect, null, cause, EntityPotionEffectEvent.Action.CLEARED);
+                 if (event.isCancelled()) {
+                     continue;
+@@ -1436,6 +1461,24 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+                 this.stopSleeping();
+             }
+ 
++            // Purpur start - One Punch Man!
++            if (damageSource.getEntity() instanceof net.minecraft.world.entity.player.Player player && damageSource.getEntity().level().purpurConfig.creativeOnePunch && !damageSource.is(DamageTypeTags.IS_PROJECTILE)) {
++                if (player.isCreative()) {
++                    org.apache.commons.lang3.mutable.MutableDouble attackDamage = new org.apache.commons.lang3.mutable.MutableDouble();
++                    player.getMainHandItem().forEachModifier(EquipmentSlot.MAINHAND, (attributeHolder, attributeModifier) -> {
++                        if (attributeModifier.operation() == AttributeModifier.Operation.ADD_VALUE) {
++                            attackDamage.addAndGet(attributeModifier.amount());
++                        }
++                    });
++
++                    if (attackDamage.doubleValue() == 0.0D) {
++                        // One punch!
++                        amount = 9999F;
++                    }
++                }
++            }
++            // Purpur end - One Punch Man!
++
+             this.noActionTime = 0;
+             if (amount < 0.0F) {
+                 amount = 0.0F;
+@@ -1697,10 +1740,10 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+     protected @Nullable Player resolvePlayerResponsibleForDamage(DamageSource damageSource) {
+         Entity entity = damageSource.getEntity();
+         if (entity instanceof Player player) {
+-            this.setLastHurtByPlayer(player, 100);
++            this.setLastHurtByPlayer(player, this.level().purpurConfig.mobLastHurtByPlayerTime); // Purpur - Config for mob last hurt by player time
+         } else if (entity instanceof Wolf wolf && wolf.isTame()) {
+             if (wolf.getOwnerReference() != null) {
+-                this.setLastHurtByPlayer(wolf.getOwnerReference().getUUID(), 100);
++                this.setLastHurtByPlayer(wolf.getOwnerReference().getUUID(), this.level().purpurConfig.mobLastHurtByPlayerTime); // Purpur - Config for mob last hurt by player time
+             } else {
+                 this.lastHurtByPlayer = null;
+                 this.lastHurtByPlayerMemoryTime = 0;
+@@ -1751,6 +1794,30 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+                 }
+             }
+ 
++            // Purpur start - Totems work in inventory
++            if (level().purpurConfig.totemOfUndyingWorksInInventory && this instanceof ServerPlayer player && (itemStack == null || itemStack.getItem() != Items.TOTEM_OF_UNDYING) && player.getBukkitEntity().hasPermission("purpur.inventory_totem")) {
++                for (ItemStack item : player.getInventory().getNonEquipmentItems()) {
++                    if (item.getItem() == Items.TOTEM_OF_UNDYING) {
++                        itemInHand = item;
++                        itemStack = item.copy();
++                        break;
++                    }
++                }
++            }
++            // Purpur end - Totems work in inventory
++
++            // Purpur start - Totems work in inventory
++            if (level().purpurConfig.totemOfUndyingWorksInInventory && this instanceof ServerPlayer player && (itemStack == null || itemStack.getItem() != Items.TOTEM_OF_UNDYING) && player.getBukkitEntity().hasPermission("purpur.inventory_totem")) {
++                for (ItemStack item : player.getInventory().getNonEquipmentItems()) {
++                    if (item.getItem() == Items.TOTEM_OF_UNDYING) {
++                        itemInHand = item;
++                        itemStack = item.copy();
++                        break;
++                    }
++                }
++            }
++            // Purpur end - Totems work in inventory
++
+             final org.bukkit.inventory.EquipmentSlot handSlot = (hand != null) ? org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand) : null;
+             final EntityResurrectEvent event = new EntityResurrectEvent((org.bukkit.entity.LivingEntity) this.getBukkitEntity(), handSlot);
+             event.setCancelled(itemStack == null);
+@@ -1932,6 +1999,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+         boolean flag = this.lastHurtByPlayerMemoryTime > 0;
+         this.dropEquipment(level); // CraftBukkit - from below
+         if (this.shouldDropLoot(level)) {
++            if (!(damageSource.is(net.minecraft.world.damagesource.DamageTypes.CRAMMING) && level().purpurConfig.disableDropsOnCrammingDeath)) { // Purpur - Disable loot drops on death by cramming
+             this.dropFromLootTable(level, damageSource, flag);
+             // Paper start
+             final boolean prev = this.clearEquipmentSlots;
+@@ -1940,6 +2008,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+             // Paper end
+             this.dropCustomDeathLoot(level, damageSource, flag);
+             this.clearEquipmentSlots = prev; // Paper
++            } // Purpur - Disable loot drops on death by cramming
+         }
+ 
+         // CraftBukkit start - Call death event // Paper start - call advancement triggers with correct entity equipment
+@@ -3214,6 +3283,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+             float f = (float)(d * 10.0 - 3.0);
+             if (f > 0.0F) {
+                 this.playSound(this.getFallDamageSound((int)f), 1.0F, 1.0F);
++                if (level().purpurConfig.elytraKineticDamage) // Purpur - Toggle for kinetic damage
+                 this.hurt(this.damageSources().flyIntoWall(), f);
+             }
+         }
+@@ -4680,6 +4750,12 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+             : slot == equippable.slot() && this.canUseSlot(equippable.slot()) && equippable.canBeEquippedBy(this.getType());
+     }
+ 
++    // Purpur start - Dispenser curse of binding protection
++    public @Nullable EquipmentSlot getEquipmentSlotForDispenserItem(ItemStack itemstack) {
++        return EnchantmentHelper.getItemEnchantmentLevel(net.minecraft.world.item.enchantment.Enchantments.BINDING_CURSE, itemstack) > 0 ? null : this.getEquipmentSlotForItem(itemstack);
++    }
++    // Purpur end - Dispenser curse of binding protection
++
+     private static SlotAccess createEquipmentSlotAccess(LivingEntity entity, EquipmentSlot slot) {
+         return slot != EquipmentSlot.HEAD && slot != EquipmentSlot.MAINHAND && slot != EquipmentSlot.OFFHAND
+             ? SlotAccess.forEquipmentSlot(entity, slot, itemStack -> itemStack.isEmpty() || entity.getEquipmentSlotForItem(itemStack) == slot)

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/Mob.java.patch

@@ -0,0 +1,88 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
+index 92175cc019750e829fcad7691a937024c2649882..cf2cbc3bf5e0000737ebeac3867f12d7e07bda01 100644
+--- a/net/minecraft/world/entity/Mob.java
++++ b/net/minecraft/world/entity/Mob.java
+@@ -150,6 +150,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+     private int homeRadius = -1;
+     public boolean aware = true; // CraftBukkit
+     public net.kyori.adventure.util.TriState despawnInPeacefulOverride = net.kyori.adventure.util.TriState.NOT_SET; // Paper - allow changing despawnInPeaceful
++    public int ticksSinceLastInteraction; // Purpur - Entity lifespan
+ 
+     protected Mob(EntityType<? extends Mob> type, Level level) {
+         super(type, level);
+@@ -292,6 +293,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+                 target = null;
+             }
+         }
++        if (target instanceof net.minecraft.server.level.ServerPlayer) this.ticksSinceLastInteraction = 0; // Purpur - Entity lifespan
+         this.target = target;
+         return true;
+         // CraftBukkit end
+@@ -335,8 +337,28 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+         }
+ 
+         profilerFiller.pop();
++        incrementTicksSinceLastInteraction(); // Purpur - Entity lifespan
+     }
+ 
++    // Purpur start - Entity lifespan
++    private void incrementTicksSinceLastInteraction() {
++        ++this.ticksSinceLastInteraction;
++        if (getRider() != null) {
++            this.ticksSinceLastInteraction = 0;
++            return;
++        }
++        if (this.level().purpurConfig.entityLifeSpan <= 0) {
++            return; // feature disabled
++        }
++        if (!this.removeWhenFarAway(0) || isPersistenceRequired() || requiresCustomPersistence() || hasCustomName()) {
++            return; // mob persistent
++        }
++        if (this.ticksSinceLastInteraction > this.level().purpurConfig.entityLifeSpan) {
++            this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
++        }
++    }
++    // Purpur end - Entity lifespan
++
+     @Override
+     protected void playHurtSound(DamageSource damageSource) {
+         this.resetAmbientSoundTime();
+@@ -439,6 +461,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+             output.putString("Paper.DespawnInPeacefulOverride", this.despawnInPeacefulOverride.name());
+         }
+         // Paper end - allow changing despawnInPeaceful
++        output.putInt("Purpur.ticksSinceLastInteraction", this.ticksSinceLastInteraction); // Purpur - Entity lifespan
+     }
+ 
+     @Override
+@@ -466,6 +489,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+         this.lootTableSeed = input.getLongOr("DeathLootTableSeed", 0L);
+         this.setNoAi(input.getBooleanOr("NoAI", false));
+         this.aware = input.getBooleanOr("Bukkit.Aware", true); // CraftBukkit
++        this.ticksSinceLastInteraction = input.getIntOr("Purpur.ticksSinceLastInteraction", 0); // Purpur- Entity lifespan
+         // Paper start - allow changing despawnInPeaceful
+         this.despawnInPeacefulOverride = readDespawnInPeacefulOverride(input);
+     }
+@@ -1246,7 +1270,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+             );
+         }
+ 
+-        this.setLeftHanded(random.nextFloat() < 0.05F);
++        this.setLeftHanded(random.nextFloat() < level.getLevel().purpurConfig.entityLeftHandedChance); // Purpur - Changeable Mob Left Handed Chance
+         return spawnGroupData;
+     }
+ 
+@@ -1597,6 +1621,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+         }
+ 
+         this.lungeForwardMaybe();
++        if (target instanceof net.minecraft.server.level.ServerPlayer) this.ticksSinceLastInteraction = 0; // Purpur - Entity lifespan
+         return flag;
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/attributes/RangedAttribute.java.patch

@@ -0,0 +1,18 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/attributes/RangedAttribute.java b/net/minecraft/world/entity/ai/attributes/RangedAttribute.java
+index 0a0e5d9fd64182c1bed4c0aa6a40d8b2cdf8bc9d..353d571b4a2bf18414a08239abe2b079e3750d89 100644
+--- a/net/minecraft/world/entity/ai/attributes/RangedAttribute.java
++++ b/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 - Add attribute clamping and armor limit config
+         return Double.isNaN(value) ? this.minValue : Mth.clamp(value, this.minValue, this.maxValue);
+     }
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/behavior/AcquirePoi.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+index 278addb7dbe4f57e99fb91ce1cd1bf3559e239a3..3e0fd09a0c0047cfe100e878186471090f8909a0 100644
+--- a/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
++++ b/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+@@ -85,7 +85,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, acquirablePois, predicate1, mob.blockPosition(), 48, 48*48, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes);
++                            io.papermc.paper.util.PoiAccess.findNearestPoiPositions(poiManager, acquirablePois, predicate1, mob.blockPosition(), level.purpurConfig.villagerAcquirePoiSearchRadius, level.purpurConfig.villagerAcquirePoiSearchRadius*level.purpurConfig.villagerAcquirePoiSearchRadius, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes); // Purpur - Configurable villager search radius
+                             final Set<Pair<Holder<PoiType>, BlockPos>> set = new java.util.HashSet<>(poiposes.size());
+                             for (final Pair<Holder<PoiType>, BlockPos> poiPose : poiposes) {
+                                 if (predicate.test(level, poiPose.getSecond())) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/behavior/InteractWithDoor.java.patch

@@ -0,0 +1,37 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/InteractWithDoor.java b/net/minecraft/world/entity/ai/behavior/InteractWithDoor.java
+index df185d375658d765b07648dfb42ea56c84be671e..5c845d78e8baee41809e0678e3d99523368a2882 100644
+--- a/net/minecraft/world/entity/ai/behavior/InteractWithDoor.java
++++ b/net/minecraft/world/entity/ai/behavior/InteractWithDoor.java
+@@ -55,7 +55,7 @@ public class InteractWithDoor {
+                             Node nextNode = path.getNextNode();
+                             BlockPos blockPos = previousNode.asBlockPos();
+                             BlockState blockState = level.getBlockState(blockPos);
+-                            if (blockState.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock)) {
++                            if (blockState.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock)&& !DoorBlock.requiresRedstone(entity.level(), blockState, blockPos)) { // Purpur - Option to make doors require redstone
+                                 DoorBlock doorBlock = (DoorBlock)blockState.getBlock();
+                                 if (!doorBlock.isOpen(blockState)) {
+                                     // CraftBukkit start - entities opening doors
+@@ -72,7 +72,7 @@ public class InteractWithDoor {
+ 
+                             BlockPos blockPos1 = nextNode.asBlockPos();
+                             BlockState blockState1 = level.getBlockState(blockPos1);
+-                            if (blockState1.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock)) {
++                            if (blockState1.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock) && !DoorBlock.requiresRedstone(entity.level(), blockState1, blockPos1)) { // Purpur - Option to make doors require redstone
+                                 DoorBlock doorBlock1 = (DoorBlock)blockState1.getBlock();
+                                 if (!doorBlock1.isOpen(blockState1)) {
+                                     // CraftBukkit start - entities opening doors
+@@ -118,7 +118,7 @@ public class InteractWithDoor {
+                     iterator.remove();
+                 } else {
+                     BlockState blockState = level.getBlockState(blockPos);
+-                    if (!blockState.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock)) {
++                    if (!blockState.is(BlockTags.MOB_INTERACTABLE_DOORS, state -> state.getBlock() instanceof DoorBlock) || DoorBlock.requiresRedstone(entity.level(), blockState, blockPos)) { // Purpur - Option to make doors require redstone
+                         iterator.remove();
+                     } else {
+                         DoorBlock doorBlock = (DoorBlock)blockState.getBlock();

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/behavior/ShowTradesToPlayer.java.patch

@@ -0,0 +1,18 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/ShowTradesToPlayer.java b/net/minecraft/world/entity/ai/behavior/ShowTradesToPlayer.java
+index 338f9850a9ee968ade1a5554936a10b8a3786fe5..8cac46b6fd025f7f10b17903579f021482ed4b18 100644
+--- a/net/minecraft/world/entity/ai/behavior/ShowTradesToPlayer.java
++++ b/net/minecraft/world/entity/ai/behavior/ShowTradesToPlayer.java
+@@ -45,6 +45,7 @@ public class ShowTradesToPlayer extends Behavior<Villager> {
+ 
+     @Override
+     public boolean canStillUse(ServerLevel level, Villager entity, long gameTime) {
++        if (!entity.level().purpurConfig.villagerDisplayTradeItem) return false; // Purpur - Option for villager display trade item
+         return this.checkExtraStartConditions(level, entity)
+             && this.lookTime > 0
+             && entity.getBrain().getMemory(MemoryModuleType.INTERACTION_TARGET).isPresent();

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/behavior/TransportItemsBetweenContainers.java.patch

@@ -0,0 +1,62 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/TransportItemsBetweenContainers.java b/net/minecraft/world/entity/ai/behavior/TransportItemsBetweenContainers.java
+index 3741e32fa1aa85e3b5b45c3b05fcb3a0a807a6e7..2a7cda7fbc400a13e7ab71a6a82496068d9c7ae6 100644
+--- a/net/minecraft/world/entity/ai/behavior/TransportItemsBetweenContainers.java
++++ b/net/minecraft/world/entity/ai/behavior/TransportItemsBetweenContainers.java
+@@ -285,7 +285,7 @@ public class TransportItemsBetweenContainers extends Behavior<PathfinderMob> {
+             LevelChunk chunkNow = level.getChunkSource().getChunkNow(chunkPos.x, chunkPos.z);
+             if (chunkNow != null) {
+                 for (BlockEntity blockEntity : chunkNow.getBlockEntities().values()) {
+-                    if (blockEntity instanceof ChestBlockEntity chestBlockEntity) {
++                    if (blockEntity instanceof net.minecraft.world.level.block.entity.BaseContainerBlockEntity chestBlockEntity) { // Purpur - copper golem can place items in barrels or shulkers option
+                         double d1 = chestBlockEntity.getBlockPos().distToCenterSqr(mob.position());
+                         if (d1 < d) {
+                             TransportItemsBetweenContainers.TransportItemTarget transportItemTarget1 = this.isTargetValidToPick(
+@@ -369,7 +369,11 @@ public class TransportItemsBetweenContainers extends Behavior<PathfinderMob> {
+     }
+ 
+     private boolean isTargetBlocked(Level level, TransportItemsBetweenContainers.TransportItemTarget target) {
+-        return ChestBlock.isChestBlockedAt(level, target.pos);
++        // Purpur start - copper golem can place items in barrels or shulkers option
++        boolean isBarrelBlocked = !level.purpurConfig.copperGolemCanOpenBarrel && target.state.is(net.minecraft.world.level.block.Blocks.BARREL);
++        boolean isShulkerBlocked = !level.purpurConfig.copperGolemCanOpenShulker && target.blockEntity instanceof net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity shulkerBoxBlockEntity && !net.minecraft.world.level.block.ShulkerBoxBlock.canOpen(target.state, level, target.pos, shulkerBoxBlockEntity);
++        return target.state.is(net.minecraft.world.level.block.Blocks.BARREL) ? isBarrelBlocked : isShulkerBlocked || net.minecraft.world.level.block.ChestBlock.isChestBlockedAt(level, target.pos);
++        // Purpur end - copper golem can place items in barrels or shulkers option
+     }
+ 
+     private boolean targetHasNotChanged(Level level, TransportItemsBetweenContainers.TransportItemTarget target) {
+@@ -446,7 +450,7 @@ public class TransportItemsBetweenContainers extends Behavior<PathfinderMob> {
+     }
+ 
+     private boolean isWantedBlock(PathfinderMob mob, BlockState state) {
+-        return isPickingUpItems(mob) ? this.sourceBlockType.test(state) : this.destinationBlockType.test(state);
++        return isPickingUpItems(mob) ? this.sourceBlockType.test(state) : (mob.level().purpurConfig.copperGolemCanOpenBarrel && state.is(net.minecraft.world.level.block.Blocks.BARREL)) || (mob.level().purpurConfig.copperGolemCanOpenShulker && state.is(net.minecraft.tags.BlockTags.SHULKER_BOXES)) || this.destinationBlockType.test(state); // Purpur - copper golem can place items in barrels or shulkers option
+     }
+ 
+     private static double getInteractionRange(PathfinderMob mob) {
+@@ -488,6 +492,11 @@ public class TransportItemsBetweenContainers extends Behavior<PathfinderMob> {
+     }
+ 
+     private static boolean matchesLeavingItemsRequirement(PathfinderMob mob, Container container) {
++        // Purpur start - copper golem can place items in barrels or shulkers option
++        if (mob.level().purpurConfig.copperGolemCanOpenShulker && container instanceof net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity && mob.getMainHandItem().is(net.minecraft.tags.ItemTags.SHULKER_BOXES)) {
++            return false;
++        }
++        // Purpur end - copper golem can place items in barrels or shulkers option
+         return container.isEmpty() || hasItemMatchingHandItem(mob, container);
+     }
+ 
+@@ -525,7 +534,7 @@ public class TransportItemsBetweenContainers extends Behavior<PathfinderMob> {
+         int i = 0;
+ 
+         for (ItemStack itemStack : container) {
+-            if (!itemStack.isEmpty()) {
++            if (!itemStack.isEmpty() && (!(container instanceof net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity) || !itemStack.is(net.minecraft.tags.ItemTags.SHULKER_BOXES))) { // Purpur - copper golem can place items in barrels or shulkers option
+                 int min = Math.min(itemStack.getCount(), 16);
+                 return container.removeItem(i, min);
+             }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/goal/SwellGoal.java.patch

@@ -0,0 +1,25 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/goal/SwellGoal.java b/net/minecraft/world/entity/ai/goal/SwellGoal.java
+index 2bc0c7f5973d5d5695ec291f404a836a78e8348e..ccbd344a49a568e97606c364082ab3f74ad5e6ed 100644
+--- a/net/minecraft/world/entity/ai/goal/SwellGoal.java
++++ b/net/minecraft/world/entity/ai/goal/SwellGoal.java
+@@ -47,6 +47,14 @@ public class SwellGoal extends Goal {
+             this.creeper.setSwellDir(-1);
+         } else {
+             this.creeper.setSwellDir(1);
++            // Purpur start - option to allow creeper to encircle target when fusing
++            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 - option to allow creeper to encircle target when fusing
+         }
+     }
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java b/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
+index 066faa704338c573472381e1ebd063e0d52aaaa4..1f96fd5085bacb4c584576c7cb9f51e7898e9b03 100644
+--- a/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
++++ b/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(), level.purpurConfig.villagerNearestBedSensorSearchRadius, PoiManager.Occupancy.ANY, false, Integer.MAX_VALUE, poiposes); // Purpur - Configurable villager search radius
+             Path path = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes));
+             // Paper end - optimise POI access
+             if (path != null && path.canReach()) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/Animal.java.patch

@@ -0,0 +1,42 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/Animal.java b/net/minecraft/world/entity/animal/Animal.java
+index 023b68549e3b185d8ad2f505f34bb59556bbf961..2e7e7c1913f5cbc20ce116c5ae3e185fc83094c0 100644
+--- a/net/minecraft/world/entity/animal/Animal.java
++++ b/net/minecraft/world/entity/animal/Animal.java
+@@ -146,7 +146,7 @@ public abstract class Animal extends AgeableMob {
+         ItemStack itemInHand = player.getItemInHand(hand);
+         if (this.isFood(itemInHand)) {
+             int age = this.getAge();
+-            if (player instanceof ServerPlayer serverPlayer && age == 0 && this.canFallInLove()) {
++            if (player instanceof ServerPlayer serverPlayer && age == 0 && this.canFallInLove() && (this.level().purpurConfig.animalBreedingCooldownSeconds <= 0 || !this.level().hasBreedingCooldown(player.getUUID(), this.getClass()))) { // Purpur - Add adjustable breeding cooldown to config
+                 final ItemStack breedCopy = itemInHand.copy(); // Paper - Fix EntityBreedEvent copying
+                 this.usePlayerItem(player, hand, itemInHand);
+                 this.setInLove(serverPlayer, breedCopy); // Paper - Fix EntityBreedEvent copying
+@@ -227,10 +227,20 @@ public abstract class Animal extends AgeableMob {
+     public void spawnChildFromBreeding(ServerLevel level, Animal partner) {
+         AgeableMob breedOffspring = this.getBreedOffspring(level, partner);
+         if (breedOffspring != null) {
+-            breedOffspring.setBaby(true);
+-            breedOffspring.snapTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F);
++            //breedOffspring.setBaby(true); // Purpur - Add adjustable breeding cooldown to config - moved down
++            //breedOffspring.snapTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F); // Purpur - Add adjustable breeding cooldown to config - moved down
+             // CraftBukkit start - Call EntityBreedEvent
+             ServerPlayer breeder = Optional.ofNullable(this.getLoveCause()).or(() -> Optional.ofNullable(partner.getLoveCause())).orElse(null);
++            // Purpur start - Add adjustable breeding cooldown to config
++            if (breeder != null && level.purpurConfig.animalBreedingCooldownSeconds > 0) {
++                if (level.hasBreedingCooldown(breeder.getUUID(), this.getClass())) {
++                    return;
++                }
++                level.addBreedingCooldown(breeder.getUUID(), this.getClass());
++            }
++            breedOffspring.setBaby(true);
++            breedOffspring.snapTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F);
++            // Purpur end - Add adjustable breeding cooldown to config
+             int experience = this.getRandom().nextInt(7) + 1;
+             org.bukkit.event.entity.EntityBreedEvent entityBreedEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityBreedEvent(breedOffspring, this, partner, breeder, this.breedItem, experience);
+             if (entityBreedEvent.isCancelled()) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/bee/Bee.java.patch

@@ -0,0 +1,81 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/bee/Bee.java b/net/minecraft/world/entity/animal/bee/Bee.java
+index 0cbcf23b6edba2305dfbbc95abb06a90a6edd42b..7b9280526af353c3ab1f32e5195499e773731352 100644
+--- a/net/minecraft/world/entity/animal/bee/Bee.java
++++ b/net/minecraft/world/entity/animal/bee/Bee.java
+@@ -171,7 +171,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+         // Paper end - Fix MC-167279
+         this.lookControl = new Bee.BeeLookControl(this);
+         this.setPathfindingMalus(PathType.DANGER_FIRE, -1.0F);
+-        this.setPathfindingMalus(PathType.WATER, -1.0F);
++        if (this.level().purpurConfig.beeCanInstantlyStartDrowning) this.setPathfindingMalus(PathType.WATER, -1.0F); // Purpur - bee can instantly start drowning in water option
+         this.setPathfindingMalus(PathType.WATER_BORDER, 16.0F);
+         this.setPathfindingMalus(PathType.COCOA, -1.0F);
+         this.setPathfindingMalus(PathType.FENCE, -1.0F);
+@@ -360,13 +360,19 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+         if (this.stayOutOfHiveCountdown <= 0 && !this.beePollinateGoal.isPollinating() && !this.hasStung() && this.getTarget() == null) {
+             boolean flag = this.hasNectar()
+                 || this.isTiredOfLookingForNectar()
+-                || this.level().environmentAttributes().getValue(EnvironmentAttributes.BEES_STAY_IN_HIVE, this.position());
++                || this.level().environmentAttributes().getValue(EnvironmentAttributes.BEES_STAY_IN_HIVE, this.position()) || isNightOrRaining(this.level()); // Purpur - Bee can work when raining or at night
+             return flag && !this.isHiveNearFire();
+         } else {
+             return false;
+         }
+     }
+ 
++    // Purpur start - Bee can work when raining or at night
++    public static boolean isNightOrRaining(Level level) {
++        return level.dimensionType().hasSkyLight() && (level.isDarkOutside() && !level.purpurConfig.beeCanWorkAtNight || level.isRaining() && !level.purpurConfig.beeCanWorkInRain); // Purpur - Bee can work when raining or at night
++    }
++    // Purpur end - Bee can work when raining or at night
++
+     public void setStayOutOfHiveCountdown(int stayOutOfHiveCountdown) {
+         this.stayOutOfHiveCountdown = stayOutOfHiveCountdown;
+     }
+@@ -387,7 +393,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+     @Override
+     protected void customServerAiStep(ServerLevel level) {
+         boolean hasStung = this.hasStung();
+-        if (this.isInWater()) {
++        if (this.level().purpurConfig.beeCanInstantlyStartDrowning && this.isInWater()) { // Purpur - bee can instantly start drowning in water option
+             this.underWaterTicks++;
+         } else {
+             this.underWaterTicks = 0;
+@@ -397,6 +403,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+             this.hurtServer(level, this.damageSources().drown(), 1.0F);
+         }
+ 
++        if (hasStung && !this.level().purpurConfig.beeDiesAfterSting) setHasStung(false); else // Purpur - Stop bees from dying after stinging
+         if (hasStung) {
+             this.timeSinceSting++;
+             if (this.timeSinceSting % 5 == 0 && this.random.nextInt(Mth.clamp(1200 - this.timeSinceSting, 1, 1200)) == 0) {
+@@ -1130,6 +1137,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+                     Bee.this.savedFlowerPos = optional.get();
+                     Bee.this.navigation
+                         .moveTo(Bee.this.savedFlowerPos.getX() + 0.5, Bee.this.savedFlowerPos.getY() + 0.5, Bee.this.savedFlowerPos.getZ() + 0.5, 1.2F);
++                    new org.purpurmc.purpur.event.entity.BeeFoundFlowerEvent((org.bukkit.entity.Bee) Bee.this.getBukkitEntity(), org.bukkit.craftbukkit.util.CraftLocation.toBukkit(Bee.this.savedFlowerPos, Bee.this.level())).callEvent(); // Purpur - Bee API
+                     return true;
+                 } else {
+                     Bee.this.remainingCooldownBeforeLocatingNewFlower = Mth.nextInt(Bee.this.random, 20, 60);
+@@ -1176,6 +1184,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 : org.bukkit.craftbukkit.util.CraftLocation.toBukkit(Bee.this.savedFlowerPos, Bee.this.level()), Bee.this.hasNectar()).callEvent(); // Purpur - Bee API
+         }
+ 
+         @Override
+@@ -1222,6 +1231,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(), org.bukkit.craftbukkit.util.CraftLocation.toBukkit(Bee.this.savedFlowerPos, Bee.this.level())).callEvent(); // Purpur - Bee API
+                             this.successfulPollinatingTicks++;
+                             if (Bee.this.random.nextFloat() < 0.05F && this.successfulPollinatingTicks > this.lastSoundPlayedTick + 60) {
+                                 this.lastSoundPlayedTick = this.successfulPollinatingTicks;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/cow/AbstractCow.java.patch

@@ -0,0 +1,98 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/cow/AbstractCow.java b/net/minecraft/world/entity/animal/cow/AbstractCow.java
+index e10f7d1b264a85798de063b4387bab62621bf54b..f6f251227db315b58bee45f8011624a347eb8fea 100644
+--- a/net/minecraft/world/entity/animal/cow/AbstractCow.java
++++ b/net/minecraft/world/entity/animal/cow/AbstractCow.java
+@@ -40,7 +40,7 @@ public abstract class AbstractCow extends Animal {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+         this.goalSelector.addGoal(1, new PanicGoal(this, 2.0));
+         this.goalSelector.addGoal(2, new BreedGoal(this, 1.0));
+-        this.goalSelector.addGoal(3, new TemptGoal(this, 1.25, itemStack -> itemStack.is(ItemTags.COW_FOOD), false));
++        this.goalSelector.addGoal(3, new TemptGoal(this, 1.25, itemStack -> level().purpurConfig.cowFeedMushrooms > 0 && (itemStack.is(net.minecraft.world.level.block.Blocks.RED_MUSHROOM.asItem()) || itemStack.is(net.minecraft.world.level.block.Blocks.BROWN_MUSHROOM.asItem())) || itemStack.is(ItemTags.COW_FOOD), false)); // Purpur - Cows eat mushrooms
+         this.goalSelector.addGoal(4, new FollowParentGoal(this, 1.25));
+         this.goalSelector.addGoal(5, new WaterAvoidingRandomStrollGoal(this, 1.0));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));
+@@ -96,6 +96,10 @@ public abstract class AbstractCow extends Animal {
+             ItemStack itemStack = ItemUtils.createFilledResult(itemInHand, player, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getItemStack())); // CraftBukkit
+             player.setItemInHand(hand, itemStack);
+             return InteractionResult.SUCCESS;
++        // Purpur start - Cows eat mushrooms - feed mushroom to change to mooshroom
++        } else if (level().purpurConfig.cowFeedMushrooms > 0 && this.getType() != EntityType.MOOSHROOM && isMushroom(itemInHand)) {
++            return this.feedMushroom(player, itemInHand);
++        // Purpur end - Cows eat mushrooms
+         } else {
+             return super.mobInteract(player, hand);
+         }
+@@ -105,4 +109,67 @@ public abstract class AbstractCow extends Animal {
+     public EntityDimensions getDefaultDimensions(Pose pose) {
+         return this.isBaby() ? BABY_DIMENSIONS : super.getDefaultDimensions(pose);
+     }
++
++    // Purpur start - Cows eat mushrooms - feed mushroom to change to mooshroom
++    private int redMushroomsFed = 0;
++    private int brownMushroomsFed = 0;
++
++    private boolean isMushroom(ItemStack stack) {
++        return stack.getItem() == net.minecraft.world.level.block.Blocks.RED_MUSHROOM.asItem() || stack.getItem() == net.minecraft.world.level.block.Blocks.BROWN_MUSHROOM.asItem();
++    }
++
++    private int incrementFeedCount(ItemStack stack) {
++        if (stack.getItem() == net.minecraft.world.level.block.Blocks.RED_MUSHROOM.asItem()) {
++            return ++redMushroomsFed;
++        } else {
++            return ++brownMushroomsFed;
++        }
++    }
++
++    private InteractionResult feedMushroom(Player player, ItemStack stack) {
++        level().broadcastEntityEvent(this, (byte) 18); // hearts
++        playSound(SoundEvents.COW_MILK, 1.0F, 1.0F);
++        if (incrementFeedCount(stack) < level().purpurConfig.cowFeedMushrooms) {
++            if (!player.getAbilities().instabuild) {
++                stack.shrink(1);
++            }
++            return InteractionResult.CONSUME; // require 5 mushrooms to transform (prevents mushroom duping)
++        }
++        MushroomCow mooshroom = EntityType.MOOSHROOM.create(level(), net.minecraft.world.entity.EntitySpawnReason.CONVERSION);
++        if (mooshroom == null) {
++            return InteractionResult.PASS;
++        }
++        if (stack.getItem() == net.minecraft.world.level.block.Blocks.BROWN_MUSHROOM.asItem()) {
++            mooshroom.setVariant(MushroomCow.Variant.BROWN);
++        } else {
++            mooshroom.setVariant(MushroomCow.Variant.RED);
++        }
++        mooshroom.snapTo(this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot());
++        mooshroom.setHealth(this.getHealth());
++        mooshroom.setAge(getAge());
++        mooshroom.copyPosition(this);
++        mooshroom.setYBodyRot(this.yBodyRot);
++        mooshroom.setYHeadRot(this.getYHeadRot());
++        mooshroom.yRotO = this.yRotO;
++        mooshroom.xRotO = this.xRotO;
++        if (this.hasCustomName()) {
++            mooshroom.setCustomName(this.getCustomName());
++        }
++        if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTransformEvent(this, mooshroom, org.bukkit.event.entity.EntityTransformEvent.TransformReason.INFECTION).isCancelled()) {
++            return InteractionResult.PASS;
++        }
++        this.level().addFreshEntity(mooshroom);
++        this.remove(RemovalReason.DISCARDED, org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
++        if (!player.getAbilities().instabuild) {
++            stack.shrink(1);
++        }
++        for (int i = 0; i < 15; ++i) {
++            ((net.minecraft.server.level.ServerLevel) level()).sendParticlesSource(((net.minecraft.server.level.ServerLevel) level()).players(), null, net.minecraft.core.particles.ParticleTypes.HAPPY_VILLAGER,
++                    false, true,
++                    getX() + random.nextFloat(), getY() + (random.nextFloat() * 2), getZ() + random.nextFloat(), 1,
++                    random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, 0);
++        }
++        return InteractionResult.SUCCESS;
++    }
++    // Purpur end - Cows eat mushrooms
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/dolphin/Dolphin.java.patch

@@ -0,0 +1,55 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/dolphin/Dolphin.java b/net/minecraft/world/entity/animal/dolphin/Dolphin.java
+index 3a3c9694d3a704aaaa241bd8601c7fd2439436cc..50b8abff1e20855ba8c8acb225c251a1223b8b58 100644
+--- a/net/minecraft/world/entity/animal/dolphin/Dolphin.java
++++ b/net/minecraft/world/entity/animal/dolphin/Dolphin.java
+@@ -75,6 +75,7 @@ public class Dolphin extends AgeableWaterCreature {
+     public static final float BABY_SCALE = 0.65F;
+     private static final boolean DEFAULT_GOT_FISH = false;
+     @Nullable public BlockPos treasurePos;
++    private boolean isNaturallyAggressiveToPlayers; // Purpur - Dolphins naturally aggressive to players chance
+ 
+     public Dolphin(EntityType<? extends Dolphin> type, Level level) {
+         super(type, level);
+@@ -90,6 +91,7 @@ public class Dolphin extends AgeableWaterCreature {
+         this.setAirSupply(this.getMaxAirSupply());
+         this.setXRot(0.0F);
+         SpawnGroupData spawnGroupData1 = Objects.requireNonNullElseGet(spawnGroupData, () -> new AgeableMob.AgeableMobGroupData(0.1F));
++        this.isNaturallyAggressiveToPlayers = level.getLevel().purpurConfig.dolphinNaturallyAggressiveToPlayersChance > 0.0D && random.nextDouble() <= level.getLevel().purpurConfig.dolphinNaturallyAggressiveToPlayersChance; // Purpur - Dolphins naturally aggressive to players chance
+         return super.finalizeSpawn(level, difficulty, spawnReason, spawnGroupData1);
+     }
+ 
+@@ -155,17 +157,19 @@ public class Dolphin extends AgeableWaterCreature {
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new BreathAirGoal(this));
+         this.goalSelector.addGoal(0, new TryFindWaterGoal(this));
++        this.goalSelector.addGoal(1, new MeleeAttackGoal(this, 1.2000000476837158D, true)); // Purpur - Dolphins naturally aggressive to players chance
+         this.goalSelector.addGoal(1, new Dolphin.DolphinSwimToTreasureGoal(this));
+         this.goalSelector.addGoal(2, new Dolphin.DolphinSwimWithPlayerGoal(this, 4.0));
+         this.goalSelector.addGoal(4, new RandomSwimmingGoal(this, 1.0, 10));
+         this.goalSelector.addGoal(4, new RandomLookAroundGoal(this));
+         this.goalSelector.addGoal(5, new LookAtPlayerGoal(this, Player.class, 6.0F));
+         this.goalSelector.addGoal(5, new DolphinJumpGoal(this, 10));
+-        this.goalSelector.addGoal(6, new MeleeAttackGoal(this, 1.2F, true));
++        //this.goalSelector.addGoal(6, new MeleeAttackGoal(this, 1.2F, true)); // Purpur - moved up - Dolphins naturally aggressive to players chance
+         this.goalSelector.addGoal(8, new Dolphin.PlayWithItemsGoal());
+         this.goalSelector.addGoal(8, new FollowBoatGoal(this));
+         this.goalSelector.addGoal(9, new AvoidEntityGoal<>(this, Guardian.class, 8.0F, 1.0, 1.0));
+         this.targetSelector.addGoal(1, new HurtByTargetGoal(this, Guardian.class).setAlertOthers());
++        this.targetSelector.addGoal(2, new net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, (ignored, ignored2) -> isNaturallyAggressiveToPlayers)); // Purpur - Dolphins naturally aggressive to players chance
+     }
+ 
+     public static AttributeSupplier.Builder createAttributes() {
+@@ -392,6 +396,7 @@ public class Dolphin extends AgeableWaterCreature {
+ 
+         @Override
+         public boolean canUse() {
++            if (this.dolphin.level().purpurConfig.dolphinDisableTreasureSearching) return false; // Purpur - Add option to disable dolphin treasure searching
+             return this.dolphin.gotFish() && this.dolphin.getAirSupply() >= 100;
+         }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/equine/Llama.java.patch

@@ -0,0 +1,50 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/equine/Llama.java b/net/minecraft/world/entity/animal/equine/Llama.java
+index 1522efc1e6937bc8a24a2df77d5421ae04a6642b..cceb66525a4d017b2db21bd301e63670c639223f 100644
+--- a/net/minecraft/world/entity/animal/equine/Llama.java
++++ b/net/minecraft/world/entity/animal/equine/Llama.java
+@@ -76,6 +76,7 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+     boolean didSpit;
+     private @Nullable Llama caravanHead;
+     public @Nullable Llama caravanTail; // Paper - public
++    public boolean shouldJoinCaravan = true; // Purpur - Llama API
+ 
+     public Llama(EntityType<? extends Llama> type, Level level) {
+         super(type, level);
+@@ -105,6 +106,7 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+         super.addAdditionalSaveData(output);
+         output.store("Variant", Llama.Variant.LEGACY_CODEC, this.getVariant());
+         output.putInt("Strength", this.getStrength());
++        output.putBoolean("Purpur.ShouldJoinCaravan", shouldJoinCaravan); // Purpur - Llama API
+     }
+ 
+     @Override
+@@ -112,6 +114,7 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+         this.setStrength(input.getIntOr("Strength", 0));
+         super.readAdditionalSaveData(input);
+         this.setVariant(input.read("Variant", Llama.Variant.LEGACY_CODEC).orElse(Llama.Variant.DEFAULT));
++        this.shouldJoinCaravan = input.getBooleanOr("Purpur.ShouldJoinCaravan", true); // Purpur - Llama API
+     }
+ 
+     @Override
+@@ -388,6 +391,7 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+ 
+     public void leaveCaravan() {
+         if (this.caravanHead != null) {
++            new org.purpurmc.purpur.event.entity.LlamaLeaveCaravanEvent((org.bukkit.entity.Llama) getBukkitEntity()).callEvent(); // Purpur - Llama API
+             this.caravanHead.caravanTail = null;
+         }
+ 
+@@ -395,6 +399,7 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+     }
+ 
+     public void joinCaravan(Llama caravanHead) {
++        if (!this.level().purpurConfig.llamaJoinCaravans || !shouldJoinCaravan || !new org.purpurmc.purpur.event.entity.LlamaJoinCaravanEvent((org.bukkit.entity.Llama) getBukkitEntity(), (org.bukkit.entity.Llama) caravanHead.getBukkitEntity()).callEvent()) return; // Purpur - Llama API // Purpur - Config to disable Llama caravans
+         this.caravanHead = caravanHead;
+         this.caravanHead.caravanTail = this;
+     }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/feline/Cat.java.patch

@@ -0,0 +1,34 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/feline/Cat.java b/net/minecraft/world/entity/animal/feline/Cat.java
+index f17d7a4ef7061d6ede9a755b5a77324a28c3eeaa..6acd39413ab4fed1eaf251d3b6d9b9e184060e5c 100644
+--- a/net/minecraft/world/entity/animal/feline/Cat.java
++++ b/net/minecraft/world/entity/animal/feline/Cat.java
+@@ -354,6 +354,14 @@ public class Cat extends TamableAnimal {
+         return this.isTame() && otherAnimal instanceof Cat cat && cat.isTame() && super.canMate(otherAnimal);
+     }
+ 
++    // Purpur start - Configurable default collar color
++    @Override
++    public void tame(Player player) {
++        setCollarColor(level().purpurConfig.catDefaultCollarColor);
++        super.tame(player);
++    }
++    // Purpur end - Configurable default collar color
++
+     @Override
+     public @Nullable SpawnGroupData finalizeSpawn(
+         ServerLevelAccessor level, DifficultyInstance difficulty, EntitySpawnReason spawnReason, @Nullable SpawnGroupData spawnGroupData
+@@ -451,7 +459,7 @@ public class Cat extends TamableAnimal {
+     }
+ 
+     private void tryToTame(Player player) {
+-        if (this.random.nextInt(3) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit
++        if (((this.level().purpurConfig.alwaysTameInCreative && player.hasInfiniteMaterials()) || this.random.nextInt(3) == 0) && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit // Purpur - Config to always tame in Creative
+             this.tame(player);
+             this.setOrderedToSit(true);
+             this.level().broadcastEntityEvent(this, EntityEvent.TAMING_SUCCEEDED);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/feline/Ocelot.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/feline/Ocelot.java b/net/minecraft/world/entity/animal/feline/Ocelot.java
+index cf940de8767df6d07551d7a221a0e87df4e41785..94fdbae92dabf7505a7c7b518d4c07b4f68c8e9c 100644
+--- a/net/minecraft/world/entity/animal/feline/Ocelot.java
++++ b/net/minecraft/world/entity/animal/feline/Ocelot.java
+@@ -234,7 +234,7 @@ public class Ocelot extends Animal {
+     public boolean checkSpawnObstruction(LevelReader level) {
+         if (level.isUnobstructed(this) && !level.containsAnyLiquid(this.getBoundingBox())) {
+             BlockPos blockPos = this.blockPosition();
+-            if (blockPos.getY() < level.getSeaLevel()) {
++            if (!level().purpurConfig.ocelotSpawnUnderSeaLevel && blockPos.getY() < level.getSeaLevel()) { // Purpur - Option Ocelot Spawn Under Sea Level
+                 return false;
+             }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/fish/WaterAnimal.java.patch

@@ -0,0 +1,20 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/fish/WaterAnimal.java b/net/minecraft/world/entity/animal/fish/WaterAnimal.java
+index 3965cb8ae6fdd8d9d0135e6695463e6bef624fe2..9ff11eb96bc8d0c9bd611c8d45d8799c67f1fb61 100644
+--- a/net/minecraft/world/entity/animal/fish/WaterAnimal.java
++++ b/net/minecraft/world/entity/animal/fish/WaterAnimal.java
+@@ -76,8 +76,7 @@ public abstract class WaterAnimal extends PathfinderMob {
+         seaLevel = level.getMinecraftWorld().paperConfig().entities.spawning.wateranimalSpawnHeight.maximum.or(seaLevel);
+         i = level.getMinecraftWorld().paperConfig().entities.spawning.wateranimalSpawnHeight.minimum.or(i);
+         // Paper end - Make water animal spawn height configurable
+-        return pos.getY() >= i
+-            && pos.getY() <= seaLevel
++        return ((spawnReason == EntitySpawnReason.SPAWNER && level.getMinecraftWorld().purpurConfig.spawnerFixMC238526) || (pos.getY() >= i && pos.getY() <= seaLevel)) // Purpur - MC-238526 - Fix spawner not spawning water animals correctly
+             && level.getFluidState(pos.below()).is(FluidTags.WATER)
+             && level.getBlockState(pos.above()).is(Blocks.WATER);
+     }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/golem/CopperGolemAi.java.patch

@@ -0,0 +1,31 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/golem/CopperGolemAi.java b/net/minecraft/world/entity/animal/golem/CopperGolemAi.java
+index 56872b4674ae4ce0ebcb6c28ae606265384777cd..fd556e10ff87eac5e965a5eef31cfe0c0f8fbd66 100644
+--- a/net/minecraft/world/entity/animal/golem/CopperGolemAi.java
++++ b/net/minecraft/world/entity/animal/golem/CopperGolemAi.java
+@@ -43,7 +43,7 @@ public class CopperGolemAi {
+     private static final int TICK_TO_START_ON_REACHED_INTERACTION = 1;
+     private static final int TICK_TO_PLAY_ON_REACHED_SOUND = 9;
+     private static final Predicate<BlockState> TRANSPORT_ITEM_SOURCE_BLOCK = state -> state.is(BlockTags.COPPER_CHESTS);
+-    private static final Predicate<BlockState> TRANSPORT_ITEM_DESTINATION_BLOCK = state -> state.is(Blocks.CHEST) || state.is(Blocks.TRAPPED_CHEST);
++    private static final Predicate<BlockState> TRANSPORT_ITEM_DESTINATION_BLOCK = state -> state.is(Blocks.CHEST) || state.is(Blocks.TRAPPED_CHEST); // Purpur - copper golem can place items in barrels or shulkers option - diff on change
+     private static final ImmutableList<SensorType<? extends Sensor<? super CopperGolem>>> SENSOR_TYPES = ImmutableList.of(
+         SensorType.NEAREST_LIVING_ENTITIES, SensorType.HURT_BY
+     );
+@@ -158,6 +158,11 @@ public class CopperGolemAi {
+                 }
+ 
+                 if (integer == 60) {
++                    // Purpur start - copper golem can place items in barrels or shulkers option
++                    if (container instanceof net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity shulkerBoxBlockEntity && shulkerBoxBlockEntity.openCount > 0) {
++                        container.stopOpen(copperGolem);
++                    }
++                    // Purpur end - copper golem can place items in barrels or shulkers option
+                     if (container.getEntitiesWithContainerOpen().contains(pathfinderMob)) {
+                         container.stopOpen(copperGolem);
+                     }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/golem/IronGolem.java.patch

@@ -0,0 +1,60 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/golem/IronGolem.java b/net/minecraft/world/entity/animal/golem/IronGolem.java
+index b2c4e93f6063ded665b18ba3b4eaa0eb4cd98732..32425f0aaa748c7f80f2e5cf95ef27238fe50489 100644
+--- a/net/minecraft/world/entity/animal/golem/IronGolem.java
++++ b/net/minecraft/world/entity/animal/golem/IronGolem.java
+@@ -58,13 +58,25 @@ public class IronGolem extends AbstractGolem implements NeutralMob {
+     private static final UniformInt PERSISTENT_ANGER_TIME = TimeUtil.rangeOfSeconds(20, 39);
+     private long persistentAngerEndTime;
+     private @Nullable EntityReference<LivingEntity> persistentAngerTarget;
++    private java.util.@Nullable UUID summoner; // Purpur - Summoner API
+ 
+     public IronGolem(EntityType<? extends IronGolem> type, Level level) {
+         super(type, level);
+     }
+ 
++    // Purpur start - Summoner API
++    public java.util.@Nullable UUID getSummoner() {
++        return summoner;
++    }
++
++    public void setSummoner(java.util.@Nullable UUID summoner) {
++        this.summoner = summoner;
++    }
++    // Purpur end - Summoner API
++
+     @Override
+     protected void registerGoals() {
++        if (this.level().purpurConfig.ironGolemPoppyCalm) this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.ReceiveFlower(this)); // Purpur - Iron golem calm anger options
+         this.goalSelector.addGoal(1, new MeleeAttackGoal(this, 1.0, true));
+         this.goalSelector.addGoal(2, new MoveTowardsTargetGoal(this, 0.9, 32.0F));
+         this.goalSelector.addGoal(2, new MoveBackToVillageGoal(this, 0.6, false));
+@@ -142,6 +154,7 @@ public class IronGolem extends AbstractGolem implements NeutralMob {
+     protected void addAdditionalSaveData(ValueOutput output) {
+         super.addAdditionalSaveData(output);
+         output.putBoolean("PlayerCreated", this.isPlayerCreated());
++        output.storeNullable("Purpur.Summoner", net.minecraft.core.UUIDUtil.CODEC, getSummoner()); // Purpur - Summoner API
+         this.addPersistentAngerSaveData(output);
+     }
+ 
+@@ -149,6 +162,7 @@ public class IronGolem extends AbstractGolem implements NeutralMob {
+     protected void readAdditionalSaveData(ValueInput input) {
+         super.readAdditionalSaveData(input);
+         this.setPlayerCreated(input.getBooleanOr("PlayerCreated", false));
++        this.setSummoner(input.read("Purpur.Summoner", net.minecraft.core.UUIDUtil.CODEC).orElse(null)); // Purpur - Summoner API
+         this.readPersistentAngerSaveData(this.level(), input);
+     }
+ 
+@@ -267,6 +281,7 @@ public class IronGolem extends AbstractGolem implements NeutralMob {
+                 float f = 1.0F + (this.random.nextFloat() - this.random.nextFloat()) * 0.2F;
+                 this.playSound(SoundEvents.IRON_GOLEM_REPAIR, 1.0F, f);
+                 itemInHand.consume(1, player);
++                if (this.level().purpurConfig.ironGolemHealCalm && isAngry() && getHealth() == getMaxHealth()) stopBeingAngry(); // Purpur - Iron golem calm anger options
+                 return InteractionResult.SUCCESS;
+             }
+         }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/parrot/Parrot.java.patch

@@ -0,0 +1,59 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/parrot/Parrot.java b/net/minecraft/world/entity/animal/parrot/Parrot.java
+index 62a26395ee0c3ee450ad3b1ac88bc85523dd27b4..0337ddcd664cd0329d98286214d1aa4daf83e1ea 100644
+--- a/net/minecraft/world/entity/animal/parrot/Parrot.java
++++ b/net/minecraft/world/entity/animal/parrot/Parrot.java
+@@ -164,6 +164,7 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new TamableAnimal.TamableAnimalPanicGoal(1.25));
+         this.goalSelector.addGoal(0, new FloatGoal(this));
++        if (this.level().purpurConfig.parrotBreedable) this.goalSelector.addGoal(1, new net.minecraft.world.entity.ai.goal.BreedGoal(this, 1.0D)); // Purpur - Breedable parrots
+         this.goalSelector.addGoal(1, new LookAtPlayerGoal(this, Player.class, 8.0F));
+         this.goalSelector.addGoal(2, new SitWhenOrderedToGoal(this));
+         this.goalSelector.addGoal(2, new FollowOwnerGoal(this, 1.0, 5.0F, 1.0F));
+@@ -269,7 +270,7 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+             }
+ 
+             if (!this.level().isClientSide()) {
+-                if (this.random.nextInt(10) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit
++                if (((this.level().purpurConfig.alwaysTameInCreative && player.hasInfiniteMaterials()) || this.random.nextInt(10) == 0) && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit // Purpur - Config to always tame in Creative
+                     this.tame(player);
+                     this.level().broadcastEntityEvent(this, EntityEvent.TAMING_SUCCEEDED);
+                 } else {
+@@ -277,6 +278,7 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+                 }
+             }
+ 
++            if (this.level().purpurConfig.parrotBreedable) return super.mobInteract(player, hand); // Purpur - Breedable parrots
+             return InteractionResult.SUCCESS;
+         } else if (!itemInHand.is(ItemTags.PARROT_POISONOUS_FOOD)) {
+             if (!this.isFlying() && this.isTame() && this.isOwnedBy(player)) {
+@@ -301,7 +303,7 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+ 
+     @Override
+     public boolean isFood(ItemStack stack) {
+-        return false;
++        return this.level().purpurConfig.parrotBreedable && stack.is(ItemTags.PARROT_FOOD); // Purpur - Breedable parrots
+     }
+ 
+     public static boolean checkParrotSpawnRules(
+@@ -316,12 +318,12 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+ 
+     @Override
+     public boolean canMate(Animal otherAnimal) {
+-        return false;
++        return super.canMate(otherAnimal); // Purpur - Breedable parrots
+     }
+ 
+     @Override
+     public @Nullable AgeableMob getBreedOffspring(ServerLevel level, AgeableMob partner) {
+-        return null;
++        return level.purpurConfig.parrotBreedable ? EntityType.PARROT.create(level, EntitySpawnReason.BREEDING) : null; // Purpur - Breedable parrots
+     }
+ 
+     @Override

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/pig/Pig.java.patch

@@ -0,0 +1,30 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/pig/Pig.java b/net/minecraft/world/entity/animal/pig/Pig.java
+index 8f5d1e2d98472e8e313fad285bd1629aea4173a9..943bd459554e9f3374978e595ba369a479d44941 100644
+--- a/net/minecraft/world/entity/animal/pig/Pig.java
++++ b/net/minecraft/world/entity/animal/pig/Pig.java
+@@ -138,6 +138,19 @@ public class Pig extends Animal implements ItemSteerable {
+     @Override
+     public InteractionResult mobInteract(Player player, InteractionHand hand) {
+         boolean isFood = this.isFood(player.getItemInHand(hand));
++        // Purpur start - Pigs give saddle back
++        if (level().purpurConfig.pigGiveSaddleBack && player.isSecondaryUseActive() && !isFood && isSaddled() && !isVehicle()) {
++            this.setItemSlot(EquipmentSlot.SADDLE, ItemStack.EMPTY);
++            if (!player.getAbilities().instabuild) {
++                ItemStack saddle = new ItemStack(Items.SADDLE);
++                if (!player.getInventory().add(saddle)) {
++                    player.drop(saddle, false);
++                }
++            }
++            return InteractionResult.SUCCESS;
++        }
++        // Purpur end - Pigs give saddle back
++
+         if (!isFood && this.isSaddled() && !this.isVehicle() && !player.isSecondaryUseActive()) {
+             if (!this.level().isClientSide()) {
+                 player.startRiding(this);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/polarbear/PolarBear.java.patch

@@ -0,0 +1,62 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/polarbear/PolarBear.java b/net/minecraft/world/entity/animal/polarbear/PolarBear.java
+index 8fd0d632e7c6fc7fcb7e9cf141638b5171800799..df4b4a4d32019ef3a667841a0ce4485a8325e897 100644
+--- a/net/minecraft/world/entity/animal/polarbear/PolarBear.java
++++ b/net/minecraft/world/entity/animal/polarbear/PolarBear.java
+@@ -66,6 +66,29 @@ public class PolarBear extends Animal implements NeutralMob {
+         super(type, level);
+     }
+ 
++    // Purpur start - Breedable Polar Bears
++    public boolean canMate(Animal other) {
++        if (other == this) {
++            return false;
++        } else if (this.isStanding()) {
++            return false;
++        } else if (this.getTarget() != null) {
++            return false;
++        } else if (!(other instanceof PolarBear)) {
++            return false;
++        } else {
++            PolarBear bear = (PolarBear) other;
++            if (bear.isStanding()) {
++                return false;
++            }
++            if (bear.getTarget() != null) {
++                return false;
++            }
++            return this.isInLove() && bear.isInLove();
++        }
++    }
++    // Purpur end - Breedable Polar Bears
++
+     @Override
+     public @Nullable AgeableMob getBreedOffspring(ServerLevel level, AgeableMob partner) {
+         return EntityType.POLAR_BEAR.create(level, EntitySpawnReason.BREEDING);
+@@ -73,7 +96,7 @@ public class PolarBear extends Animal implements NeutralMob {
+ 
+     @Override
+     public boolean isFood(ItemStack stack) {
+-        return false;
++        return level().purpurConfig.polarBearBreedableItem != null && stack.getItem() == level().purpurConfig.polarBearBreedableItem; // Purpur - Breedable Polar Bears
+     }
+ 
+     @Override
+@@ -82,6 +105,12 @@ public class PolarBear extends Animal implements NeutralMob {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+         this.goalSelector.addGoal(1, new PolarBear.PolarBearMeleeAttackGoal());
+         this.goalSelector.addGoal(1, new PanicGoal(this, 2.0, mob -> mob.isBaby() ? DamageTypeTags.PANIC_CAUSES : DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES));
++        // Purpur start - Breedable Polar Bears
++        if (level().purpurConfig.polarBearBreedableItem != null) {
++            this.goalSelector.addGoal(2, new net.minecraft.world.entity.ai.goal.BreedGoal(this, 1.0D));
++            this.goalSelector.addGoal(3, new net.minecraft.world.entity.ai.goal.TemptGoal(this, 1.0D, net.minecraft.world.item.crafting.Ingredient.of(level().purpurConfig.polarBearBreedableItem), false));
++        }
++        // Purpur end - Breedable Polar Bears
+         this.goalSelector.addGoal(4, new FollowParentGoal(this, 1.25));
+         this.goalSelector.addGoal(5, new RandomStrollGoal(this, 1.0));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/rabbit/Rabbit.java.patch

@@ -0,0 +1,34 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/rabbit/Rabbit.java b/net/minecraft/world/entity/animal/rabbit/Rabbit.java
+index 17e58836d18afc7cfcc1cf7a8ac5b9e66ceb5f0d..d5e7599c23405eb5a4519e2dfd93ddbe2853fa3b 100644
+--- a/net/minecraft/world/entity/animal/rabbit/Rabbit.java
++++ b/net/minecraft/world/entity/animal/rabbit/Rabbit.java
+@@ -404,10 +404,23 @@ public class Rabbit extends Animal {
+         }
+ 
+         this.setVariant(randomRabbitVariant);
++
++        // Purpur start - Special mobs naturally spawn
++        if (randomRabbitVariant != Variant.EVIL && level.getLevel().purpurConfig.rabbitNaturalToast > 0D && random.nextDouble() <= level.getLevel().purpurConfig.rabbitNaturalToast) {
++            setCustomName(Component.translatable("Toast"));
++        }
++        // Purpur end - Special mobs naturally spawn
++
+         return super.finalizeSpawn(level, difficulty, spawnReason, spawnGroupData);
+     }
+ 
+     private static Rabbit.Variant getRandomRabbitVariant(LevelAccessor level, BlockPos pos) {
++        // Purpur start - Special mobs naturally spawn
++        Level world = level.getMinecraftWorld();
++        if (world.purpurConfig.rabbitNaturalKiller > 0D && world.getRandom().nextDouble() <= world.purpurConfig.rabbitNaturalKiller) {
++            return Rabbit.Variant.EVIL;
++        }
++        // Purpur end - Special mobs naturally spawn
+         Holder<Biome> biome = level.getBiome(pos);
+         int randomInt = level.getRandom().nextInt(100);
+         if (biome.is(BiomeTags.SPAWNS_WHITE_RABBITS)) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/squid/Squid.java.patch

@@ -0,0 +1,58 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/squid/Squid.java b/net/minecraft/world/entity/animal/squid/Squid.java
+index 0e13879ce2802ff8ef0ee9b745a23396727c3e30..504573bf4cbdf1debfa9f9bd071fa40d443b860d 100644
+--- a/net/minecraft/world/entity/animal/squid/Squid.java
++++ b/net/minecraft/world/entity/animal/squid/Squid.java
+@@ -48,10 +48,29 @@ public class Squid extends AgeableWaterCreature {
+ 
+     public Squid(EntityType<? extends Squid> type, Level level) {
+         super(type, level);
+-        // this.random.setSeed(this.getId()); // Paper - Share random for entities to make them more random
++        if (!level.purpurConfig.entitySharedRandom) this.random.setSeed(this.getId()); // Paper - Share random for entities to make them more random // Purpur - Add toggle for RNG manipulation
+         this.tentacleSpeed = 1.0F / (this.random.nextFloat() + 1.0F) * 0.2F;
+     }
+ 
++    // Purpur start - Stop squids floating on top of water
++    @Override
++    public net.minecraft.world.phys.AABB getAxisForFluidCheck() {
++        // Stops squids from floating just over the water
++        return super.getAxisForFluidCheck().offsetY(level().purpurConfig.squidOffsetWaterCheck);
++    }
++    // Purpur end - Stop squids floating on top of water
++
++    // Purpur start - Flying squids! Oh my!
++    public boolean canFly() {
++        return this.level().purpurConfig.squidsCanFly;
++    }
++
++    @Override
++    public boolean isInWater() {
++        return this.wasTouchingWater || canFly();
++    }
++    // Purpur end - Flying squids! Oh my!
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new Squid.SquidRandomMovementGoal(this));
+@@ -128,6 +147,7 @@ public class Squid extends AgeableWaterCreature {
+         }
+ 
+         if (this.isInWater()) {
++            if (canFly()) setNoGravity(!wasTouchingWater); // Purpur - Flying squids! Oh my!
+             if (this.tentacleMovement < (float) Math.PI) {
+                 float f = this.tentacleMovement / (float) Math.PI;
+                 this.tentacleAngle = Mth.sin(f * f * (float) Math.PI) * (float) Math.PI * 0.25F;
+@@ -308,7 +328,7 @@ public class Squid extends AgeableWaterCreature {
+             int noActionTime = this.squid.getNoActionTime();
+             if (noActionTime > 100) {
+                 this.squid.movementVector = Vec3.ZERO;
+-            } else if (this.squid.getRandom().nextInt(reducedTickDelay(50)) == 0 || !this.squid.wasTouchingWater || !this.squid.hasMovementVector()) {
++            } else if (this.squid.getRandom().nextInt(reducedTickDelay(50)) == 0 || !this.squid.isInWater() || !this.squid.hasMovementVector()) { // Purpur - Flying squids! Oh my!
+                 float f = this.squid.getRandom().nextFloat() * (float) (Math.PI * 2);
+                 this.squid.movementVector = new Vec3(Mth.cos(f) * 0.2F, -0.1F + this.squid.getRandom().nextFloat() * 0.2F, Mth.sin(f) * 0.2F);
+             }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/animal/wolf/Wolf.java.patch

@@ -0,0 +1,176 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/animal/wolf/Wolf.java b/net/minecraft/world/entity/animal/wolf/Wolf.java
+index ffad6072280fb4d02f0a37a97d8c83fba85d3bc2..725624f63a2fbf0bd489a92e2c5862c82d72556c 100644
+--- a/net/minecraft/world/entity/animal/wolf/Wolf.java
++++ b/net/minecraft/world/entity/animal/wolf/Wolf.java
+@@ -100,6 +100,37 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         EntityType<?> type = entity.getType();
+         return type == EntityType.SHEEP || type == EntityType.RABBIT || type == EntityType.FOX;
+     };
++    // Purpur start - Configurable chance for wolves to spawn rabid
++    private boolean isRabid = false;
++    private static final TargetingConditions.Selector RABID_PREDICATE = (entity, ignored) -> entity instanceof net.minecraft.server.level.ServerPlayer || entity instanceof net.minecraft.world.entity.Mob;
++    private final net.minecraft.world.entity.ai.goal.Goal PATHFINDER_VANILLA = new NonTameRandomTargetGoal<>(this, Animal.class, false, PREY_SELECTOR);
++    private final net.minecraft.world.entity.ai.goal.Goal PATHFINDER_RABID = new NonTameRandomTargetGoal<>(this, LivingEntity.class, false, RABID_PREDICATE);
++    private static final class AvoidRabidWolfGoal extends AvoidEntityGoal<Wolf> {
++        private final Wolf wolf;
++
++        public AvoidRabidWolfGoal(Wolf wolf, float distance, double minSpeed, double maxSpeed) {
++            super(wolf, Wolf.class, distance, minSpeed, maxSpeed);
++            this.wolf = wolf;
++        }
++
++        @Override
++        public boolean canUse() {
++            return super.canUse() && !this.wolf.isRabid() && this.toAvoid != null && this.toAvoid.isRabid(); // wolves which are not rabid run away from rabid wolves
++        }
++
++        @Override
++        public void start() {
++            this.wolf.setTarget(null);
++            super.start();
++        }
++
++        @Override
++        public void tick() {
++            this.wolf.setTarget(null);
++            super.tick();
++        }
++    }
++    // Purpur end - Configurable chance for wolves to spawn rabid
+     private static final float START_HEALTH = 8.0F;
+     private static final float TAME_HEALTH = 40.0F;
+     private static final float ARMOR_REPAIR_UNIT = 0.125F;
+@@ -121,12 +152,47 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         this.setPathfindingMalus(PathType.DANGER_POWDER_SNOW, -1.0F);
+     }
+ 
++    // Purpur start - Configurable chance for wolves to spawn rabid
++    public boolean isRabid() {
++        return this.isRabid;
++    }
++
++    public void setRabid(boolean isRabid) {
++        this.isRabid = isRabid;
++        updatePathfinders(true);
++    }
++
++    public void updatePathfinders(boolean modifyEffects) {
++        this.targetSelector.removeGoal(PATHFINDER_VANILLA);
++        this.targetSelector.removeGoal(PATHFINDER_RABID);
++        if (this.isRabid) {
++            this.setOwnerReference(null);
++            setTame(false, true);
++            this.targetSelector.addGoal(5, PATHFINDER_RABID);
++            if (modifyEffects) this.addEffect(new net.minecraft.world.effect.MobEffectInstance(net.minecraft.world.effect.MobEffects.NAUSEA, 1200));
++        } else {
++            this.targetSelector.addGoal(5, PATHFINDER_VANILLA);
++            this.stopBeingAngry();
++            if (modifyEffects) this.removeEffect(net.minecraft.world.effect.MobEffects.NAUSEA);
++        }
++    }
++    // Purpur end - Configurable chance for wolves to spawn rabid
++
++    // Purpur start - Configurable default collar color
++    @Override
++    public void tame(Player player) {
++        setCollarColor(level().purpurConfig.wolfDefaultCollarColor);
++        super.tame(player);
++    }
++    // Purpur end - Configurable default collar color
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new FloatGoal(this));
+         this.goalSelector.addGoal(1, new TamableAnimal.TamableAnimalPanicGoal(1.5, DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES));
+         this.goalSelector.addGoal(2, new SitWhenOrderedToGoal(this));
+         this.goalSelector.addGoal(3, new Wolf.WolfAvoidEntityGoal<>(this, Llama.class, 24.0F, 1.5, 1.5));
++        this.goalSelector.addGoal(3, new AvoidRabidWolfGoal(this, 24.0F, 1.5D, 1.5D)); // Purpur - Configurable chance for wolves to spawn rabid
+         this.goalSelector.addGoal(4, new LeapAtTargetGoal(this, 0.4F));
+         this.goalSelector.addGoal(5, new MeleeAttackGoal(this, 1.0, true));
+         this.goalSelector.addGoal(6, new FollowOwnerGoal(this, 1.0, 10.0F, 2.0F));
+@@ -139,7 +205,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         this.targetSelector.addGoal(2, new OwnerHurtTargetGoal(this));
+         this.targetSelector.addGoal(3, new HurtByTargetGoal(this).setAlertOthers());
+         this.targetSelector.addGoal(4, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::isAngryAt));
+-        this.targetSelector.addGoal(5, new NonTameRandomTargetGoal<>(this, Animal.class, false, PREY_SELECTOR));
++        //this.targetSelector.addGoal(5, new NonTameRandomTargetGoal<>(this, Animal.class, false, PREY_SELECTOR)); // Purpur - Configurable chance for wolves to spawn rabid - moved to updatePathfinders()
+         this.targetSelector.addGoal(6, new NonTameRandomTargetGoal<>(this, Turtle.class, false, Turtle.BABY_ON_LAND_SELECTOR));
+         this.targetSelector.addGoal(7, new NearestAttackableTargetGoal<>(this, AbstractSkeleton.class, false));
+         this.targetSelector.addGoal(8, new ResetUniversalAngerTargetGoal<>(this, true));
+@@ -229,6 +295,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+     protected void addAdditionalSaveData(ValueOutput output) {
+         super.addAdditionalSaveData(output);
+         output.store("CollarColor", DyeColor.LEGACY_ID_CODEC, this.getCollarColor());
++        output.putBoolean("Purpur.IsRabid", this.isRabid); // Purpur - Configurable chance for wolves to spawn rabid
+         VariantUtils.writeVariant(output, this.getVariant());
+         this.addPersistentAngerSaveData(output);
+         this.getSoundVariant()
+@@ -243,6 +310,10 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         super.readAdditionalSaveData(input);
+         VariantUtils.readVariant(input, Registries.WOLF_VARIANT).ifPresent(this::setVariant);
+         this.setCollarColor(input.read("CollarColor", DyeColor.LEGACY_ID_CODEC).orElse(DEFAULT_COLLAR_COLOR));
++        // Purpur start - Configurable chance for wolves to spawn rabid
++        this.isRabid = input.getBooleanOr("Purpur.IsRabid", false);
++        this.updatePathfinders(false);
++        // Purpur end - Configurable chance for wolves to spawn rabid
+         this.readPersistentAngerSaveData(this.level(), input);
+         input.read("sound_variant", ResourceKey.codec(Registries.WOLF_SOUND_VARIANT))
+             .flatMap(resourceKey -> this.registryAccess().lookupOrThrow(Registries.WOLF_SOUND_VARIANT).get((ResourceKey<WolfSoundVariant>)resourceKey))
+@@ -266,6 +337,10 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         }
+ 
+         this.setSoundVariant(WolfSoundVariants.pickRandomSoundVariant(this.registryAccess(), level.getRandom()));
++        // Purpur start - Configurable chance for wolves to spawn rabid
++        this.isRabid = level.getLevel().purpurConfig.wolfNaturalRabid > 0.0D && random.nextDouble() <= level.getLevel().purpurConfig.wolfNaturalRabid;
++        this.updatePathfinders(false);
++        // Purpur end - Configurable chance for wolves to spawn rabid
+         return super.finalizeSpawn(level, difficulty, spawnReason, spawnGroupData);
+     }
+ 
+@@ -316,6 +391,11 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+     public void tick() {
+         super.tick();
+         if (this.isAlive()) {
++            // Purpur start - Configurable chance for wolves to spawn rabid
++            if (this.age % 300 == 0 && this.isRabid()) {
++                this.addEffect(new net.minecraft.world.effect.MobEffectInstance(net.minecraft.world.effect.MobEffects.NAUSEA, 400));
++            }
++            // Purpur end - Configurable chance for wolves to spawn rabid
+             this.interestedAngleO = this.interestedAngle;
+             if (this.isInterested()) {
+                 this.interestedAngle = this.interestedAngle + (1.0F - this.interestedAngle) * 0.4F;
+@@ -517,13 +597,27 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+             itemInHand.consume(1, player);
+             this.tryToTame(player);
+             return InteractionResult.SUCCESS_SERVER;
++        // Purpur start - Configurable chance for wolves to spawn rabid
++        } else if (this.level().purpurConfig.wolfMilkCuresRabies && itemInHand.getItem() == Items.MILK_BUCKET && this.isRabid()) {
++            if (!player.isCreative()) {
++                player.setItemInHand(hand, new ItemStack(Items.BUCKET));
++            }
++            this.setRabid(false);
++            for (int i = 0; i < 10; ++i) {
++                ((ServerLevel) level()).sendParticlesSource(((ServerLevel) level()).players(), null, ParticleTypes.HAPPY_VILLAGER,
++                        false, true,
++                        getX() + random.nextFloat(), getY() + (random.nextFloat() * 1.5), getZ() + random.nextFloat(), 1,
++                        random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, 0);
++            }
++            return InteractionResult.SUCCESS_SERVER;
++        // Purpur end - Configurable chance for wolves to spawn rabid
+         }
+ 
+         return super.mobInteract(player, hand);
+     }
+ 
+     private void tryToTame(Player player) {
+-        if (this.random.nextInt(3) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit - added event call
++        if (((this.level().purpurConfig.alwaysTameInCreative && player.hasInfiniteMaterials()) || this.random.nextInt(3) == 0) && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit - added event call // Purpur - Config to always tame in Creative
+             this.tame(player);
+             this.navigation.stop();
+             this.setTarget(null);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java.patch

@@ -0,0 +1,64 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java b/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+index c095f42aa103b7874fb5d8dcece1b1484c2e2968..d1c593ccfab7bee4366ee7c56606a230964e3fb7 100644
+--- a/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
++++ b/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+@@ -39,6 +39,24 @@ public class EndCrystal extends Entity {
+         this.setPos(x, y, z);
+     }
+ 
++    // Purpur start - End crystal explosion options
++    public boolean shouldExplode() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplode : level().purpurConfig.baselessEndCrystalExplode;
++    }
++
++    public float getExplosionPower() {
++        return (float) (showsBottom() ? level().purpurConfig.basedEndCrystalExplosionPower : level().purpurConfig.baselessEndCrystalExplosionPower);
++    }
++
++    public boolean hasExplosionFire() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplosionFire : level().purpurConfig.baselessEndCrystalExplosionFire;
++    }
++
++    public Level.ExplosionInteraction getExplosionEffect() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplosionEffect : level().purpurConfig.baselessEndCrystalExplosionEffect;
++    }
++    // Purpur end - End crystal explosion options
++
+     @Override
+     protected Entity.MovementEmission getMovementEmission() {
+         return Entity.MovementEmission.NONE;
+@@ -75,6 +93,8 @@ 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 - End Crystal Cramming
++
+     }
+ 
+     @Override
+@@ -115,15 +135,17 @@ public class EndCrystal extends Entity {
+                 }
+                 // CraftBukkit end
+                 if (!damageSource.is(DamageTypeTags.IS_EXPLOSION)) {
++                    if (shouldExplode()) {// Purpur - End crystal explosion options
+                     DamageSource damageSource1 = damageSource.getEntity() != null ? this.damageSources().explosion(this, damageSource.getEntity()) : null;
+                     // CraftBukkit start
+-                    org.bukkit.event.entity.ExplosionPrimeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callExplosionPrimeEvent(this, 6.0F, false);
++                    org.bukkit.event.entity.ExplosionPrimeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callExplosionPrimeEvent(this, getExplosionPower(), hasExplosionFire()); // Purpur - End crystal explosion options
+                     if (event.isCancelled()) {
+                         return false;
+                     }
+ 
+                     this.remove(Entity.RemovalReason.KILLED, org.bukkit.event.entity.EntityRemoveEvent.Cause.EXPLODE); // Paper - add Bukkit remove cause
+-                    level.explode(this, damageSource1, null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.BLOCK);
++                    level.explode(this, damageSource1, null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), getExplosionEffect()); // Purpur - End crystal explosion options
++                    } else this.unsetRemoved(); // Purpur - End crystal explosion options
+                 } else {
+                     this.remove(Entity.RemovalReason.KILLED, org.bukkit.event.entity.EntityRemoveEvent.Cause.DEATH); // Paper - add Bukkit remove cause
+                     // CraftBukkit end

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java.patch

@@ -0,0 +1,27 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index 1daf8f52148043339f723aaebdf6135763dd805b..9c38e3b8c09caa2701a207b91761f344c5e53385 100644
+--- a/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
++++ b/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+@@ -957,6 +957,7 @@ public class EnderDragon extends Mob implements Enemy {
+ 
+     @Override
+     protected boolean canRide(Entity entity) {
++        if (this.level().purpurConfig.enderDragonCanRideVehicles) return this.boardingCooldown <= 0; // Purpur - Configs for if Wither/Ender Dragon can ride vehicles
+         return false;
+     }
+ 
+@@ -992,7 +993,7 @@ public class EnderDragon extends Mob implements Enemy {
+         boolean flag = level.getGameRules().get(GameRules.MOB_DROPS);
+         int i = 500;
+ 
+-        if (this.dragonFight != null && !this.dragonFight.hasPreviouslyKilledDragon()) {
++        if (this.dragonFight != null && (level().purpurConfig.enderDragonAlwaysDropsFullExp || !this.dragonFight.hasPreviouslyKilledDragon())) { // Purpur - Ender dragon always drop full exp
+             i = 12000;
+         }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/boss/wither/WitherBoss.java.patch

@@ -0,0 +1,81 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/boss/wither/WitherBoss.java b/net/minecraft/world/entity/boss/wither/WitherBoss.java
+index 86b6b94c3e63bb52917fe0f708d24aa813f433c7..be74b2f6e21e9adb1e5c96414854a5c4f07655fc 100644
+--- a/net/minecraft/world/entity/boss/wither/WitherBoss.java
++++ b/net/minecraft/world/entity/boss/wither/WitherBoss.java
+@@ -80,6 +80,7 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+     private static final TargetingConditions.Selector LIVING_ENTITY_SELECTOR = (entity, level) -> !entity.getType().is(EntityTypeTags.WITHER_FRIENDS)
+         && entity.attackable();
+     private static final TargetingConditions TARGETING_CONDITIONS = TargetingConditions.forCombat().range(20.0).selector(LIVING_ENTITY_SELECTOR);
++    private java.util.@Nullable UUID summoner; // Purpur - Summoner API
+ 
+     public WitherBoss(EntityType<? extends WitherBoss> type, Level level) {
+         super(type, level);
+@@ -88,6 +89,16 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+         this.xpReward = 50;
+     }
+ 
++    // Purpur start - Summoner API
++    public java.util.@Nullable UUID getSummoner() {
++        return summoner;
++    }
++
++    public void setSummoner(java.util.@Nullable UUID summoner) {
++        this.summoner = summoner;
++    }
++    // Purpur end - Summoner API
++
+     @Override
+     protected PathNavigation createNavigation(Level level) {
+         FlyingPathNavigation flyingPathNavigation = new FlyingPathNavigation(this, level);
+@@ -120,6 +131,7 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+     protected void addAdditionalSaveData(ValueOutput output) {
+         super.addAdditionalSaveData(output);
+         output.putInt("Invul", this.getInvulnerableTicks());
++        output.storeNullable("Purpur.Summoner", net.minecraft.core.UUIDUtil.CODEC, getSummoner()); // Purpur - Summoner API
+     }
+ 
+     @Override
+@@ -129,6 +141,7 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+         if (this.hasCustomName()) {
+             this.bossEvent.setName(this.getDisplayName());
+         }
++        this.setSummoner(input.read("Purpur.Summoner", net.minecraft.core.UUIDUtil.CODEC).orElse(null)); // Purpur - Summoner API
+     }
+ 
+     @Override
+@@ -272,7 +285,7 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+                     level.explode(this, this.getX(), this.getEyeY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.MOB);
+                 }
+                 // CraftBukkit end
+-                if (!this.isSilent()) {
++                if (!this.isSilent() && level.purpurConfig.witherPlaySpawnSound) { // Purpur - Toggle for Wither's spawn sound
+                     // CraftBukkit start - Use relative location for far away sounds
+                     // level.globalLevelEvent(LevelEvent.SOUND_WITHER_BOSS_SPAWN, this.blockPosition(), 0);
+                     int viewDistance = level.getCraftServer().getViewDistance() * 16;
+@@ -379,8 +392,10 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+                 }
+             }
+ 
+-            if (this.tickCount % 20 == 0) {
+-                this.heal(1.0F, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.REGEN); // CraftBukkit
++            // Purpur start - Customizable wither health and healing - customizable heal rate and amount
++            if (this.tickCount % level().purpurConfig.witherHealthRegenDelay == 0) {
++                this.heal(level().purpurConfig.witherHealthRegenAmount, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.REGEN); // CraftBukkit
++            // Purpur end - Customizable wither health and healing
+             }
+ 
+             this.bossEvent.setProgress(this.getHealth() / this.getMaxHealth());
+@@ -577,6 +592,7 @@ public class WitherBoss extends Monster implements RangedAttackMob {
+ 
+     @Override
+     protected boolean canRide(Entity entity) {
++        if (this.level().purpurConfig.witherCanRideVehicles) return this.boardingCooldown <= 0; // Purpur - Configs for if Wither/Ender Dragon can ride vehicles
+         return false;
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/item/ItemEntity.java.patch

@@ -0,0 +1,54 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/item/ItemEntity.java b/net/minecraft/world/entity/item/ItemEntity.java
+index e82bb8f2d2b0e771dc371fd7e709116e1f5f204f..ddf7fa8e67440beb102b6bf91b30f2b340b52a8e 100644
+--- a/net/minecraft/world/entity/item/ItemEntity.java
++++ b/net/minecraft/world/entity/item/ItemEntity.java
+@@ -54,6 +54,12 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     public boolean canMobPickup = true; // Paper - Item#canEntityPickup
+     private int despawnRate = -1; // Paper - Alternative item-despawn-rate
+     public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // Paper - Friction API
++    // Purpur start - Item entity immunities
++    public boolean immuneToCactus = false;
++    public boolean immuneToExplosion = false;
++    public boolean immuneToFire = false;
++    public boolean immuneToLightning = false;
++    // Purpur end - Item entity immunities
+ 
+     public ItemEntity(EntityType<? extends ItemEntity> type, Level level) {
+         super(type, level);
+@@ -330,7 +336,16 @@ public class ItemEntity extends Entity implements TraceableEntity {
+ 
+     @Override
+     public final boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
+-        if (this.isInvulnerableToBase(damageSource)) {
++        // Purpur start - Item entity immunities
++        if (
++            (immuneToCactus && damageSource.is(net.minecraft.world.damagesource.DamageTypes.CACTUS)) ||
++            (immuneToFire && (damageSource.is(net.minecraft.tags.DamageTypeTags.IS_FIRE) || damageSource.is(net.minecraft.world.damagesource.DamageTypes.ON_FIRE) || damageSource.is(net.minecraft.world.damagesource.DamageTypes.IN_FIRE))) ||
++            (immuneToLightning && damageSource.is(net.minecraft.world.damagesource.DamageTypes.LIGHTNING_BOLT)) ||
++            (immuneToExplosion && damageSource.is(net.minecraft.tags.DamageTypeTags.IS_EXPLOSION))
++        ) {
++            return false;
++        } else if (this.isInvulnerableToBase(damageSource)) {
++        // Purpur end - Item entity immunities
+             return false;
+         } else if (!level.getGameRules().get(GameRules.MOB_GRIEFING) && damageSource.getEntity() instanceof Mob) {
+             return false;
+@@ -508,6 +523,12 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     public void setItem(ItemStack stack) {
+         this.getEntityData().set(DATA_ITEM, stack);
+         this.despawnRate = this.level().paperConfig().entities.spawning.altItemDespawnRate.enabled ? this.level().paperConfig().entities.spawning.altItemDespawnRate.items.getOrDefault(stack.getItem(), this.level().spigotConfig.itemDespawnRate) : this.level().spigotConfig.itemDespawnRate; // Paper - Alternative item-despawn-rate
++        // Purpur start - Item entity immunities
++        if (level().purpurConfig.itemImmuneToCactus.contains(stack.getItem())) immuneToCactus = true;
++        if (level().purpurConfig.itemImmuneToExplosion.contains(stack.getItem())) immuneToExplosion = true;
++        if (level().purpurConfig.itemImmuneToFire.contains(stack.getItem())) immuneToFire = true;
++        if (level().purpurConfig.itemImmuneToLightning.contains(stack.getItem())) immuneToLightning = true;
++        // level end - Item entity immunities
+     }
+ 
+     @Override

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Creeper.java.patch

@@ -0,0 +1,73 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Creeper.java b/net/minecraft/world/entity/monster/Creeper.java
+index e6d93c7a339f06c40b78f554f4e7070fb7fcad02..168003b7159b5e9ea3e3ca19d0b939ed1cfd2311 100644
+--- a/net/minecraft/world/entity/monster/Creeper.java
++++ b/net/minecraft/world/entity/monster/Creeper.java
+@@ -56,6 +56,7 @@ public class Creeper extends Monster {
+     public int explosionRadius = 3;
+     public boolean droppedSkulls;
+     public @Nullable Entity entityIgniter; // CraftBukkit
++    private boolean exploding = false; // Purpur - Config to make Creepers explode on death
+ 
+     public Creeper(EntityType<? extends Creeper> type, Level level) {
+         super(type, level);
+@@ -159,6 +160,27 @@ public class Creeper extends Monster {
+         return false; // CraftBukkit
+     }
+ 
++    // Purpur start - Special mobs naturally spawn
++    @Override
++    public net.minecraft.world.entity.SpawnGroupData finalizeSpawn(net.minecraft.world.level.ServerLevelAccessor world, net.minecraft.world.DifficultyInstance difficulty, net.minecraft.world.entity.EntitySpawnReason spawnReason, net.minecraft.world.entity.@Nullable SpawnGroupData entityData) {
++        double chance = world.getLevel().purpurConfig.creeperChargedChance;
++        if (chance > 0D && random.nextDouble() <= chance) {
++            setPowered(true);
++        }
++        return super.finalizeSpawn(world, difficulty, spawnReason, entityData);
++    }
++    // Purpur end - Special mobs naturally spawn
++
++    // Purpur start - Config to make Creepers explode on death
++    @Override
++    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
++        if (!this.exploding && this.level().purpurConfig.creeperExplodeWhenKilled && damageSource.getEntity() instanceof net.minecraft.server.level.ServerPlayer) {
++            this.explodeCreeper();
++        }
++        return super.dropAllDeathLoot(world, damageSource);
++    }
++    // Purpur end - Config to make Creepers explode on death
++
+     @Override
+     public SoundEvent getHurtSound(DamageSource damageSource) {
+         return SoundEvents.CREEPER_HURT;
+@@ -243,14 +265,16 @@ public class Creeper extends Monster {
+     }
+ 
+     public void explodeCreeper() {
++        this.exploding = true; // Purpur - Config to make Creepers explode on death
+         if (this.level() instanceof ServerLevel serverLevel) {
+             float f = this.isPowered() ? 2.0F : 1.0F;
++            float multiplier = serverLevel.purpurConfig.creeperHealthRadius ? this.getHealth() / this.getMaxHealth() : 1; // Purpur - Config for health to impact Creeper explosion radius
+             // CraftBukkit start
+-            org.bukkit.event.entity.ExplosionPrimeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callExplosionPrimeEvent(this, this.explosionRadius * f, false);
++            org.bukkit.event.entity.ExplosionPrimeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callExplosionPrimeEvent(this, (this.explosionRadius * f) * multiplier, false); // Purpur - Config for health to impact Creeper explosion radius
+             if (!event.isCancelled()) {
+             // CraftBukkit end
+             this.dead = true;
+-            serverLevel.explode(this, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.MOB); // CraftBukkit // Paper - fix DamageSource API (revert to vanilla, no, just no, don't change this)
++            serverLevel.explode(this, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), serverLevel.getGameRules().get(net.minecraft.world.level.gamerules.GameRules.MOB_GRIEFING) && level().purpurConfig.creeperAllowGriefing ? Level.ExplosionInteraction.MOB : Level.ExplosionInteraction.NONE); // CraftBukkit // Paper - fix DamageSource API (revert to vanilla, no, just no, don't change this) // Purpur - Add enderman and creeper griefing controls
+             this.spawnLingeringCloud();
+             this.triggerOnDeathMobEffects(serverLevel, Entity.RemovalReason.KILLED);
+             this.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.EXPLODE); // CraftBukkit - add Bukkit remove cause
+@@ -261,6 +285,7 @@ public class Creeper extends Monster {
+             }
+             // CraftBukkit end
+         }
++        this.exploding = false; // Purpur - Config to make Creepers explode on death
+     }
+ 
+     private void spawnLingeringCloud() {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Ghast.java.patch

@@ -0,0 +1,22 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Ghast.java b/net/minecraft/world/entity/monster/Ghast.java
+index 605c47f3bd5c4e72389587d50e70fcd57f2a2b27..b8774eb91d21e9f154cc70c5d3bd26de25be41c4 100644
+--- a/net/minecraft/world/entity/monster/Ghast.java
++++ b/net/minecraft/world/entity/monster/Ghast.java
+@@ -156,6 +156,11 @@ public class Ghast extends Mob implements Enemy {
+     public static boolean checkGhastSpawnRules(
+         EntityType<Ghast> entityType, LevelAccessor level, EntitySpawnReason spawnReason, BlockPos pos, RandomSource random
+     ) {
++        // Purpur start - Config to disable hostile mob spawn on ice
++        if (net.minecraft.world.entity.monster.Monster.canSpawnInBlueAndPackedIce(level, pos)) {
++            return false;
++        }
++        // Purpur end - Config to disable hostile mob spawn on ice
+         return level.getDifficulty() != Difficulty.PEACEFUL && random.nextInt(20) == 0 && checkMobSpawnRules(entityType, level, spawnReason, pos, random);
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Monster.java.patch

@@ -0,0 +1,47 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Monster.java b/net/minecraft/world/entity/monster/Monster.java
+index 07293a33c45a0834f3b623a47a1bd25f3e059f54..54033572e325f8486a438e31dde34f8407f9180a 100644
+--- a/net/minecraft/world/entity/monster/Monster.java
++++ b/net/minecraft/world/entity/monster/Monster.java
+@@ -84,6 +84,11 @@ public abstract class Monster extends PathfinderMob implements Enemy {
+     }
+ 
+     public static boolean isDarkEnoughToSpawn(ServerLevelAccessor level, BlockPos pos, RandomSource random) {
++        // Purpur start - Config to disable hostile mob spawn on ice
++        if (canSpawnInBlueAndPackedIce(level, pos)) {
++            return false;
++        }
++        // Purpur end - Config to disable hostile mob spawn on ice
+         if (level.getBrightness(LightLayer.SKY, pos) > random.nextInt(32)) {
+             return false;
+         } else {
+@@ -109,6 +114,11 @@ public abstract class Monster extends PathfinderMob implements Enemy {
+     public static boolean checkAnyLightMonsterSpawnRules(
+         EntityType<? extends Monster> entityType, LevelAccessor level, EntitySpawnReason spawnReason, BlockPos pos, RandomSource random
+     ) {
++        // Purpur start - Config to disable hostile mob spawn on ice
++        if (canSpawnInBlueAndPackedIce(level, pos)) {
++            return false;
++        }
++        // Purpur end - Config to disable hostile mob spawn on ice
+         return level.getDifficulty() != Difficulty.PEACEFUL && checkMobSpawnRules(entityType, level, spawnReason, pos, random);
+     }
+ 
+@@ -146,4 +156,12 @@ public abstract class Monster extends PathfinderMob implements Enemy {
+             return ItemStack.EMPTY;
+         }
+     }
++
++    // Purpur start - Config to disable hostile mob spawn on ice
++    public static boolean canSpawnInBlueAndPackedIce(LevelAccessor level, BlockPos pos) {
++        net.minecraft.world.level.block.state.BlockState spawnBlock = level.getBlockState(pos.below());
++
++        return (!level.getMinecraftWorld().purpurConfig.mobsSpawnOnPackedIce && spawnBlock.is(net.minecraft.world.level.block.Blocks.PACKED_ICE)) || (!level.getMinecraftWorld().purpurConfig.mobsSpawnOnBlueIce && spawnBlock.is(net.minecraft.world.level.block.Blocks.BLUE_ICE));
++    }
++    // Purpur end - Config to disable hostile mob spawn on ice
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Phantom.java.patch

@@ -0,0 +1,23 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Phantom.java b/net/minecraft/world/entity/monster/Phantom.java
+index 62c40a04a105eff471599c4535239fee9726dbd1..d26b7970490a2a108affee11c3fb74e38509d92b 100644
+--- a/net/minecraft/world/entity/monster/Phantom.java
++++ b/net/minecraft/world/entity/monster/Phantom.java
+@@ -166,7 +166,11 @@ public class Phantom extends Mob implements Enemy {
+         ServerLevelAccessor level, DifficultyInstance difficulty, EntitySpawnReason spawnReason, @Nullable SpawnGroupData spawnGroupData
+     ) {
+         this.anchorPoint = this.blockPosition().above(5);
+-        this.setPhantomSize(0);
++        // Purpur start - Configurable phantom size
++        int min = level.getLevel().purpurConfig.phantomMinSize;
++        int max = level.getLevel().purpurConfig.phantomMaxSize;
++        this.setPhantomSize(min == max ? min : level.getRandom().nextInt(max + 1 - min) + min);
++        // Purpur end - Configurable phantom size
+         return super.finalizeSpawn(level, difficulty, spawnReason, spawnGroupData);
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Ravager.java.patch

@@ -0,0 +1,27 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Ravager.java b/net/minecraft/world/entity/monster/Ravager.java
+index 631092f088355be45f598bb91bd5d38a39a55d5b..a10c693a8948d1b7c4bd06b957a08a9cea9170ad 100644
+--- a/net/minecraft/world/entity/monster/Ravager.java
++++ b/net/minecraft/world/entity/monster/Ravager.java
+@@ -76,6 +76,7 @@ public class Ravager extends Raider {
+     protected void registerGoals() {
+         super.registerGoals();
+         this.goalSelector.addGoal(0, new FloatGoal(this));
++        if (level().purpurConfig.ravagerAvoidRabbits) this.goalSelector.addGoal(3, new net.minecraft.world.entity.ai.goal.AvoidEntityGoal<>(this, net.minecraft.world.entity.animal.rabbit.Rabbit.class, 6.0F, 1.0D, 1.2D)); // Purpur - option to make ravagers afraid of rabbits
+         this.goalSelector.addGoal(4, new MeleeAttackGoal(this, 1.0, true));
+         this.goalSelector.addGoal(5, new WaterAvoidingRandomStrollGoal(this, 0.4));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));
+@@ -154,7 +155,7 @@ public class Ravager extends Raider {
+                 )) {
+                     BlockState blockState = serverLevel.getBlockState(blockPos);
+                     Block block = blockState.getBlock();
+-                    if (block instanceof LeavesBlock) {
++                    if (this.level().purpurConfig.ravagerGriefableBlocks.contains(block)) { // Purpur - Configurable ravager griefable blocks list
+                         // CraftBukkit start
+                         if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this, blockPos, blockState.getFluidState().createLegacyBlock())) { // Paper - fix wrong block state
+                             continue;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Shulker.java.patch

@@ -0,0 +1,67 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Shulker.java b/net/minecraft/world/entity/monster/Shulker.java
+index 935c608ba0fc2246a3f79bf4865cfeb6fe68b0f4..6e8400c4d523da8799d586c5c9019ae78710fbcb 100644
+--- a/net/minecraft/world/entity/monster/Shulker.java
++++ b/net/minecraft/world/entity/monster/Shulker.java
+@@ -93,6 +93,21 @@ public class Shulker extends AbstractGolem implements Enemy {
+         this.lookControl = new Shulker.ShulkerLookControl(this);
+     }
+ 
++    // Purpur start - Shulker change color with dye
++    @Override
++    protected net.minecraft.world.InteractionResult mobInteract(Player player, net.minecraft.world.InteractionHand hand) {
++        net.minecraft.world.item.ItemStack itemstack = player.getItemInHand(hand);
++        if (player.level().purpurConfig.shulkerChangeColorWithDye && itemstack.getItem() instanceof net.minecraft.world.item.DyeItem dye && dye.getDyeColor() != this.getColor()) {
++            this.setVariant(Optional.of(dye.getDyeColor()));
++            if (!player.getAbilities().instabuild) {
++                itemstack.shrink(1);
++            }
++            return net.minecraft.world.InteractionResult.SUCCESS;
++        }
++        return super.mobInteract(player, hand);
++    }
++    // Purpur end - Shulker change color with dye
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new LookAtPlayerGoal(this, Player.class, 8.0F, 0.02F, true));
+@@ -454,11 +469,21 @@ public class Shulker extends AbstractGolem implements Enemy {
+     private void hitByShulkerBullet() {
+         Vec3 vec3 = this.position();
+         AABB boundingBox = this.getBoundingBox();
+-        if (!this.isClosed() && this.teleportSomewhere()) {
+-            int size = this.level().getEntities(EntityType.SHULKER, boundingBox.inflate(8.0), Entity::isAlive).size();
+-            float f = (size - 1) / 5.0F;
+-            if (!(this.level().random.nextFloat() < f)) {
++        // Purpur start - Shulker spawn from bullet options
++        if ((!this.level().purpurConfig.shulkerSpawnFromBulletRequireOpenLid || !this.isClosed()) && this.teleportSomewhere()) {
++            float chance = this.level().purpurConfig.shulkerSpawnFromBulletBaseChance;
++            if (!this.level().purpurConfig.shulkerSpawnFromBulletNearbyEquation.isBlank()) {
++                int nearby = this.level().getEntities((net.minecraft.world.level.entity.EntityTypeTest) EntityType.SHULKER, boundingBox.inflate(this.level().purpurConfig.shulkerSpawnFromBulletNearbyRange), Entity::isAlive).size();
++                try {
++                    chance -= ((Number) scriptEngine.eval("let nearby = " + nearby + "; " + this.level().purpurConfig.shulkerSpawnFromBulletNearbyEquation)).floatValue();
++                } catch (javax.script.ScriptException e) {
++                    e.printStackTrace();
++                    chance -= (nearby - 1) / 5.0F;
++                }
++            }
++            if (this.level().random.nextFloat() <= chance) {
+                 Shulker shulker = EntityType.SHULKER.create(this.level(), EntitySpawnReason.BREEDING);
++                // Purpur end - Shulker spawn from bullet options
+                 if (shulker != null) {
+                     shulker.setVariant(this.getVariant());
+                     shulker.snapTo(vec3);
+@@ -565,7 +590,7 @@ public class Shulker extends AbstractGolem implements Enemy {
+     }
+ 
+     public Optional<DyeColor> getVariant() {
+-        return Optional.ofNullable(this.getColor());
++        return Optional.ofNullable(this.level().purpurConfig.shulkerSpawnFromBulletRandomColor ? DyeColor.random(this.level().random) : this.getColor()); // Purpur - Shulker spawn from bullet options
+     }
+ 
+     public @Nullable DyeColor getColor() {

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/Strider.java.patch

@@ -0,0 +1,29 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/Strider.java b/net/minecraft/world/entity/monster/Strider.java
+index b451566378401e471a98db63df502b7c4cd20f42..beaffb771e6c8d4b992437997ab27be218425c5a 100644
+--- a/net/minecraft/world/entity/monster/Strider.java
++++ b/net/minecraft/world/entity/monster/Strider.java
+@@ -390,6 +390,18 @@ public class Strider extends Animal implements ItemSteerable {
+     @Override
+     public InteractionResult mobInteract(Player player, InteractionHand hand) {
+         boolean isFood = this.isFood(player.getItemInHand(hand));
++        // Purpur start
++        if (level().purpurConfig.striderGiveSaddleBack && player.isSecondaryUseActive() && !isFood && isSaddled() && !isVehicle()) {
++            this.setItemSlot(EquipmentSlot.SADDLE, ItemStack.EMPTY);
++            if (!player.getAbilities().instabuild) {
++                ItemStack saddle = new ItemStack(Items.SADDLE);
++                if (!player.getInventory().add(saddle)) {
++                    player.drop(saddle, false);
++                }
++            }
++            return InteractionResult.SUCCESS;
++        }
++        // Purpur end
+         if (!isFood && this.isSaddled() && !this.isVehicle() && !player.isSecondaryUseActive()) {
+             if (!this.level().isClientSide()) {
+                 player.startRiding(this);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/illager/Vindicator.java.patch

@@ -0,0 +1,22 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/illager/Vindicator.java b/net/minecraft/world/entity/monster/illager/Vindicator.java
+index bfad794ff21e2f97654fbb1207b14fd088aec721..0cdc52cf3b1bb9c00e6ca8c8e564de60e195d6fc 100644
+--- a/net/minecraft/world/entity/monster/illager/Vindicator.java
++++ b/net/minecraft/world/entity/monster/illager/Vindicator.java
+@@ -131,6 +131,11 @@ public class Vindicator extends AbstractIllager {
+         RandomSource random = level.getRandom();
+         this.populateDefaultEquipmentSlots(random, difficulty);
+         this.populateDefaultEquipmentEnchantments(level, random, difficulty);
++        // Purpur start - Special mobs naturally spawn
++        if (level().purpurConfig.vindicatorJohnnySpawnChance > 0D && random.nextDouble() <= level().purpurConfig.vindicatorJohnnySpawnChance) {
++            setCustomName(Component.translatable("Johnny"));
++        }
++        // Purpur end - Special mobs naturally spawn
+         return spawnGroupData1;
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/piglin/PiglinAi.java.patch

@@ -0,0 +1,36 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/piglin/PiglinAi.java b/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+index 436b17a709517766fdb9d7198f0ae457facd90a1..49294ccf5c4ac3acf7793c8d7cbc449a0d0f44e6 100644
+--- a/net/minecraft/world/entity/monster/piglin/PiglinAi.java
++++ b/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+@@ -660,7 +660,10 @@ public class PiglinAi {
+ 
+     public static boolean isWearingSafeArmor(LivingEntity entity) {
+         for (EquipmentSlot equipmentSlot : EquipmentSlotGroup.ARMOR) {
+-            if (entity.getItemBySlot(equipmentSlot).is(ItemTags.PIGLIN_SAFE_ARMOR)) {
++            // Purpur start - piglins ignore gold-trimmed armor
++            net.minecraft.world.item.ItemStack itemStack = entity.getItemBySlot(equipmentSlot);
++            if (itemStack.is(ItemTags.PIGLIN_SAFE_ARMOR) || (entity.level().purpurConfig.piglinIgnoresArmorWithGoldTrim && isWearingGoldTrim(itemStack))) {
++            // Purpur end - piglins ignore gold-trimmed armor
+                 return true;
+             }
+         }
+@@ -668,6 +671,13 @@ public class PiglinAi {
+         return false;
+     }
+ 
++    // Purpur start - piglins ignore gold-trimmed armor
++    private static boolean isWearingGoldTrim(net.minecraft.world.item.ItemStack itemstack) {
++        net.minecraft.world.item.equipment.trim.ArmorTrim armorTrim = itemstack.getComponents().get(net.minecraft.core.component.DataComponents.TRIM);
++        return armorTrim != null && armorTrim.material().is(net.minecraft.world.item.equipment.trim.TrimMaterials.GOLD);
++    }
++    // Purpur end - piglins ignore gold-trimmed armor
++
+     private static void stopWalking(Piglin piglin) {
+         piglin.getBrain().eraseMemory(MemoryModuleType.WALK_TARGET);
+         piglin.getNavigation().stop();

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/skeleton/AbstractSkeleton.java.patch

@@ -0,0 +1,28 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/skeleton/AbstractSkeleton.java b/net/minecraft/world/entity/monster/skeleton/AbstractSkeleton.java
+index 0f5bfbfc97c2826de72985c4e2e1dec1d94337f2..1ba7777164c7fd8516c97e1bd964183df37c029f 100644
+--- a/net/minecraft/world/entity/monster/skeleton/AbstractSkeleton.java
++++ b/net/minecraft/world/entity/monster/skeleton/AbstractSkeleton.java
+@@ -137,7 +137,7 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
+         this.populateDefaultEquipmentEnchantments(level, random, difficulty);
+         this.reassessWeaponGoal();
+         this.setCanPickUpLoot(level.getLevel().paperConfig().entities.behavior.mobsCanAlwaysPickUpLoot.skeletons || random.nextFloat() < 0.55F * difficulty.getSpecialMultiplier()); // Paper - Add world settings for mobs picking up loot
+-        if (this.getItemBySlot(EquipmentSlot.HEAD).isEmpty() && SpecialDates.isHalloween() && random.nextFloat() < 0.25F) {
++        if (this.getItemBySlot(EquipmentSlot.HEAD).isEmpty() && (level.getLevel().purpurConfig.forceHalloweenSeason || SpecialDates.isHalloween()) && random.nextFloat() < this.level().purpurConfig.chanceHeadHalloweenOnEntity) { // Purpur - Halloween options and optimizations
+             this.setItemSlot(EquipmentSlot.HEAD, new ItemStack(random.nextFloat() < 0.1F ? Blocks.JACK_O_LANTERN : Blocks.CARVED_PUMPKIN));
+             this.setDropChance(EquipmentSlot.HEAD, 0.0F);
+         }
+@@ -184,7 +184,7 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
+         double squareRoot = Math.sqrt(d * d + d2 * d2);
+         if (this.level() instanceof ServerLevel serverLevel) {
+             Projectile.Delayed<AbstractArrow> delayedEntity = Projectile.spawnProjectileUsingShootDelayed( // Paper - delayed
+-                arrow, serverLevel, projectile, d, d1 + squareRoot * 0.2F, d2, 1.6F, 14 - serverLevel.getDifficulty().getId() * 4
++                arrow, serverLevel, projectile, d, d1 + squareRoot * 0.2F, d2, 1.6F, serverLevel.purpurConfig.skeletonBowAccuracyMap.getOrDefault(serverLevel.getDifficulty().getId(), (float) (14 - serverLevel.getDifficulty().getId() * 4))  // Purpur - skeleton bow accuracy option
+             );
+ 
+             // Paper start - call EntityShootBowEvent

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/zombie/Drowned.java.patch

@@ -0,0 +1,35 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/zombie/Drowned.java b/net/minecraft/world/entity/monster/zombie/Drowned.java
+index db164101d440c503e2e88b1f31af7f0638faaec5..604d5e6a4962de61fb97988a2f3de2965908bada 100644
+--- a/net/minecraft/world/entity/monster/zombie/Drowned.java
++++ b/net/minecraft/world/entity/monster/zombie/Drowned.java
+@@ -86,10 +86,23 @@ public class Drowned extends Zombie implements RangedAttackMob {
+         this.goalSelector.addGoal(2, new Drowned.DrownedAttackGoal(this, 1.0, false));
+         this.goalSelector.addGoal(5, new Drowned.DrownedGoToBeachGoal(this, 1.0));
+         this.goalSelector.addGoal(6, new Drowned.DrownedSwimUpGoal(this, 1.0, this.level().getSeaLevel()));
++        if (level().purpurConfig.drownedBreakDoors) this.goalSelector.addGoal(6, new net.minecraft.world.entity.ai.goal.MoveThroughVillageGoal(this, 1.0D, true, 4, this::canBreakDoors)); // Purpur - Option to make drowned break doors
+         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0));
+         this.targetSelector.addGoal(1, new HurtByTargetGoal(this, Drowned.class).setAlertOthers(ZombifiedPiglin.class));
+         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, (entity, level) -> this.okTarget(entity)));
+-        if (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Paper - Check drowned for villager aggression config
++        // Purpur start - Add option to disable zombie aggressiveness towards villagers
++        if (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false) { // Paper - Check drowned for villager aggression config
++            @Override
++            public boolean canUse() {
++                return (level().purpurConfig.zombieAggressiveTowardsVillagerWhenLagging || !level().getServer().server.isLagging()) && super.canUse();
++            }
++
++            @Override
++            public boolean canContinueToUse() {
++                return (level().purpurConfig.zombieAggressiveTowardsVillagerWhenLagging || !level().getServer().server.isLagging()) && super.canContinueToUse();
++            }
++        });
++        // Purpur end - Add option to disable zombie aggressiveness towards villagers
+         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
+         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Axolotl.class, true, false));
+         this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR));

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/monster/zombie/ZombieVillager.java.patch

@@ -0,0 +1,23 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/monster/zombie/ZombieVillager.java b/net/minecraft/world/entity/monster/zombie/ZombieVillager.java
+index 8af935a11a0988f10a2908f6337504f7f6e13d1b..c6f271a921fde124df1a7c5d175cb83b420cd2e3 100644
+--- a/net/minecraft/world/entity/monster/zombie/ZombieVillager.java
++++ b/net/minecraft/world/entity/monster/zombie/ZombieVillager.java
+@@ -159,10 +159,10 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder {
+     public InteractionResult mobInteract(Player player, InteractionHand hand) {
+         ItemStack itemInHand = player.getItemInHand(hand);
+         if (itemInHand.is(Items.GOLDEN_APPLE)) {
+-            if (this.hasEffect(MobEffects.WEAKNESS)) {
++            if (this.hasEffect(MobEffects.WEAKNESS) && level().purpurConfig.zombieVillagerCureEnabled) { // Purpur - Add option to disable zombie villagers cure
+                 itemInHand.consume(1, player);
+                 if (!this.level().isClientSide()) {
+-                    this.startConverting(player.getUUID(), this.random.nextInt(2401) + 3600);
++                    this.startConverting(player.getUUID(), this.random.nextInt(level().purpurConfig.zombieVillagerCuringTimeMax - level().purpurConfig.zombieVillagerCuringTimeMin + 1) + level().purpurConfig.zombieVillagerCuringTimeMin); // Purpur - Customizable Zombie Villager curing times
+                 }
+ 
+                 return InteractionResult.SUCCESS_SERVER;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/npc/CatSpawner.java.patch

@@ -0,0 +1,49 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/npc/CatSpawner.java b/net/minecraft/world/entity/npc/CatSpawner.java
+index 5401976c4fa86e2db6622743c8e8ea7381f72878..278a4000d06690a41e58a059d54e0044944a51fe 100644
+--- a/net/minecraft/world/entity/npc/CatSpawner.java
++++ b/net/minecraft/world/entity/npc/CatSpawner.java
+@@ -23,7 +23,7 @@ public class CatSpawner implements CustomSpawner {
+     public void tick(ServerLevel level, boolean spawnEnemies) {
+         this.nextTick--;
+         if (this.nextTick <= 0) {
+-            this.nextTick = 1200;
++            this.nextTick = level.purpurConfig.catSpawnDelay; // Purpur - Cat spawning options
+             Player randomPlayer = level.getRandomPlayer();
+             if (randomPlayer != null) {
+                 RandomSource randomSource = level.random;
+@@ -45,9 +45,12 @@ public class CatSpawner implements CustomSpawner {
+     }
+ 
+     private void spawnInVillage(ServerLevel level, BlockPos pos) {
+-        int i = 48;
+-        if (level.getPoiManager().getCountInRange(holder -> holder.is(PoiTypes.HOME), pos, 48, PoiManager.Occupancy.IS_OCCUPIED) > 4L) {
+-            List<Cat> entitiesOfClass = level.getEntitiesOfClass(Cat.class, new AABB(pos).inflate(48.0, 8.0, 48.0));
++        // Purpur start - Cat spawning options
++        int range = level.purpurConfig.catSpawnVillageScanRange;
++        if (range <= 0) return;
++        if (level.getPoiManager().getCountInRange(holder -> holder.is(PoiTypes.HOME), pos, range, PoiManager.Occupancy.IS_OCCUPIED) > 4L) {
++            List<Cat> entitiesOfClass = level.getEntitiesOfClass(Cat.class, new AABB(pos).inflate(range, 8.0, range));
++        // Purpur end - Cat spawning options
+             if (entitiesOfClass.size() < 5) {
+                 this.spawnCat(pos, level, false);
+             }
+@@ -55,8 +58,11 @@ public class CatSpawner implements CustomSpawner {
+     }
+ 
+     private void spawnInHut(ServerLevel level, BlockPos pos) {
+-        int i = 16;
+-        List<Cat> entitiesOfClass = level.getEntitiesOfClass(Cat.class, new AABB(pos).inflate(16.0, 8.0, 16.0));
++        // Purpur start - Cat spawning options
++        int range = level.purpurConfig.catSpawnSwampHutScanRange;
++        if (range <= 0) return;
++        List<Cat> entitiesOfClass = level.getEntitiesOfClass(Cat.class, new AABB(pos).inflate(range, 8.0, range));
++        // Purpur end - Cat spawning options
+         if (entitiesOfClass.isEmpty()) {
+             this.spawnCat(pos, level, true);
+         }

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/npc/villager/Villager.java.patch

@@ -0,0 +1,149 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/npc/villager/Villager.java b/net/minecraft/world/entity/npc/villager/Villager.java
+index 89844d7e804cc8a2110b694e448bc5993991bea7..e117ae1b114c7e2ca314a00335473efc41137f7f 100644
+--- a/net/minecraft/world/entity/npc/villager/Villager.java
++++ b/net/minecraft/world/entity/npc/villager/Villager.java
+@@ -179,6 +179,8 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         MemoryModuleType.MEETING_POINT,
+         (villager, poiType) -> poiType.is(PoiTypes.MEETING)
+     );
++    private boolean isLobotomized = false; public boolean isLobotomized() { return this.isLobotomized; } // Purpur - Lobotomize stuck villagers
++    private int notLobotomizedCount = 0; // Purpur - Lobotomize stuck villagers
+ 
+     public Villager(EntityType<? extends Villager> type, Level level) {
+         this(type, level, VillagerType.PLAINS);
+@@ -197,6 +199,57 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         this.setVillagerData(this.getVillagerData().withType(villagerType).withProfession(level.registryAccess(), VillagerProfession.NONE));
+     }
+ 
++    // Purpur start - Allow leashing villagers
++    @Override
++    public boolean canBeLeashed() {
++        return level().purpurConfig.villagerCanBeLeashed;
++    }
++    // Purpur end - Allow leashing villagers
++
++    // Purpur start - Lobotomize stuck villagers
++    private boolean checkLobotomized() {
++        int interval = this.level().purpurConfig.villagerLobotomizeCheckInterval;
++        boolean shouldCheckForTradeLocked = this.level().purpurConfig.villagerLobotomizeWaitUntilTradeLocked;
++        if (this.notLobotomizedCount > 3) {
++            // check half as often if not lobotomized for the last 3+ consecutive checks
++            interval *= 2;
++        }
++        if (this.level().getGameTime() % interval == 0) {
++            // offset Y for short blocks like dirt_path/farmland
++            this.isLobotomized = !(shouldCheckForTradeLocked && this.getVillagerXp() == 0) && !canTravelFrom(BlockPos.containing(this.position().x, this.getBoundingBox().minY + 0.0625D, this.position().z));
++
++            if (this.isLobotomized) {
++                this.notLobotomizedCount = 0;
++            } else {
++                this.notLobotomizedCount++;
++            }
++        }
++        return this.isLobotomized;
++    }
++
++    private boolean canTravelFrom(BlockPos pos) {
++        return canTravelTo(pos.east()) || canTravelTo(pos.west()) || canTravelTo(pos.north()) || canTravelTo(pos.south());
++    }
++
++    private boolean canTravelTo(BlockPos pos) {
++        net.minecraft.world.level.block.state.BlockState state = this.level().getBlockStateIfLoaded(pos);
++        if (state == null) {
++            // chunk not loaded
++            return false;
++        }
++        net.minecraft.world.level.block.Block bottom = state.getBlock();
++        if (bottom instanceof net.minecraft.world.level.block.FenceBlock ||
++            bottom instanceof net.minecraft.world.level.block.FenceGateBlock ||
++            bottom instanceof net.minecraft.world.level.block.WallBlock) {
++            // bottom block is too tall to get over
++            return false;
++        }
++        net.minecraft.world.level.block.Block top = level().getBlockState(pos.above()).getBlock();
++        // only if both blocks have no collision
++        return !bottom.hasCollision && !top.hasCollision;
++    }
++    // Purpur end - Lobotomize stuck villagers
++
+     @Override
+     public Brain<Villager> getBrain() {
+         return (Brain<Villager>)super.getBrain();
+@@ -293,11 +346,22 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         // Paper start - EAR 2
+         this.customServerAiStep(level, false);
+     }
+-    protected void customServerAiStep(ServerLevel level, final boolean inactive) {
++    protected void customServerAiStep(ServerLevel level, boolean inactive) { // Purpur - Lobotomize stuck villagers - not final
+         // Paper end - EAR 2
+         ProfilerFiller profilerFiller = Profiler.get();
+         profilerFiller.push("villagerBrain");
+-        if (!inactive) this.getBrain().tick(level, this); // Paper - EAR 2
++        // Purpur start - Lobotomize stuck villagers
++        if (this.level().purpurConfig.villagerLobotomizeEnabled) {
++            // treat as inactive if lobotomized
++            inactive = inactive || checkLobotomized();
++        } else {
++            this.isLobotomized = false;
++        }
++        if (!inactive) {
++            this.getBrain().tick(level, this); // Paper - EAR 2
++        }
++        else if (this.isLobotomized && shouldRestock(level)) restock();
++        // Purpur end - Lobotomize stuck villagers
+         profilerFiller.pop();
+         if (this.assignProfessionWhenSpawned) {
+             this.assignProfessionWhenSpawned = false;
+@@ -369,6 +433,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+                     return InteractionResult.CONSUME;
+                 }
+ 
++                if (this.level().purpurConfig.villagerAllowTrading) // Purpur - Add config for villager trading
+                 this.startTrading(player);
+             }
+ 
+@@ -500,7 +565,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     public void updateDemand() {
+         for (MerchantOffer merchantOffer : this.getOffers()) {
+-            merchantOffer.updateDemand();
++            merchantOffer.updateDemand(this.level().purpurConfig.villagerMinimumDemand); // Purpur - Configurable minimum demand for trades
+         }
+     }
+ 
+@@ -692,7 +757,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     public boolean canBreed() {
+-        return this.foodLevel + this.countFoodPointsInInventory() >= 12 && !this.isSleeping() && this.getAge() == 0;
++        return this.level().purpurConfig.villagerCanBreed && this.foodLevel + this.countFoodPointsInInventory() >= 12 && !this.isSleeping() && this.getAge() == 0; // Purpur - Configurable villager breeding
+     }
+ 
+     private boolean hungry() {
+@@ -915,6 +980,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+     }
+ 
+     public void spawnGolemIfNeeded(ServerLevel level, long gameTime, int minVillagerAmount) {
++        if (level.purpurConfig.villagerSpawnIronGolemRadius > 0 && level.getEntitiesOfClass(net.minecraft.world.entity.animal.golem.IronGolem.class, getBoundingBox().inflate(level.purpurConfig.villagerSpawnIronGolemRadius)).size() > level.purpurConfig.villagerSpawnIronGolemLimit) return; // Purpur - Implement configurable search radius for villagers to spawn iron golems
+         if (this.wantsToSpawnGolem(gameTime)) {
+             AABB aabb = this.getBoundingBox().inflate(10.0, 10.0, 10.0);
+             List<Villager> entitiesOfClass = level.getEntitiesOfClass(Villager.class, aabb);
+@@ -982,6 +1048,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     public void startSleeping(BlockPos pos) {
++        // Purpur start - Option for beds to explode on villager sleep
++        if (level().purpurConfig.bedExplodeOnVillagerSleep && this.level().getBlockState(pos).getBlock() instanceof net.minecraft.world.level.block.BedBlock) {
++            this.level().explode(null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, (float) this.level().purpurConfig.bedExplosionPower, this.level().purpurConfig.bedExplosionFire, this.level().purpurConfig.bedExplosionEffect);
++            return;
++        }
++        // Purpur end - Option for beds to explode on villager sleep
+         super.startSleeping(pos);
+         this.brain.setMemory(MemoryModuleType.LAST_SLEPT, this.level().getGameTime());
+         this.brain.eraseMemory(MemoryModuleType.WALK_TARGET);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/npc/wanderingtrader/WanderingTrader.java.patch

@@ -0,0 +1,44 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/npc/wanderingtrader/WanderingTrader.java b/net/minecraft/world/entity/npc/wanderingtrader/WanderingTrader.java
+index 3eb6ee2ffecbdeb6057d81b7936b80e205db7cdc..aceeb9919473f5ff1b84efe950d10aa4dbc10121 100644
+--- a/net/minecraft/world/entity/npc/wanderingtrader/WanderingTrader.java
++++ b/net/minecraft/world/entity/npc/wanderingtrader/WanderingTrader.java
+@@ -61,6 +61,13 @@ public class WanderingTrader extends AbstractVillager implements Consumable.Over
+         super(type, level);
+     }
+ 
++    // Purpur start - Allow leashing villagers
++    @Override
++    public boolean canBeLeashed() {
++        return level().purpurConfig.wanderingTraderCanBeLeashed;
++    }
++    // Purpur end - Allow leashing villagers
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+@@ -81,7 +88,7 @@ public class WanderingTrader extends AbstractVillager implements Consumable.Over
+                     this,
+                     new ItemStack(Items.MILK_BUCKET),
+                     SoundEvents.WANDERING_TRADER_REAPPEARED,
+-                    wanderingTrader -> this.canDrinkMilk && this.level().isBrightOutside() && wanderingTrader.isInvisible() // Paper - Add more WanderingTrader API
++                    wanderingTrader -> level().purpurConfig.milkClearsBeneficialEffects && this.canDrinkMilk && this.level().isBrightOutside() && wanderingTrader.isInvisible() // Paper - Add more WanderingTrader API // // Purpur - Milk Keeps Beneficial Effects
+                 )
+             );
+         this.goalSelector.addGoal(1, new TradeWithPlayerGoal(this));
+@@ -124,8 +131,10 @@ public class WanderingTrader extends AbstractVillager implements Consumable.Over
+                     return InteractionResult.CONSUME;
+                 }
+ 
++                if (this.level().purpurConfig.wanderingTraderAllowTrading) { // Purpur - Add config for villager trading
+                 this.setTradingPlayer(player);
+                 this.openTradingScreen(player, this.getDisplayName(), 1);
++                } // Purpur - Add config for villager trading
+             }
+ 
+             return InteractionResult.SUCCESS;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/npc/wanderingtrader/WanderingTraderSpawner.java.patch

@@ -0,0 +1,29 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/npc/wanderingtrader/WanderingTraderSpawner.java b/net/minecraft/world/entity/npc/wanderingtrader/WanderingTraderSpawner.java
+index 44b43ca9fba989f975133f966cedd582a93d3350..7aef337fc0b6fd52c27ad5ca3f38d74f213d9725 100644
+--- a/net/minecraft/world/entity/npc/wanderingtrader/WanderingTraderSpawner.java
++++ b/net/minecraft/world/entity/npc/wanderingtrader/WanderingTraderSpawner.java
+@@ -134,7 +134,17 @@ public class WanderingTraderSpawner implements CustomSpawner {
+             int i1 = pos.getX() + this.random.nextInt(maxDistance * 2) - maxDistance;
+             int i2 = pos.getZ() + this.random.nextInt(maxDistance * 2) - maxDistance;
+             int height = level.getHeight(Heightmap.Types.WORLD_SURFACE, i1, i2);
+-            BlockPos blockPos1 = new BlockPos(i1, height, i2);
++            // Purpur start - Allow toggling special MobSpawners per world - allow traders to spawn below nether roof
++            BlockPos.MutableBlockPos blockPos1 = new BlockPos.MutableBlockPos(i1, height, i2);
++            if (level.dimensionType().hasCeiling()) {
++                do {
++                    blockPos1.relative(net.minecraft.core.Direction.DOWN);
++                } while (!level.getBlockState(blockPos1).isAir());
++                do {
++                    blockPos1.relative(net.minecraft.core.Direction.DOWN);
++                } while (level.getBlockState(blockPos1).isAir() && blockPos1.getY() > 0);
++            }
++            // Purpur end - Allow toggling special MobSpawners per world
+             if (placementType.isSpawnPositionOk(level, blockPos1, EntityType.WANDERING_TRADER)) {
+                 blockPos = blockPos1;
+                 break;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/player/Player.java.patch

@@ -0,0 +1,119 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
+index e5540b85cfa159d102a5710b4ccea5c3b61b7f1d..616c1aafcda05ae1d2a833f2f725b9eefb52cbc6 100644
+--- a/net/minecraft/world/entity/player/Player.java
++++ b/net/minecraft/world/entity/player/Player.java
+@@ -179,11 +179,20 @@ public abstract class Player extends Avatar implements ContainerUser {
+     private int currentImpulseContextResetGraceTime = 0;
+     public boolean affectsSpawning = true; // Paper - Affects Spawning API
+     public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
++    public int burpDelay = 0; // Purpur - Burp delay
++    public boolean canPortalInstant = false; // Purpur - Add portal permission bypass
+ 
+     // CraftBukkit start
+     public boolean fauxSleeping;
+     public int oldLevel = -1;
+ 
++    // Purpur start - AFK API
++    public abstract void setAfk(boolean afk);
++
++    public boolean isAfk() {
++        return false;
++    }
++    // Purpur end - AFK API
+     @Override
+     public org.bukkit.craftbukkit.entity.CraftHumanEntity getBukkitEntity() {
+         return (org.bukkit.craftbukkit.entity.CraftHumanEntity) super.getBukkitEntity();
+@@ -245,6 +254,12 @@ public abstract class Player extends Avatar implements ContainerUser {
+ 
+     @Override
+     public void tick() {
++        // Purpur start - Burp delay
++        if (this.burpDelay > 0 && --this.burpDelay == 0) {
++            this.level().playSound(null, getX(), getY(), getZ(), SoundEvents.PLAYER_BURP, SoundSource.PLAYERS, 1.0F, this.level().random.nextFloat() * 0.1F + 0.9F);
++        }
++        // Purpur end - Burp delay
++
+         this.noPhysics = this.isSpectator();
+         if (this.isSpectator() || this.isPassenger()) {
+             this.setOnGround(false);
+@@ -302,6 +317,17 @@ public abstract class Player extends Avatar implements ContainerUser {
+             this.turtleHelmetTick();
+         }
+ 
++        // Purpur start - Full netherite armor grants fire resistance
++        if (this.level().purpurConfig.playerNetheriteFireResistanceDuration > 0 && this.level().getGameTime() % 20 == 0) {
++            if (this.getItemBySlot(EquipmentSlot.HEAD).is(Items.NETHERITE_HELMET)
++                && this.getItemBySlot(EquipmentSlot.CHEST).is(Items.NETHERITE_CHESTPLATE)
++                && this.getItemBySlot(EquipmentSlot.LEGS).is(Items.NETHERITE_LEGGINGS)
++                && this.getItemBySlot(EquipmentSlot.FEET).is(Items.NETHERITE_BOOTS)) {
++                this.addEffect(new MobEffectInstance(MobEffects.FIRE_RESISTANCE, this.level().purpurConfig.playerNetheriteFireResistanceDuration, this.level().purpurConfig.playerNetheriteFireResistanceAmplifier, this.level().purpurConfig.playerNetheriteFireResistanceAmbient, this.level().purpurConfig.playerNetheriteFireResistanceShowParticles, this.level().purpurConfig.playerNetheriteFireResistanceShowIcon), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.NETHERITE_ARMOR);
++            }
++        }
++        // Purpur end - Full netherite armor grants fire resistance
++
+         this.cooldowns.tick();
+         this.updatePlayerPose();
+         if (this.currentImpulseContextResetGraceTime > 0) {
+@@ -510,7 +536,7 @@ public abstract class Player extends Avatar implements ContainerUser {
+             List<Entity> list = Lists.newArrayList();
+ 
+             for (Entity entity : entities) {
+-                if (entity.getType() == EntityType.EXPERIENCE_ORB) {
++                if (entity.getType() == EntityType.EXPERIENCE_ORB && entity.level().purpurConfig.playerExpPickupDelay >= 0) { // Purpur - Configurable player pickup exp delay
+                     list.add(entity);
+                 } else if (!entity.isRemoved()) {
+                     this.touch(entity);
+@@ -1052,7 +1078,7 @@ public abstract class Player extends Avatar implements ContainerUser {
+                     flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
+                     if (flag2) {
+                         damageSource = damageSource.critical(); // Paper - critical damage API
+-                        f *= 1.5F;
++                        f *= (float) this.level().purpurConfig.playerCriticalDamageMultiplier; // Purpur - Add config change multiplier critical damage value
+                     }
+ 
+                     float f2 = f + f1;
+@@ -1764,7 +1790,23 @@ public abstract class Player extends Avatar implements ContainerUser {
+ 
+     @Override
+     protected int getBaseExperienceReward(ServerLevel level) {
+-        return !level.getGameRules().get(GameRules.KEEP_INVENTORY) && !this.isSpectator() ? Math.min(this.experienceLevel * 7, 100) : 0;
++        // Purpur start - Add player death exp control options
++        if (!level.getGameRules().get(GameRules.KEEP_INVENTORY) && !this.isSpectator()) {
++            int toDrop;
++            try {
++                toDrop = Math.round(((Number) scriptEngine.eval("let expLevel = " + experienceLevel + "; " +
++                    "let expTotal = " + totalExperience + "; " +
++                    "let exp = " + experienceProgress + "; " +
++                    level().purpurConfig.playerDeathExpDropEquation)).floatValue());
++            } catch (javax.script.ScriptException e) {
++                e.printStackTrace();
++                toDrop = experienceLevel * 7;
++            }
++            return Math.min(toDrop, level().purpurConfig.playerDeathExpDropMax);
++        } else {
++            return 0;
++        }
++        // Purpur end - Add player death exp control options
+     }
+ 
+     @Override
+@@ -1808,6 +1850,13 @@ public abstract class Player extends Avatar implements ContainerUser {
+         return this.inventory.add(stack);
+     }
+ 
++    // Purpur start - Player ridable in water option
++    @Override
++    public boolean dismountsUnderwater() {
++        return !level().purpurConfig.playerRidableInWater;
++    }
++    // Purpur end - Player ridable in water option
++
+     public abstract @Nullable GameType gameMode();
+ 
+     @Override

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/projectile/arrow/ThrownTrident.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/projectile/arrow/ThrownTrident.java b/net/minecraft/world/entity/projectile/arrow/ThrownTrident.java
+index 483b8247d3be5839f9d764912ae5b879a9f729aa..fc29a8c27ce02ce81e3799fc999aba70b9800c10 100644
+--- a/net/minecraft/world/entity/projectile/arrow/ThrownTrident.java
++++ b/net/minecraft/world/entity/projectile/arrow/ThrownTrident.java
+@@ -72,7 +72,7 @@ public class ThrownTrident extends AbstractArrow {
+ 
+         Entity owner = this.getOwner();
+         int i = this.entityData.get(ID_LOYALTY);
+-        if (i > 0 && (this.dealtDamage || this.isNoPhysics()) && owner != null) {
++        if (i > 0 && (this.dealtDamage || this.isNoPhysics() || (level().purpurConfig.tridentLoyaltyVoidReturnHeight < 0.0D && getY() < level().purpurConfig.tridentLoyaltyVoidReturnHeight)) && owner != null) { // Purpur - Add option to allow loyalty on tridents to work in the void
+             if (!this.isAcceptibleReturnOwner()) {
+                 if (this.level() instanceof ServerLevel serverLevel && this.pickup == AbstractArrow.Pickup.ALLOWED) {
+                     this.spawnAtLocation(serverLevel, this.getPickupItem(), 0.1F);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/projectile/throwableitemprojectile/Snowball.java.patch

@@ -0,0 +1,52 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/projectile/throwableitemprojectile/Snowball.java b/net/minecraft/world/entity/projectile/throwableitemprojectile/Snowball.java
+index 89a061cd0a2b39fc05ea96ac0f5d5a8c26582f97..3dfe7eef12d40d986d2eb3f750b09b47ee04aecc 100644
+--- a/net/minecraft/world/entity/projectile/throwableitemprojectile/Snowball.java
++++ b/net/minecraft/world/entity/projectile/throwableitemprojectile/Snowball.java
+@@ -53,10 +53,40 @@ public class Snowball extends ThrowableItemProjectile {
+     protected void onHitEntity(EntityHitResult result) {
+         super.onHitEntity(result);
+         Entity entity = result.getEntity();
+-        int i = entity instanceof Blaze ? 3 : 0;
++        int i = entity.level().purpurConfig.snowballDamage >= 0 ? entity.level().purpurConfig.snowballDamage : entity instanceof Blaze ? 3 : 0; // Purpur - Add configurable snowball damage
+         entity.hurt(this.damageSources().thrown(this, this.getOwner()), i);
+     }
+ 
++    // Purpur start - options to extinguish fire blocks with snowballs - borrowed and modified code from ThrownPotion#onHitBlock and ThrownPotion#dowseFire
++    @Override
++    protected void onHitBlock(net.minecraft.world.phys.BlockHitResult blockHitResult) {
++        super.onHitBlock(blockHitResult);
++
++        if (!this.level().isClientSide()) {
++            net.minecraft.core.BlockPos pos = blockHitResult.getBlockPos();
++            net.minecraft.core.BlockPos relativePos = pos.relative(blockHitResult.getDirection());
++
++            net.minecraft.world.level.block.state.BlockState blockState = this.level().getBlockState(pos);
++
++            if (this.level().purpurConfig.snowballExtinguishesFire && this.level().getBlockState(relativePos).is(net.minecraft.world.level.block.Blocks.FIRE)) {
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this, relativePos, net.minecraft.world.level.block.Blocks.AIR.defaultBlockState())) {
++                    this.level().removeBlock(relativePos, false);
++                }
++            } else if (this.level().purpurConfig.snowballExtinguishesCandles && net.minecraft.world.level.block.AbstractCandleBlock.isLit(blockState)) {
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this, pos, blockState.setValue(net.minecraft.world.level.block.AbstractCandleBlock.LIT, false))) {
++                    net.minecraft.world.level.block.AbstractCandleBlock.extinguish(null, blockState, this.level(), pos);
++                }
++            } else if (this.level().purpurConfig.snowballExtinguishesCampfires && net.minecraft.world.level.block.CampfireBlock.isLitCampfire(blockState)) {
++                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this, pos, blockState.setValue(net.minecraft.world.level.block.CampfireBlock.LIT, false))) {
++                    this.level().levelEvent(null, 1009, pos, 0);
++                    net.minecraft.world.level.block.CampfireBlock.dowse(this.getOwner(), this.level(), pos, blockState);
++                    this.level().setBlockAndUpdate(pos, blockState.setValue(net.minecraft.world.level.block.CampfireBlock.LIT, false));
++                }
++            }
++        }
++    }
++    // Purpur end - options to extinguish fire blocks with snowballs
++
+     @Override
+     protected void onHit(HitResult result) {
+         super.onHit(result);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/projectile/throwableitemprojectile/ThrownEnderpearl.java.patch

@@ -0,0 +1,31 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/projectile/throwableitemprojectile/ThrownEnderpearl.java b/net/minecraft/world/entity/projectile/throwableitemprojectile/ThrownEnderpearl.java
+index 66df6c69a95c5ca6b07294fdb3b13eee6651d22d..6ad07d8f82c0f745d3c3c742f25d05b9b38193c2 100644
+--- a/net/minecraft/world/entity/projectile/throwableitemprojectile/ThrownEnderpearl.java
++++ b/net/minecraft/world/entity/projectile/throwableitemprojectile/ThrownEnderpearl.java
+@@ -112,9 +112,10 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+                             return;
+                         }
+                         // CraftBukkit end
+-                        if (this.random.nextFloat() < 0.05F && serverLevel.isSpawningMonsters()) {
++                        if (this.random.nextFloat() < serverLevel.purpurConfig.enderPearlEndermiteChance && serverLevel.isSpawningMonsters()) { // Purpur - Configurable Ender Pearl RNG
+                             Endermite endermite = EntityType.ENDERMITE.create(serverLevel, EntitySpawnReason.TRIGGERED);
+                             if (endermite != null) {
++                                endermite.setPlayerSpawned(true); // Purpur - Add back player spawned endermite API
+                                 endermite.snapTo(preTeleportX, preTeleportY, preTeleportZ, preTeleportYRot, preTeleportXRot); // Paper - spawn endermite at pre teleport position as teleport has been moved up
+                                 serverLevel.addFreshEntity(endermite, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.ENDER_PEARL); // Paper - add reason
+                             }
+@@ -134,7 +135,7 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+                         if (serverPlayer1 != null) {
+                             serverPlayer1.resetFallDistance();
+                             serverPlayer1.resetCurrentImpulseContext();
+-                            serverPlayer1.hurtServer(serverPlayer.level(), this.damageSources().enderPearl().eventEntityDamager(this), 5.0F); // CraftBukkit // Paper - fix DamageSource API
++                            serverPlayer1.hurtServer(serverPlayer.level(), this.damageSources().enderPearl().eventEntityDamager(this), this.level().purpurConfig.enderPearlDamage); // CraftBukkit // Paper - fix DamageSource API // Purpur - Configurable Ender Pearl damage
+                         }
+ 
+                         this.playSound(serverLevel, vec3);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/raid/Raids.java.patch

@@ -0,0 +1,50 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/raid/Raids.java b/net/minecraft/world/entity/raid/Raids.java
+index 9ded4e75da1efd2fb351fa1544dca33da8455d98..f96d8c241bc0aa44750da7231edbbc5abd802619 100644
+--- a/net/minecraft/world/entity/raid/Raids.java
++++ b/net/minecraft/world/entity/raid/Raids.java
+@@ -31,6 +31,7 @@ import org.jspecify.annotations.Nullable;
+ 
+ public class Raids extends SavedData {
+     private static final String RAID_FILE_ID = "raids";
++    public final java.util.Map<java.util.UUID, Integer> playerCooldowns = com.google.common.collect.Maps.newHashMap(); // Purpur - Raid cooldown setting
+     public static final Codec<Raids> CODEC = RecordCodecBuilder.create(
+         instance -> instance.group(
+                 Raids.RaidWithId.CODEC
+@@ -82,6 +83,17 @@ public class Raids extends SavedData {
+ 
+     public void tick(ServerLevel level) {
+         this.tick++;
++        // Purpur start - Raid cooldown setting
++        if (level.purpurConfig.raidCooldownSeconds != 0 && this.tick % 20 == 0) {
++            com.google.common.collect.ImmutableMap.copyOf(playerCooldowns).forEach((uuid, i) -> {
++                if (i < 1) {
++                    playerCooldowns.remove(uuid);
++                } else {
++                    playerCooldowns.put(uuid, i - 1);
++                }
++            });
++        }
++        // Purpur end - Raid cooldown setting
+         Iterator<Raid> iterator = this.raidMap.values().iterator();
+ 
+         while (iterator.hasNext()) {
+@@ -144,11 +156,11 @@ public class Raids extends SavedData {
+                 // }
+ 
+                 if (!raid.isStarted() || (raid.isInProgress() && raid.getRaidOmenLevel() < raid.getMaxRaidOmenLevel())) { // CraftBukkit - fixed a bug with raid: players could add up Bad Omen level even when the raid had finished
+-                    // CraftBukkit start
++                    if (serverLevel.purpurConfig.raidCooldownSeconds != 0 && playerCooldowns.containsKey(player.getUUID())) return null; // Purpur - Raid cooldown setting// CraftBukkit start
+                     if (!org.bukkit.craftbukkit.event.CraftEventFactory.callRaidTriggerEvent(serverLevel, raid, player)) {
+                         player.removeEffect(net.minecraft.world.effect.MobEffects.RAID_OMEN);
+                         return null;
+-                    }
++                    }if (serverLevel.purpurConfig.raidCooldownSeconds != 0) playerCooldowns.put(player.getUUID(), serverLevel.purpurConfig.raidCooldownSeconds); // Purpur - Raid cooldown setting
+ 
+                     if (!raid.isStarted() && !this.raidMap.containsValue(raid)) {
+                         this.raidMap.put(this.getUniqueId(), raid);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/vehicle/boat/AbstractBoat.java.patch

@@ -0,0 +1,18 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/vehicle/boat/AbstractBoat.java b/net/minecraft/world/entity/vehicle/boat/AbstractBoat.java
+index 6b337848d91cc4f24655d053bc69b0cd22447dda..d17269c9274bd29c761403138bfc56355c800d9c 100644
+--- a/net/minecraft/world/entity/vehicle/boat/AbstractBoat.java
++++ b/net/minecraft/world/entity/vehicle/boat/AbstractBoat.java
+@@ -431,6 +431,7 @@ public abstract class AbstractBoat extends VehicleEntity implements Leashable {
+             float groundFriction = this.getGroundFriction();
+             if (groundFriction > 0.0F) {
+                 this.landFriction = groundFriction;
++                if (level().purpurConfig.boatEjectPlayersOnLand) ejectPassengers(); // Purpur - Add option for boats to eject players on land
+                 return AbstractBoat.Status.ON_LAND;
+             } else {
+                 return AbstractBoat.Status.IN_AIR;

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/vehicle/minecart/NewMinecartBehavior.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/vehicle/minecart/NewMinecartBehavior.java b/net/minecraft/world/entity/vehicle/minecart/NewMinecartBehavior.java
+index 7cc494d53c9a6d2fa0d34a60da50a9d199d65340..84b11654411eaa561a9b58ffa1210ca3d3b5a7cd 100644
+--- a/net/minecraft/world/entity/vehicle/minecart/NewMinecartBehavior.java
++++ b/net/minecraft/world/entity/vehicle/minecart/NewMinecartBehavior.java
+@@ -391,7 +391,7 @@ public class NewMinecartBehavior extends MinecartBehavior {
+     private Vec3 calculateBoostTrackSpeed(Vec3 speed, BlockPos pos, BlockState state) {
+         if (state.is(Blocks.POWERED_RAIL) && state.getValue(PoweredRailBlock.POWERED)) {
+             if (speed.length() > 0.01) {
+-                return speed.normalize().scale(speed.length() + 0.06);
++                return speed.normalize().scale(speed.length() + this.level().purpurConfig.poweredRailBoostModifier); // Purpur - Configurable powered rail boost modifier
+             } else {
+                 Vec3 redstoneDirection = this.minecart.getRedstoneDirection(pos);
+                 return redstoneDirection.lengthSqr() <= 0.0 ? speed : redstoneDirection.scale(speed.length() + 0.2);

purpur-server/minecraft-patches/rejected/net/minecraft/world/entity/vehicle/minecart/OldMinecartBehavior.java.patch

@@ -0,0 +1,21 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/entity/vehicle/minecart/OldMinecartBehavior.java b/net/minecraft/world/entity/vehicle/minecart/OldMinecartBehavior.java
+index 780b53eab14a087436e5f27c8d646042f4b357c9..7ab2542ddd7494585f240657906ccee80cd7944e 100644
+--- a/net/minecraft/world/entity/vehicle/minecart/OldMinecartBehavior.java
++++ b/net/minecraft/world/entity/vehicle/minecart/OldMinecartBehavior.java
+@@ -243,8 +243,8 @@ public class OldMinecartBehavior extends MinecartBehavior {
+             Vec3 deltaMovement1 = this.getDeltaMovement();
+             double d13 = deltaMovement1.horizontalDistance();
+             if (d13 > 0.01) {
+-                double d14 = 0.06;
+-                this.setDeltaMovement(deltaMovement1.add(deltaMovement1.x / d13 * 0.06, 0.0, deltaMovement1.z / d13 * 0.06));
++                double d14 = level.purpurConfig.poweredRailBoostModifier; // Purpur - Configurable powered rail boost modifier
++                this.setDeltaMovement(deltaMovement1.add(deltaMovement1.x / d13 * level.purpurConfig.poweredRailBoostModifier, 0.0, deltaMovement1.z / d13 * level.purpurConfig.poweredRailBoostModifier)); // Purpur - Configurable powered rail boost modifier
+             } else {
+                 Vec3 deltaMovement2 = this.getDeltaMovement();
+                 double d15 = deltaMovement2.x;

purpur-server/minecraft-patches/rejected/net/minecraft/world/food/FoodData.java.patch

@@ -0,0 +1,27 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/food/FoodData.java b/net/minecraft/world/food/FoodData.java
+index f4925847ee2dac8740148ffa82d8c23c4d0c7af0..5fa21ff6624df90925a6850f9f9f092396ed8b83 100644
+--- a/net/minecraft/world/food/FoodData.java
++++ b/net/minecraft/world/food/FoodData.java
+@@ -39,6 +39,7 @@ public class FoodData {
+         int oldFoodLevel = this.foodLevel;
+         org.bukkit.event.entity.FoodLevelChangeEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callFoodLevelChangeEvent(serverPlayer, foodProperties.nutrition() + oldFoodLevel, stack);
+         if (!event.isCancelled()) {
++            if (serverPlayer.level().purpurConfig.playerBurpWhenFull && event.getFoodLevel() == 20 && oldFoodLevel < 20) serverPlayer.burpDelay = serverPlayer.level().purpurConfig.playerBurpDelay; // Purpur - Burp after eating food fills hunger bar completely
+             this.add(event.getFoodLevel() - oldFoodLevel, foodProperties.saturation());
+         }
+         serverPlayer.getBukkitEntity().sendHealthUpdate();
+@@ -87,7 +88,7 @@ public class FoodData {
+             this.tickTimer++;
+             if (this.tickTimer >= this.starvationRate) { // CraftBukkit - add regen rate manipulation
+                 if (player.getHealth() > 10.0F || difficulty == Difficulty.HARD || player.getHealth() > 1.0F && difficulty == Difficulty.NORMAL) {
+-                    player.hurtServer(serverLevel, player.damageSources().starve(), 1.0F);
++                    player.hurtServer(serverLevel, player.damageSources().starve(), player.level().purpurConfig.hungerStarvationDamage); // Purpur - Configurable hunger starvation damage
+                 }
+ 
+                 this.tickTimer = 0;

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/AbstractFurnaceMenu.java.patch

@@ -0,0 +1,25 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/AbstractFurnaceMenu.java b/net/minecraft/world/inventory/AbstractFurnaceMenu.java
+index 6e13b05ebd924d98066624d9ff6ee7f61e248617..9304bc239ffafbef3b34c5a5a42039c86acd5e80 100644
+--- a/net/minecraft/world/inventory/AbstractFurnaceMenu.java
++++ b/net/minecraft/world/inventory/AbstractFurnaceMenu.java
+@@ -121,7 +121,13 @@ public abstract class AbstractFurnaceMenu extends RecipeBookMenu {
+             } else if (slotIndex != 1 && slotIndex != 0) {
+                 if (this.canSmelt(item)) {
+                     if (!this.moveItemStackTo(item, 0, 1, false)) {
+-                        return ItemStack.EMPTY;
++                        // Purpur start - Added the ability to add combustible items
++                        if (this.isFuel(item)) {
++                            if (!this.moveItemStackTo(item, 1, 2, false)) {
++                                return ItemStack.EMPTY;
++                            }
++                        }
++                        // Purpur end - Added the ability to add combustible items
+                     }
+                 } else if (this.isFuel(item)) {
+                     if (!this.moveItemStackTo(item, 1, 2, false)) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/AnvilMenu.java.patch

@@ -0,0 +1,204 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/AnvilMenu.java b/net/minecraft/world/inventory/AnvilMenu.java
+index 7939f19b87364a32a40e58e001cea14e06348f86..b790b9476ec0a0569470d5de4067caa5373b2f6b 100644
+--- a/net/minecraft/world/inventory/AnvilMenu.java
++++ b/net/minecraft/world/inventory/AnvilMenu.java
+@@ -23,6 +23,12 @@ import net.minecraft.world.level.block.state.BlockState;
+ import org.jspecify.annotations.Nullable;
+ import org.slf4j.Logger;
+ 
++// Purpur start - Anvil API
++import net.minecraft.network.protocol.game.ClientboundContainerSetDataPacket;
++import net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket;
++import net.minecraft.server.level.ServerPlayer;
++// Purpur end - Anvil API
++
+ public class AnvilMenu extends ItemCombinerMenu {
+     public static final int INPUT_SLOT = 0;
+     public static final int ADDITIONAL_SLOT = 1;
+@@ -51,6 +57,10 @@ public class AnvilMenu extends ItemCombinerMenu {
+     private org.bukkit.craftbukkit.inventory.view.CraftAnvilView bukkitEntity;
+     // CraftBukkit end
+     public boolean bypassEnchantmentLevelRestriction = false; // Paper - bypass anvil level restrictions
++    // Purpur start - Anvil API
++    public boolean bypassCost = false;
++    public boolean canDoUnsafeEnchants = false;
++    // Purpur end - Anvil API
+ 
+     public AnvilMenu(int containerId, Inventory playerInventory) {
+         this(containerId, playerInventory, ContainerLevelAccess.NULL);
+@@ -76,12 +86,17 @@ public class AnvilMenu extends ItemCombinerMenu {
+ 
+     @Override
+     protected boolean mayPickup(Player player, boolean hasStack) {
+-        return (player.hasInfiniteMaterials() || player.experienceLevel >= this.cost.get()) && this.cost.get() > AnvilMenu.DEFAULT_DENIED_COST && hasStack; // CraftBukkit - allow cost 0 like a free item
++        return (player.hasInfiniteMaterials() || player.experienceLevel >= this.cost.get()) && (this.bypassCost || this.cost.get() > AnvilMenu.DEFAULT_DENIED_COST) && hasStack; // CraftBukkit - allow cost 0 like a free item // Purpur - Anvil API
+     }
+ 
+     @Override
+     protected void onTake(Player player, ItemStack stack) {
++        // Purpur start - Anvil API
++        ItemStack itemstack = this.activeQuickItem != null ? this.activeQuickItem : stack;
++        if (org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent.getHandlerList().getRegisteredListeners().length > 0) new org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent(player.getBukkitEntity(), getBukkitView(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack)).callEvent();
++        // Purpur end - Anvil API
+         if (!player.hasInfiniteMaterials()) {
++            if (this.bypassCost) ((ServerPlayer) player).lastSentExp = -1; else // Purpur - Anvil API
+             player.giveExperienceLevels(-this.cost.get());
+         }
+ 
+@@ -134,13 +149,19 @@ public class AnvilMenu extends ItemCombinerMenu {
+ 
+     @Override
+     public void createResult() {
++        // Purpur start - Anvil API
++        this.bypassCost = false;
++        this.canDoUnsafeEnchants = false;
++        if (org.purpurmc.purpur.event.inventory.AnvilUpdateResultEvent.getHandlerList().getRegisteredListeners().length > 0) new org.purpurmc.purpur.event.inventory.AnvilUpdateResultEvent(getBukkitView()).callEvent();
++        // Purpur end - Anvil API
++
+         ItemStack item = this.inputSlots.getItem(0);
+         this.onlyRenaming = false;
+         this.cost.set(1);
+         int i = 0;
+         long l = 0L;
+         int i1 = 0;
+-        if (!item.isEmpty() && EnchantmentHelper.canStoreEnchantments(item)) {
++        if (!item.isEmpty() && this.canDoUnsafeEnchants || EnchantmentHelper.canStoreEnchantments(item)) { // Purpur - Anvil API
+             ItemStack itemStack = item.copy();
+             ItemStack item1 = this.inputSlots.getItem(1);
+             ItemEnchantments.Mutable mutable = new ItemEnchantments.Mutable(EnchantmentHelper.getEnchantmentsForCrafting(itemStack));
+@@ -198,23 +219,34 @@ public class AnvilMenu extends ItemCombinerMenu {
+                         int intValue = entry.getIntValue();
+                         intValue = level == intValue ? intValue + 1 : Math.max(intValue, level);
+                         Enchantment enchantment = holder.value();
+-                        boolean canEnchant = enchantment.canEnchant(item);
++                        // Purpur start - Config to allow unsafe enchants
++                        boolean canEnchant = this.canDoUnsafeEnchants || org.purpurmc.purpur.PurpurConfig.allowInapplicableEnchants || enchantment.canEnchant(item); // whether the enchantment can be applied on specific item type
++                        boolean canEnchant1 = true; // whether two incompatible enchantments can be applied on a single item
++                        // Purpur end - Config to allow unsafe enchants
+                         if (this.player.hasInfiniteMaterials() || item.is(Items.ENCHANTED_BOOK)) {
+                             canEnchant = true;
+                         }
+ 
++                        java.util.Set<Holder<Enchantment>> removedEnchantments = new java.util.HashSet<>(); // Purpur - Config to allow unsafe enchants
+                         for (Holder<Enchantment> holder1 : mutable.keySet()) {
+                             if (!holder1.equals(holder) && !Enchantment.areCompatible(holder, holder1)) {
+-                                canEnchant = false;
++                                canEnchant1 = this.canDoUnsafeEnchants || org.purpurmc.purpur.PurpurConfig.allowIncompatibleEnchants; // Purpur - Anvil API // Purpur - canEnchant -> canEnchant1 - Config to allow unsafe enchants
++                                // Purpur start - Config to allow unsafe enchants
++                                if (!canEnchant1 && org.purpurmc.purpur.PurpurConfig.replaceIncompatibleEnchants) {
++                                    removedEnchantments.add(holder1);
++                                    canEnchant1 = true;
++                                }
++                                // Purpur end - Config to allow unsafe enchants
+                                 i++;
+                             }
+                         }
++                        mutable.removeIf(removedEnchantments::contains); // Purpur - Config to allow unsafe enchants
+ 
+-                        if (!canEnchant) {
++                        if (!canEnchant || !canEnchant1) { // Purpur - Config to allow unsafe enchants
+                             flag1 = true;
+                         } else {
+                             flag = true;
+-                            if (intValue > enchantment.getMaxLevel() && !this.bypassEnchantmentLevelRestriction) { // Paper - bypass anvil level restrictions
++                            if (!org.purpurmc.purpur.PurpurConfig.allowHigherEnchantsLevels && intValue > enchantment.getMaxLevel() && !this.bypassEnchantmentLevelRestriction) { // Paper - bypass anvil level restrictions // Purpur - Config to allow unsafe enchants
+                                 intValue = enchantment.getMaxLevel();
+                             }
+ 
+@@ -243,6 +275,54 @@ public class AnvilMenu extends ItemCombinerMenu {
+                 if (!this.itemName.equals(item.getHoverName().getString())) {
+                     i1 = 1;
+                     i += i1;
++                    // Purpur start - Allow anvil colors
++                    if (this.player != null) {
++                        org.bukkit.craftbukkit.entity.CraftHumanEntity player = this.player.getBukkitEntity();
++                        String name = this.itemName;
++                        boolean removeItalics = false;
++                        if (player.hasPermission("purpur.anvil.remove_italics")) {
++                            if (name.startsWith("&r")) {
++                                name = name.substring(2);
++                                removeItalics = true;
++                            } else if (name.startsWith("<r>")) {
++                                name = name.substring(3);
++                                removeItalics = true;
++                            } else if (name.startsWith("<reset>")) {
++                                name = name.substring(7);
++                                removeItalics = true;
++                            }
++                        }
++                        if (this.player.level().purpurConfig.anvilAllowColors) {
++                            if (player.hasPermission("purpur.anvil.color")) {
++                                java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("(?i)&([0-9a-fr])").matcher(name);
++                                while (matcher.find()) {
++                                    String match = matcher.group(1);
++                                    name = name.replace("&" + match, "\u00a7" + match.toLowerCase(java.util.Locale.ROOT));
++                                }
++                                //name = name.replaceAll("(?i)&([0-9a-fr])", "\u00a7$1");
++                            }
++                            if (player.hasPermission("purpur.anvil.format")) {
++                                java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("(?i)&([k-or])").matcher(name);
++                                while (matcher.find()) {
++                                    String match = matcher.group(1);
++                                    name = name.replace("&" + match, "\u00a7" + match.toLowerCase(java.util.Locale.ROOT));
++                                }
++                                //name = name.replaceAll("(?i)&([l-or])", "\u00a7$1");
++                            }
++                        }
++                        net.kyori.adventure.text.Component component;
++                        if (this.player.level().purpurConfig.anvilColorsUseMiniMessage && player.hasPermission("purpur.anvil.minimessage")) {
++                            component = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.bukkit.ChatColor.stripColor(name));
++                        } else {
++                            component = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(name);
++                        }
++                        if (removeItalics) {
++                            component = component.decoration(net.kyori.adventure.text.format.TextDecoration.ITALIC, false);
++                        }
++                        itemStack.set(DataComponents.CUSTOM_NAME, io.papermc.paper.adventure.PaperAdventure.asVanilla(component));
++                    }
++                    else
++                    // Purpur end - Allow anvil colors
+                     itemStack.set(DataComponents.CUSTOM_NAME, Component.literal(this.itemName));
+                 }
+             } else if (item.has(DataComponents.CUSTOM_NAME)) {
+@@ -267,6 +347,12 @@ public class AnvilMenu extends ItemCombinerMenu {
+                 this.onlyRenaming = true;
+             }
+ 
++            // Purpur start - Anvil API
++            if (this.bypassCost && this.cost.get() >= this.maximumRepairCost) {
++                this.cost.set(this.maximumRepairCost - 1);
++            }
++            // Purpur end - Anvil API
++
+             if (this.cost.get() >= this.maximumRepairCost && !this.player.hasInfiniteMaterials()) { // CraftBukkit
+                 itemStack = ItemStack.EMPTY;
+             }
+@@ -287,6 +373,13 @@ public class AnvilMenu extends ItemCombinerMenu {
+ 
+             org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareAnvilEvent(this.getBukkitView(), itemStack); // CraftBukkit
+             this.broadcastChanges();
++
++            // Purpur start - Anvil API
++            if ((this.canDoUnsafeEnchants || org.purpurmc.purpur.PurpurConfig.allowInapplicableEnchants || org.purpurmc.purpur.PurpurConfig.allowIncompatibleEnchants) && itemStack != ItemStack.EMPTY) { // Purpur - Config to allow unsafe enchants
++                ((ServerPlayer) this.player).connection.send(new ClientboundContainerSetSlotPacket(this.containerId, this.incrementStateId(), 2, itemStack));
++                ((ServerPlayer) this.player).connection.send(new ClientboundContainerSetDataPacket(this.containerId, 0, this.cost.get()));
++            }
++            // Purpur end - Anvil API
+         } else {
+             org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareAnvilEvent(this.getBukkitView(), ItemStack.EMPTY); // CraftBukkit
+             this.cost.set(AnvilMenu.DEFAULT_DENIED_COST); // CraftBukkit - use a variable for set a cost for denied item
+@@ -295,7 +388,7 @@ public class AnvilMenu extends ItemCombinerMenu {
+     }
+ 
+     public static int calculateIncreasedRepairCost(int oldRepairCost) {
+-        return (int)Math.min(oldRepairCost * 2L + 1L, 2147483647L);
++        return org.purpurmc.purpur.PurpurConfig.anvilCumulativeCost ? (int)Math.min(oldRepairCost * 2L + 1L, 2147483647L) : 0; // Purpur - Make anvil cumulative cost configurable
+     }
+ 
+     public boolean setItemName(String itemName) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/ArmorSlot.java.patch

@@ -0,0 +1,19 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/ArmorSlot.java b/net/minecraft/world/inventory/ArmorSlot.java
+index f9fef56709a40e2581170a807a0035b593795b05..cdc95952311e6a2df757c3d8ec1224e3e5ad3069 100644
+--- a/net/minecraft/world/inventory/ArmorSlot.java
++++ b/net/minecraft/world/inventory/ArmorSlot.java
+@@ -46,7 +46,7 @@ class ArmorSlot extends Slot {
+     @Override
+     public boolean mayPickup(Player player) {
+         ItemStack item = this.getItem();
+-        return (item.isEmpty() || player.isCreative() || !EnchantmentHelper.has(item, EnchantmentEffectComponents.PREVENT_ARMOR_CHANGE))
++        return (item.isEmpty() || player.isCreative() || (!EnchantmentHelper.has(item, EnchantmentEffectComponents.PREVENT_ARMOR_CHANGE) || player.level().purpurConfig.playerRemoveBindingWithWeakness && player.hasEffect(net.minecraft.world.effect.MobEffects.WEAKNESS))) // Purpur - Config to remove curse of binding with weakness
+             && super.mayPickup(player);
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/EnchantmentMenu.java.patch

@@ -0,0 +1,59 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/EnchantmentMenu.java b/net/minecraft/world/inventory/EnchantmentMenu.java
+index 385eecd0c59d3c9510e39f96aa9614a7a57fb65a..40860d2facd6720300793dcc2cf99cb3367e61f7 100644
+--- a/net/minecraft/world/inventory/EnchantmentMenu.java
++++ b/net/minecraft/world/inventory/EnchantmentMenu.java
+@@ -63,6 +63,22 @@ public class EnchantmentMenu extends AbstractContainerMenu {
+                 return access.getLocation();
+             }
+             // CraftBukkit end
++
++            // Purpur start - Enchantment Table Persists Lapis
++            @Override
++            public void onClose(org.bukkit.craftbukkit.entity.CraftHumanEntity who) {
++                super.onClose(who);
++
++                if (who.getHandle().level().purpurConfig.enchantmentTableLapisPersists) {
++                    access.execute((level, pos) -> {
++                        net.minecraft.world.level.block.entity.BlockEntity blockEntity = level.getBlockEntity(pos);
++                        if (blockEntity instanceof net.minecraft.world.level.block.entity.EnchantingTableBlockEntity enchantmentTable) {
++                            enchantmentTable.setLapis(this.getItem(1).getCount());
++                        }
++                    });
++                }
++            }
++            // Purpur end - Enchantment Table Persists Lapis
+         };
+         // Paper end - Add missing InventoryHolders
+         this.access = access;
+@@ -83,6 +99,16 @@ public class EnchantmentMenu extends AbstractContainerMenu {
+                 return EnchantmentMenu.EMPTY_SLOT_LAPIS_LAZULI;
+             }
+         });
++        // Purpur start - Enchantment Table Persists Lapis
++        access.execute((level, pos) -> {
++            if (level.purpurConfig.enchantmentTableLapisPersists) {
++                net.minecraft.world.level.block.entity.BlockEntity blockEntity = level.getBlockEntity(pos);
++                if (blockEntity instanceof net.minecraft.world.level.block.entity.EnchantingTableBlockEntity enchantmentTable) {
++                    this.getSlot(1).set(new ItemStack(Items.LAPIS_LAZULI, enchantmentTable.getLapis()));
++                }
++            }
++        });
++        // Purpur end - Enchantment Table Persists Lapis
+         this.addStandardInventorySlots(playerInventory, 8, 84);
+         this.addDataSlot(DataSlot.shared(this.costs, 0));
+         this.addDataSlot(DataSlot.shared(this.costs, 1));
+@@ -299,7 +325,7 @@ public class EnchantmentMenu extends AbstractContainerMenu {
+     @Override
+     public void removed(Player player) {
+         super.removed(player);
+-        this.access.execute((level, pos) -> this.clearContainer(player, this.enchantSlots));
++        this.access.execute((level, pos) -> {if (level.purpurConfig.enchantmentTableLapisPersists) this.getSlot(1).set(ItemStack.EMPTY);this.clearContainer(player, this.enchantSlots);}); // Purpur - Enchantment Table Persists Lapis
+     }
+ 
+     @Override

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/GrindstoneMenu.java.patch

@@ -0,0 +1,146 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/GrindstoneMenu.java b/net/minecraft/world/inventory/GrindstoneMenu.java
+index ad70a0f7debee27d9f3b2ff39cb0429b39485190..e991ca16d069fddc3e4eb6d8c78c0dbffeb75a54 100644
+--- a/net/minecraft/world/inventory/GrindstoneMenu.java
++++ b/net/minecraft/world/inventory/GrindstoneMenu.java
+@@ -92,11 +92,13 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+             @Override
+             public void onTake(Player player, ItemStack stack) {
+                 access.execute((level, blockPos) -> {
++                    ItemStack itemstack = activeQuickItem == null ? stack : activeQuickItem; // Purpur - Grindstone API
+                     if (level instanceof ServerLevel) {
+                         // Paper start - Fire BlockExpEvent on grindstone use
+                         org.bukkit.event.block.BlockExpEvent event = new org.bukkit.event.block.BlockExpEvent(org.bukkit.craftbukkit.block.CraftBlock.at(level, blockPos), this.getExperienceAmount(level));
+                         event.callEvent();
+-                        ExperienceOrb.awardWithDirection((ServerLevel) level, Vec3.atCenterOf(blockPos), Vec3.ZERO, event.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player, null);
++                        org.purpurmc.purpur.event.inventory.GrindstoneTakeResultEvent grindstoneTakeResultEvent = new org.purpurmc.purpur.event.inventory.GrindstoneTakeResultEvent(player.getBukkitEntity(), getBukkitView(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack), event.getExpToDrop()); grindstoneTakeResultEvent.callEvent(); // Purpur - Grindstone API
++                        ExperienceOrb.awardWithDirection((ServerLevel) level, Vec3.atCenterOf(blockPos), Vec3.ZERO, grindstoneTakeResultEvent.getExperienceAmount(), org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player, null); // Purpur - Grindstone API
+                         // Paper end - Fire BlockExpEvent on grindstone use
+                     }
+ 
+@@ -125,7 +127,7 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+                 for (Entry<Holder<Enchantment>> entry : enchantmentsForCrafting.entrySet()) {
+                     Holder<Enchantment> holder = entry.getKey();
+                     int intValue = entry.getIntValue();
+-                    if (!holder.is(EnchantmentTags.CURSE)) {
++                    if (!org.purpurmc.purpur.PurpurConfig.grindstoneIgnoredEnchants.contains(holder.value())) { // Purpur - Config for grindstones
+                         i += holder.value().getMinCost(intValue);
+                     }
+                 }
+@@ -203,15 +205,75 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+ 
+             for (Entry<Holder<Enchantment>> entry : enchantmentsForCrafting.entrySet()) {
+                 Holder<Enchantment> holder = entry.getKey();
+-                if (!holder.is(EnchantmentTags.CURSE) || mutable.getLevel(holder) == 0) {
++                if (!org.purpurmc.purpur.PurpurConfig.grindstoneIgnoredEnchants.contains(holder.value()) || mutable.getLevel(holder) == 0) { // Purpur - Config for grindstones
+                     mutable.upgrade(holder, entry.getIntValue());
+                 }
+             }
+         });
+     }
+ 
++    // Purpur start - Config for grindstones
++    private java.util.List<net.minecraft.core.component.DataComponentType<?>> GRINDSTONE_REMOVE_ATTRIBUTES_REMOVAL_LIST = java.util.List.of(
++        // DataComponents.MAX_STACK_SIZE,
++        // DataComponents.DAMAGE,
++        // DataComponents.BLOCK_STATE,
++        DataComponents.CUSTOM_DATA,
++        // DataComponents.MAX_DAMAGE,
++        // DataComponents.UNBREAKABLE,
++        // DataComponents.CUSTOM_NAME,
++        // DataComponents.ITEM_NAME,
++        // DataComponents.LORE,
++        // DataComponents.RARITY,
++        // DataComponents.ENCHANTMENTS,
++        // DataComponents.CAN_PLACE_ON,
++        // DataComponents.CAN_BREAK,
++        DataComponents.ATTRIBUTE_MODIFIERS,
++        DataComponents.CUSTOM_MODEL_DATA,
++        // DataComponents.HIDE_ADDITIONAL_TOOLTIP,
++        // DataComponents.HIDE_TOOLTIP,
++        // DataComponents.REPAIR_COST,
++        // DataComponents.CREATIVE_SLOT_LOCK,
++        // DataComponents.ENCHANTMENT_GLINT_OVERRIDE,
++        // DataComponents.INTANGIBLE_PROJECTILE,
++        // DataComponents.FOOD,
++        // DataComponents.FIRE_RESISTANT,
++        // DataComponents.TOOL,
++        // DataComponents.STORED_ENCHANTMENTS,
++        DataComponents.DYED_COLOR,
++        // DataComponents.MAP_COLOR,
++        // DataComponents.MAP_ID,
++        // DataComponents.MAP_DECORATIONS,
++        // DataComponents.MAP_POST_PROCESSING,
++        // DataComponents.CHARGED_PROJECTILES,
++        // DataComponents.BUNDLE_CONTENTS,
++        // DataComponents.POTION_CONTENTS,
++        DataComponents.SUSPICIOUS_STEW_EFFECTS
++        // DataComponents.WRITABLE_BOOK_CONTENT,
++        // DataComponents.WRITTEN_BOOK_CONTENT,
++        // DataComponents.TRIM,
++        // DataComponents.DEBUG_STICK_STATE,
++        // DataComponents.ENTITY_DATA,
++        // DataComponents.BUCKET_ENTITY_DATA,
++        // DataComponents.BLOCK_ENTITY_DATA,
++        // DataComponents.INSTRUMENT,
++        // DataComponents.OMINOUS_BOTTLE_AMPLIFIER,
++        // DataComponents.RECIPES,
++        // DataComponents.LODESTONE_TRACKER,
++        // DataComponents.FIREWORK_EXPLOSION,
++        // DataComponents.FIREWORKS,
++        // DataComponents.PROFILE,
++        // DataComponents.NOTE_BLOCK_SOUND,
++        // DataComponents.BANNER_PATTERNS,
++        // DataComponents.BASE_COLOR,
++        // DataComponents.POT_DECORATIONS,
++        // DataComponents.CONTAINER,
++        // DataComponents.BEES,
++        // DataComponents.LOCK,
++        // DataComponents.CONTAINER_LOOT,
++    );
++    // Purpur end - Config for grindstones
+     private ItemStack removeNonCursesFrom(ItemStack item) {
+-        ItemEnchantments itemEnchantments = EnchantmentHelper.updateEnchantments(item, mutable -> mutable.removeIf(holder -> !holder.is(EnchantmentTags.CURSE)));
++        ItemEnchantments itemEnchantments = EnchantmentHelper.updateEnchantments(item, mutable -> mutable.removeIf(holder -> !org.purpurmc.purpur.PurpurConfig.grindstoneIgnoredEnchants.contains(holder.value()))); // Purpur - Config for grindstones
+         if (item.is(Items.ENCHANTED_BOOK) && itemEnchantments.isEmpty()) {
+             item = item.transmuteCopy(Items.BOOK);
+         }
+@@ -223,6 +285,23 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+         }
+ 
+         item.set(DataComponents.REPAIR_COST, i);
++
++        // Purpur start - Config for grindstones
++        net.minecraft.core.component.DataComponentPatch.Builder builder = net.minecraft.core.component.DataComponentPatch.builder();
++        if (org.purpurmc.purpur.PurpurConfig.grindstoneRemoveAttributes) {
++            item.getComponents().forEach(typedDataComponent -> {
++                if (GRINDSTONE_REMOVE_ATTRIBUTES_REMOVAL_LIST.contains(typedDataComponent.type())) {
++                    builder.remove(typedDataComponent.type());
++                }
++            });
++        }
++        if (org.purpurmc.purpur.PurpurConfig.grindstoneRemoveDisplay) {
++            builder.remove(DataComponents.CUSTOM_NAME);
++            builder.remove(DataComponents.LORE);
++        }
++        item.applyComponents(builder.build());
++        // Purpur end - Config for grindstones
++
+         return item;
+     }
+ 
+@@ -279,7 +358,9 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+                 return ItemStack.EMPTY;
+             }
+ 
++            this.activeQuickItem = itemStack; // Purpur - Grindstone API
+             slot.onTake(player, item);
++            this.activeQuickItem = null; // Purpur - Grindstone API
+         }
+ 
+         return itemStack;

purpur-server/minecraft-patches/rejected/net/minecraft/world/inventory/ItemCombinerMenu.java.patch

@@ -0,0 +1,20 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/inventory/ItemCombinerMenu.java b/net/minecraft/world/inventory/ItemCombinerMenu.java
+index 1296631fc74e83e6c9d6af0cd46d12d9851a30b1..e6c3a0086963298be31befbbbf8d42e85f379c79 100644
+--- a/net/minecraft/world/inventory/ItemCombinerMenu.java
++++ b/net/minecraft/world/inventory/ItemCombinerMenu.java
+@@ -156,7 +156,9 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu {
+                 return ItemStack.EMPTY;
+             }
+ 
++            this.activeQuickItem = itemStack; // Purpur - Anvil API
+             slot.onTake(player, item);
++            this.activeQuickItem = null; // Purpur - Anvil API
+         }
+ 
+         return itemStack;

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/FarmBlock.java.patch

@@ -0,0 +1,57 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/FarmBlock.java b/net/minecraft/world/level/block/FarmBlock.java
+index da822a89e134e98696308315799d872944e7712f..75b38812b538e0938bbbde62427fa9fd23d372a1 100644
+--- a/net/minecraft/world/level/block/FarmBlock.java
++++ b/net/minecraft/world/level/block/FarmBlock.java
+@@ -112,7 +112,7 @@ public class FarmBlock extends Block {
+     public void fallOn(Level level, BlockState state, BlockPos pos, Entity entity, double fallDistance) {
+         super.fallOn(level, state, pos, entity, fallDistance); // CraftBukkit - moved here as game rules / events shouldn't affect fall damage.
+         if (level instanceof ServerLevel serverLevel
+-            && level.random.nextFloat() < fallDistance - 0.5
++            && (serverLevel.purpurConfig.farmlandTrampleHeight >= 0D ? fallDistance >= serverLevel.purpurConfig.farmlandTrampleHeight : level.random.nextFloat() < fallDistance - 0.5) // Purpur - Configurable farmland trample height
+             && entity instanceof LivingEntity
+             && (entity instanceof Player || serverLevel.getGameRules().get(GameRules.MOB_GRIEFING))
+             && entity.getBbWidth() * entity.getBbWidth() * entity.getBbHeight() > 0.512F) {
+@@ -129,6 +129,28 @@ public class FarmBlock extends Block {
+                     return;
+                 }
+ 
++                if (level.purpurConfig.farmlandTramplingDisabled) return; // Purpur - Farmland trampling changes
++                if (level.purpurConfig.farmlandTramplingOnlyPlayers && !(entity instanceof Player)) return; // Purpur - Farmland trampling changes
++
++                // Purpur start - Ability to re-add farmland mechanics from Alpha
++                if (level.purpurConfig.farmlandAlpha) {
++                    Block block = level.getBlockState(pos.below()).getBlock();
++                    if (block instanceof FenceBlock || block instanceof WallBlock) {
++                        return;
++                    }
++                }
++                // Purpur end - Ability to re-add farmland mechanics from Alpha
++
++                // Purpur start - Farmland trampling changes
++                if (level.purpurConfig.farmlandTramplingFeatherFalling) {
++                    net.minecraft.world.item.ItemStack bootsItem = ((net.minecraft.world.entity.LivingEntity) entity).getItemBySlot(net.minecraft.world.entity.EquipmentSlot.FEET);
++
++                    if (bootsItem != net.minecraft.world.item.ItemStack.EMPTY && net.minecraft.world.item.enchantment.EnchantmentHelper.getItemEnchantmentLevel(net.minecraft.world.item.enchantment.Enchantments.FEATHER_FALLING, bootsItem) >= (int) entity.fallDistance) {
++                        return;
++                    }
++                }
++                // Purpur end - Farmland trampling changes
++
+                 if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.DIRT.defaultBlockState())) {
+                     return;
+                 }
+@@ -177,7 +199,7 @@ public class FarmBlock extends Block {
+             }
+         }
+ 
+-        return false;
++        return ((ServerLevel) level).purpurConfig.farmlandGetsMoistFromBelow && level.getFluidState(pos.relative(Direction.DOWN)).is(FluidTags.WATER); // Purpur - Allow soil to moisten from water directly under it
+         // Paper end - Perf: remove abstract block iteration
+     }
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java.patch

@@ -0,0 +1,41 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+index 1215ac44fd30dc872f9d319be34e5e08ba880ea2..c0bb687b94f3baa9ffda9c47c69a1d6d244acd4e 100644
+--- a/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+@@ -187,6 +187,21 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         }
+ 
+         ItemStack itemStack = furnace.items.get(1);
++        // Purpur start - Furnace uses lava from underneath
++        boolean usedLavaFromUnderneath = false;
++        if (level.purpurConfig.furnaceUseLavaFromUnderneath && !furnace.isLit() && itemStack.isEmpty() && !furnace.items.get(0).isEmpty() && level.getGameTime() % 20 == 0) {
++            BlockPos below = furnace.getBlockPos().below();
++            BlockState belowState = level.getBlockStateIfLoaded(below);
++            if (belowState != null && belowState.is(Blocks.LAVA)) {
++                net.minecraft.world.level.material.FluidState fluidState = belowState.getFluidState();
++                if (fluidState != null && fluidState.isSource()) {
++                    level.setBlock(below, Blocks.AIR.defaultBlockState(), 3);
++                    itemStack = Items.LAVA_BUCKET.getDefaultInstance();
++                    usedLavaFromUnderneath = true;
++                }
++            }
++        }
++        // Purpur end - Furnace uses lava from underneath
+         ItemStack itemStack1 = furnace.items.get(0);
+         boolean flag1 = !itemStack1.isEmpty();
+         boolean flag2 = !itemStack.isEmpty();
+@@ -270,6 +285,8 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         if (flag) {
+             setChanged(level, pos, state);
+         }
++
++        if (usedLavaFromUnderneath) furnace.items.set(1, ItemStack.EMPTY); // Purpur - Furnace uses lava from underneath
+     }
+ 
+     private static boolean canBurn(

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/BeaconBlockEntity.java.patch

@@ -0,0 +1,66 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+index 0db33d7e1227e914326e9eb3b50338b001872938..cc301cff64e1bf604a1432f6e36be8aa17db53e7 100644
+--- a/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -138,6 +138,16 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+ 
+     public double getEffectRange() {
+         if (this.effectRange < 0) {
++            // Purpur start - Beacon Activation Range Configurable
++            if (this.level != null) {
++                switch (this.levels) {
++                    case 1: return this.level.purpurConfig.beaconLevelOne;
++                    case 2: return this.level.purpurConfig.beaconLevelTwo;
++                    case 3: return this.level.purpurConfig.beaconLevelThree;
++                    case 4: return this.level.purpurConfig.beaconLevelFour;
++                }
++            }
++            // Purpur end - Beacon Activation Range Configurable
+             return this.levels * 10 + 10;
+         } else {
+             return effectRange;
+@@ -166,6 +176,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+         int y = pos.getY();
+         int z = pos.getZ();
+         BlockPos blockPos;
++        boolean isTintedGlass = false; // Purpur - allow beacon effects when covered by tinted glass
+         if (blockEntity.lastCheckY < y) {
+             blockPos = pos;
+             blockEntity.checkingBeamSections = Lists.newArrayList();
+@@ -195,11 +206,15 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+                     }
+                 }
+             } else {
+-                if (section == null || blockState.getLightBlock() >= 15 && !blockState.is(Blocks.BEDROCK)) {
++                if (level.purpurConfig.beaconAllowEffectsWithTintedGlass && blockState.getBlock().equals(Blocks.TINTED_GLASS)) {isTintedGlass = true;} // Purpur - allow beacon effects when covered by tinted glass
++                // Purpur start - fix effects being applied when tinted glass is covered
++                if (section == null || blockState.getLightBlock() >= 15 && !blockState.is(Blocks.BEDROCK) && !(blockState.getBlock().equals(Blocks.TINTED_GLASS) && level.purpurConfig.beaconAllowEffectsWithTintedGlass)) {
+                     blockEntity.checkingBeamSections.clear();
+                     blockEntity.lastCheckY = height;
++                    isTintedGlass = false;
+                     break;
+                 }
++                // Purpur end - fix effects being applied when tinted glass is covered
+ 
+                 section.increaseHeight();
+             }
+@@ -210,11 +225,11 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+ 
+         int i = blockEntity.levels; final int originalLevels = i; // Paper - OBFHELPER
+         if (level.getGameTime() % 80L == 0L) {
+-            if (!blockEntity.beamSections.isEmpty()) {
++            if (!blockEntity.beamSections.isEmpty() || (level.purpurConfig.beaconAllowEffectsWithTintedGlass && isTintedGlass)) { // Purpur - fix beacon effects persisting with broken base while tinted glass is used
+                 blockEntity.levels = updateBase(level, x, y, z);
+             }
+ 
+-            if (blockEntity.levels > 0 && !blockEntity.beamSections.isEmpty()) {
++            if (blockEntity.levels > 0 && (!blockEntity.beamSections.isEmpty() || (level.purpurConfig.beaconAllowEffectsWithTintedGlass && isTintedGlass))) { // Purpur - allow beacon effects when covered by tinted glass
+                 applyEffects(level, pos, blockEntity.levels, blockEntity.primaryPower, blockEntity.secondaryPower, blockEntity); // Paper - Custom beacon ranges
+                 playSound(level, pos, SoundEvents.BEACON_AMBIENT);
+             }

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java.patch

@@ -0,0 +1,64 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java b/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+index c989b7d52e16d93e65afb0f921d514c68b814921..9261bc38258ee80aa6ec2f4bcb27a48c01f84b8f 100644
+--- a/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+@@ -79,7 +79,7 @@ public class BeehiveBlockEntity extends BlockEntity {
+         "leash",
+         "UUID"
+     );
+-    public static final int MAX_OCCUPANTS = 3;
++    public static final int MAX_OCCUPANTS = org.purpurmc.purpur.PurpurConfig.beeInsideBeeHive; // Purpur - Config to change max number of bees
+     private static final int MIN_TICKS_BEFORE_REENTERING_HIVE = 400;
+     private static final int MIN_OCCUPATION_TICKS_NECTAR = 2400;
+     public static final int MIN_OCCUPATION_TICKS_NECTARLESS = 600;
+@@ -153,11 +153,33 @@ public class BeehiveBlockEntity extends BlockEntity {
+         return list;
+     }
+ 
++    // Purpur start - Stored Bee API
++    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 - Stored Bee API
++
+     @VisibleForDebug
+     public int getOccupantCount() {
+         return this.stored.size();
+     }
+ 
++    // Purpur start - Stored Bee API
++    public List<BeeData> getStored() {
++        return stored;
++    }
++    // Purpur end - Stored Bee API
++
+     // Paper start - Add EntityBlockStorage clearEntities
+     public void clearBees() {
+         this.stored.clear();
+@@ -398,8 +420,8 @@ public class BeehiveBlockEntity extends BlockEntity {
+         registrar.register(DebugSubscriptions.BEE_HIVES, () -> DebugHiveInfo.pack(this));
+     }
+ 
+-    static class BeeData {
+-        private final BeehiveBlockEntity.Occupant occupant;
++    public static class BeeData { // Purpur - make public - Stored Bee API
++        public final BeehiveBlockEntity.Occupant occupant; // Purpur - make public - Stored Bee API
+         private int exitTickCounter; // Paper - Fix bees aging inside hives; separate counter for checking if bee should exit to reduce exit attempts
+         private int ticksInHive;
+ 

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/BlockEntity.java.patch

@@ -0,0 +1,50 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/BlockEntity.java b/net/minecraft/world/level/block/entity/BlockEntity.java
+index fb22ebe9758014ebf2aebcda21155f1c4c83fafe..7cbb92c23f0b3d49b8ea6cd66ed4f377dd22ee98 100644
+--- a/net/minecraft/world/level/block/entity/BlockEntity.java
++++ b/net/minecraft/world/level/block/entity/BlockEntity.java
+@@ -105,6 +105,10 @@ public abstract class BlockEntity implements DebugValueSource {
+         input.read("PublicBukkitValues", CompoundTag.CODEC)
+             .ifPresent(this.persistentDataContainer::putAll);
+         // Paper end - read persistent data container
++
++
++        this.persistentLore = input.read("Purpur.persistentLore", net.minecraft.world.item.component.ItemLore.CODEC).orElse(null); // Purpur - Persistent BlockEntity Lore and DisplayName
++
+     }
+ 
+     public final void loadWithComponents(ValueInput input) {
+@@ -117,6 +121,11 @@ public abstract class BlockEntity implements DebugValueSource {
+     }
+ 
+     protected void saveAdditional(ValueOutput output) {
++        // Purpur start - Persistent BlockEntity Lore and DisplayName
++        if (this.persistentLore != null) {
++            output.store("Purpur.persistentLore", net.minecraft.world.item.component.ItemLore.CODEC, this.persistentLore);
++        }
++        // Purpur end - Persistent BlockEntity Lore and DisplayName
+     }
+ 
+     public final CompoundTag saveWithFullMetadata(HolderLookup.Provider registries) {
+@@ -402,4 +411,16 @@ public abstract class BlockEntity implements DebugValueSource {
+             return this.blockEntity.getNameForReporting() + "@" + this.blockEntity.getBlockPos();
+         }
+     }
++
++    // Purpur start - Persistent BlockEntity Lore and DisplayName
++    private net.minecraft.world.item.component.@Nullable ItemLore persistentLore = null;
++
++    public void setPersistentLore(net.minecraft.world.item.component.ItemLore lore) {
++        this.persistentLore = lore;
++    }
++
++    public @org.jetbrains.annotations.Nullable net.minecraft.world.item.component.ItemLore getPersistentLore() {
++        return this.persistentLore;
++    }
++    // Purpur end - Persistent BlockEntity Lore and DisplayName
+ }

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/ConduitBlockEntity.java.patch

@@ -0,0 +1,74 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/ConduitBlockEntity.java b/net/minecraft/world/level/block/entity/ConduitBlockEntity.java
+index be4b46d56ca67cb5c0fac5e0bbc9456fb5552d78..816d9a0f7f35b95b369ffbfc02e4d1f306b814c5 100644
+--- a/net/minecraft/world/level/block/entity/ConduitBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/ConduitBlockEntity.java
+@@ -150,7 +150,7 @@ public class ConduitBlockEntity extends BlockEntity {
+                         BlockPos blockPos1 = pos.offset(i, i1, i2x);
+                         BlockState blockState = level.getBlockState(blockPos1);
+ 
+-                        for (Block block : VALID_BLOCKS) {
++                        for (Block block : level.purpurConfig.conduitBlocks) { // Purpur - Conduit behavior configuration
+                             if (blockState.is(block)) {
+                                 positions.add(blockPos1);
+                             }
+@@ -165,13 +165,13 @@ public class ConduitBlockEntity extends BlockEntity {
+ 
+     private static void applyEffects(Level level, BlockPos pos, List<BlockPos> positions) {
+         // CraftBukkit start
+-        ConduitBlockEntity.applyEffects(level, pos, ConduitBlockEntity.getRange(positions));
++        ConduitBlockEntity.applyEffects(level, pos, ConduitBlockEntity.getRange(positions, level)); // Purpur - Conduit behavior configuration
+     }
+ 
+-    public static int getRange(List<BlockPos> positions) {
++    public static int getRange(List<BlockPos> positions, Level level) { // Purpur - Conduit behavior configuration
+         // CraftBukkit end
+         int size = positions.size();
+-        int i = size / 7 * 16;
++        int i = size / 7 * level.purpurConfig.conduitDistance; // Purpur - Conduit behavior configuration
+         // CraftBukkit start
+         return i;
+     }
+@@ -201,7 +201,7 @@ public class ConduitBlockEntity extends BlockEntity {
+         EntityReference<LivingEntity> entityReference = updateDestroyTarget(blockEntity.destroyTarget, level, pos, canDestroy);
+         LivingEntity livingEntity = EntityReference.getLivingEntity(entityReference, level);
+         if (damageTarget && livingEntity != null) { // CraftBukkit
+-            if (livingEntity.hurtServer(level, level.damageSources().magic().eventBlockDamager(level, pos), 4.0F)) // CraftBukkit - move up
++            if (livingEntity.hurtServer(level, level.damageSources().magic().eventBlockDamager(level, pos), level.purpurConfig.conduitDamageAmount)) // CraftBukkit - move up // Purpur - Conduit behavior configuration
+             level.playSound(
+                 null, livingEntity.getX(), livingEntity.getY(), livingEntity.getZ(), SoundEvents.CONDUIT_ATTACK_TARGET, SoundSource.BLOCKS, 1.0F, 1.0F
+             );
+@@ -222,19 +222,25 @@ public class ConduitBlockEntity extends BlockEntity {
+             return selectNewTarget(level, pos);
+         } else {
+             LivingEntity livingEntity = EntityReference.getLivingEntity(destroyTarget, level);
+-            return livingEntity != null && livingEntity.isAlive() && pos.closerThan(livingEntity.blockPosition(), 8.0) ? destroyTarget : null;
++            return livingEntity != null && livingEntity.isAlive() && pos.closerThan(livingEntity.blockPosition(), level.purpurConfig.conduitDamageDistance) ? destroyTarget : null; // Purpur - Conduit behavior configuration
+         }
+     }
+ 
+     private static @Nullable EntityReference<LivingEntity> selectNewTarget(ServerLevel level, BlockPos pos) {
+         List<LivingEntity> entitiesOfClass = level.getEntitiesOfClass(
+-            LivingEntity.class, getDestroyRangeAABB(pos), livingEntity -> livingEntity instanceof Enemy && livingEntity.isInWaterOrRain()
++            LivingEntity.class, getDestroyRangeAABB(pos, level), livingEntity -> livingEntity instanceof Enemy && livingEntity.isInWaterOrRain() // Purpur - Conduit behavior configuration
+         );
+         return entitiesOfClass.isEmpty() ? null : EntityReference.of(Util.getRandom(entitiesOfClass, level.random));
+     }
+ 
+     public static AABB getDestroyRangeAABB(BlockPos pos) {
+-        return new AABB(pos).inflate(8.0);
++        // Purpur start - Conduit behavior configuration
++        return getDestroyRangeAABB(pos, null);
++    }
++
++    private static AABB getDestroyRangeAABB(BlockPos pos, Level level) {
++        // Purpur end - Conduit behavior configuration
++        return new AABB(pos).inflate(level == null ? 8.0 : level.purpurConfig.conduitDamageDistance); // Purpur - Conduit behavior configuration
+     }
+ 
+     private static void animationTick(Level level, BlockPos pos, List<BlockPos> positions, @Nullable Entity entity, int tickCount) {

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/entity/SignBlockEntity.java.patch

@@ -0,0 +1,73 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/entity/SignBlockEntity.java b/net/minecraft/world/level/block/entity/SignBlockEntity.java
+index ce6108ea608463a28f9349010e912f23a7a1cb0c..e93f399c02aa3c47b08e33b8cf2f8b474273c33b 100644
+--- a/net/minecraft/world/level/block/entity/SignBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/SignBlockEntity.java
+@@ -149,16 +149,32 @@ public class SignBlockEntity extends BlockEntity {
+         return this.setText(updater.apply(text), isFrontText);
+     }
+ 
++    // Purpur start - Signs allow color codes
++    private Component translateColors(org.bukkit.entity.Player player, String line, Style style) {
++        if (level.purpurConfig.signAllowColors) {
++            if (player.hasPermission("purpur.sign.color")) line = line.replaceAll("(?i)&([0-9a-fr])", "\u00a7$1");
++            if (player.hasPermission("purpur.sign.style")) line = line.replaceAll("(?i)&([l-or])", "\u00a7$1");
++            if (player.hasPermission("purpur.sign.magic")) line = line.replaceAll("(?i)&([kr])", "\u00a7$1");
++
++            return io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(line));
++        } else {
++            return Component.literal(line).setStyle(style);
++        }
++    }
++    // Purpur end - Signs allow color codes
++
+     private SignText setMessages(Player player, List<FilteredText> filteredText, SignText text, boolean front) { // CraftBukkit
+         SignText originalText = text; // CraftBukkit
+         for (int i = 0; i < filteredText.size(); i++) {
+             FilteredText filteredText1 = filteredText.get(i);
+             Style style = text.getMessage(i, player.isTextFilteringEnabled()).getStyle();
++
++            org.bukkit.entity.Player craftPlayer =  (org.bukkit.craftbukkit.entity.CraftPlayer) player.getBukkitEntity(); // Purpur - Signs allow color codes
+             if (player.isTextFilteringEnabled()) {
+-                text = text.setMessage(i, Component.literal(net.minecraft.util.StringUtil.filterText(filteredText1.filteredOrEmpty())).setStyle(style)); // Paper - filter sign text to chat only
++                text = text.setMessage(i, translateColors(craftPlayer, net.minecraft.util.StringUtil.filterText(filteredText1.filteredOrEmpty()), style)); // Paper - filter sign text to chat only // Purpur - Signs allow color codes
+             } else {
+                 text = text.setMessage(
+-                    i, Component.literal(filteredText1.raw()).setStyle(style), Component.literal(net.minecraft.util.StringUtil.filterText(filteredText1.filteredOrEmpty())).setStyle(style) // Paper - filter sign text to chat only
++                    i, translateColors(craftPlayer, net.minecraft.util.StringUtil.filterText(filteredText1.raw()), style), translateColors(craftPlayer, net.minecraft.util.StringUtil.filterText(filteredText1.filteredOrEmpty()), style) // Paper - filter sign text to chat only // Purpur - Signs allow color codes
+                 );
+             }
+         }
+@@ -308,6 +324,27 @@ public class SignBlockEntity extends BlockEntity {
+         return new CommandSourceStack(commandSource, Vec3.atCenterOf(pos), Vec2.ZERO, level, LevelBasedPermissionSet.GAMEMASTER, string, component, level.getServer(), player); // Paper - Fix commands from signs not firing command events
+     }
+ 
++    // Purpur start - Signs allow color codes
++    public ClientboundBlockEntityDataPacket getTranslatedUpdatePacket(boolean filtered, boolean front) {
++        try (net.minecraft.util.ProblemReporter.ScopedCollector scopedCollector = new net.minecraft.util.ProblemReporter.ScopedCollector(this.problemPath(), LOGGER)) {
++            net.minecraft.world.level.storage.TagValueOutput tagValueOutput = net.minecraft.world.level.storage.TagValueOutput.createWithContext(scopedCollector, this.getLevel().registryAccess());
++            this.saveAdditional(tagValueOutput);
++
++            final Component[] lines = front ? frontText.getMessages(filtered) : backText.getMessages(filtered);
++            final String side = front ? "front_text" : "back_text";
++            net.minecraft.world.level.storage.ValueOutput sideNbt = tagValueOutput.child(side);
++            net.minecraft.world.level.storage.ValueOutput.TypedOutputList<String> messagesNbt = sideNbt.list("messages", com.mojang.serialization.Codec.STRING);
++            for (int i = 0; i < 4; i++) {
++                final net.kyori.adventure.text.Component component = io.papermc.paper.adventure.PaperAdventure.asAdventure(lines[i]);
++                final String line = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().serialize(component);
++                messagesNbt.add(line);
++            }
++            tagValueOutput.putString("PurpurEditor", "true");
++            return ClientboundBlockEntityDataPacket.create(this, (blockEntity, registryAccess) -> tagValueOutput.buildResult());
++        }
++    }
++    // Purpur end - Signs allow color codes
++
+     @Override
+     public ClientboundBlockEntityDataPacket getUpdatePacket() {
+         return ClientboundBlockEntityDataPacket.create(this);

purpur-server/minecraft-patches/rejected/net/minecraft/world/level/block/piston/PistonStructureResolver.java.patch

@@ -0,0 +1,37 @@
+From 56a0a83ddb1b7472dbc9762e2aca396605c62085 Mon Sep 17 00:00:00 2001
+From: File <noreply+automated@papermc.io>
+Date: Sun, 20 Apr 1997 05:37:42 -0800
+Subject: [PATCH] purpur File Patches
+
+
+diff --git a/net/minecraft/world/level/block/piston/PistonStructureResolver.java b/net/minecraft/world/level/block/piston/PistonStructureResolver.java
+index ad143a92569f5b420ccaa2089758b2fb3b4ab7c5..5a3660e02bc805e9a35a81b8a61f07b3f20b5ba9 100644
+--- a/net/minecraft/world/level/block/piston/PistonStructureResolver.java
++++ b/net/minecraft/world/level/block/piston/PistonStructureResolver.java
+@@ -81,7 +81,7 @@ public class PistonStructureResolver {
+             return true;
+         } else {
+             int i = 1;
+-            if (i + this.toPush.size() > 12) {
++            if (i + this.toPush.size() > this.level.purpurConfig.pistonBlockPushLimit) { // Purpur - Configurable piston push limit
+                 return false;
+             } else {
+                 while (isSticky(blockState)) {
+@@ -95,7 +95,7 @@ public class PistonStructureResolver {
+                         break;
+                     }
+ 
+-                    if (++i + this.toPush.size() > 12) {
++                    if (++i + this.toPush.size() > this.level.purpurConfig.pistonBlockPushLimit) { // Purpur - Configurable piston push limit
+                         return false;
+                     }
+                 }
+@@ -140,7 +140,7 @@ public class PistonStructureResolver {
+                         return true;
+                     }
+ 
+-                    if (this.toPush.size() >= 12) {
++                    if (this.toPush.size() >= this.level.purpurConfig.pistonBlockPushLimit) { // Purpur - Configurable piston push limit
+                         return false;
+                     }
+