patches

2026-02-19 01:17:42 +01:00 · 2022-06-08 10:32:02 -04:00
parent e217008618
commit 9b5c48b84d
291 changed files with 6635 additions and 1160 deletions
--- a/patches/unapplied/0021-Alternative-Keepalive-Handling.patch
+++ b/patches/unapplied/0021-Alternative-Keepalive-Handling.patch
@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 11 Oct 2019 00:17:39 -0500
+Subject: [PATCH] Alternative Keepalive Handling
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index d9e4a2c56820ea6de0d31721e1796ea7165cb256..1c380b6954edb6806a1b3bfc66e1b6a19c0fd219 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -227,6 +227,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+     private long keepAliveTime = Util.getMillis();
+     private boolean keepAlivePending;
+     private long keepAliveChallenge;
+    private java.util.List<Long> keepAlives = new java.util.ArrayList<>(); // Purpur
+     // CraftBukkit start - multithreaded fields
+     private final AtomicInteger chatSpamTickCount = new AtomicInteger();
+     private final java.util.concurrent.atomic.AtomicInteger tabSpamLimiter = new java.util.concurrent.atomic.AtomicInteger(); // Paper - configurable tab spam limits
+@@ -370,6 +371,21 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+         long currentTime = Util.getMillis();
+         long elapsedTime = currentTime - this.keepAliveTime;
+ 
+        // Purpur start
+        if (org.purpurmc.purpur.PurpurConfig.useAlternateKeepAlive) {
+            if (elapsedTime >= 1000L) { // 1 second
+                if (!processedDisconnect && keepAlives.size() > KEEPALIVE_LIMIT) {
+                    LOGGER.warn("{} was kicked due to keepalive timeout!", player.getName());
+                    disconnect(new TranslatableComponent("disconnect.timeout"));
+                } else {
+                    keepAliveTime = currentTime; // hijack this field for 1 second intervals
+                    keepAlives.add(currentTime); // currentTime is ID
+                    send(new ClientboundKeepAlivePacket(currentTime));
+                }
+            }
+        } else
+        // Purpur end
+
+         if (this.keepAlivePending) {
+             if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
+                 ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getScoreboardName()); // more info
+@@ -3171,6 +3187,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+ 
+     @Override
+     public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
+        // Purpur start
+        if (org.purpurmc.purpur.PurpurConfig.useAlternateKeepAlive) {
+            long id = packet.getId();
+            if (keepAlives.size() > 0 && keepAlives.contains(id)) {
+                int ping = (int) (Util.getMillis() - id);
+                player.latency = (player.latency * 3 + ping) / 4;
+                keepAlives.clear(); // we got a valid response, lets roll with it and forget the rest
+            }
+        } else
+        // Purpur end
+         //PlayerConnectionUtils.ensureMainThread(packetplayinkeepalive, this, this.player.getWorldServer()); // CraftBukkit // Paper - This shouldn't be on the main thread
+         if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
+             int i = (int) (Util.getMillis() - this.keepAliveTime);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 3b417ecebe7bb621aee76d5155d97695c826f4a6..8124b27f043beb763d70881593a883e06ea59f6e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -191,6 +191,11 @@ public class PurpurConfig {
+         laggingThreshold = getDouble("settings.lagging-threshold", laggingThreshold);
+     }
+ 
+    public static boolean useAlternateKeepAlive = false;
+    private static void useAlternateKeepAlive() {
+        useAlternateKeepAlive = getBoolean("settings.use-alternate-keepalive", useAlternateKeepAlive);
+    }
+
+     public static int barrelRows = 3;
+     public static boolean enderChestSixRows = false;
+     public static boolean enderChestPermissionRows = false;
--- a/patches/unapplied/0022-Silk-touch-spawners.patch
+++ b/patches/unapplied/0022-Silk-touch-spawners.patch
@@ -0,0 +1,213 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 9 May 2019 14:27:37 -0500
+Subject: [PATCH] Silk touch spawners
+
+
+diff --git a/src/main/java/net/minecraft/world/item/Items.java b/src/main/java/net/minecraft/world/item/Items.java
+index 20444c6887cbdd444b23bf018a6d63f22359e5e7..85329295afacad3edb6865846166aa56ebae0ed2 100644
+--- a/src/main/java/net/minecraft/world/item/Items.java
+++ b/src/main/java/net/minecraft/world/item/Items.java
+@@ -258,7 +258,7 @@ public class Items {
+     public static final Item PURPUR_BLOCK = registerBlock(Blocks.PURPUR_BLOCK, CreativeModeTab.TAB_BUILDING_BLOCKS);
+     public static final Item PURPUR_PILLAR = registerBlock(Blocks.PURPUR_PILLAR, CreativeModeTab.TAB_BUILDING_BLOCKS);
+     public static final Item PURPUR_STAIRS = registerBlock(Blocks.PURPUR_STAIRS, CreativeModeTab.TAB_BUILDING_BLOCKS);
+-    public static final Item SPAWNER = registerBlock(new BlockItem(Blocks.SPAWNER, (new Item.Properties()).rarity(Rarity.EPIC)));
+    public static final Item SPAWNER = registerBlock(Blocks.SPAWNER, new org.purpurmc.purpur.item.SpawnerItem(Blocks.SPAWNER, new Item.Properties().rarity(Rarity.EPIC))); // Purpur
+     public static final Item OAK_STAIRS = registerBlock(Blocks.OAK_STAIRS, CreativeModeTab.TAB_BUILDING_BLOCKS);
+     public static final Item CHEST = registerBlock(Blocks.CHEST, CreativeModeTab.TAB_DECORATIONS);
+     public static final Item CRAFTING_TABLE = registerBlock(Blocks.CRAFTING_TABLE, CreativeModeTab.TAB_DECORATIONS);
+diff --git a/src/main/java/net/minecraft/world/level/block/SpawnerBlock.java b/src/main/java/net/minecraft/world/level/block/SpawnerBlock.java
+index 130ffb06b12565efb35afb55b6da20b1b16f6f06..4ebe35d522e43a847c6a7f6b4fa529092630823d 100644
+--- a/src/main/java/net/minecraft/world/level/block/SpawnerBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SpawnerBlock.java
+@@ -1,9 +1,19 @@
+ package net.minecraft.world.level.block;
+ 
+ import javax.annotation.Nullable;
+
+import net.kyori.adventure.text.minimessage.MiniMessage;
+ import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.StringTag;
+import net.minecraft.resources.ResourceLocation;
+ import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.enchantment.EnchantmentHelper;
+import net.minecraft.world.item.enchantment.Enchantments;
+ import net.minecraft.world.level.BlockGetter;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.block.entity.BlockEntity;
+@@ -13,6 +23,20 @@ import net.minecraft.world.level.block.entity.SpawnerBlockEntity;
+ import net.minecraft.world.level.block.state.BlockBehaviour;
+ import net.minecraft.world.level.block.state.BlockState;
+ 
+// Purpur start
+import io.papermc.paper.adventure.PaperAdventure;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextReplacementConfig;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
+
+import static net.kyori.adventure.text.format.TextDecoration.ITALIC;
+// Purpur end
+
+ public class SpawnerBlock extends BaseEntityBlock {
+ 
+     protected SpawnerBlock(BlockBehaviour.Properties settings) {
+@@ -30,6 +54,55 @@ public class SpawnerBlock extends BaseEntityBlock {
+         return createTickerHelper(type, BlockEntityType.MOB_SPAWNER, world.isClientSide ? SpawnerBlockEntity::clientTick : SpawnerBlockEntity::serverTick);
+     }
+ 
+    // Purpur start
+    @Override
+    public void playerDestroy(Level level, Player player, BlockPos pos, BlockState state, BlockEntity blockEntity, ItemStack stack) {
+        if (level.purpurConfig.silkTouchEnabled && player.getBukkitEntity().hasPermission("purpur.drop.spawners") && isSilkTouch(level, stack)) {
+            Optional<EntityType<?>> type = EntityType.by(((SpawnerBlockEntity) blockEntity).getSpawner().nextSpawnData.getEntityToSpawn());
+            if (type.isPresent()) {
+                final Component mobName = PaperAdventure.asAdventure(type.get().getDescription());
+                CompoundTag display = new CompoundTag();
+                CompoundTag tag = new CompoundTag();
+
+                String name = level.purpurConfig.silkTouchSpawnerName;
+                if (name != null && !name.isEmpty() && !name.equals("Spawner")) {
+                    Component displayName = MiniMessage.miniMessage().deserialize(name, net.kyori.adventure.text.minimessage.tag.resolver.Placeholder.component("mob", mobName));
+                    if (name.startsWith("<reset>")) {
+                        displayName = displayName.decoration(ITALIC, false);
+                    }
+                    display.put("Name", StringTag.valueOf(PaperAdventure.asJsonString(displayName, Locale.ROOT)));
+                    tag.put("display", display);
+                }
+
+                List<String> lore = level.purpurConfig.silkTouchSpawnerLore;
+                if (lore != null && !lore.isEmpty()) {
+                    ListTag list = new ListTag();
+                    for (String line : lore) {
+                        Component lineComponent = MiniMessage.miniMessage().deserialize(line, net.kyori.adventure.text.minimessage.tag.resolver.Placeholder.component("mob", mobName));
+                        if (line.startsWith("<reset>")) {
+                            lineComponent = lineComponent.decoration(ITALIC, false);
+                        }
+                        list.add(StringTag.valueOf(PaperAdventure.asJsonString(lineComponent, Locale.ROOT)));
+                    }
+                    display.put("Lore", list);
+                    tag.put("display", display);
+                }
+
+                ItemStack item = new ItemStack(Blocks.SPAWNER.asItem());
+                tag.putString("Purpur.mob_type", type.get().getName());
+                item.setTag(tag);
+
+                popResource(level, pos, item);
+            }
+        }
+        super.playerDestroy(level, player, pos, state, blockEntity, stack);
+    }
+
+    private boolean isSilkTouch(Level level, ItemStack stack) {
+        return stack != null && level.purpurConfig.silkTouchTools.contains(stack.getItem()) && EnchantmentHelper.getItemEnchantmentLevel(Enchantments.SILK_TOUCH, stack) >= level.purpurConfig.minimumSilkTouchSpawnerRequire;
+    }
+    // Purpur end
+
+     @Override
+     public void spawnAfterBreak(BlockState state, ServerLevel world, BlockPos pos, ItemStack stack) {
+         super.spawnAfterBreak(state, world, pos, stack);
+@@ -38,6 +111,7 @@ public class SpawnerBlock extends BaseEntityBlock {
+ 
+     @Override
+     public int getExpDrop(BlockState iblockdata, ServerLevel worldserver, BlockPos blockposition, ItemStack itemstack) {
+        if (isSilkTouch(worldserver, itemstack)) return 0; // Purpur
+         int i = 15 + worldserver.random.nextInt(15) + worldserver.random.nextInt(15);
+ 
+         // this.popExperience(worldserver, blockposition, i);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 93d89fb27044e5e97574122b0e7863694d245bf0..50b0cdb6c95fc076216b41018b2bd1a30a643efa 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -111,6 +111,38 @@ public class PurpurWorldConfig {
+         playerInvulnerableWhileAcceptingResourcePack = getBoolean("gameplay-mechanics.player.invulnerable-while-accepting-resource-pack", playerInvulnerableWhileAcceptingResourcePack);
+     }
+ 
+    public boolean silkTouchEnabled = false;
+    public String silkTouchSpawnerName = "<reset><white>Spawner";
+    public List<String> silkTouchSpawnerLore = new ArrayList<>();
+    public List<Item> silkTouchTools = new ArrayList<>();
+    public int minimumSilkTouchSpawnerRequire = 1;
+    private void silkTouchSettings() {
+        if (PurpurConfig.version < 21) {
+            String oldName = getString("gameplay-mechanics.silk-touch.spawner-name", silkTouchSpawnerName);
+            set("gameplay-mechanics.silk-touch.spawner-name", "<reset>" + ChatColor.toMM(oldName.replace("{mob}", "<mob>")));
+            List<String> list = new ArrayList<>();
+            getList("gameplay-mechanics.silk-touch.spawner-lore", List.of("Spawns a <mob>"))
+                    .forEach(line -> list.add("<reset>" + ChatColor.toMM(line.toString().replace("{mob}", "<mob>"))));
+            set("gameplay-mechanics.silk-touch.spawner-lore", list);
+        }
+        silkTouchEnabled = getBoolean("gameplay-mechanics.silk-touch.enabled", silkTouchEnabled);
+        silkTouchSpawnerName = getString("gameplay-mechanics.silk-touch.spawner-name", silkTouchSpawnerName);
+        minimumSilkTouchSpawnerRequire = getInt("gameplay-mechanics.silk-touch.minimal-level", minimumSilkTouchSpawnerRequire);
+        silkTouchSpawnerLore.clear();
+        getList("gameplay-mechanics.silk-touch.spawner-lore", List.of("Spawns a <mob>"))
+                .forEach(line -> silkTouchSpawnerLore.add(line.toString()));
+        silkTouchTools.clear();
+        getList("gameplay-mechanics.silk-touch.tools", List.of(
+            "minecraft:iron_pickaxe",
+            "minecraft:golden_pickaxe",
+            "minecraft:diamond_pickaxe",
+            "minecraft:netherite_pickaxe"
+        )).forEach(key -> {
+            Item item = Registry.ITEM.get(new ResourceLocation(key.toString()));
+            if (item != Items.AIR) silkTouchTools.add(item);
+        });
+    }
+
+     public boolean babiesAreRidable = true;
+     public boolean untamedTamablesAreRidable = true;
+     public boolean useNightVisionWhenRiding = false;
+diff --git a/src/main/java/org/purpurmc/purpur/item/SpawnerItem.java b/src/main/java/org/purpurmc/purpur/item/SpawnerItem.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ede5c1855e799d250ed47eabff36291a636aa729
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/item/SpawnerItem.java
+@@ -0,0 +1,36 @@
+package org.purpurmc.purpur.item;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.SpawnerBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class SpawnerItem extends BlockItem {
+
+    public SpawnerItem(Block block, Properties settings) {
+        super(block, settings);
+    }
+
+    @Override
+    protected boolean updateCustomBlockEntityTag(BlockPos pos, Level level, Player player, ItemStack stack, BlockState state) {
+        boolean handled = super.updateCustomBlockEntityTag(pos, level, player, stack, state);
+        if (level.purpurConfig.silkTouchEnabled && player.getBukkitEntity().hasPermission("purpur.place.spawners")) {
+            BlockEntity spawner = level.getBlockEntity(pos);
+            if (spawner instanceof SpawnerBlockEntity && stack.hasTag()) {
+                CompoundTag tag = stack.getTag();
+                if (tag.contains("Purpur.mob_type")) {
+                    EntityType.byString(tag.getString("Purpur.mob_type")).ifPresent(type ->
+                            ((SpawnerBlockEntity) spawner).getSpawner().setEntityId(type));
+                }
+            }
+        }
+        return handled;
+    }
+}
--- a/patches/unapplied/0023-MC-168772-Fix-Add-turtle-egg-block-options.patch
+++ b/patches/unapplied/0023-MC-168772-Fix-Add-turtle-egg-block-options.patch
@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 6 Jun 2019 22:15:46 -0500
+Subject: [PATCH] MC-168772 Fix - Add turtle egg block options
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+index 45d5133ff2303b9b44ccacbfb7919708cb50edd6..b1846a5c73f5be800ab1e4efe81e110e245b4726 100644
+--- a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+@@ -9,11 +9,15 @@ import net.minecraft.sounds.SoundSource;
+ import net.minecraft.tags.BlockTags;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.ExperienceOrb;
+ import net.minecraft.world.entity.LivingEntity;
+ import net.minecraft.world.entity.ambient.Bat;
+ import net.minecraft.world.entity.animal.Turtle;
+import net.minecraft.world.entity.item.ItemEntity;
+ import net.minecraft.world.entity.monster.Zombie;
+ import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.vehicle.AbstractMinecart;
+import net.minecraft.world.item.Item;
+ import net.minecraft.world.item.ItemStack;
+ import net.minecraft.world.item.context.BlockPlaceContext;
+ import net.minecraft.world.level.BlockGetter;
+@@ -186,6 +190,23 @@ public class TurtleEggBlock extends Block {
+     }
+ 
+     private boolean canDestroyEgg(Level world, Entity entity) {
+-        return !(entity instanceof Turtle) && !(entity instanceof Bat) ? (!(entity instanceof LivingEntity) ? false : entity instanceof Player || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) : false;
+        // Purpur start - fix MC-168772
+        if (entity instanceof Turtle) {
+            return false;
+        }
+        if (!world.purpurConfig.turtleEggsBreakFromExpOrbs && entity instanceof ExperienceOrb) {
+            return false;
+        }
+        if (!world.purpurConfig.turtleEggsBreakFromItems && entity instanceof ItemEntity) {
+            return false;
+        }
+        if (!world.purpurConfig.turtleEggsBreakFromMinecarts && entity instanceof AbstractMinecart) {
+            return false;
+        }
+        if (entity instanceof LivingEntity && !(entity instanceof Player)) {
+            return world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+        }
+        return true;
+        // Purpur end
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 50b0cdb6c95fc076216b41018b2bd1a30a643efa..4d9f7a90928fd4a3dd514799df3661f4ceb2ca36 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -143,6 +143,15 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean turtleEggsBreakFromExpOrbs = true;
+    public boolean turtleEggsBreakFromItems = true;
+    public boolean turtleEggsBreakFromMinecarts = true;
+    private void turtleEggSettings() {
+        turtleEggsBreakFromExpOrbs = getBoolean("blocks.turtle_egg.break-from-exp-orbs", turtleEggsBreakFromExpOrbs);
+        turtleEggsBreakFromItems = getBoolean("blocks.turtle_egg.break-from-items", turtleEggsBreakFromItems);
+        turtleEggsBreakFromMinecarts = getBoolean("blocks.turtle_egg.break-from-minecarts", turtleEggsBreakFromMinecarts);
+    }
+
+     public boolean babiesAreRidable = true;
+     public boolean untamedTamablesAreRidable = true;
+     public boolean useNightVisionWhenRiding = false;
--- a/patches/unapplied/0024-Fix-vanilla-command-permission-handler.patch
+++ b/patches/unapplied/0024-Fix-vanilla-command-permission-handler.patch
@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 28 Mar 2020 01:51:32 -0500
+Subject: [PATCH] Fix vanilla command permission handler
+
+
+diff --git a/src/main/java/com/mojang/brigadier/tree/CommandNode.java b/src/main/java/com/mojang/brigadier/tree/CommandNode.java
+index f64aa22ed6fcb4af67317b99f459ee5296392548..36c91793e0aa4895193623cf8cba7820d31f4eca 100644
+--- a/src/main/java/com/mojang/brigadier/tree/CommandNode.java
+++ b/src/main/java/com/mojang/brigadier/tree/CommandNode.java
+@@ -34,6 +34,7 @@ public abstract class CommandNode<S> implements Comparable<CommandNode<S>> {
+     private final RedirectModifier<S> modifier;
+     private final boolean forks;
+     private Command<S> command;
+    private String permission = null; public String getPermission() { return permission; } public void setPermission(String permission) { this.permission = permission; } // Purpur
+     // CraftBukkit start
+     public void removeCommand(String name) {
+         this.children.remove(name);
+diff --git a/src/main/java/org/bukkit/craftbukkit/command/VanillaCommandWrapper.java b/src/main/java/org/bukkit/craftbukkit/command/VanillaCommandWrapper.java
+index 4525fb3bc9b137bce3b59310a8aecca96d6ad5ba..75aeceb76b15a4c9cc7cffc35d15d76509c5620a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/command/VanillaCommandWrapper.java
+++ b/src/main/java/org/bukkit/craftbukkit/command/VanillaCommandWrapper.java
+@@ -94,6 +94,7 @@ public final class VanillaCommandWrapper extends BukkitCommand {
+     }
+ 
+     public static String getPermission(CommandNode<CommandSourceStack> vanillaCommand) {
+        if (vanillaCommand.getPermission() != null) return vanillaCommand.getPermission(); // Purpur
+         // Paper start
+         final String commandName;
+         if (vanillaCommand.getRedirect() == null) {
--- a/patches/unapplied/0025-Logger-settings-suppressing-pointless-logs.patch
+++ b/patches/unapplied/0025-Logger-settings-suppressing-pointless-logs.patch
@@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 19 Oct 2019 00:52:12 -0500
+Subject: [PATCH] Logger settings (suppressing pointless logs)
+
+
+diff --git a/src/main/java/net/minecraft/server/PlayerAdvancements.java b/src/main/java/net/minecraft/server/PlayerAdvancements.java
+index b16287a47870978706734b928b87f2357e91e3a1..048413655ef636b3dae687452fc5a95780058a22 100644
+--- a/src/main/java/net/minecraft/server/PlayerAdvancements.java
+++ b/src/main/java/net/minecraft/server/PlayerAdvancements.java
+@@ -186,6 +186,7 @@ public class PlayerAdvancements {
+                         if (advancement == null) {
+                             // CraftBukkit start
+                             if (entry.getKey().getNamespace().equals("minecraft")) {
+                                if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressIgnoredAdvancementWarnings) // Purpur
+                                 PlayerAdvancements.LOGGER.warn("Ignored advancement '{}' in progress file {} - it doesn't exist anymore?", entry.getKey(), this.file);
+                             }
+                             // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+index 1e656438d9ee89b97c660f3b3ec671be6546c6b7..c4b2a50ad65b4ca2f8cc5903213c70cafde3e41c 100644
+--- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+@@ -287,6 +287,7 @@ public class WorldGenRegion implements WorldGenLevel {
+             return true;
+         } else {
+             // Paper start
+            if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressSetBlockFarChunk) // Purpur
+             if (!hasSetFarWarned) {
+             Util.logAndPauseIfInIde("Detected setBlock in a far chunk [" + i + ", " + j + "], pos: " + pos + ", status: " + this.generatingStatus + (this.currentlyGenerating == null ? "" : ", currently generating: " + (String) this.currentlyGenerating.get()));
+             hasSetFarWarned = true;
+diff --git a/src/main/java/net/minecraft/stats/ServerRecipeBook.java b/src/main/java/net/minecraft/stats/ServerRecipeBook.java
+index d13ed3069e944d138442ea440ac3eaf8d44c18d3..29ac7f202aa23f7e6fcdc9829af3d59875c92d4e 100644
+--- a/src/main/java/net/minecraft/stats/ServerRecipeBook.java
+++ b/src/main/java/net/minecraft/stats/ServerRecipeBook.java
+@@ -122,6 +122,7 @@ public class ServerRecipeBook extends RecipeBook {
+                 Optional<? extends Recipe<?>> optional = recipeManager.byKey(minecraftkey);
+ 
+                 if (!optional.isPresent()) {
+                    if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressUnrecognizedRecipeErrors) // Purpur
+                     ServerRecipeBook.LOGGER.error("Tried to load unrecognized recipe: {} removed now.", minecraftkey);
+                 } else {
+                     handler.accept((Recipe) optional.get());
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+index b2a15c986c7500a0ce227a54cb61ec3f5378f6f3..14600a7bc01bf61e8ffb736816d23df6aa794a16 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+++ b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+@@ -255,6 +255,7 @@ public final class CraftLegacy {
+     }
+ 
+     static {
+        if (!org.purpurmc.purpur.PurpurConfig.loggerSuppressInitLegacyMaterialError) // Purpur
+         System.err.println("Initializing Legacy Material Support. Unless you have legacy plugins and/or data this is a bug!");
+         if (MinecraftServer.getServer() != null && MinecraftServer.getServer().isDebugging()) {
+             new Exception().printStackTrace();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 8124b27f043beb763d70881593a883e06ea59f6e..dab104575c5a12857faffb8efc5620a123580a9e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -230,4 +230,15 @@ public class PurpurConfig {
+         org.bukkit.event.inventory.InventoryType.ENDER_CHEST.setDefaultSize(enderChestSixRows ? 54 : 27);
+         enderChestPermissionRows = getBoolean("settings.blocks.ender_chest.use-permissions-for-rows", enderChestPermissionRows);
+     }
+
+    public static boolean loggerSuppressInitLegacyMaterialError = false;
+    public static boolean loggerSuppressIgnoredAdvancementWarnings = false;
+    public static boolean loggerSuppressUnrecognizedRecipeErrors = false;
+    public static boolean loggerSuppressSetBlockFarChunk = false;
+    private static void loggerSettings() {
+        loggerSuppressInitLegacyMaterialError = getBoolean("settings.logger.suppress-init-legacy-material-errors", loggerSuppressInitLegacyMaterialError);
+        loggerSuppressIgnoredAdvancementWarnings = getBoolean("settings.logger.suppress-ignored-advancement-warnings", loggerSuppressIgnoredAdvancementWarnings);
+        loggerSuppressUnrecognizedRecipeErrors = getBoolean("settings.logger.suppress-unrecognized-recipe-errors", loggerSuppressUnrecognizedRecipeErrors);
+        loggerSuppressSetBlockFarChunk = getBoolean("settings.logger.suppress-setblock-in-far-chunk-errors", loggerSuppressSetBlockFarChunk);
+    }
+ }
--- a/patches/unapplied/0026-Disable-outdated-build-check.patch
+++ b/patches/unapplied/0026-Disable-outdated-build-check.patch
@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 15 Dec 2019 12:53:59 -0600
+Subject: [PATCH] Disable outdated build check
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index dd8ab900bb3ff451c7c200f9cb3e3eca3e78a2c6..639dc3bb56cc90b84da08dc93cea89c658ed6dc8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -265,7 +265,7 @@ public class Main {
+                     System.setProperty(TerminalConsoleAppender.JLINE_OVERRIDE_PROPERTY, "false"); // Paper
+                 }
+ 
+-                if (Main.class.getPackage().getImplementationVendor() != null && System.getProperty("IReallyKnowWhatIAmDoingISwear") == null) {
+                if (false && Main.class.getPackage().getImplementationVendor() != null && System.getProperty("IReallyKnowWhatIAmDoingISwear") == null) {  // Purpur
+                     Date buildDate = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z").parse(Main.class.getPackage().getImplementationVendor()); // Paper
+ 
+                     Calendar deadline = Calendar.getInstance();
--- a/patches/unapplied/0027-Giants-AI-settings.patch
+++ b/patches/unapplied/0027-Giants-AI-settings.patch
@@ -0,0 +1,147 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 12 May 2019 00:43:12 -0500
+Subject: [PATCH] Giants AI settings
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Giant.java b/src/main/java/net/minecraft/world/entity/monster/Giant.java
+index 61d39062021ca23aa94d9fcf584f14599fd7411c..0d26d2388cc1963df9bc361b31a572c12e2f8709 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Giant.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Giant.java
+@@ -1,13 +1,36 @@
+ package net.minecraft.world.entity.monster;
+ 
+ import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.DifficultyInstance;
+ import net.minecraft.world.entity.EntityDimensions;
+ import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.MobSpawnType;
+ import net.minecraft.world.entity.Pose;
+import net.minecraft.world.entity.SpawnGroupData;
+ import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+ import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.goal.FloatGoal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.MeleeAttackGoal;
+import net.minecraft.world.entity.ai.goal.MoveTowardsRestrictionGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.ai.goal.WaterAvoidingRandomStrollGoal;
+import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal;
+import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal;
+import net.minecraft.world.entity.animal.IronGolem;
+import net.minecraft.world.entity.animal.Turtle;
+import net.minecraft.world.entity.npc.Villager;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.ServerLevelAccessor;
+
+import javax.annotation.Nullable;
+ 
+ public class Giant extends Monster {
+     public Giant(EntityType<? extends Giant> type, Level world) {
+@@ -31,18 +54,59 @@ public class Giant extends Monster {
+         return level.purpurConfig.giantControllable;
+     }
+ 
+-    @Override
+-    protected void registerGoals() {
+-        this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+-        this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+-    }
+-
+     @Override
+     protected void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.giantMaxHealth);
+         this.getAttribute(Attributes.MOVEMENT_SPEED).setBaseValue(this.level.purpurConfig.giantMovementSpeed);
+         this.getAttribute(Attributes.ATTACK_DAMAGE).setBaseValue(this.level.purpurConfig.giantAttackDamage);
+     }
+
+    @Override
+    protected void registerGoals() {
+        if (level.purpurConfig.giantHaveAI) {
+            this.goalSelector.addGoal(0, new FloatGoal(this));
+            this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+            this.goalSelector.addGoal(7, new WaterAvoidingRandomStrollGoal(this, 1.0D));
+            this.goalSelector.addGoal(8, new LookAtPlayerGoal(this, Player.class, 16.0F));
+            this.goalSelector.addGoal(8, new RandomLookAroundGoal(this));
+            this.goalSelector.addGoal(5, new MoveTowardsRestrictionGoal(this, 1.0D));
+            if (level.purpurConfig.giantHaveHostileAI) {
+                this.goalSelector.addGoal(2, new MeleeAttackGoal(this, 1.0D, false));
+                this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+                this.targetSelector.addGoal(1, new HurtByTargetGoal(this).setAlertOthers(ZombifiedPiglin.class));
+                this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, true));
+                this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Villager.class, false));
+                this.targetSelector.addGoal(4, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
+                this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, true));
+            }
+        }
+    }
+
+    @Override
+    public SpawnGroupData finalizeSpawn(ServerLevelAccessor world, DifficultyInstance difficulty, MobSpawnType spawnReason, @Nullable SpawnGroupData entityData, @Nullable CompoundTag entityNbt) {
+        SpawnGroupData groupData = super.finalizeSpawn(world, difficulty, spawnReason, entityData, entityNbt);
+        if (groupData == null) {
+            populateDefaultEquipmentSlots(difficulty);
+            populateDefaultEquipmentEnchantments(difficulty);
+        }
+        return groupData;
+    }
+
+    @Override
+    protected void populateDefaultEquipmentSlots(DifficultyInstance difficulty) {
+        super.populateDefaultEquipmentSlots(difficulty);
+        // TODO make configurable
+        if (random.nextFloat() < (level.getDifficulty() == Difficulty.HARD ? 0.1F : 0.05F)) {
+            this.setItemSlot(EquipmentSlot.MAINHAND, new ItemStack(Items.IRON_SWORD));
+        }
+    }
+
+    @Override
+    public float getJumpPower() {
+        // make giants jump as high as everything else relative to their size
+        // 1.0 makes bottom of feet about as high as their waist when they jump
+        return level.purpurConfig.giantJumpHeight;
+    }
+     // Purpur end
+ 
+     @Override
+@@ -56,6 +120,6 @@ public class Giant extends Monster {
+ 
+     @Override
+     public float getWalkTargetValue(BlockPos pos, LevelReader world) {
+-        return world.getBrightness(pos) - 0.5F;
+        return super.getWalkTargetValue(pos, world); // Purpur - fix light requirements for natural spawns
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 4d9f7a90928fd4a3dd514799df3661f4ceb2ca36..336b214230600b8b1d223c65470820e388f676d9 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -511,6 +511,10 @@ public class PurpurWorldConfig {
+     public double giantMovementSpeed = 0.5D;
+     public double giantAttackDamage = 50.0D;
+     public double giantMaxHealth = 100.0D;
+    public float giantStepHeight = 2.0F;
+    public float giantJumpHeight = 1.0F;
+    public boolean giantHaveAI = false;
+    public boolean giantHaveHostileAI = false;
+     private void giantSettings() {
+         giantRidable = getBoolean("mobs.giant.ridable", giantRidable);
+         giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater);
+@@ -527,6 +531,10 @@ public class PurpurWorldConfig {
+             set("mobs.giant.attributes.max_health", oldValue);
+         }
+         giantMaxHealth = getDouble("mobs.giant.attributes.max_health", giantMaxHealth);
+        giantStepHeight = (float) getDouble("mobs.giant.step-height", giantStepHeight);
+        giantJumpHeight = (float) getDouble("mobs.giant.jump-height", giantJumpHeight);
+        giantHaveAI = getBoolean("mobs.giant.have-ai", giantHaveAI);
+        giantHaveHostileAI = getBoolean("mobs.giant.have-hostile-ai", giantHaveHostileAI);
+     }
+ 
+     public boolean glowSquidRidable = false;
--- a/patches/unapplied/0028-Zombie-horse-naturally-spawn.patch
+++ b/patches/unapplied/0028-Zombie-horse-naturally-spawn.patch
@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 7 Jul 2019 19:52:16 -0500
+Subject: [PATCH] Zombie horse naturally spawn
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 8066a3372d21823357942771adc0b4768f505ea2..ac233f1f6a645a927631efdda15aee91040705d8 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -772,9 +772,15 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                 boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * paperConfig.skeleHorseSpawnChance && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
+ 
+                 if (flag1) {
+-                    SkeletonHorse entityhorseskeleton = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);
+-
+-                    entityhorseskeleton.setTrap(true);
+                    // Purpur start
+                    net.minecraft.world.entity.animal.horse.AbstractHorse entityhorseskeleton = EntityType.SKELETON_HORSE.create(this);
+                    if (purpurConfig.zombieHorseSpawnChance > 0D && random.nextDouble() <= purpurConfig.zombieHorseSpawnChance) {
+                        entityhorseskeleton = EntityType.ZOMBIE_HORSE.create(this);
+                    } else {
+                        entityhorseskeleton = EntityType.SKELETON_HORSE.create(this);
+                        ((SkeletonHorse) entityhorseskeleton).setTrap(true);
+                    }
+                    // Purpur end
+                     entityhorseskeleton.setAge(0);
+                     entityhorseskeleton.setPos((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ());
+                     this.addFreshEntity(entityhorseskeleton, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 336b214230600b8b1d223c65470820e388f676d9..6a5507be0f9a78855225437676865e15f06bcd9a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1416,6 +1416,7 @@ public class PurpurWorldConfig {
+     public double zombieHorseJumpStrengthMax = 1.0D;
+     public double zombieHorseMovementSpeedMin = 0.2D;
+     public double zombieHorseMovementSpeedMax = 0.2D;
+    public double zombieHorseSpawnChance = 0.0D;
+     private void zombieHorseSettings() {
+         zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater);
+         zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim);
+@@ -1431,6 +1432,7 @@ public class PurpurWorldConfig {
+         zombieHorseJumpStrengthMax = getDouble("mobs.zombie_horse.attributes.jump_strength.max", zombieHorseJumpStrengthMax);
+         zombieHorseMovementSpeedMin = getDouble("mobs.zombie_horse.attributes.movement_speed.min", zombieHorseMovementSpeedMin);
+         zombieHorseMovementSpeedMax = getDouble("mobs.zombie_horse.attributes.movement_speed.max", zombieHorseMovementSpeedMax);
+        zombieHorseSpawnChance = getDouble("mobs.zombie_horse.spawn-chance", zombieHorseSpawnChance);
+     }
+ 
+     public boolean zombieVillagerRidable = false;
--- a/patches/unapplied/0029-Charged-creeper-naturally-spawn.patch
+++ b/patches/unapplied/0029-Charged-creeper-naturally-spawn.patch
@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 29 Nov 2019 22:37:44 -0600
+Subject: [PATCH] Charged creeper naturally spawn
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+index 9921fd8278d14deeae9d61101f6800be58412948..e51bcd5158d17db613311e38f2810b650d522cf4 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -143,6 +143,14 @@ public class Creeper extends Monster implements PowerableMob {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.creeperMaxHealth);
+     }
+
+    public net.minecraft.world.entity.SpawnGroupData finalizeSpawn(net.minecraft.world.level.ServerLevelAccessor world, net.minecraft.world.DifficultyInstance difficulty, net.minecraft.world.entity.MobSpawnType spawnReason, @Nullable net.minecraft.world.entity.SpawnGroupData entityData, @Nullable CompoundTag entityNbt) {
+        double chance = world.getLevel().purpurConfig.creeperChargedChance;
+        if (chance > 0D && random.nextDouble() <= chance) {
+            setPowered(true);
+        }
+        return super.finalizeSpawn(world, difficulty, spawnReason, entityData, entityNbt);
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 6a5507be0f9a78855225437676865e15f06bcd9a..a1d8065ef1ac0f065cf6bc030a8746e9418690aa 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -313,6 +313,7 @@ public class PurpurWorldConfig {
+     public boolean creeperRidableInWater = false;
+     public boolean creeperControllable = true;
+     public double creeperMaxHealth = 20.0D;
+    public double creeperChargedChance = 0.0D;
+     private void creeperSettings() {
+         creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
+         creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
+@@ -323,6 +324,7 @@ public class PurpurWorldConfig {
+             set("mobs.creeper.attributes.max_health", oldValue);
+         }
+         creeperMaxHealth = getDouble("mobs.creeper.attributes.max_health", creeperMaxHealth);
+        creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance);
+     }
+ 
+     public boolean dolphinRidable = false;
--- a/patches/unapplied/0030-Rabbit-naturally-spawn-toast-and-killer.patch
+++ b/patches/unapplied/0030-Rabbit-naturally-spawn-toast-and-killer.patch
@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 31 Aug 2019 17:47:11 -0500
+Subject: [PATCH] Rabbit naturally spawn toast and killer
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+index 76ea5b3d0d70eb8bdbbbb4bf7bed31d0d7d712a3..5b30a1d34d7efb1a5c86ae187027313fec1fd700 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+@@ -435,7 +435,11 @@ public class Rabbit extends Animal {
+             if (!this.hasCustomName()) {
+                 this.setCustomName(new TranslatableComponent(Util.makeDescriptionId("entity", Rabbit.KILLER_BUNNY)));
+             }
+        // Purpur start
+        } else if (rabbitType == 98) {
+            setCustomName(new TranslatableComponent("Toast"));
+         }
+        // Purpur end
+ 
+         this.entityData.set(Rabbit.DATA_TYPE_ID, rabbitType);
+     }
+@@ -456,6 +460,16 @@ public class Rabbit extends Animal {
+     }
+ 
+     private int getRandomRabbitType(LevelAccessor world) {
+        // Purpur start
+        Level level = world.getMinecraftWorld();
+        if (level.purpurConfig.rabbitNaturalKiller > 0D && random.nextDouble() <= level.purpurConfig.rabbitNaturalKiller) {
+            return 99;
+        }
+        if (level.purpurConfig.rabbitNaturalToast > 0D && random.nextDouble() <= level.purpurConfig.rabbitNaturalToast) {
+            return 98;
+        }
+        // Purpur end
+
+         Holder<Biome> holder = world.getBiome(this.blockPosition());
+         int i = this.random.nextInt(100);
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a1d8065ef1ac0f065cf6bc030a8746e9418690aa..91f892e411b9f6ce2a64138ed3d3576b43e482ea 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -945,6 +945,8 @@ public class PurpurWorldConfig {
+     public boolean rabbitRidableInWater = false;
+     public boolean rabbitControllable = true;
+     public double rabbitMaxHealth = 3.0D;
+    public double rabbitNaturalToast = 0.0D;
+    public double rabbitNaturalKiller = 0.0D;
+     private void rabbitSettings() {
+         rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable);
+         rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater);
+@@ -955,6 +957,8 @@ public class PurpurWorldConfig {
+             set("mobs.rabbit.attributes.max_health", oldValue);
+         }
+         rabbitMaxHealth = getDouble("mobs.rabbit.attributes.max_health", rabbitMaxHealth);
+        rabbitNaturalToast = getDouble("mobs.rabbit.spawn-toast-chance", rabbitNaturalToast);
+        rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller);
+     }
+ 
+     public boolean ravagerRidable = false;
--- a/patches/unapplied/0031-Fix-outdated-server-showing-in-ping-before-server-fu.patch
+++ b/patches/unapplied/0031-Fix-outdated-server-showing-in-ping-before-server-fu.patch
@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Tue, 4 Jun 2019 15:50:08 -0500
+Subject: [PATCH] Fix 'outdated server' showing in ping before server fully
+ boots
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
+index 4fa79d37ff4e70c61672cce7c55257c46232c026..df43d0a0f3d1e34baabae150cbf01a008eb5a588 100644
+--- a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
+@@ -153,6 +153,7 @@ public class ServerStatusPacketListenerImpl implements ServerStatusPacketListene
+             this.connection.send(new ClientboundStatusResponsePacket(ping));
+             // CraftBukkit end
+             */
+            if (this.server.getStatus().getVersion() == null) return; // Purpur - do not respond to pings before we know the protocol version
+             com.destroystokyo.paper.network.StandardPaperServerListPingEventImpl.processRequest(this.server, this.connection);
+             // Paper end
+         }
--- a/patches/unapplied/0032-Tulips-change-fox-type.patch
+++ b/patches/unapplied/0032-Tulips-change-fox-type.patch
@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 13 Jul 2019 15:56:22 -0500
+Subject: [PATCH] Tulips change fox type
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index 1e0239434fc6a9b39e2326d5ee98f01e9bcb263f..4b42d8047f70d23eed09b6210b447ae2a272af0a 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -35,6 +35,7 @@ import net.minecraft.tags.ItemTags;
+ import net.minecraft.util.Mth;
+ import net.minecraft.world.DifficultyInstance;
+ import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+ import net.minecraft.world.damagesource.DamageSource;
+ import net.minecraft.world.entity.AgeableMob;
+ import net.minecraft.world.entity.Entity;
+@@ -87,6 +88,7 @@ import net.minecraft.world.level.block.Blocks;
+ import net.minecraft.world.level.block.CaveVines;
+ import net.minecraft.world.level.block.SweetBerryBushBlock;
+ import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.gameevent.GameEvent;
+ import net.minecraft.world.level.pathfinder.BlockPathTypes;
+ import net.minecraft.world.phys.Vec3;
+ 
+@@ -380,6 +382,11 @@ public class Fox extends Animal {
+     }
+ 
+     private void setTargetGoals() {
+        // Purpur start - do not add duplicate goals
+        this.targetSelector.removeGoal(this.landTargetGoal);
+        this.targetSelector.removeGoal(this.turtleEggTargetGoal);
+        this.targetSelector.removeGoal(this.fishTargetGoal);
+        // Purpur end
+         if (this.getFoxType() == Fox.Type.RED) {
+             this.targetSelector.addGoal(4, this.landTargetGoal);
+             this.targetSelector.addGoal(4, this.turtleEggTargetGoal);
+@@ -412,6 +419,7 @@ public class Fox extends Animal {
+ 
+     public void setFoxType(Fox.Type type) {
+         this.entityData.set(Fox.DATA_TYPE_ID, type.getId());
+        this.setTargetGoals(); // Purpur - fix API bug not updating pathfinders on type change
+     }
+ 
+     List<UUID> getTrustedUUIDs() {
+@@ -742,6 +750,29 @@ public class Fox extends Animal {
+         return this.getTrustedUUIDs().contains(uuid);
+     }
+ 
+    // Purpur start
+    @Override
+    public InteractionResult mobInteract(Player player, InteractionHand hand) {
+        if (level.purpurConfig.foxTypeChangesWithTulips) {
+            ItemStack itemstack = player.getItemInHand(hand);
+            if (getFoxType() == Type.RED && itemstack.getItem() == Items.WHITE_TULIP) {
+                setFoxType(Type.SNOW);
+                if (!player.getAbilities().instabuild) {
+                    itemstack.shrink(1);
+                }
+                return InteractionResult.SUCCESS;
+            } else if (getFoxType() == Type.SNOW && itemstack.getItem() == Items.ORANGE_TULIP) {
+                setFoxType(Type.RED);
+                if (!player.getAbilities().instabuild) {
+                    itemstack.shrink(1);
+                }
+                return InteractionResult.SUCCESS;
+            }
+        }
+        return super.mobInteract(player, hand);
+    }
+    // Purpur end
+
+     @Override
+     // Paper start - Cancellable death event
+     protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(DamageSource source) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 91f892e411b9f6ce2a64138ed3d3576b43e482ea..53a6c64338a77f22ee2293fbb85522ad51a97276 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -477,6 +477,7 @@ public class PurpurWorldConfig {
+     public boolean foxRidableInWater = false;
+     public boolean foxControllable = true;
+     public double foxMaxHealth = 10.0D;
+    public boolean foxTypeChangesWithTulips = false;
+     private void foxSettings() {
+         foxRidable = getBoolean("mobs.fox.ridable", foxRidable);
+         foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater);
+@@ -487,6 +488,7 @@ public class PurpurWorldConfig {
+             set("mobs.fox.attributes.max_health", oldValue);
+         }
+         foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth);
+        foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips);
+     }
+ 
+     public boolean ghastRidable = false;
--- a/patches/unapplied/0033-Breedable-Polar-Bears.patch
+++ b/patches/unapplied/0033-Breedable-Polar-Bears.patch
@@ -0,0 +1,83 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 26 Mar 2020 19:46:44 -0500
+Subject: [PATCH] Breedable Polar Bears
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+index 4a21babeb23efe2b4bfd99ae3d08eb677b93bac9..b370a0c392f69a1b42a4908ae012ee4c6bf6984d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+++ b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+@@ -97,6 +97,27 @@ public class PolarBear extends Animal implements NeutralMob {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.polarBearMaxHealth);
+     }
+
+    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
+ 
+     @Override
+@@ -106,7 +127,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
+     }
+ 
+     @Override
+@@ -116,6 +137,12 @@ public class PolarBear extends Animal implements NeutralMob {
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+         this.goalSelector.addGoal(1, new PolarBear.PolarBearMeleeAttackGoal());
+         this.goalSelector.addGoal(1, new PolarBear.PolarBearPanicGoal());
+        // Purpur start
+        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
+         this.goalSelector.addGoal(4, new FollowParentGoal(this, 1.25D));
+         this.goalSelector.addGoal(5, new RandomStrollGoal(this, 1.0D));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 53a6c64338a77f22ee2293fbb85522ad51a97276..ad0474ca08510f55cb20b2b5d11f7c4a7223b40e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -917,6 +917,8 @@ public class PurpurWorldConfig {
+     public boolean polarBearRidableInWater = false;
+     public boolean polarBearControllable = true;
+     public double polarBearMaxHealth = 30.0D;
+    public String polarBearBreedableItemString = "";
+    public Item polarBearBreedableItem = null;
+     private void polarBearSettings() {
+         polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable);
+         polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater);
+@@ -927,6 +929,9 @@ public class PurpurWorldConfig {
+             set("mobs.polar_bear.attributes.max_health", oldValue);
+         }
+         polarBearMaxHealth = getDouble("mobs.polar_bear.attributes.max_health", polarBearMaxHealth);
+        polarBearBreedableItemString = getString("mobs.polar_bear.breedable-item", polarBearBreedableItemString);
+        Item item = Registry.ITEM.get(new ResourceLocation(polarBearBreedableItemString));
+        if (item != Items.AIR) polarBearBreedableItem = item;
+     }
+ 
+     public boolean pufferfishRidable = false;
--- a/patches/unapplied/0034-Chickens-can-retaliate.patch
+++ b/patches/unapplied/0034-Chickens-can-retaliate.patch
@@ -0,0 +1,72 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 12 Apr 2020 13:19:34 -0500
+Subject: [PATCH] Chickens can retaliate
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Chicken.java b/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+index 6f0a3e303d7b4d95302f477eef0d2590b89bef42..826ffd0bec67d1239edeaddc64e2805ac884311c 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+@@ -71,6 +71,9 @@ public class Chicken extends Animal {
+     @Override
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.chickenMaxHealth);
+        if (level.purpurConfig.chickenRetaliate) {
+            this.getAttribute(Attributes.ATTACK_DAMAGE).setBaseValue(2.0D);
+        }
+     }
+     // Purpur end
+ 
+@@ -78,13 +81,21 @@ public class Chicken extends Animal {
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+-        this.goalSelector.addGoal(1, new PanicGoal(this, 1.4D));
+        // this.goalSelector.addGoal(1, new PanicGoal(this, 1.4D)); // Purpur - moved down
+         this.goalSelector.addGoal(2, new BreedGoal(this, 1.0D));
+         this.goalSelector.addGoal(3, new TemptGoal(this, 1.0D, Chicken.FOOD_ITEMS, false));
+         this.goalSelector.addGoal(4, new FollowParentGoal(this, 1.1D));
+         this.goalSelector.addGoal(5, new WaterAvoidingRandomStrollGoal(this, 1.0D));
+         this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F));
+         this.goalSelector.addGoal(7, new RandomLookAroundGoal(this));
+        // Purpur start
+        if (level.purpurConfig.chickenRetaliate) {
+            this.goalSelector.addGoal(1, new net.minecraft.world.entity.ai.goal.MeleeAttackGoal(this, 1.0D, false));
+            this.targetSelector.addGoal(1, new net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal(this));
+        } else {
+            this.goalSelector.addGoal(1, new PanicGoal(this, 1.4D));
+        }
+        // Purpur end
+     }
+ 
+     @Override
+@@ -93,7 +104,7 @@ public class Chicken extends Animal {
+     }
+ 
+     public static AttributeSupplier.Builder createAttributes() {
+-        return Mob.createMobAttributes().add(Attributes.MAX_HEALTH, 4.0D).add(Attributes.MOVEMENT_SPEED, 0.25D);
+        return Mob.createMobAttributes().add(Attributes.MAX_HEALTH, 4.0D).add(Attributes.MOVEMENT_SPEED, 0.25D).add(Attributes.ATTACK_DAMAGE, 0.0D); // Purpur
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ad0474ca08510f55cb20b2b5d11f7c4a7223b40e..62bb7fafb686170f8ae6d2f7c7b10d04365e433c 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -267,6 +267,7 @@ public class PurpurWorldConfig {
+     public boolean chickenRidableInWater = false;
+     public boolean chickenControllable = true;
+     public double chickenMaxHealth = 4.0D;
+    public boolean chickenRetaliate = false;
+     private void chickenSettings() {
+         chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable);
+         chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater);
+@@ -277,6 +278,7 @@ public class PurpurWorldConfig {
+             set("mobs.chicken.attributes.max_health", oldValue);
+         }
+         chickenMaxHealth = getDouble("mobs.chicken.attributes.max_health", chickenMaxHealth);
+        chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate);
+     }
+ 
+     public boolean codRidable = false;
--- a/patches/unapplied/0035-Add-option-to-set-armorstand-step-height.patch
+++ b/patches/unapplied/0035-Add-option-to-set-armorstand-step-height.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 6 Oct 2019 12:46:35 -0500
+Subject: [PATCH] Add option to set armorstand step height
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+index e5ef24d92de21c4c0e6a98e06985e52d47bfdce0..dc1630a1a769f848059f576c3d1220a216b5465c 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -668,6 +668,7 @@ public class ArmorStand extends LivingEntity {
+ 
+     @Override
+     public void tick() {
+        maxUpStep = level.purpurConfig.armorstandStepHeight;
+         // Paper start
+         if (!this.canTick) {
+             if (this.noTickPoseDirty) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7ce2825871386d63301f90179408e52a2e101275..cdb0cae8af965f57d6c5d128d2190f9c496ea9b7 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -89,6 +89,11 @@ public class PurpurWorldConfig {
+         return value.isEmpty() ? fallback : value;
+     }
+ 
+    public float armorstandStepHeight = 0.0F;
+    private void armorstandSettings() {
+        armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+    }
+
+     public boolean idleTimeoutKick = true;
+     public boolean idleTimeoutTickNearbyEntities = true;
+     public boolean idleTimeoutCountAsSleeping = false;
--- a/patches/unapplied/0036-Cat-spawning-options.patch
+++ b/patches/unapplied/0036-Cat-spawning-options.patch
@@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 26 Dec 2019 18:52:55 -0600
+Subject: [PATCH] Cat spawning options
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+index bef89f40498f1dc18ce3abe492ed41fd697c12fd..9239ca35f4aa5ef1964c13b4d9e889b429bb1571 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+@@ -33,7 +33,7 @@ public class CatSpawner implements CustomSpawner {
+             if (this.nextTick > 0) {
+                 return 0;
+             } else {
+-                this.nextTick = 1200;
+                this.nextTick = world.purpurConfig.catSpawnDelay; // Purpur
+                 Player player = world.getRandomPlayer();
+                 if (player == null) {
+                     return 0;
+@@ -69,9 +69,13 @@ public class CatSpawner implements CustomSpawner {
+     }
+ 
+     private int spawnInVillage(ServerLevel world, BlockPos pos) {
+-        int i = 48;
+-        if (world.getPoiManager().getCountInRange(PoiType.HOME.getPredicate(), pos, 48, PoiManager.Occupancy.IS_OCCUPIED) > 4L) {
+-            List<Cat> list = world.getEntitiesOfClass(Cat.class, (new AABB(pos)).inflate(48.0D, 8.0D, 48.0D));
+        // Purpur start
+        int range = world.purpurConfig.catSpawnVillageScanRange;
+        if (range <= 0) return 0;
+
+        if (world.getPoiManager().getCountInRange(PoiType.HOME.getPredicate(), pos, range, PoiManager.Occupancy.IS_OCCUPIED) > 4L) {
+            List<Cat> list = world.getEntitiesOfClass(Cat.class, (new AABB(pos)).inflate(range, 8.0D, range));
+            // Purpur end
+             if (list.size() < 5) {
+                 return this.spawnCat(pos, world);
+             }
+@@ -81,8 +85,11 @@ public class CatSpawner implements CustomSpawner {
+     }
+ 
+     private int spawnInHut(ServerLevel world, BlockPos pos) {
+-        int i = 16;
+-        List<Cat> list = world.getEntitiesOfClass(Cat.class, (new AABB(pos)).inflate(16.0D, 8.0D, 16.0D));
+        // Purpur start
+        int range = world.purpurConfig.catSpawnSwampHutScanRange;
+        if (range <= 0) return 0;
+        List<Cat> list = world.getEntitiesOfClass(Cat.class, (new AABB(pos)).inflate(range, 8.0D, range));
+        // Purpur end
+         return list.size() < 1 ? this.spawnCat(pos, world) : 0;
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7ab9864662b1a3de509e43b2177272078a7f3882..38f4ac177823bd6317d778163ae924c4869e8a91 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -240,6 +240,9 @@ public class PurpurWorldConfig {
+     public boolean catRidableInWater = false;
+     public boolean catControllable = true;
+     public double catMaxHealth = 10.0D;
+    public int catSpawnDelay = 1200;
+    public int catSpawnSwampHutScanRange = 16;
+    public int catSpawnVillageScanRange = 48;
+     private void catSettings() {
+         catRidable = getBoolean("mobs.cat.ridable", catRidable);
+         catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater);
+@@ -250,6 +253,9 @@ public class PurpurWorldConfig {
+             set("mobs.cat.attributes.max_health", oldValue);
+         }
+         catMaxHealth = getDouble("mobs.cat.attributes.max_health", catMaxHealth);
+        catSpawnDelay = getInt("mobs.cat.spawn-delay", catSpawnDelay);
+        catSpawnSwampHutScanRange = getInt("mobs.cat.scan-range-for-other-cats.swamp-hut", catSpawnSwampHutScanRange);
+        catSpawnVillageScanRange = getInt("mobs.cat.scan-range-for-other-cats.village", catSpawnVillageScanRange);
+     }
+ 
+     public boolean caveSpiderRidable = false;
--- a/patches/unapplied/0037-MC-147659-Fix-non-black-cats-spawning-in-swamp-huts.patch
+++ b/patches/unapplied/0037-MC-147659-Fix-non-black-cats-spawning-in-swamp-huts.patch
@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 2 Jan 2020 01:23:22 -0600
+Subject: [PATCH] MC-147659 - Fix non black cats spawning in swamp huts
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+index 9239ca35f4aa5ef1964c13b4d9e889b429bb1571..0c5dcaf1a0b2f7819cea09009bb84178c202e803 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+@@ -98,8 +98,9 @@ public class CatSpawner implements CustomSpawner {
+         if (cat == null) {
+             return 0;
+         } else {
+            cat.moveTo(pos, 0.0F, 0.0F); // Purpur
+             cat.finalizeSpawn(world, world.getCurrentDifficultyAt(pos), MobSpawnType.NATURAL, (SpawnGroupData)null, (CompoundTag)null);
+-            cat.moveTo(pos, 0.0F, 0.0F);
+            // cat.moveTo(pos, 0.0F, 0.0F); // Purpur - move up - fixes non black cat types spawning inside swamp huts
+             world.addFreshEntityWithPassengers(cat);
+             return 1;
+         }
--- a/patches/unapplied/0038-Cows-eat-mushrooms.patch
+++ b/patches/unapplied/0038-Cows-eat-mushrooms.patch
@@ -0,0 +1,135 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 4 May 2019 01:10:30 -0500
+Subject: [PATCH] Cows eat mushrooms
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Cow.java b/src/main/java/net/minecraft/world/entity/animal/Cow.java
+index dd4d5e2e7cbfed18cf3b4664dbe08eaf9d95f61e..732c560383da3b8a270139758f29734d73b775be 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cow.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cow.java
+@@ -1,6 +1,7 @@
+ package net.minecraft.world.entity.animal;
+ 
+ import net.minecraft.core.BlockPos;
+import net.minecraft.core.particles.ParticleTypes;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.sounds.SoundEvent;
+ import net.minecraft.sounds.SoundEvents;
+@@ -28,6 +29,7 @@ import net.minecraft.world.item.ItemUtils;
+ import net.minecraft.world.item.Items;
+ import net.minecraft.world.item.crafting.Ingredient;
+ import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+ import net.minecraft.world.level.block.state.BlockState;
+ // CraftBukkit start
+ import org.bukkit.craftbukkit.event.CraftEventFactory;
+@@ -68,6 +70,7 @@ public class Cow extends Animal {
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+         this.goalSelector.addGoal(1, new PanicGoal(this, 2.0D));
+         this.goalSelector.addGoal(2, new BreedGoal(this, 1.0D));
+        if (level.purpurConfig.cowFeedMushrooms > 0) this.goalSelector.addGoal(3, new TemptGoal(this, 1.25D, Ingredient.of(Items.WHEAT, Blocks.RED_MUSHROOM.asItem(), Blocks.BROWN_MUSHROOM.asItem()), false)); else // Purpur
+         this.goalSelector.addGoal(3, new TemptGoal(this, 1.25D, Ingredient.of(Items.WHEAT), false));
+         this.goalSelector.addGoal(4, new FollowParentGoal(this, 1.25D));
+         this.goalSelector.addGoal(5, new WaterAvoidingRandomStrollGoal(this, 1.0D));
+@@ -123,11 +126,80 @@ public class Cow extends Animal {
+ 
+             player.setItemInHand(hand, itemstack1);
+             return InteractionResult.sidedSuccess(this.level.isClientSide);
+        // Purpur start - feed mushroom to change to mooshroom
+        } else if (level.purpurConfig.cowFeedMushrooms > 0 && this.getType() != EntityType.MOOSHROOM && isMushroom(itemstack)) {
+            return this.feedMushroom(player, itemstack);
+        // Purpur end
+         } else {
+             return super.mobInteract(player, hand);
+         }
+     }
+ 
+    // Purpur start - feed mushroom to change to mooshroom
+    private int redMushroomsFed = 0;
+    private int brownMushroomsFed = 0;
+
+    private boolean isMushroom(ItemStack stack) {
+        return stack.getItem() == Blocks.RED_MUSHROOM.asItem() || stack.getItem() == Blocks.BROWN_MUSHROOM.asItem();
+    }
+
+    private int incrementFeedCount(ItemStack stack) {
+        if (stack.getItem() == 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);
+        if (mooshroom == null) {
+            return InteractionResult.PASS;
+        }
+        if (stack.getItem() == Blocks.BROWN_MUSHROOM.asItem()) {
+            mooshroom.setMushroomType(MushroomCow.MushroomType.BROWN);
+        } else {
+            mooshroom.setMushroomType(MushroomCow.MushroomType.RED);
+        }
+        mooshroom.moveTo(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 (CraftEventFactory.callEntityTransformEvent(this, mooshroom, org.bukkit.event.entity.EntityTransformEvent.TransformReason.INFECTION).isCancelled()) {
+            return InteractionResult.PASS;
+        }
+        if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), mooshroom.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.INFECTED).callEvent()) {
+            return InteractionResult.PASS;
+        }
+        this.level.addFreshEntity(mooshroom);
+        this.remove(RemovalReason.DISCARDED);
+        if (!player.getAbilities().instabuild) {
+            stack.shrink(1);
+        }
+        for (int i = 0; i < 15; ++i) {
+            ((ServerLevel) level).sendParticles(((ServerLevel) level).players, null, ParticleTypes.HAPPY_VILLAGER,
+                getX() + random.nextFloat(), getY() + (random.nextFloat() * 2), getZ() + random.nextFloat(), 1,
+                random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, 0, true);
+        }
+        return InteractionResult.SUCCESS;
+    }
+    // Purpur end
+
+     @Override
+     public Cow getBreedOffspring(ServerLevel world, AgeableMob entity) {
+         return (Cow) EntityType.COW.create(world);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 38f4ac177823bd6317d778163ae924c4869e8a91..2108615ad64bac1e7b9d4950b9dd62407d16504a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -310,6 +310,7 @@ public class PurpurWorldConfig {
+     public boolean cowRidableInWater = false;
+     public boolean cowControllable = true;
+     public double cowMaxHealth = 10.0D;
+    public int cowFeedMushrooms = 0;
+     private void cowSettings() {
+         cowRidable = getBoolean("mobs.cow.ridable", cowRidable);
+         cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater);
+@@ -320,6 +321,7 @@ public class PurpurWorldConfig {
+             set("mobs.cow.attributes.max_health", oldValue);
+         }
+         cowMaxHealth = getDouble("mobs.cow.attributes.max_health", cowMaxHealth);
+        cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms);
+     }
+ 
+     public boolean creeperRidable = false;
--- a/patches/unapplied/0039-Fix-cow-rotation-when-shearing-mooshroom.patch
+++ b/patches/unapplied/0039-Fix-cow-rotation-when-shearing-mooshroom.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 3 May 2019 23:53:16 -0500
+Subject: [PATCH] Fix cow rotation when shearing mooshroom
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+index 2846c17ddbb546d49407338f136e171a329b347e..d4237fce253b2414337344b327250c1db2b19dfa 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+@@ -202,7 +202,13 @@ public class MushroomCow extends Cow implements Shearable {
+ 
+             entitycow.moveTo(this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot());
+             entitycow.setHealth(this.getHealth());
+            // Purpur start
+            entitycow.copyPosition(this);
+             entitycow.yBodyRot = this.yBodyRot;
+            entitycow.setYHeadRot(this.getYHeadRot());
+            entitycow.yRotO = this.yRotO;
+            entitycow.xRotO = this.xRotO;
+            // Purpur end
+             if (this.hasCustomName()) {
+                 entitycow.setCustomName(this.getCustomName());
+                 entitycow.setCustomNameVisible(this.isCustomNameVisible());
--- a/patches/unapplied/0040-Pigs-give-saddle-back.patch
+++ b/patches/unapplied/0040-Pigs-give-saddle-back.patch
@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 12 May 2019 01:14:46 -0500
+Subject: [PATCH] Pigs give saddle back
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Pig.java b/src/main/java/net/minecraft/world/entity/animal/Pig.java
+index 62a1e63fb6ca80e165db46c4d03e28815196aaff..7787d30ad7bb9aa6041c369a368deb382c9554c2 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Pig.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Pig.java
+@@ -175,6 +175,17 @@ public class Pig extends Animal implements ItemSteerable, Saddleable {
+     public InteractionResult mobInteract(Player player, InteractionHand hand) {
+         boolean flag = this.isFood(player.getItemInHand(hand));
+ 
+        if (level.purpurConfig.pigGiveSaddleBack && player.isSecondaryUseActive() && !flag && isSaddled() && !isVehicle()) {
+            this.steering.setSaddle(false);
+            if (!player.getAbilities().instabuild) {
+                ItemStack saddle = new ItemStack(Items.SADDLE);
+                if (!player.getInventory().add(saddle)) {
+                    player.drop(saddle, false);
+                }
+            }
+            return InteractionResult.SUCCESS;
+        }
+
+         if (!flag && this.isSaddled() && !this.isVehicle() && !player.isSecondaryUseActive()) {
+             if (!this.level.isClientSide) {
+                 player.startRiding(this);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 2108615ad64bac1e7b9d4950b9dd62407d16504a..0d042476484fd6fd2e7ad98cb695e80be2e0a1d4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -868,6 +868,7 @@ public class PurpurWorldConfig {
+     public boolean pigRidableInWater = false;
+     public boolean pigControllable = true;
+     public double pigMaxHealth = 10.0D;
+    public boolean pigGiveSaddleBack = false;
+     private void pigSettings() {
+         pigRidable = getBoolean("mobs.pig.ridable", pigRidable);
+         pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater);
+@@ -878,6 +879,7 @@ public class PurpurWorldConfig {
+             set("mobs.pig.attributes.max_health", oldValue);
+         }
+         pigMaxHealth = getDouble("mobs.pig.attributes.max_health", pigMaxHealth);
+        pigGiveSaddleBack = getBoolean("mobs.pig.give-saddle-back", pigGiveSaddleBack);
+     }
+ 
+     public boolean piglinRidable = false;
--- a/patches/unapplied/0041-Snowman-drop-and-put-back-pumpkin.patch
+++ b/patches/unapplied/0041-Snowman-drop-and-put-back-pumpkin.patch
@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 3 May 2019 23:58:44 -0500
+Subject: [PATCH] Snowman drop and put back pumpkin
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+index f7863f9703c7ab5f2f1faac7a52311ed7ef79042..1336fd13ce69812e2eae6fb8fb91575006e9a318 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+++ b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+@@ -192,6 +192,14 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM
+             }
+ 
+             return InteractionResult.sidedSuccess(this.level.isClientSide);
+            // Purpur start
+        } else if (level.purpurConfig.snowGolemPutPumpkinBack && !hasPumpkin() && itemstack.getItem() == Blocks.CARVED_PUMPKIN.asItem()) {
+            setPumpkin(true);
+            if (!player.getAbilities().instabuild) {
+                itemstack.shrink(1);
+            }
+            return InteractionResult.SUCCESS;
+            // Purpur end
+         } else {
+             return tryRide(player, hand); // Purpur
+         }
+@@ -203,6 +211,7 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM
+         if (!this.level.isClientSide()) {
+             this.setPumpkin(false);
+             this.forceDrops = true; // CraftBukkit
+            if (level.purpurConfig.snowGolemDropsPumpkin) // Purpur
+             this.spawnAtLocation(new ItemStack(Items.CARVED_PUMPKIN), 1.7F);
+             this.forceDrops = false; // CraftBukkit
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 0d042476484fd6fd2e7ad98cb695e80be2e0a1d4..54c0fe906604b14314125ff35322f75c84c1ee7d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1131,6 +1131,8 @@ public class PurpurWorldConfig {
+     public boolean snowGolemControllable = true;
+     public boolean snowGolemLeaveTrailWhenRidden = false;
+     public double snowGolemMaxHealth = 4.0D;
+    public boolean snowGolemDropsPumpkin = true;
+    public boolean snowGolemPutPumpkinBack = false;
+     private void snowGolemSettings() {
+         snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable);
+         snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater);
+@@ -1142,6 +1144,8 @@ public class PurpurWorldConfig {
+             set("mobs.snow_golem.attributes.max_health", oldValue);
+         }
+         snowGolemMaxHealth = getDouble("mobs.snow_golem.attributes.max_health", snowGolemMaxHealth);
+        snowGolemDropsPumpkin = getBoolean("mobs.snow_golem.drop-pumpkin-when-sheared", snowGolemDropsPumpkin);
+        snowGolemPutPumpkinBack = getBoolean("mobs.snow_golem.pumpkin-can-be-added-back", snowGolemPutPumpkinBack);
+     }
+ 
+     public boolean squidRidable = false;
--- a/patches/unapplied/0042-Ender-dragon-always-drop-full-exp.patch
+++ b/patches/unapplied/0042-Ender-dragon-always-drop-full-exp.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 24 Aug 2019 14:42:54 -0500
+Subject: [PATCH] Ender dragon always drop full exp
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index 63ba8083c4f4a7ead9fec21eb96584f192c5cade..1a454c782391ff906c58cdb71c4345bb15943649 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+@@ -728,7 +728,7 @@ public class EnderDragon extends Mob implements Enemy {
+         boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT);
+         short short0 = 500;
+ 
+-        if (this.dragonFight != null && !this.dragonFight.hasPreviouslyKilledDragon()) {
+        if (this.dragonFight != null && (level.purpurConfig.enderDragonAlwaysDropsFullExp || !this.dragonFight.hasPreviouslyKilledDragon())) {
+             short0 = 12000;
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 54c0fe906604b14314125ff35322f75c84c1ee7d..fa3ae133ed06e4b57a4bc3ea2a32b5f1aef2636b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -423,6 +423,7 @@ public class PurpurWorldConfig {
+     public boolean enderDragonControllable = true;
+     public double enderDragonMaxY = 320D;
+     public double enderDragonMaxHealth = 200.0D;
+    public boolean enderDragonAlwaysDropsFullExp = false;
+     private void enderDragonSettings() {
+         enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable);
+         enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater);
+@@ -438,6 +439,7 @@ public class PurpurWorldConfig {
+             set("mobs.ender_dragon.attributes.max_health", oldValue);
+         }
+         enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth);
+        enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp);
+     }
+ 
+     public boolean endermanRidable = false;
--- a/patches/unapplied/0043-Signs-editable-on-right-click.patch
+++ b/patches/unapplied/0043-Signs-editable-on-right-click.patch
@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 24 May 2019 02:39:25 -0500
+Subject: [PATCH] Signs editable on right click
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/SignBlock.java b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+index ed3d78494735ceda14ad0ea23adeadc374f3b35e..a0d23b7e244e7df8a462b801dee18fd421b3b8ef 100644
+--- a/src/main/java/net/minecraft/world/level/block/SignBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+@@ -14,6 +14,7 @@ import net.minecraft.world.item.DyeItem;
+ import net.minecraft.world.item.Item;
+ import net.minecraft.world.item.ItemStack;
+ import net.minecraft.world.item.Items;
+import net.minecraft.world.item.SignItem;
+ import net.minecraft.world.level.BlockGetter;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.LevelAccessor;
+@@ -108,6 +109,17 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
+                         }
+                     }
+ 
+                    // Purpur start - right click to open sign editor
+                    if (world.purpurConfig.signRightClickEdit && itemStack.getItem() instanceof SignItem &&
+                        !player.isCrouching() && player.getAbilities().mayBuild &&
+                        player.getBukkitEntity().hasPermission("purpur.sign.edit")) {
+                        signBlockEntity.setEditable(true);
+                        signBlockEntity.setAllowedPlayerEditor(player.getUUID());
+                        player.openTextEdit(signBlockEntity);
+                        return InteractionResult.SUCCESS;
+                    }
+                    // Purpur end
+
+                     return signBlockEntity.executeClickCommands((ServerPlayer)player) ? InteractionResult.SUCCESS : InteractionResult.PASS;
+                 } else {
+                     return InteractionResult.PASS;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 149b3cf94e6e60007a91cb1653419aed7b88b388..6469e3c2976ef07fb10be7298b4126efbb46ea61 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -148,6 +148,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean signRightClickEdit = false;
+    private void signSettings() {
+        signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
+    }
+
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;
--- a/patches/unapplied/0044-Allow-soil-to-moisten-from-water-directly-under-it.patch
+++ b/patches/unapplied/0044-Allow-soil-to-moisten-from-water-directly-under-it.patch
@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 21 Jun 2019 14:37:10 -0500
+Subject: [PATCH] Allow soil to moisten from water directly under it
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FarmBlock.java b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+index 499eae5ab30921f49045dc73bd077941255f727a..f9c363a9148d30b1ecc8f744a7eaa131a9fd1428 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -158,7 +158,7 @@ public class FarmBlock extends Block {
+             }
+         }
+ 
+-        return false;
+        return ((ServerLevel) world).purpurConfig.farmlandGetsMoistFromBelow && world.getFluidState(pos.relative(Direction.DOWN)).is(FluidTags.WATER); // Purpur;
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 79e618ce91686370d439a5f6ed6a7f46f579ae74..620a68fbef5d3bc8894ee83d9c52ec8ba58e98d3 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -148,6 +148,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean farmlandGetsMoistFromBelow = false;
+    private void farmlandSettings() {
+        farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+    }
+
+     public boolean signRightClickEdit = false;
+     private void signSettings() {
+         signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
--- a/patches/unapplied/0045-Minecart-settings-and-WASD-controls.patch
+++ b/patches/unapplied/0045-Minecart-settings-and-WASD-controls.patch
@@ -0,0 +1,222 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 29 Jun 2019 02:32:40 -0500
+Subject: [PATCH] Minecart settings and WASD controls
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 3c42c1d0c9542f8ce058cd2bfc931f53ad0a82e8..54c6433daec4574fd1653a73fa80761ddf49549e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1023,6 +1023,7 @@ public class ServerPlayer extends Player {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else {
+            if (source == DamageSource.FALL && getRootVehicle() instanceof net.minecraft.world.entity.vehicle.AbstractMinecart && level.purpurConfig.minecartControllable && !level.purpurConfig.minecartControllableFallDamage) return false; // Purpur
+             boolean flag = this.server.isDedicatedServer() && this.isPvpAllowed() && "fall".equals(source.msgId);
+ 
+             if (!flag && isSpawnInvulnerable() && source != DamageSource.OUT_OF_WORLD) { // Purpur
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+index 96a7bfd921e59f298f0ee502d356cc3552c30ce8..dac3f948481e444b3b641ab00eabca0cc8f17fa8 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -107,11 +107,13 @@ public abstract class AbstractMinecart extends Entity {
+     private double flyingY = 0.949999988079071D; // Paper - restore vanilla precision
+     private double flyingZ = 0.949999988079071D; // Paper - restore vanilla precision
+     public double maxSpeed = 0.4D;
+    public double storedMaxSpeed; // Purpur
+     // CraftBukkit end
+ 
+     protected AbstractMinecart(EntityType<?> type, Level world) {
+         super(type, world);
+         this.blocksBuilding = true;
+        if (world != null) maxSpeed = storedMaxSpeed = world.purpurConfig.minecartMaxSpeed; // Purpur
+     }
+ 
+     protected AbstractMinecart(EntityType<?> type, Level world, double x, double y, double z) {
+@@ -324,6 +326,12 @@ public abstract class AbstractMinecart extends Entity {
+ 
+     @Override
+     public void tick() {
+        // Purpur start
+        if (storedMaxSpeed != level.purpurConfig.minecartMaxSpeed) {
+            maxSpeed = storedMaxSpeed = level.purpurConfig.minecartMaxSpeed;
+        }
+        // Purpur end
+
+         // CraftBukkit start
+         double prevX = this.getX();
+         double prevY = this.getY();
+@@ -487,16 +495,62 @@ public abstract class AbstractMinecart extends Entity {
+ 
+     public void activateMinecart(int x, int y, int z, boolean powered) {}
+ 
+    // Purpur start
+    private Double lastSpeed;
+
+    public double getControllableSpeed() {
+        BlockPos pos = new BlockPos(this);
+        Block block = level.getBlockState(pos).getBlock();
+        if (!block.material.isSolid()) {
+            block = level.getBlockState(pos.relative(Direction.DOWN)).getBlock();
+        }
+        Double speed = level.purpurConfig.minecartControllableBlockSpeeds.get(block);
+        if (!block.material.isSolid()) {
+            speed = lastSpeed;
+        } else if (speed == null) {
+            speed = level.purpurConfig.minecartControllableBaseSpeed;
+        }
+        return lastSpeed = speed;
+    }
+    // Purpur end
+
+     protected void comeOffTrack() {
+         double d0 = this.getMaxSpeed();
+         Vec3 vec3d = this.getDeltaMovement();
+ 
+         this.setDeltaMovement(Mth.clamp(vec3d.x, -d0, d0), vec3d.y, Mth.clamp(vec3d.z, -d0, d0));
+
+        // Purpur start
+        if (level.purpurConfig.minecartControllable && !isInWater() && !isInLava() && !passengers.isEmpty()) {
+            Entity passenger = passengers.get(0);
+            if (passenger instanceof Player) {
+                Player player = (Player) passenger;
+                if (player.jumping && this.onGround) {
+                    setDeltaMovement(new Vec3(getDeltaMovement().x, level.purpurConfig.minecartControllableHopBoost, getDeltaMovement().z));
+                }
+                if (player.zza != 0.0F) {
+                    Vector velocity = player.getBukkitEntity().getEyeLocation().getDirection().normalize().multiply(getControllableSpeed());
+                    if (player.zza < 0.0) {
+                        velocity.multiply(-0.5);
+                    }
+                    setDeltaMovement(new Vec3(velocity.getX(), getDeltaMovement().y, velocity.getZ()));
+                }
+                this.setYRot(passenger.getYRot() - 90);
+                maxUpStep = level.purpurConfig.minecartControllableStepHeight;
+            } else {
+                maxUpStep = 0.0F;
+            }
+        } else {
+            maxUpStep = 0.0F;
+        }
+        // Purpur end
+
+         if (this.onGround) {
+             // CraftBukkit start - replace magic numbers with our variables
+             this.setDeltaMovement(new Vec3(this.getDeltaMovement().x * this.derailedX, this.getDeltaMovement().y * this.derailedY, this.getDeltaMovement().z * this.derailedZ));
+             // CraftBukkit end
+         }
+        else if (level.purpurConfig.minecartControllable) setDeltaMovement(new Vec3(getDeltaMovement().x * derailedX, getDeltaMovement().y, getDeltaMovement().z * derailedZ)); // Purpur
+ 
+         this.move(MoverType.SELF, this.getDeltaMovement());
+         if (!this.onGround) {
+diff --git a/src/main/java/net/minecraft/world/item/MinecartItem.java b/src/main/java/net/minecraft/world/item/MinecartItem.java
+index 024124249fafa1ed2cf0257037f655ca8fb0aea2..f6c8def0d9d2f9580a172c3a36a7db0adfa20aeb 100644
+--- a/src/main/java/net/minecraft/world/item/MinecartItem.java
+++ b/src/main/java/net/minecraft/world/item/MinecartItem.java
+@@ -120,8 +120,9 @@ public class MinecartItem extends Item {
+         BlockState iblockdata = world.getBlockState(blockposition);
+ 
+         if (!iblockdata.is(BlockTags.RAILS)) {
+-            return InteractionResult.FAIL;
+-        } else {
+            if (!world.purpurConfig.minecartPlaceAnywhere) return InteractionResult.FAIL;
+            if (iblockdata.getMaterial().isSolid()) blockposition = blockposition.relative(context.getClickedFace());
+        } // else { // Purpur - place minecarts anywhere
+             ItemStack itemstack = context.getItemInHand();
+ 
+             if (!world.isClientSide) {
+@@ -149,6 +150,6 @@ public class MinecartItem extends Item {
+ 
+             itemstack.shrink(1);
+             return InteractionResult.sidedSuccess(world.isClientSide);
+-        }
+        // } // Purpur - place minecarts anywhere
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 7f83c9390823b42fc30d04e1d3222e2825eaad50..e837091037402e990f763903d851c2f70888ada7 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -71,7 +71,7 @@ import net.minecraft.world.phys.shapes.VoxelShape;
+ public abstract class BlockBehaviour {
+ 
+     public static final Direction[] UPDATE_SHAPE_ORDER = new Direction[]{Direction.WEST, Direction.EAST, Direction.NORTH, Direction.SOUTH, Direction.DOWN, Direction.UP}; // Paper - public
+-    protected final Material material;
+    public final Material material; // Purpur - protected -> public
+     public final boolean hasCollision;
+     protected final float explosionResistance;
+     protected final boolean isRandomlyTicking;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 620a68fbef5d3bc8894ee83d9c52ec8ba58e98d3..e42af09797a6e0ad976c4f734f1ad714bc377383 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -94,6 +94,68 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
+    public double minecartMaxSpeed = 0.4D;
+    public boolean minecartPlaceAnywhere = false;
+    public boolean minecartControllable = false;
+    public float minecartControllableStepHeight = 1.0F;
+    public double minecartControllableHopBoost = 0.5D;
+    public boolean minecartControllableFallDamage = true;
+    public double minecartControllableBaseSpeed = 0.1D;
+    public Map<Block, Double> minecartControllableBlockSpeeds = new HashMap<>();
+    private void minecartSettings() {
+        if (PurpurConfig.version < 12) {
+            boolean oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.place-anywhere", minecartPlaceAnywhere);
+            set("gameplay-mechanics.controllable-minecarts.place-anywhere", null);
+            set("gameplay-mechanics.minecart.place-anywhere", oldBool);
+            oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.enabled", minecartControllable);
+            set("gameplay-mechanics.controllable-minecarts.enabled", null);
+            set("gameplay-mechanics.minecart.controllable.enabled", oldBool);
+            double oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.step-height", minecartControllableStepHeight);
+            set("gameplay-mechanics.controllable-minecarts.step-height", null);
+            set("gameplay-mechanics.minecart.controllable.step-height", oldDouble);
+            oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.hop-boost", minecartControllableHopBoost);
+            set("gameplay-mechanics.controllable-minecarts.hop-boost", null);
+            set("gameplay-mechanics.minecart.controllable.hop-boost", oldDouble);
+            oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.fall-damage", minecartControllableFallDamage);
+            set("gameplay-mechanics.controllable-minecarts.fall-damage", null);
+            set("gameplay-mechanics.minecart.controllable.fall-damage", oldBool);
+            oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.base-speed", minecartControllableBaseSpeed);
+            set("gameplay-mechanics.controllable-minecarts.base-speed", null);
+            set("gameplay-mechanics.minecart.controllable.base-speed", oldDouble);
+            ConfigurationSection section = getConfigurationSection("gameplay-mechanics.controllable-minecarts.block-speed");
+            if (section != null) {
+                for (String key : section.getKeys(false)) {
+                    if ("grass-block".equals(key)) key = "grass_block"; // oopsie
+                    oldDouble = section.getDouble(key, minecartControllableBaseSpeed);
+                    set("gameplay-mechanics.controllable-minecarts.block-speed." + key, null);
+                    set("gameplay-mechanics.minecart.controllable.block-speed." + key, oldDouble);
+                }
+                set("gameplay-mechanics.controllable-minecarts.block-speed", null);
+            }
+            set("gameplay-mechanics.controllable-minecarts", null);
+        }
+
+        minecartMaxSpeed = getDouble("gameplay-mechanics.minecart.max-speed", minecartMaxSpeed);
+        minecartPlaceAnywhere = getBoolean("gameplay-mechanics.minecart.place-anywhere", minecartPlaceAnywhere);
+        minecartControllable = getBoolean("gameplay-mechanics.minecart.controllable.enabled", minecartControllable);
+        minecartControllableStepHeight = (float) getDouble("gameplay-mechanics.minecart.controllable.step-height", minecartControllableStepHeight);
+        minecartControllableHopBoost = getDouble("gameplay-mechanics.minecart.controllable.hop-boost", minecartControllableHopBoost);
+        minecartControllableFallDamage = getBoolean("gameplay-mechanics.minecart.controllable.fall-damage", minecartControllableFallDamage);
+        minecartControllableBaseSpeed = getDouble("gameplay-mechanics.minecart.controllable.base-speed", minecartControllableBaseSpeed);
+        ConfigurationSection section = getConfigurationSection("gameplay-mechanics.minecart.controllable.block-speed");
+        if (section != null) {
+            for (String key : section.getKeys(false)) {
+                Block block = Registry.BLOCK.get(new ResourceLocation(key));
+                if (block != Blocks.AIR) {
+                    minecartControllableBlockSpeeds.put(block, section.getDouble(key, minecartControllableBaseSpeed));
+                }
+            }
+        } else {
+            set("gameplay-mechanics.minecart.controllable.block-speed.grass_block", 0.3D);
+            set("gameplay-mechanics.minecart.controllable.block-speed.stone", 0.5D);
+        }
+    }
+
+     public boolean idleTimeoutKick = true;
+     public boolean idleTimeoutTickNearbyEntities = true;
+     public boolean idleTimeoutCountAsSleeping = false;
--- a/patches/unapplied/0046-Disable-loot-drops-on-death-by-cramming.patch
+++ b/patches/unapplied/0046-Disable-loot-drops-on-death-by-cramming.patch
@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Wed, 3 Jul 2019 23:58:31 -0500
+Subject: [PATCH] Disable loot drops on death by cramming
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 86d3e06aa27357240c9c24672dc8430d8b02dd3a..292744702aef86b99cea45a161e9696f9ec1a608 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1725,6 +1725,7 @@ public abstract class LivingEntity extends Entity {
+ 
+         this.dropEquipment(); // CraftBukkit - from below
+         if (this.shouldDropLoot() && this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+            if (!(source == DamageSource.CRAMMING && level.purpurConfig.disableDropsOnCrammingDeath)) { // Purpur
+             this.dropFromLootTable(source, flag);
+             // Paper start
+             final boolean prev = this.clearEquipmentSlots;
+@@ -1733,6 +1734,7 @@ public abstract class LivingEntity extends Entity {
+             // Paper end
+             this.dropCustomDeathLoot(source, i, flag);
+             this.clearEquipmentSlots = prev; // Paper
+            } // Purpur
+         }
+         // CraftBukkit start - Call death event // Paper start - call advancement triggers with correct entity equipment
+         org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, this.drops, () -> {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index e42af09797a6e0ad976c4f734f1ad714bc377383..eb86bc06b2e7c6c7655d6111de96837ad921cbbb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -94,6 +94,11 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
+    public boolean disableDropsOnCrammingDeath = false;
+    private void miscGameplayMechanicsSettings() {
+        disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+    }
+
+     public double minecartMaxSpeed = 0.4D;
+     public boolean minecartPlaceAnywhere = false;
+     public boolean minecartControllable = false;
--- a/patches/unapplied/0047-Option-to-toggle-milk-curing-bad-omen.patch
+++ b/patches/unapplied/0047-Option-to-toggle-milk-curing-bad-omen.patch
@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Wed, 10 Jul 2019 20:43:05 -0500
+Subject: [PATCH] Option to toggle milk curing bad omen
+
+
+diff --git a/src/main/java/net/minecraft/world/item/MilkBucketItem.java b/src/main/java/net/minecraft/world/item/MilkBucketItem.java
+index f33977d95b6db473be4f95075ba99caf90ad0220..56dc04d8875971ee9a5d077a695509af74fe2473 100644
+--- a/src/main/java/net/minecraft/world/item/MilkBucketItem.java
+++ b/src/main/java/net/minecraft/world/item/MilkBucketItem.java
+@@ -5,6 +5,8 @@ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.stats.Stats;
+ import net.minecraft.world.InteractionHand;
+ import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+ import net.minecraft.world.entity.LivingEntity;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.level.Level;
+@@ -31,7 +33,9 @@ public class MilkBucketItem extends Item {
+         }
+ 
+         if (!world.isClientSide) {
+            MobEffectInstance badOmen = user.getEffect(MobEffects.BAD_OMEN);
+             user.removeAllEffects(org.bukkit.event.entity.EntityPotionEffectEvent.Cause.MILK); // CraftBukkit
+            if (!world.purpurConfig.milkCuresBadOmen && badOmen != null) user.addEffect(badOmen); // Purpur
+         }
+ 
+         return stack.isEmpty() ? new ItemStack(Items.BUCKET) : stack;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a252c0d92d83eddfc65ecda9cf889b6789f4ee16..928f903e0a607646be42dca6e9ad2a84ccd56583 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -95,8 +95,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean disableDropsOnCrammingDeath = false;
+    public boolean milkCuresBadOmen = true;
+     private void miscGameplayMechanicsSettings() {
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+        milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+     }
+ 
+     public double minecartMaxSpeed = 0.4D;
--- a/patches/unapplied/0048-End-gateway-should-check-if-entity-can-use-portal.patch
+++ b/patches/unapplied/0048-End-gateway-should-check-if-entity-can-use-portal.patch
@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 21 Mar 2020 18:33:05 -0500
+Subject: [PATCH] End gateway should check if entity can use portal
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 4e435a16a16c703a2978f4dc82606b8710742670..a952f19530983ca9a72969ad25f9565a2a03688a 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -177,6 +177,7 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+ 
+     public static void teleportEntity(Level world, BlockPos pos, BlockState state, Entity entity, TheEndGatewayBlockEntity blockEntity) {
+         if (world instanceof ServerLevel && !blockEntity.isCoolingDown()) {
+            if (!entity.canChangeDimensions()) return; // Purpur
+             ServerLevel worldserver = (ServerLevel) world;
+ 
+             blockEntity.teleportCooldown = 100;
--- a/patches/unapplied/0049-Fix-the-dead-lagging-the-server.patch
+++ b/patches/unapplied/0049-Fix-the-dead-lagging-the-server.patch
@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 6 Mar 2020 13:37:26 -0600
+Subject: [PATCH] Fix the dead lagging the server
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 19756aac2e13914d0cf3cabed3621d2a4228330b..f44b29dd23bdc1974300e90501331383f639756d 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1782,6 +1782,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         this.yRotO = this.getYRot();
+         this.xRotO = this.getXRot();
+         this.setYHeadRot(yaw); // Paper - Update head rotation
+        if (valid && !this.isRemoved()) level.getChunk((int) Math.floor(this.getX()) >> 4, (int) Math.floor(this.getZ()) >> 4); // CraftBukkit // Paper // Purpur
+     }
+ 
+     public void absMoveTo(double x, double y, double z) {
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 5b07633ce5d001ee25766b88e90cc3f1d4508ff0..5fd3b3cf20b31a9baaf5a703aab62bb5161001b4 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -2942,7 +2942,7 @@ public abstract class LivingEntity extends Entity {
+             }
+         }
+ 
+-        this.aiStep();
+        if (!this.isRemoved()) this.aiStep(); // Purpur
+         double d0 = this.getX() - this.xo;
+         double d1 = this.getZ() - this.zo;
+         float f = (float) (d0 * d0 + d1 * d1);
--- a/patches/unapplied/0050-Skip-events-if-there-s-no-listeners.patch
+++ b/patches/unapplied/0050-Skip-events-if-there-s-no-listeners.patch
@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 4 Apr 2020 03:07:59 -0500
+Subject: [PATCH] Skip events if there's no listeners
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index b66afde6851ceaeccb84aea00cdc333dfbf3d4b0..c79c89bab8972a26c7a48f63ad20ac34b0fc8750 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -391,6 +391,7 @@ public class Commands {
+     }
+ 
+     private void runSync(ServerPlayer player, Collection<String> bukkit, RootCommandNode<SharedSuggestionProvider> rootcommandnode) {
+        if (PlayerCommandSendEvent.getHandlerList().getRegisteredListeners().length > 0) { // Purpur - skip all this crap if there's nothing listening
+         // Paper end - Async command map building
+         new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendCommandsEvent<CommandSourceStack>(player.getBukkitEntity(), (RootCommandNode) rootcommandnode, false).callEvent(); // Paper
+         PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit));
+@@ -403,6 +404,7 @@ public class Commands {
+             }
+         }
+         // CraftBukkit end
+        } // Purpur - skip event
+         player.connection.send(new ClientboundCommandsPacket(rootcommandnode));
+     }
+ 
--- a/patches/unapplied/0051-Add-permission-for-F3-N-debug.patch
+++ b/patches/unapplied/0051-Add-permission-for-F3-N-debug.patch
@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 28 Dec 2019 04:21:54 -0600
+Subject: [PATCH] Add permission for F3+N debug
+
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 6ad2ccf91a384bf431e3716d374f0eb45c6c0fe8..fe5191550b0472a33122f3378142cdef83c89ce5 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1169,6 +1169,7 @@ public abstract class PlayerList {
+             } else {
+                 b0 = (byte) (24 + permissionLevel);
+             }
+            if (b0 < 28 && player.getBukkitEntity().hasPermission("purpur.debug.f3n")) b0 = 28; // Purpur
+ 
+             player.connection.send(new ClientboundEntityEventPacket(player, b0));
+         }
--- a/patches/unapplied/0052-Configurable-TPS-Catchup.patch
+++ b/patches/unapplied/0052-Configurable-TPS-Catchup.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 26 Mar 2020 19:06:22 -0500
+Subject: [PATCH] Configurable TPS Catchup
+
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 3e514e341632c813898a9af295e6233a91243c51..120f800573246fd67e735cdf2fce435a2497dc7b 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1230,7 +1230,13 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                     this.tickServer(this::haveTime);
+                     this.profiler.popPush("nextTickWait");
+                     this.mayHaveDelayedTasks = true;
+-                    this.delayedTasksMaxNextTickTime = Math.max(Util.getMillis() + 50L, this.nextTickTime);
+                    // Purpur start - tps catchup
+                    if (org.purpurmc.purpur.PurpurConfig.tpsCatchup) {
+                        this.delayedTasksMaxNextTickTime = Math.max(Util.getMillis() + 50L, this.nextTickTime);
+                    } else {
+                        this.delayedTasksMaxNextTickTime = this.nextTickTime = curTime / 1000000L + 50L;
+                    }
+                    // Purpur end - tps catchup
+                     this.waitUntilNextTick();
+                     this.profiler.pop();
+                     this.endMetricsRecordingTick();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index dab104575c5a12857faffb8efc5620a123580a9e..b41d73318d6795c0fa7b9c60431ef141026fa9d6 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -241,4 +241,9 @@ public class PurpurConfig {
+         loggerSuppressUnrecognizedRecipeErrors = getBoolean("settings.logger.suppress-unrecognized-recipe-errors", loggerSuppressUnrecognizedRecipeErrors);
+         loggerSuppressSetBlockFarChunk = getBoolean("settings.logger.suppress-setblock-in-far-chunk-errors", loggerSuppressSetBlockFarChunk);
+     }
+
+    public static boolean tpsCatchup = true;
+    private static void tpsCatchup() {
+        tpsCatchup = getBoolean("settings.tps-catchup", tpsCatchup);
+    }
+ }
--- a/patches/unapplied/0053-Add-option-to-allow-loyalty-on-tridents-to-work-in-t.patch
+++ b/patches/unapplied/0053-Add-option-to-allow-loyalty-on-tridents-to-work-in-t.patch
@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 19 Mar 2020 19:39:34 -0500
+Subject: [PATCH] Add option to allow loyalty on tridents to work in the void
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+index a367f50b0e3fe9e7a1b87892a8c98e88bd678f6f..52d41fb8d0495f61346c718c8f2395bc622027af 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+@@ -60,7 +60,7 @@ public class ThrownTrident extends AbstractArrow {
+         Entity entity = this.getOwner();
+         byte b0 = (Byte) this.entityData.get(ThrownTrident.ID_LOYALTY);
+ 
+-        if (b0 > 0 && (this.dealtDamage || this.isNoPhysics()) && entity != null) {
+        if (b0 > 0 && (this.dealtDamage || this.isNoPhysics() || (level.purpurConfig.tridentLoyaltyVoidReturnHeight < 0.0D && getY() < level.purpurConfig.tridentLoyaltyVoidReturnHeight)) && entity != null) { // Purpur
+             if (!this.isAcceptibleReturnOwner()) {
+                 if (!this.level.isClientSide && this.pickup == AbstractArrow.Pickup.ALLOWED) {
+                     this.spawnAtLocation(this.getPickupItem(), 0.1F);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 928f903e0a607646be42dca6e9ad2a84ccd56583..4b81cc5d43182fa117c2a5d720a89f17ddf7f39b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -96,9 +96,11 @@ public class PurpurWorldConfig {
+ 
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean milkCuresBadOmen = true;
+    public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     private void miscGameplayMechanicsSettings() {
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+        tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
+     }
+ 
+     public double minecartMaxSpeed = 0.4D;
--- a/patches/unapplied/0054-Add-enderman-and-creeper-griefing-controls.patch
+++ b/patches/unapplied/0054-Add-enderman-and-creeper-griefing-controls.patch
@@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 26 Apr 2020 16:28:38 -0500
+Subject: [PATCH] Add enderman and creeper griefing controls
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+index e51bcd5158d17db613311e38f2810b650d522cf4..f486b722ef0c82b449238effc045fa9f68860193 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -349,7 +349,7 @@ public class Creeper extends Monster implements PowerableMob {
+ 
+     public void explodeCreeper() {
+         if (!this.level.isClientSide) {
+-            Explosion.BlockInteraction explosion_effect = this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) ? Explosion.BlockInteraction.DESTROY : Explosion.BlockInteraction.NONE;
+            Explosion.BlockInteraction explosion_effect = this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && level.purpurConfig.creeperAllowGriefing ? Explosion.BlockInteraction.DESTROY : Explosion.BlockInteraction.NONE; // Purpur
+             float f = this.isPowered() ? 2.0F : 1.0F;
+ 
+             // CraftBukkit start
+diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+index 5d2dc22c920c61d4afb7b61c863f2facf8d6ec10..f3ea85978b5714e82b7722d1cf03d136d383824d 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -519,6 +519,7 @@ public class EnderMan extends Monster implements NeutralMob {
+ 
+         @Override
+         public boolean canUse() {
+            if (!enderman.level.purpurConfig.endermanAllowGriefing) return false; // Purpur
+             return this.enderman.getCarriedBlock() == null ? false : (!this.enderman.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) ? false : this.enderman.getRandom().nextInt(reducedTickDelay(2000)) == 0);
+         }
+ 
+@@ -566,6 +567,7 @@ public class EnderMan extends Monster implements NeutralMob {
+ 
+         @Override
+         public boolean canUse() {
+            if (!enderman.level.purpurConfig.endermanAllowGriefing) return false; // Purpur
+             return this.enderman.getCarriedBlock() != null ? false : (!this.enderman.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) ? false : this.enderman.getRandom().nextInt(reducedTickDelay(20)) == 0);
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 725d29b3e79e45d95635b73c9ea783ff2a04ad39..ce46f2530aad6f2fb96618b101f5dfdec974908e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -410,6 +410,7 @@ public class PurpurWorldConfig {
+     public boolean creeperControllable = true;
+     public double creeperMaxHealth = 20.0D;
+     public double creeperChargedChance = 0.0D;
+    public boolean creeperAllowGriefing = true;
+     private void creeperSettings() {
+         creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
+         creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
+@@ -421,6 +422,7 @@ public class PurpurWorldConfig {
+         }
+         creeperMaxHealth = getDouble("mobs.creeper.attributes.max_health", creeperMaxHealth);
+         creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance);
+        creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing);
+     }
+ 
+     public boolean dolphinRidable = false;
+@@ -527,6 +529,7 @@ public class PurpurWorldConfig {
+     public boolean endermanRidableInWater = false;
+     public boolean endermanControllable = true;
+     public double endermanMaxHealth = 40.0D;
+    public boolean endermanAllowGriefing = true;
+     private void endermanSettings() {
+         endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
+         endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
+@@ -537,6 +540,7 @@ public class PurpurWorldConfig {
+             set("mobs.enderman.attributes.max_health", oldValue);
+         }
+         endermanMaxHealth = getDouble("mobs.enderman.attributes.max_health", endermanMaxHealth);
+        endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing);
+     }
+ 
+     public boolean endermiteRidable = false;
--- a/patches/unapplied/0055-Villagers-follow-emerald-blocks.patch
+++ b/patches/unapplied/0055-Villagers-follow-emerald-blocks.patch
@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 29 Nov 2019 22:10:12 -0600
+Subject: [PATCH] Villagers follow emerald blocks
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
+index 79bb13c5614bab1f0749c5f8f57f762c6216c564..2cbc9adc8e417def48be03d08174a5833068ec65 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
+@@ -62,7 +62,7 @@ public class TemptGoal extends Goal {
+     }
+ 
+     private boolean shouldFollow(LivingEntity entity) {
+-        return this.items.test(entity.getMainHandItem()) || this.items.test(entity.getOffhandItem());
+        return (this.items.test(entity.getMainHandItem()) || this.items.test(entity.getOffhandItem())) && (!(this.mob instanceof net.minecraft.world.entity.npc.Villager villager) || !villager.isSleeping()); // Purpur Fix #512
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java b/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
+index bd283f71cb05ffbe1fed39afb41ae54dc52ec297..d7ebbd785d89fc5c1fec1a020a259a94b2b78827 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
+@@ -43,6 +43,7 @@ import org.bukkit.event.entity.VillagerAcquireTradeEvent;
+ // CraftBukkit end
+ 
+ public abstract class AbstractVillager extends AgeableMob implements InventoryCarrier, Npc, Merchant {
+    static final net.minecraft.world.item.crafting.Ingredient TEMPT_ITEMS = net.minecraft.world.item.crafting.Ingredient.of(net.minecraft.world.level.block.Blocks.EMERALD_BLOCK.asItem()); // Purpur
+ 
+     // CraftBukkit start
+     private CraftMerchant craftMerchant;
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 2786df9e1ee9f7e774fef3d9f4bb3db3b9440b10..22229c1040a578bf20d67cdfcb25021539c84150 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -176,6 +176,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+        if (level.purpurConfig.villagerFollowEmeraldBlock) this.goalSelector.addGoal(3, new net.minecraft.world.entity.ai.goal.TemptGoal(this, 1.0D, TEMPT_ITEMS, false));
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+index 8bfa041297db79e8f1452ce7059d1536a6e2854f..615fdf709b81693cced9a208cc96a33fb686c9a1 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -108,6 +108,7 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+         this.goalSelector.addGoal(1, new PanicGoal(this, 0.5D));
+         this.goalSelector.addGoal(1, new LookAtTradingPlayerGoal(this));
+         this.goalSelector.addGoal(2, new WanderingTrader.WanderToPositionGoal(this, 2.0D, 0.35D));
+        if (level.purpurConfig.wanderingTraderFollowEmeraldBlock) this.goalSelector.addGoal(3, new net.minecraft.world.entity.ai.goal.TemptGoal(this, 1.0D, TEMPT_ITEMS, false)); // Purpur
+         this.goalSelector.addGoal(4, new MoveTowardsRestrictionGoal(this, 0.35D));
+         this.goalSelector.addGoal(8, new WaterAvoidingRandomStrollGoal(this, 0.35D));
+         this.goalSelector.addGoal(9, new InteractGoal(this, Player.class, 3.0F, 1.0F));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ce46f2530aad6f2fb96618b101f5dfdec974908e..11e9eeeb1ef515ea65701629f61b2a74c5986412 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1379,6 +1379,7 @@ public class PurpurWorldConfig {
+     public double villagerMaxHealth = 20.0D;
+     public int villagerBrainTicks = 1;
+     public boolean villagerUseBrainTicksOnlyWhenLagging = true;
+    public boolean villagerFollowEmeraldBlock = false;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1391,6 +1392,7 @@ public class PurpurWorldConfig {
+         villagerMaxHealth = getDouble("mobs.villager.attributes.max_health", villagerMaxHealth);
+         villagerBrainTicks = getInt("mobs.villager.brain-ticks", villagerBrainTicks);
+         villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging);
+        villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1413,6 +1415,7 @@ public class PurpurWorldConfig {
+     public boolean wanderingTraderRidableInWater = false;
+     public boolean wanderingTraderControllable = true;
+     public double wanderingTraderMaxHealth = 20.0D;
+    public boolean wanderingTraderFollowEmeraldBlock = false;
+     private void wanderingTraderSettings() {
+         wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable);
+         wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater);
+@@ -1423,6 +1426,7 @@ public class PurpurWorldConfig {
+             set("mobs.wandering_trader.attributes.max_health", oldValue);
+         }
+         wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth);
+        wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock);
+     }
+ 
+     public boolean witchRidable = false;
--- a/patches/unapplied/0056-Allow-leashing-villagers.patch
+++ b/patches/unapplied/0056-Allow-leashing-villagers.patch
@@ -0,0 +1,86 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 3 Oct 2019 18:08:03 -0500
+Subject: [PATCH] Allow leashing villagers
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index f72b0defbc25ec8efc7346e56a6d1e68aac5a902..88705ce6b18091e3a8bf10f11bdd38830cd6af22 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1243,6 +1243,7 @@ public abstract class Mob extends LivingEntity {
+         if (!this.isAlive()) {
+             return InteractionResult.PASS;
+         } else if (this.getLeashHolder() == player) {
+            if (hand == InteractionHand.OFF_HAND && (level.purpurConfig.villagerCanBeLeashed || level.purpurConfig.wanderingTraderCanBeLeashed) && this instanceof net.minecraft.world.entity.npc.AbstractVillager) return InteractionResult.CONSUME; // Purpur
+             // CraftBukkit start - fire PlayerUnleashEntityEvent
+             // Paper start - drop leash variable
+             org.bukkit.event.player.PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(this, player, !player.getAbilities().instabuild);
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 22229c1040a578bf20d67cdfcb25021539c84150..ff2715b465c1c62a5675f6cd1f99597f10d3233d 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -183,6 +183,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.villagerMaxHealth);
+     }
+
+    @Override
+    public boolean canBeLeashed(Player player) {
+        return level.purpurConfig.villagerCanBeLeashed && !this.isLeashed();
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+index 615fdf709b81693cced9a208cc96a33fb686c9a1..8756e0d8d0077308f5fb74bf45fe093d0f043c99 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -86,6 +86,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+     public void initAttributes() {
+         this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.wanderingTraderMaxHealth);
+     }
+
+    @Override
+    public boolean canBeLeashed(Player player) {
+        return level.purpurConfig.wanderingTraderCanBeLeashed && !this.isLeashed();
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 11e9eeeb1ef515ea65701629f61b2a74c5986412..9cab405a67c76e920754d0ba10978cf5476f1b82 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1380,6 +1380,7 @@ public class PurpurWorldConfig {
+     public int villagerBrainTicks = 1;
+     public boolean villagerUseBrainTicksOnlyWhenLagging = true;
+     public boolean villagerFollowEmeraldBlock = false;
+    public boolean villagerCanBeLeashed = false;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1393,6 +1394,7 @@ public class PurpurWorldConfig {
+         villagerBrainTicks = getInt("mobs.villager.brain-ticks", villagerBrainTicks);
+         villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging);
+         villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
+        villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1416,6 +1418,7 @@ public class PurpurWorldConfig {
+     public boolean wanderingTraderControllable = true;
+     public double wanderingTraderMaxHealth = 20.0D;
+     public boolean wanderingTraderFollowEmeraldBlock = false;
+    public boolean wanderingTraderCanBeLeashed = false;
+     private void wanderingTraderSettings() {
+         wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable);
+         wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater);
+@@ -1427,6 +1430,7 @@ public class PurpurWorldConfig {
+         }
+         wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth);
+         wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock);
+        wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed);
+     }
+ 
+     public boolean witchRidable = false;
--- a/patches/unapplied/0057-Implement-configurable-search-radius-for-villagers-t.patch
+++ b/patches/unapplied/0057-Implement-configurable-search-radius-for-villagers-t.patch
@@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Mon, 22 Jul 2019 17:32:17 -0500
+Subject: [PATCH] Implement configurable search radius for villagers to spawn
+ iron golems
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index ff2715b465c1c62a5675f6cd1f99597f10d3233d..2c99eda984bd147e5ce7d32dd11b818d8b8561aa 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -1052,6 +1052,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Nullable
+     private IronGolem trySpawnGolem(ServerLevel world) {
+        if (world.purpurConfig.villagerSpawnIronGolemRadius > 0 && world.getEntitiesOfClass(IronGolem.class, getBoundingBox().inflate(world.purpurConfig.villagerSpawnIronGolemRadius)).size() > world.purpurConfig.villagerSpawnIronGolemLimit) return null; // Purpur
+         BlockPos blockposition = this.blockPosition();
+ 
+         for (int i = 0; i < 10; ++i) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9cab405a67c76e920754d0ba10978cf5476f1b82..39b47c37523950e9282b8db9e028795ee48f1155 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1381,6 +1381,8 @@ public class PurpurWorldConfig {
+     public boolean villagerUseBrainTicksOnlyWhenLagging = true;
+     public boolean villagerFollowEmeraldBlock = false;
+     public boolean villagerCanBeLeashed = false;
+    public int villagerSpawnIronGolemRadius = 0;
+    public int villagerSpawnIronGolemLimit = 0;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1395,6 +1397,8 @@ public class PurpurWorldConfig {
+         villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging);
+         villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
+         villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+        villagerSpawnIronGolemRadius = getInt("mobs.villager.spawn-iron-golem.radius", villagerSpawnIronGolemRadius);
+        villagerSpawnIronGolemLimit = getInt("mobs.villager.spawn-iron-golem.limit", villagerSpawnIronGolemLimit);
+     }
+ 
+     public boolean vindicatorRidable = false;
--- a/patches/unapplied/0058-Implement-infinite-liquids.patch
+++ b/patches/unapplied/0058-Implement-infinite-liquids.patch
@@ -0,0 +1,114 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 23 Nov 2019 17:55:42 -0600
+Subject: [PATCH] Implement infinite liquids
+
+
+diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+index c2c3ed6ba79f9f41497e042571f699a0fc6e9335..a1d0329401dbb9e5f0fd27bd42d1c5a7c40d1c03 100644
+--- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+@@ -226,7 +226,7 @@ public abstract class FlowingFluid extends Fluid {
+             }
+         }
+ 
+-        if (this.canConvertToSource() && j >= 2) {
+        if (this.canConvertToSource(world) && j >= getRequiredSources(world)) {
+             BlockState iblockdata2 = world.getBlockState(pos.below());
+             FluidState fluid1 = iblockdata2.getFluidState();
+ 
+@@ -322,6 +322,16 @@ public abstract class FlowingFluid extends Fluid {
+         return (FluidState) this.getSource().defaultFluidState().setValue(FlowingFluid.FALLING, falling);
+     }
+ 
+    // Purpur start
+    protected boolean canConvertToSource(LevelReader world) {
+        return canConvertToSource();
+    }
+
+    protected int getRequiredSources(LevelReader world) {
+        return 2;
+    }
+    // Purpur end
+
+     protected abstract boolean canConvertToSource();
+ 
+     protected void spreadTo(LevelAccessor world, BlockPos pos, BlockState state, Direction direction, FluidState fluidState) {
+diff --git a/src/main/java/net/minecraft/world/level/material/LavaFluid.java b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+index 5dfa257e99c778113cfa8ca74f56482285b3a006..3bba47381e07c5edad4b18dfbdf152812baeef13 100644
+--- a/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+@@ -198,6 +198,18 @@ public abstract class LavaFluid extends FlowingFluid {
+         world.levelEvent(1501, pos, 0);
+     }
+ 
+    // Purpur start
+    @Override
+    protected boolean canConvertToSource(LevelReader world) {
+        return world.getWorldBorder().world.purpurConfig.lavaInfinite;
+    }
+
+    @Override
+    protected int getRequiredSources(LevelReader world) {
+        return world.getWorldBorder().world.purpurConfig.lavaInfiniteRequiredSources;
+    }
+    // Purpur end
+
+     @Override
+     protected boolean canConvertToSource() {
+         return false;
+diff --git a/src/main/java/net/minecraft/world/level/material/WaterFluid.java b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+index 56d50b9310d30e0f81f3d2549ff5c256eb07cc2a..4cc6d665c7d52b6edcaaa5f9ed1314077f68c224 100644
+--- a/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+@@ -63,6 +63,18 @@ public abstract class WaterFluid extends FlowingFluid {
+         return true;
+     }
+ 
+    // Purpur start
+    @Override
+    protected boolean canConvertToSource(LevelReader world) {
+        return world.getWorldBorder().world.purpurConfig.waterInfinite;
+    }
+
+    @Override
+    protected int getRequiredSources(LevelReader world) {
+        return world.getWorldBorder().world.purpurConfig.waterInfiniteRequiredSources;
+    }
+    // Purpur end
+
+     // Paper start
+     @Override
+     protected void beforeDestroyingBlock(LevelAccessor world, BlockPos pos, BlockState state,  BlockPos source) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 39b47c37523950e9282b8db9e028795ee48f1155..58e2ae7e885c1fd838001f077affe08bf4dc3da3 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -224,6 +224,13 @@ public class PurpurWorldConfig {
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+     }
+ 
+    public boolean lavaInfinite = false;
+    public int lavaInfiniteRequiredSources = 2;
+    private void lavaSettings() {
+        lavaInfinite = getBoolean("blocks.lava.infinite-source", lavaInfinite);
+        lavaInfiniteRequiredSources = getInt("blocks.lava.infinite-required-sources", lavaInfiniteRequiredSources);
+    }
+
+     public boolean signRightClickEdit = false;
+     private void signSettings() {
+         signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
+@@ -238,6 +245,13 @@ public class PurpurWorldConfig {
+         turtleEggsBreakFromMinecarts = getBoolean("blocks.turtle_egg.break-from-minecarts", turtleEggsBreakFromMinecarts);
+     }
+ 
+    public boolean waterInfinite = true;
+    public int waterInfiniteRequiredSources = 2;
+    private void waterSources() {
+        waterInfinite = getBoolean("blocks.water.infinite-source", waterInfinite);
+        waterInfiniteRequiredSources = getInt("blocks.water.infinite-required-sources", waterInfiniteRequiredSources);
+    }
+
+     public boolean babiesAreRidable = true;
+     public boolean untamedTamablesAreRidable = true;
+     public boolean useNightVisionWhenRiding = false;
--- a/patches/unapplied/0059-Make-lava-flow-speed-configurable.patch
+++ b/patches/unapplied/0059-Make-lava-flow-speed-configurable.patch
@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 2 Jan 2020 11:31:36 -0600
+Subject: [PATCH] Make lava flow speed configurable
+
+
+diff --git a/src/main/java/net/minecraft/world/level/material/LavaFluid.java b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+index 3bba47381e07c5edad4b18dfbdf152812baeef13..70b07f7d64f54806240c6aab06a232c885950791 100644
+--- a/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+@@ -180,7 +180,7 @@ public abstract class LavaFluid extends FlowingFluid {
+ 
+     @Override
+     public int getTickDelay(LevelReader world) {
+-        return world.dimensionType().ultraWarm() ? 10 : 30;
+        return world.dimensionType().ultraWarm() ? world.getWorldBorder().world.purpurConfig.lavaSpeedNether : world.getWorldBorder().world.purpurConfig.lavaSpeedNotNether; // Purpur
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 58e2ae7e885c1fd838001f077affe08bf4dc3da3..33ed5c2be8017e833d807907fea100d72dc37a23 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -226,9 +226,13 @@ public class PurpurWorldConfig {
+ 
+     public boolean lavaInfinite = false;
+     public int lavaInfiniteRequiredSources = 2;
+    public int lavaSpeedNether = 10;
+    public int lavaSpeedNotNether = 30;
+     private void lavaSettings() {
+         lavaInfinite = getBoolean("blocks.lava.infinite-source", lavaInfinite);
+         lavaInfiniteRequiredSources = getInt("blocks.lava.infinite-required-sources", lavaInfiniteRequiredSources);
+        lavaSpeedNether = getInt("blocks.lava.speed.nether", lavaSpeedNether);
+        lavaSpeedNotNether = getInt("blocks.lava.speed.not-nether", lavaSpeedNotNether);
+     }
+ 
+     public boolean signRightClickEdit = false;
--- a/patches/unapplied/0060-Add-player-death-exp-control-options.patch
+++ b/patches/unapplied/0060-Add-player-death-exp-control-options.patch
@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 26 Dec 2019 22:08:37 -0600
+Subject: [PATCH] Add player death exp control options
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
+index 0228eb3bd816c35fcf4607f0a140b1e6ef56decd..0169d40640c18440cc9b59bf201f0e3b68381578 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1925,9 +1925,18 @@ public abstract class Player extends LivingEntity {
+     @Override
+     protected int getExperienceReward(Player player) {
+         if (!this.level.getGameRules().getBoolean(GameRules.RULE_KEEPINVENTORY) && !this.isSpectator()) {
+-            int i = this.experienceLevel * 7;
+-
+-            return i > 100 ? 100 : i;
+            // Purpur start
+            int toDrop;
+            try {
+                scriptEngine.eval("expLevel = " + experienceLevel);
+                scriptEngine.eval("expTotal = " + totalExperience);
+                scriptEngine.eval("exp = " + experienceProgress);
+                toDrop = (int) Math.round((Double) scriptEngine.eval(level.purpurConfig.playerDeathExpDropEquation));
+            } catch (Exception ignore) {
+                toDrop = experienceLevel * 7;
+            }
+            return Math.min(toDrop, level.purpurConfig.playerDeathExpDropMax);
+            // Purpur end
+         } else {
+             return 0;
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 33ed5c2be8017e833d807907fea100d72dc37a23..429aec4522771c728a9586b69dcd1978b5bff8b9 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -172,6 +172,8 @@ public class PurpurWorldConfig {
+     public boolean idleTimeoutTargetPlayer = true;
+     public int playerSpawnInvulnerableTicks = 60;
+     public boolean playerInvulnerableWhileAcceptingResourcePack = false;
+    public String playerDeathExpDropEquation = "expLevel * 7";
+    public int playerDeathExpDropMax = 100;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -185,6 +187,8 @@ public class PurpurWorldConfig {
+         idleTimeoutTargetPlayer = getBoolean("gameplay-mechanics.player.idle-timeout.mobs-target", idleTimeoutTargetPlayer);
+         playerSpawnInvulnerableTicks = getInt("gameplay-mechanics.player.spawn-invulnerable-ticks", playerSpawnInvulnerableTicks);
+         playerInvulnerableWhileAcceptingResourcePack = getBoolean("gameplay-mechanics.player.invulnerable-while-accepting-resource-pack", playerInvulnerableWhileAcceptingResourcePack);
+        playerDeathExpDropEquation = getString("gameplay-mechanics.player.exp-dropped-on-death.equation", playerDeathExpDropEquation);
+        playerDeathExpDropMax = getInt("gameplay-mechanics.player.exp-dropped-on-death.maximum", playerDeathExpDropMax);
+     }
+ 
+     public boolean silkTouchEnabled = false;
--- a/patches/unapplied/0061-Configurable-void-damage-height-and-damage.patch
+++ b/patches/unapplied/0061-Configurable-void-damage-height-and-damage.patch
@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 27 Feb 2020 21:42:19 -0600
+Subject: [PATCH] Configurable void damage height and damage
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index f44b29dd23bdc1974300e90501331383f639756d..9d27266cbf53faa6e3b7ebec1a4cc9f7eb84ab0e 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -827,7 +827,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+ 
+     public void checkOutOfWorld() {
+         // Paper start - Configurable nether ceiling damage
+-        if (this.getY() < (double) (this.level.getMinBuildHeight() - 64) || (this.level.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER
+        if (this.getY() < (double) (this.level.getMinBuildHeight() + level.purpurConfig.voidDamageHeight) || (this.level.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER // Purpur
+             && level.paperConfig.doNetherTopVoidDamage()
+             && this.getY() >= this.level.paperConfig.netherVoidTopDamageHeight)) {
+             // Paper end
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 5fd3b3cf20b31a9baaf5a703aab62bb5161001b4..8b6d9d07eafe44c6dc11c2b9d3ee1f1cb88c3a34 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -2434,7 +2434,7 @@ public abstract class LivingEntity extends Entity {
+ 
+     @Override
+     protected void outOfWorld() {
+-        this.hurt(DamageSource.OUT_OF_WORLD, 4.0F);
+        this.hurt(DamageSource.OUT_OF_WORLD, (float) level.purpurConfig.voidDamageDealt); // Purpur
+     }
+ 
+     protected void updateSwingTime() {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 429aec4522771c728a9586b69dcd1978b5bff8b9..6c0f9f8f83cc5bbdad319ab608faf1320e1a7081 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -97,10 +97,14 @@ public class PurpurWorldConfig {
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean milkCuresBadOmen = true;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+    public double voidDamageHeight = -64.0D;
+    public double voidDamageDealt = 4.0D;
+     private void miscGameplayMechanicsSettings() {
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
+        voidDamageHeight = getDouble("gameplay-mechanics.void-damage-height", voidDamageHeight);
+        voidDamageDealt = getDouble("gameplay-mechanics.void-damage-dealt", voidDamageDealt);
+     }
+ 
+     public double minecartMaxSpeed = 0.4D;
--- a/patches/unapplied/0062-Add-canSaveToDisk-to-Entity.patch
+++ b/patches/unapplied/0062-Add-canSaveToDisk-to-Entity.patch
@@ -0,0 +1,80 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 18 Feb 2020 20:07:08 -0600
+Subject: [PATCH] Add canSaveToDisk to Entity
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 9d27266cbf53faa6e3b7ebec1a4cc9f7eb84ab0e..1e9fa0c362d8d2ea6c8da68f266a54dcf35782fb 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -4496,5 +4496,9 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     public boolean processClick(InteractionHand hand) {
+         return false;
+     }
+
+    public boolean canSaveToDisk() {
+        return true;
+    }
+     // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+index a39ed2d5c52d5555ebc9c595c9541a5561b61f26..5fdbbf376947e4efd85f02ae978c56de62a0610b 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+@@ -208,6 +208,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+                 // do not hit rider
+                 return target != rider && super.canHitEntity(target);
+             }
+
+            @Override
+            public boolean canSaveToDisk() {
+                return false;
+            }
+         };
+         skull.setPosRaw(headX, headY, headZ);
+         level.addFreshEntity(skull);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
+index cbdd32ef0be241b16406ed8e3889d914e3e5e5d2..d7a001419b83d5dbd7201d149722cd1be11d1040 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
+@@ -92,6 +92,7 @@ public class EntityStorage implements EntityPersistentStorage<Entity> {
+             ListTag listTag = new ListTag();
+             final java.util.Map<net.minecraft.world.entity.EntityType<?>, Integer> savedEntityCounts = new java.util.HashMap<>(); // Paper
+             dataList.getEntities().forEach((entity) -> {
+                if (!entity.canSaveToDisk()) return; // Purpur
+                 // Paper start
+                 final EntityType<?> entityType = entity.getType();
+                 final int saveLimit = this.level.paperConfig.entityPerChunkSaveLimits.getOrDefault(entityType, -1);
+diff --git a/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java b/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java
+index d55f7611599b2a339293688861100cb8dae9f6c6..5e99789e5156e8ffbf125e77114c547e1f8e7925 100644
+--- a/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java
+++ b/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java
+@@ -35,6 +35,11 @@ public class DolphinSpit extends LlamaSpit {
+                 dolphin.getZ() + (double) (dolphin.getBbWidth() + 1.0F) * 0.5D * (double) Mth.cos(dolphin.yBodyRot * 0.017453292F));
+     }
+ 
+    @Override
+    public boolean canSaveToDisk() {
+        return false;
+    }
+
+     public void tick() {
+         super_tick();
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java b/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java
+index 2eca8317e991ec46cc88a4c7d6d8b50152ba4ea7..b6a594cd6b08c687cf51c2f5494297ef96ec4b92 100644
+--- a/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java
+++ b/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java
+@@ -38,6 +38,11 @@ public class PhantomFlames extends LlamaSpit {
+                 phantom.getZ() + (double) (phantom.getBbWidth() + 1.0F) * 0.5D * (double) Mth.cos(phantom.yBodyRot * 0.017453292F));
+     }
+ 
+    @Override
+    public boolean canSaveToDisk() {
+        return false;
+    }
+
+     public void tick() {
+         super_tick();
+ 
--- a/patches/unapplied/0063-Dispenser-curse-of-binding-protection.patch
+++ b/patches/unapplied/0063-Dispenser-curse-of-binding-protection.patch
@@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 25 Aug 2019 00:09:52 -0500
+Subject: [PATCH] Dispenser curse of binding protection
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 88705ce6b18091e3a8bf10f11bdd38830cd6af22..e1a13fadcf83e84c89a1bfc6d4e4f13f2299ffa5 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -63,6 +63,7 @@ import net.minecraft.world.item.ProjectileWeaponItem;
+ import net.minecraft.world.item.SpawnEggItem;
+ import net.minecraft.world.item.SwordItem;
+ import net.minecraft.world.item.enchantment.EnchantmentHelper;
+import net.minecraft.world.item.enchantment.Enchantments;
+ import net.minecraft.world.level.GameRules;
+ import net.minecraft.world.level.ItemLike;
+ import net.minecraft.world.level.Level;
+@@ -1099,6 +1100,12 @@ public abstract class Mob extends LivingEntity {
+ 
+     }
+ 
+    // Purpur start
+    public static @Nullable EquipmentSlot getSlotForDispenser(ItemStack itemstack) {
+        return EnchantmentHelper.getItemEnchantmentLevel(Enchantments.BINDING_CURSE, itemstack) > 0 ? null : getEquipmentSlotForItem(itemstack);
+    }
+    // Purpur end
+
+     @Nullable
+     public static Item getEquipmentForSlot(EquipmentSlot equipmentSlot, int equipmentLevel) {
+         switch (equipmentSlot) {
+diff --git a/src/main/java/net/minecraft/world/item/ArmorItem.java b/src/main/java/net/minecraft/world/item/ArmorItem.java
+index baa7e055d8ee4a153842128b07984b9f6deac6ca..014dd3aa8a7313d978d4781a1b7c6f532ff04962 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorItem.java
+++ b/src/main/java/net/minecraft/world/item/ArmorItem.java
+@@ -55,7 +55,7 @@ public class ArmorItem extends Item implements Wearable {
+             return false;
+         } else {
+             LivingEntity entityliving = (LivingEntity) list.get(0);
+-            EquipmentSlot enumitemslot = Mob.getEquipmentSlotForItem(armor);
+            EquipmentSlot enumitemslot = pointer.getLevel().purpurConfig.dispenserApplyCursedArmor ? Mob.getEquipmentSlotForItem(armor) : Mob.getSlotForDispenser(armor); if (enumitemslot == null) return false; // Purpur
+             ItemStack itemstack1 = armor.split(1);
+             // CraftBukkit start
+             Level world = pointer.getLevel();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 6c0f9f8f83cc5bbdad319ab608faf1320e1a7081..7d5e570b5537960532e7b6babfd1f7ac421a3854 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -227,6 +227,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean dispenserApplyCursedArmor = true;
+    private void dispenserSettings() {
+        dispenserApplyCursedArmor = getBoolean("blocks.dispenser.apply-cursed-to-armor-slots", dispenserApplyCursedArmor);
+    }
+
+     public boolean farmlandGetsMoistFromBelow = false;
+     private void farmlandSettings() {
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
--- a/patches/unapplied/0064-Add-option-for-boats-to-eject-players-on-land.patch
+++ b/patches/unapplied/0064-Add-option-for-boats-to-eject-players-on-land.patch
@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 7 Sep 2019 22:47:59 -0500
+Subject: [PATCH] Add option for boats to eject players on land
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+index 0dbc85c450797d7384e641f80e1b1f8c56fd14fc..e4febdebc760f9babd77c55e87acccdc1625f0a5 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+++ b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+@@ -518,6 +518,7 @@ public class Boat extends Entity {
+ 
+             if (f > 0.0F) {
+                 this.landFriction = f;
+                if (level.purpurConfig.boatEjectPlayersOnLand) ejectPassengers(); // Purpur
+                 return Boat.Status.ON_LAND;
+             } else {
+                 return Boat.Status.IN_AIR;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7d5e570b5537960532e7b6babfd1f7ac421a3854..ecfbe1bbd192649095945ba13039d53d23ac2ca8 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -94,12 +94,14 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
+    public boolean boatEjectPlayersOnLand = false;
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean milkCuresBadOmen = true;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+     private void miscGameplayMechanicsSettings() {
+        boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
--- a/patches/unapplied/0065-Mending-mends-most-damages-equipment-first.patch
+++ b/patches/unapplied/0065-Mending-mends-most-damages-equipment-first.patch
@@ -0,0 +1,94 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 14 Jul 2019 19:52:47 -0500
+Subject: [PATCH] Mending mends most damages equipment first
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 4848f26a006f4d4df620ded526134b3b39e90d29..37fe86f0f6ea006f658cd6a68757c1c12ae32eb7 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -320,7 +320,7 @@ public class ExperienceOrb extends Entity {
+     }
+ 
+     private int repairPlayerItems(Player player, int amount) {
+-        Entry<EquipmentSlot, ItemStack> entry = EnchantmentHelper.getRandomItemWith(Enchantments.MENDING, player, ItemStack::isDamaged);
+        Entry<EquipmentSlot, ItemStack> entry = level.purpurConfig.useBetterMending ? EnchantmentHelper.getMostDamagedEquipment(Enchantments.MENDING, player) : EnchantmentHelper.getRandomItemWith(Enchantments.MENDING, player, ItemStack::isDamaged); // Purpur
+ 
+         if (entry != null) {
+             ItemStack itemstack = (ItemStack) entry.getValue();
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 6837c965592d4584cfc958a1008b98791a0fc780..4da450d1289c12356b24a81f267ba136983a2d20 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -523,6 +523,16 @@ public final class ItemStack {
+         return this.isDamageableItem() && this.getDamageValue() > 0;
+     }
+ 
+    // Purpur start
+    public float getDamagePercent() {
+        if (isDamaged()) {
+            return (float) getDamageValue() / (float) getItem().getMaxDamage();
+        } else {
+            return 0F;
+        }
+    }
+    // Purpur end
+
+     public int getDamageValue() {
+         return this.tag == null ? 0 : this.tag.getInt("Damage");
+     }
+diff --git a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java
+index 7b39eaf66eb74cab7caf9588947e9d5860a0ffd8..5422b68674b34d015c94194a974726ea67d07e49 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java
+++ b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java
+@@ -269,6 +269,29 @@ public class EnchantmentHelper {
+         return getItemEnchantmentLevel(Enchantments.CHANNELING, stack) > 0;
+     }
+ 
+    // Purpur start
+    @Nullable
+    public static Map.Entry<EquipmentSlot, ItemStack> getMostDamagedEquipment(Enchantment enchantment, LivingEntity entity) {
+        Map<EquipmentSlot, ItemStack> map = enchantment.getSlotItems(entity);
+        if (map.isEmpty()) {
+            return null;
+        }
+        Map.Entry<EquipmentSlot, ItemStack> item = null;
+        float maxPercent = 0F;
+        for (Map.Entry<EquipmentSlot, ItemStack> entry : map.entrySet()) {
+            ItemStack itemstack = entry.getValue();
+            if (!itemstack.isEmpty() && itemstack.isDamaged() && getItemEnchantmentLevel(enchantment, itemstack) > 0) {
+                float percent = itemstack.getDamagePercent();
+                if (item == null || percent > maxPercent) {
+                    item = entry;
+                    maxPercent = percent;
+                }
+            }
+        }
+        return item;
+    }
+    // Purpur end
+
+     @Nullable
+     public static Map.Entry<EquipmentSlot, ItemStack> getRandomItemWith(Enchantment enchantment, LivingEntity entity) {
+         return getRandomItemWith(enchantment, entity, (stack) -> {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ecfbe1bbd192649095945ba13039d53d23ac2ca8..60896b00f50501ddcaa71e1e16b59d22f78a983c 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -94,6 +94,7 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
+    public boolean useBetterMending = false;
+     public boolean boatEjectPlayersOnLand = false;
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean milkCuresBadOmen = true;
+@@ -101,6 +102,7 @@ public class PurpurWorldConfig {
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+     private void miscGameplayMechanicsSettings() {
+        useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
--- a/patches/unapplied/0066-Add-5-second-tps-average-in-tps.patch
+++ b/patches/unapplied/0066-Add-5-second-tps-average-in-tps.patch
@@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 28 Jul 2019 01:27:37 -0500
+Subject: [PATCH] Add 5 second tps average in /tps
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java b/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java
+index fa56cd09102a89692b42f1d14257990508c5c720..f9251183df72ddc56662fd3f02acf21641a2200c 100644
+--- a/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java
+++ b/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java
+@@ -58,7 +58,7 @@ public class RAMDetails extends JList<String> {
+         GraphData data = RAMGraph.DATA.peekLast();
+         Vector<String> vector = new Vector<>();
+ 
+-        double[] tps = new double[] {server.tps1.getAverage(), server.tps5.getAverage(), server.tps15.getAverage()};
+        double[] tps = new double[] {server.tps5s.getAverage(), server.tps1.getAverage(), server.tps5.getAverage(), server.tps15.getAverage()}; // Purpur
+         String[] tpsAvg = new String[tps.length];
+ 
+         for ( int g = 0; g < tps.length; g++) {
+@@ -67,7 +67,7 @@ public class RAMDetails extends JList<String> {
+         vector.add("Memory use: " + (data.getUsedMem() / 1024L / 1024L) + " mb (" + (data.getFree() * 100L / data.getMax()) + "% free)");
+         vector.add("Heap: " + (data.getTotal() / 1024L / 1024L) + " / " + (data.getMax() / 1024L / 1024L) + " mb");
+         vector.add("Avg tick: " + DECIMAL_FORMAT.format(getAverage(server.tickTimes)) + " ms");
+-        vector.add("TPS from last 1m, 5m, 15m: " + String.join(", ", tpsAvg));
+        vector.add("TPS from last 5s, 1m, 5m, 15m: " + String.join(", ", tpsAvg)); // Purpur
+ 
+         setListData(vector);
+     }
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 120f800573246fd67e735cdf2fce435a2497dc7b..d54e88162fbfe03de3f607d7fb10c9ed0bf311c4 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -302,7 +302,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public static final int TPS = 20;
+     public static final int TICK_TIME = 1000000000 / MinecraftServer.TPS;
+     private static final int SAMPLE_INTERVAL = 20; // Paper
+-    public final double[] recentTps = new double[ 3 ];
+    public final double[] recentTps = new double[ 4 ]; // Purpur
+     // Spigot end
+     public static long currentTickLong = 0L; // Paper
+     public boolean lagging = false; // Purpur
+@@ -1114,6 +1114,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     private static final long MAX_CATCHUP_BUFFER = TICK_TIME * TPS * 60L;
+     private long lastTick = 0;
+     private long catchupTime = 0;
+    public final RollingAverage tps5s = new RollingAverage(5); // Purpur
+     public final RollingAverage tps1 = new RollingAverage(60);
+     public final RollingAverage tps5 = new RollingAverage(60 * 5);
+     public final RollingAverage tps15 = new RollingAverage(60 * 15);
+@@ -1204,13 +1205,17 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                     {
+                         final long diff = curTime - tickSection;
+                         java.math.BigDecimal currentTps = TPS_BASE.divide(new java.math.BigDecimal(diff), 30, java.math.RoundingMode.HALF_UP);
+                        tps5s.add(currentTps, diff); // Purpur
+                         tps1.add(currentTps, diff);
+                         tps5.add(currentTps, diff);
+                         tps15.add(currentTps, diff);
+                         // Backwards compat with bad plugins
+-                        this.recentTps[0] = tps1.getAverage();
+-                        this.recentTps[1] = tps5.getAverage();
+-                        this.recentTps[2] = tps15.getAverage();
+                        // Purpur start
+                        this.recentTps[0] = tps5s.getAverage();
+                        this.recentTps[1] = tps1.getAverage();
+                        this.recentTps[2] = tps5.getAverage();
+                        this.recentTps[3] = tps15.getAverage();
+                        // Purpur end
+                         // Paper end
+                         lagging = recentTps[0] < org.purpurmc.purpur.PurpurConfig.laggingThreshold; // Purpur
+                         tickSection = curTime;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index da80afb59432c7bd777816d1fd0516c691abaf31..aec3440b25ca53f04361b7c256d63ff2beb5ba74 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2676,6 +2676,7 @@ public final class CraftServer implements Server {
+     @Override
+     public double[] getTPS() {
+         return new double[] {
+                net.minecraft.server.MinecraftServer.getServer().tps5s.getAverage(), // Purpur
+                 net.minecraft.server.MinecraftServer.getServer().tps1.getAverage(),
+                 net.minecraft.server.MinecraftServer.getServer().tps5.getAverage(),
+                 net.minecraft.server.MinecraftServer.getServer().tps15.getAverage()
+diff --git a/src/main/java/org/spigotmc/TicksPerSecondCommand.java b/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+index 9bede6a26c08ede063c7a38f1149c811df14b258..088239d17aa8178cf8af09ec23cfd4deaaf2bbb6 100644
+--- a/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+++ b/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+@@ -31,7 +31,7 @@ public class TicksPerSecondCommand extends Command
+         for ( int i = 0; i < tps.length; i++) {
+             tpsAvg[i] = TicksPerSecondCommand.format( tps[i] );
+         }
+-        sender.sendMessage(ChatColor.GOLD + "TPS from last 1m, 5m, 15m: " + org.apache.commons.lang.StringUtils.join(tpsAvg, ", "));
+        sender.sendMessage(ChatColor.GOLD + "TPS from last 5s, 1m, 5m, 15m: " + org.apache.commons.lang.StringUtils.join(tpsAvg, ", ")); // Purpur
+         if (args.length > 0 && args[0].equals("mem") && sender.hasPermission("bukkit.command.tpsmemory")) {
+             sender.sendMessage(ChatColor.GOLD + "Current Memory Usage: " + ChatColor.GREEN + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024)) + "/" + (Runtime.getRuntime().totalMemory() / (1024 * 1024)) + " mb (Max: " + (Runtime.getRuntime().maxMemory() / (1024 * 1024)) + " mb)");
+             if (!hasShownMemoryWarning) {
--- a/patches/unapplied/0067-Implement-elytra-settings.patch
+++ b/patches/unapplied/0067-Implement-elytra-settings.patch
@@ -0,0 +1,124 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 25 Jul 2019 18:07:37 -0500
+Subject: [PATCH] Implement elytra settings
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index d26d4db18e70bcfcf149787b822facf9824eb9f7..a50035eae2faec356bb8cc3956ae39618f8dace2 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3427,7 +3427,16 @@ public abstract class LivingEntity extends Entity {
+                     int j = i / 10;
+ 
+                     if (j % 2 == 0) {
+-                        itemstack.hurtAndBreak(1, this, (entityliving) -> {
+                        // Purpur start
+                        int damage = level.purpurConfig.elytraDamagePerSecond;
+                        if (level.purpurConfig.elytraDamageMultiplyBySpeed > 0) {
+                            double speed = getDeltaMovement().lengthSqr();
+                            if (speed > level.purpurConfig.elytraDamageMultiplyBySpeed) {
+                                damage *= (int) speed;
+                            }
+                        }
+                        itemstack.hurtAndBreak(damage, this, (entityliving) -> {
+                        // Purpur end
+                             entityliving.broadcastBreakEvent(EquipmentSlot.CHEST);
+                         });
+                     }
+diff --git a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+index 543a08f920319a2547258640bafebb1e70af65c4..dd211aa7c4ef1e158933a89898b9e5bc1451ee14 100644
+--- a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+++ b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+@@ -17,6 +17,7 @@ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.world.InteractionHand;
+ import net.minecraft.world.InteractionResult;
+ import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.EquipmentSlot;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.entity.projectile.FireworkRocketEntity;
+ import net.minecraft.world.item.context.UseOnContext;
+@@ -70,6 +71,14 @@ public class FireworkRocketItem extends Item {
+                 com.destroystokyo.paper.event.player.PlayerElytraBoostEvent event = new com.destroystokyo.paper.event.player.PlayerElytraBoostEvent((org.bukkit.entity.Player) user.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemStack), (org.bukkit.entity.Firework) fireworkRocketEntity.getBukkitEntity());
+                 if (event.callEvent() && world.addFreshEntity(fireworkRocketEntity)) {
+                     user.awardStat(Stats.ITEM_USED.get(this));
+                    // Purpur start
+                    if (world.purpurConfig.elytraDamagePerFireworkBoost > 0) {
+                        ItemStack chestItem = user.getItemBySlot(EquipmentSlot.CHEST);
+                        if (chestItem.getItem() == Items.ELYTRA) {
+                            chestItem.hurtAndBreak(world.purpurConfig.elytraDamagePerFireworkBoost, user, (entityliving) -> entityliving.broadcastBreakEvent(EquipmentSlot.CHEST));
+                        }
+                    }
+                    // Purpur end
+                     if (event.shouldConsume() && !user.getAbilities().instabuild) {
+                     itemStack.shrink(1);
+                     } else ((net.minecraft.server.level.ServerPlayer) user).getBukkitEntity().updateInventory();
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 4da450d1289c12356b24a81f267ba136983a2d20..d823e4ceba2128ee588b2b344cc8f91cd6de1d13 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -552,7 +552,7 @@ public final class ItemStack {
+             int j;
+ 
+             if (amount > 0) {
+-                j = EnchantmentHelper.getItemEnchantmentLevel(Enchantments.UNBREAKING, this);
+                j = (getItem() == Items.ELYTRA && player != null && player.level.purpurConfig.elytraIgnoreUnbreaking) ? 0 : EnchantmentHelper.getItemEnchantmentLevel(Enchantments.UNBREAKING, this);
+                 int k = 0;
+ 
+                 for (int l = 0; j > 0 && l < amount; ++l) {
+@@ -607,6 +607,12 @@ public final class ItemStack {
+                 if (this.hurt(amount, entity.getRandom(), entity /*instanceof ServerPlayer ? (ServerPlayer) entity : null*/)) { // Paper - pass LivingEntity for EntityItemDamageEvent
+                     breakCallback.accept(entity);
+                     Item item = this.getItem();
+                    // Purpur start
+                    if (item == Items.ELYTRA) {
+                        setDamageValue(item.getMaxDamage() - 1);
+                        return;
+                    }
+                    // Purpur end
+                     // CraftBukkit start - Check for item breaking
+                     if (this.count == 1 && entity instanceof net.minecraft.world.entity.player.Player) {
+                         org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemBreakEvent((net.minecraft.world.entity.player.Player) entity, this);
+diff --git a/src/main/java/net/minecraft/world/item/TridentItem.java b/src/main/java/net/minecraft/world/item/TridentItem.java
+index 998758be827efbcb7693ed36ab1dffc0ef0369bf..5beaafec0759543d3bddf99028c97d0d005be209 100644
+--- a/src/main/java/net/minecraft/world/item/TridentItem.java
+++ b/src/main/java/net/minecraft/world/item/TridentItem.java
+@@ -126,6 +126,14 @@ public class TridentItem extends Item implements Vanishable {
+                         f2 *= f6 / f5;
+                         f3 *= f6 / f5;
+                         f4 *= f6 / f5;
+
+                        // Purpur start
+                        ItemStack chestItem = entityhuman.getItemBySlot(EquipmentSlot.CHEST);
+                        if (chestItem.getItem() == Items.ELYTRA && world.purpurConfig.elytraDamagePerTridentBoost > 0) {
+                            chestItem.hurtAndBreak(world.purpurConfig.elytraDamagePerTridentBoost, entityhuman, (entity) -> entity.broadcastBreakEvent(EquipmentSlot.CHEST));
+                        }
+                        // Purpur end
+
+                         entityhuman.push((double) f2, (double) f3, (double) f4);
+                         entityhuman.startAutoSpinAttack(20);
+                         if (entityhuman.isOnGround()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 60896b00f50501ddcaa71e1e16b59d22f78a983c..17c17fb1607eb7804a2c284da861a672d9894367 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -111,6 +111,19 @@ public class PurpurWorldConfig {
+         voidDamageDealt = getDouble("gameplay-mechanics.void-damage-dealt", voidDamageDealt);
+     }
+ 
+    public int elytraDamagePerSecond = 1;
+    public double elytraDamageMultiplyBySpeed = 0;
+    public boolean elytraIgnoreUnbreaking = false;
+    public int elytraDamagePerFireworkBoost = 0;
+    public int elytraDamagePerTridentBoost = 0;
+    private void elytraSettings() {
+        elytraDamagePerSecond = getInt("gameplay-mechanics.elytra.damage-per-second", elytraDamagePerSecond);
+        elytraDamageMultiplyBySpeed = getDouble("gameplay-mechanics.elytra.damage-multiplied-by-speed", elytraDamageMultiplyBySpeed);
+        elytraIgnoreUnbreaking = getBoolean("gameplay-mechanics.elytra.ignore-unbreaking", elytraIgnoreUnbreaking);
+        elytraDamagePerFireworkBoost = getInt("gameplay-mechanics.elytra.damage-per-boost.firework", elytraDamagePerFireworkBoost);
+        elytraDamagePerTridentBoost = getInt("gameplay-mechanics.elytra.damage-per-boost.trident", elytraDamagePerTridentBoost);
+    }
+
+     public double minecartMaxSpeed = 0.4D;
+     public boolean minecartPlaceAnywhere = false;
+     public boolean minecartControllable = false;
--- a/patches/unapplied/0068-Item-entity-immunities.patch
+++ b/patches/unapplied/0068-Item-entity-immunities.patch
@@ -0,0 +1,183 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 22 Feb 2020 15:54:08 -0600
+Subject: [PATCH] Item entity immunities
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 0ab662448c24ba1d3c697f8096f03c88dd622e77..1647627a02754f5bc8c0f86e467bd11369c24be3 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -2227,7 +2227,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+ 
+     public class TrackedEntity {
+ 
+-        final ServerEntity serverEntity;
+        public final ServerEntity serverEntity; // Purpur -> package -> public
+         final Entity entity;
+         private final int range;
+         SectionPos lastSectionPos;
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index d52072ab126f2fdee30bb114f3058338edd72fd5..4eb23fd9ca0cec93c66bcee120cfbb3365513792 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -67,7 +67,7 @@ public class ServerEntity {
+     private boolean wasRiding;
+     private boolean wasOnGround;
+     // CraftBukkit start
+-    final Set<ServerPlayerConnection> trackedPlayers; // Paper - private -> package
+    public final Set<ServerPlayerConnection> trackedPlayers; // Paper - private -> package // Purpur - package -> public
+ 
+     public ServerEntity(ServerLevel worldserver, Entity entity, int i, boolean flag, Consumer<Packet<?>> consumer, Set<ServerPlayerConnection> trackedPlayers) {
+         this.trackedPlayers = trackedPlayers;
+diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+index 820ddcbc1547e2b9da3475a13d039e0cd8bc2c2a..008f92b9898f282a0c0b7e84f7965afe89da5bb4 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -55,6 +55,12 @@ public class ItemEntity extends Entity {
+     private int lastTick = MinecraftServer.currentTick - 1; // CraftBukkit
+     public boolean canMobPickup = true; // Paper
+     private int despawnRate = -1; // Paper
+    // Purpur start
+    public boolean immuneToCactus = false;
+    public boolean immuneToExplosion = false;
+    public boolean immuneToFire = false;
+    public boolean immuneToLightning = false;
+    // Purpur end
+ 
+     public ItemEntity(EntityType<? extends ItemEntity> type, Level world) {
+         super(type, world);
+@@ -328,6 +334,15 @@ public class ItemEntity extends Entity {
+             return false;
+         } else if (!this.getItem().getItem().canBeHurtBy(source)) {
+             return false;
+        // Purpur start
+        } else if (
+                (immuneToCactus && source == DamageSource.CACTUS) ||
+                (immuneToFire && (source.isFire() || source == DamageSource.IN_FIRE)) ||
+                (immuneToLightning && source == DamageSource.LIGHTNING_BOLT) ||
+                (immuneToExplosion && source.isExplosion())
+        ) {
+            return false;
+        // Purpur end
+         } else if (this.level.isClientSide) {
+             return true;
+         } else {
+@@ -514,6 +529,12 @@ public class ItemEntity extends Entity {
+         this.getEntityData().markDirty(ItemEntity.DATA_ITEM); // CraftBukkit - SPIGOT-4591, must mark dirty
+         net.minecraft.resources.ResourceLocation location = net.minecraft.core.Registry.ITEM.getKey(stack.getItem()); // Paper
+         this.despawnRate = level.paperConfig.altItemDespawnRateMap.getOrDefault(location, level.spigotConfig.itemDespawnRate); // Paper
+        // Purpur start
+        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
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+index fea44ba6a6584b4a510af6a58cab07eecec6b68b..f3bf5199bc7ddf8a3d0dc67a184e7690efa659eb 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+@@ -148,4 +148,46 @@ public class CraftItem extends CraftEntity implements Item {
+     public EntityType getType() {
+         return EntityType.DROPPED_ITEM;
+     }
+
+    // Purpur start
+    @Override
+    public void setImmuneToCactus(boolean immuneToCactus) {
+        item.immuneToCactus = immuneToCactus;
+    }
+
+    @Override
+    public boolean isImmuneToCactus() {
+        return item.immuneToCactus;
+    }
+
+    @Override
+    public void setImmuneToExplosion(boolean immuneToExplosion) {
+        item.immuneToExplosion = immuneToExplosion;
+    }
+
+    @Override
+    public boolean isImmuneToExplosion() {
+        return item.immuneToExplosion;
+    }
+
+    @Override
+    public void setImmuneToFire(boolean immuneToFire) {
+        item.immuneToFire = immuneToFire;
+    }
+
+    @Override
+    public boolean isImmuneToFire() {
+        return item.immuneToFire;
+    }
+
+    @Override
+    public void setImmuneToLightning(boolean immuneToLightning) {
+        item.immuneToLightning = immuneToLightning;
+    }
+
+    @Override
+    public boolean isImmuneToLightning() {
+        return item.immuneToLightning;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 17c17fb1607eb7804a2c284da861a672d9894367..7dd9e436b50019bb16a61314cf6798b6a5b2580b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -124,6 +124,49 @@ public class PurpurWorldConfig {
+         elytraDamagePerTridentBoost = getInt("gameplay-mechanics.elytra.damage-per-boost.trident", elytraDamagePerTridentBoost);
+     }
+ 
+    public List<Item> itemImmuneToCactus = new ArrayList<>();
+    public List<Item> itemImmuneToExplosion = new ArrayList<>();
+    public List<Item> itemImmuneToFire = new ArrayList<>();
+    public List<Item> itemImmuneToLightning = new ArrayList<>();
+    private void itemSettings() {
+        itemImmuneToCactus.clear();
+        getList("gameplay-mechanics.item.immune.cactus", new ArrayList<>()).forEach(key -> {
+            if (key.toString().equals("*")) {
+                Registry.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToCactus.add(item));
+                return;
+            }
+            Item item = Registry.ITEM.get(new ResourceLocation(key.toString()));
+            if (item != Items.AIR) itemImmuneToCactus.add(item);
+        });
+        itemImmuneToExplosion.clear();
+        getList("gameplay-mechanics.item.immune.explosion", new ArrayList<>()).forEach(key -> {
+            if (key.toString().equals("*")) {
+                Registry.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToExplosion.add(item));
+                return;
+            }
+            Item item = Registry.ITEM.get(new ResourceLocation(key.toString()));
+            if (item != Items.AIR) itemImmuneToExplosion.add(item);
+        });
+        itemImmuneToFire.clear();
+        getList("gameplay-mechanics.item.immune.fire", new ArrayList<>()).forEach(key -> {
+            if (key.toString().equals("*")) {
+                Registry.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToFire.add(item));
+                return;
+            }
+            Item item = Registry.ITEM.get(new ResourceLocation(key.toString()));
+            if (item != Items.AIR) itemImmuneToFire.add(item);
+        });
+        itemImmuneToLightning.clear();
+        getList("gameplay-mechanics.item.immune.lightning", new ArrayList<>()).forEach(key -> {
+            if (key.toString().equals("*")) {
+                Registry.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToLightning.add(item));
+                return;
+            }
+            Item item = Registry.ITEM.get(new ResourceLocation(key.toString()));
+            if (item != Items.AIR) itemImmuneToLightning.add(item);
+        });
+    }
+
+     public double minecartMaxSpeed = 0.4D;
+     public boolean minecartPlaceAnywhere = false;
+     public boolean minecartControllable = false;
--- a/patches/unapplied/0069-Add-ping-command.patch
+++ b/patches/unapplied/0069-Add-ping-command.patch
@@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 13 Mar 2020 22:29:10 -0500
+Subject: [PATCH] Add ping command
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index c79c89bab8972a26c7a48f63ad20ac34b0fc8750..00ab01661c12ecd7b384be81388c9aaa5b32d706 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -207,6 +207,7 @@ public class Commands {
+             SetPlayerIdleTimeoutCommand.register(this.dispatcher);
+             StopCommand.register(this.dispatcher);
+             WhitelistCommand.register(this.dispatcher);
+            org.purpurmc.purpur.command.PingCommand.register(this.dispatcher); // Purpur
+         }
+ 
+         if (environment.includeIntegrated) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index b41d73318d6795c0fa7b9c60431ef141026fa9d6..6d40bfc2e7ea6090589fd12057ed8d54966fe2d2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -173,12 +173,14 @@ public class PurpurConfig {
+     public static String afkBroadcastBack = "<yellow><italic>%s is no longer AFK";
+     public static String afkTabListPrefix = "[AFK] ";
+     public static String afkTabListSuffix = "";
+    public static String pingCommandOutput = "<green>%s's ping is %sms";
+     private static void messages() {
+         cannotRideMob = getString("settings.messages.cannot-ride-mob", cannotRideMob);
+         afkBroadcastAway = getString("settings.messages.afk-broadcast-away", afkBroadcastAway);
+         afkBroadcastBack = getString("settings.messages.afk-broadcast-back", afkBroadcastBack);
+         afkTabListPrefix = getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix);
+         afkTabListSuffix = getString("settings.messages.afk-tab-list-suffix", afkTabListSuffix);
+        pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+     }
+ 
+     public static String serverModName = "Purpur";
+diff --git a/src/main/java/org/purpurmc/purpur/command/PingCommand.java b/src/main/java/org/purpurmc/purpur/command/PingCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b7c57e812451320da5c97008dd36f74856fec7c8
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/command/PingCommand.java
+@@ -0,0 +1,32 @@
+package org.purpurmc.purpur.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.server.level.ServerPlayer;
+import org.purpurmc.purpur.PurpurConfig;
+import org.bukkit.craftbukkit.util.CraftChatMessage;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class PingCommand {
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(Commands.literal("ping")
+                .requires((listener) -> listener.hasPermission(2))
+                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
+                .then(Commands.argument("targets", EntityArgument.players())
+                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
+                )
+        ).setPermission("bukkit.command.ping");
+    }
+
+    private static int execute(CommandSourceStack sender, Collection<ServerPlayer> targets) {
+        for (ServerPlayer player : targets) {
+            String output = String.format(PurpurConfig.pingCommandOutput, player.getGameProfile().getName(), player.latency);
+            sender.sendSuccess(output, false);
+        }
+        return targets.size();
+    }
+}
--- a/patches/unapplied/0070-Add-demo-command.patch
+++ b/patches/unapplied/0070-Add-demo-command.patch
@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 30 Nov 2020 03:12:04 -0600
+Subject: [PATCH] Add demo command
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index 00ab01661c12ecd7b384be81388c9aaa5b32d706..a5c5f3aa76ba819541dd927c0749806bbb2f1942 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -207,6 +207,7 @@ public class Commands {
+             SetPlayerIdleTimeoutCommand.register(this.dispatcher);
+             StopCommand.register(this.dispatcher);
+             WhitelistCommand.register(this.dispatcher);
+            org.purpurmc.purpur.command.DemoCommand.register(this.dispatcher); // Purpur
+             org.purpurmc.purpur.command.PingCommand.register(this.dispatcher); // Purpur
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 6d40bfc2e7ea6090589fd12057ed8d54966fe2d2..2b161a4e098b7b17f52209ddd71d64ac7e6da5ed 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -173,6 +173,7 @@ public class PurpurConfig {
+     public static String afkBroadcastBack = "<yellow><italic>%s is no longer AFK";
+     public static String afkTabListPrefix = "[AFK] ";
+     public static String afkTabListSuffix = "";
+    public static String demoCommandOutput = "<green>%s has been shown the demo screen";
+     public static String pingCommandOutput = "<green>%s's ping is %sms";
+     private static void messages() {
+         cannotRideMob = getString("settings.messages.cannot-ride-mob", cannotRideMob);
+@@ -180,6 +181,7 @@ public class PurpurConfig {
+         afkBroadcastBack = getString("settings.messages.afk-broadcast-back", afkBroadcastBack);
+         afkTabListPrefix = getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix);
+         afkTabListSuffix = getString("settings.messages.afk-tab-list-suffix", afkTabListSuffix);
+        demoCommandOutput = getString("settings.messages.demo-command-output", demoCommandOutput);
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/command/DemoCommand.java b/src/main/java/org/purpurmc/purpur/command/DemoCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..83b3d1fb934d417702fc280e679f88d80f63cff2
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/command/DemoCommand.java
+@@ -0,0 +1,34 @@
+package org.purpurmc.purpur.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
+import net.minecraft.server.level.ServerPlayer;
+import org.purpurmc.purpur.PurpurConfig;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class DemoCommand {
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(Commands.literal("demo")
+                .requires((listener) -> listener.hasPermission(2))
+                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
+                .then(Commands.argument("targets", EntityArgument.players())
+                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
+                )
+        ).setPermission("bukkit.command.demo");
+    }
+
+    private static int execute(CommandSourceStack sender, Collection<ServerPlayer> targets) {
+        for (ServerPlayer player : targets) {
+            ClientboundGameEventPacket packet = new ClientboundGameEventPacket(ClientboundGameEventPacket.DEMO_EVENT, 0);
+            player.connection.send(packet);
+            String output = String.format(PurpurConfig.demoCommandOutput, player.getGameProfile().getName());
+            sender.sendSuccess(output, false);
+        }
+        return targets.size();
+    }
+}
--- a/patches/unapplied/0071-Add-credits-command.patch
+++ b/patches/unapplied/0071-Add-credits-command.patch
@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Fri, 30 Apr 2021 14:03:06 -0400
+Subject: [PATCH] Add credits command
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index a5c5f3aa76ba819541dd927c0749806bbb2f1942..362fd34016b83ba346a43abb6acf38d887918437 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -207,6 +207,7 @@ public class Commands {
+             SetPlayerIdleTimeoutCommand.register(this.dispatcher);
+             StopCommand.register(this.dispatcher);
+             WhitelistCommand.register(this.dispatcher);
+            org.purpurmc.purpur.command.CreditsCommand.register(this.dispatcher); // Purpur
+             org.purpurmc.purpur.command.DemoCommand.register(this.dispatcher); // Purpur
+             org.purpurmc.purpur.command.PingCommand.register(this.dispatcher); // Purpur
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 2b161a4e098b7b17f52209ddd71d64ac7e6da5ed..e49c2c16f6130eb1343d49d5a3972f505155aba2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -173,6 +173,7 @@ public class PurpurConfig {
+     public static String afkBroadcastBack = "<yellow><italic>%s is no longer AFK";
+     public static String afkTabListPrefix = "[AFK] ";
+     public static String afkTabListSuffix = "";
+    public static String creditsCommandOutput = "<green>%s has been shown the end credits";
+     public static String demoCommandOutput = "<green>%s has been shown the demo screen";
+     public static String pingCommandOutput = "<green>%s's ping is %sms";
+     private static void messages() {
+@@ -181,6 +182,7 @@ public class PurpurConfig {
+         afkBroadcastBack = getString("settings.messages.afk-broadcast-back", afkBroadcastBack);
+         afkTabListPrefix = getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix);
+         afkTabListSuffix = getString("settings.messages.afk-tab-list-suffix", afkTabListSuffix);
+        creditsCommandOutput = getString("settings.messages.credits-command-output", creditsCommandOutput);
+         demoCommandOutput = getString("settings.messages.demo-command-output", demoCommandOutput);
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/command/CreditsCommand.java b/src/main/java/org/purpurmc/purpur/command/CreditsCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2189ca24f9fe53ad20ffba73ea73f6a0dc7891b8
+--- /dev/null
+++ b/src/main/java/org/purpurmc/purpur/command/CreditsCommand.java
+@@ -0,0 +1,34 @@
+package org.purpurmc.purpur.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
+import net.minecraft.server.level.ServerPlayer;
+import org.purpurmc.purpur.PurpurConfig;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class CreditsCommand {
+    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+        dispatcher.register(Commands.literal("credits")
+                .requires((listener) -> listener.hasPermission(2))
+                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
+                .then(Commands.argument("targets", EntityArgument.players())
+                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
+                )
+        ).setPermission("bukkit.command.credits");
+    }
+
+    private static int execute(CommandSourceStack sender, Collection<ServerPlayer> targets) {
+        for (ServerPlayer player : targets) {
+            ClientboundGameEventPacket packet = new ClientboundGameEventPacket(ClientboundGameEventPacket.WIN_GAME, 1F);
+            player.connection.send(packet);
+            String output = String.format(PurpurConfig.creditsCommandOutput, player.getGameProfile().getName());
+            sender.sendSuccess(output, false);
+        }
+        return targets.size();
+    }
+}
--- a/patches/unapplied/0072-Configurable-jockey-options.patch
+++ b/patches/unapplied/0072-Configurable-jockey-options.patch
@@ -0,0 +1,271 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 26 Mar 2020 21:39:32 -0500
+Subject: [PATCH] Configurable jockey options
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+index 20529a611faef742fcd3c4c2706bbe8009f1defa..d966175c84ebb4d9054b8368d14243823d242f80 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+@@ -93,6 +93,21 @@ public class Drowned extends Zombie implements RangedAttackMob {
+     protected void randomizeReinforcementsChance() {
+         this.getAttribute(Attributes.SPAWN_REINFORCEMENTS_CHANCE).setBaseValue(this.random.nextDouble() * this.level.purpurConfig.drownedSpawnReinforcements);
+     }
+
+    @Override
+    public boolean jockeyOnlyBaby() {
+        return level.purpurConfig.drownedJockeyOnlyBaby;
+    }
+
+    @Override
+    public double jockeyChance() {
+        return level.purpurConfig.drownedJockeyChance;
+    }
+
+    @Override
+    public boolean jockeyTryExistingChickens() {
+        return level.purpurConfig.drownedJockeyTryExistingChickens;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Husk.java b/src/main/java/net/minecraft/world/entity/monster/Husk.java
+index ff84c706d42bc6859faaa9302ba688f43ddcb537..640c75c2cf7ec1f1bc514d29ac1f929c526e0caa 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Husk.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Husk.java
+@@ -47,6 +47,21 @@ public class Husk extends Zombie {
+     protected void randomizeReinforcementsChance() {
+         this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.SPAWN_REINFORCEMENTS_CHANCE).setBaseValue(this.random.nextDouble() * this.level.purpurConfig.huskSpawnReinforcements);
+     }
+
+    @Override
+    public boolean jockeyOnlyBaby() {
+        return level.purpurConfig.huskJockeyOnlyBaby;
+    }
+
+    @Override
+    public double jockeyChance() {
+        return level.purpurConfig.huskJockeyChance;
+    }
+
+    @Override
+    public boolean jockeyTryExistingChickens() {
+        return level.purpurConfig.huskJockeyTryExistingChickens;
+    }
+     // Purpur end
+ 
+     public static boolean checkHuskSpawnRules(EntityType<Husk> type, ServerLevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) {
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+index 0b3d90208b97513d295235249dfa366a2e6b3baf..c28d0b6ba64a6f7b6aa4ea2df11f10d8a2371718 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+@@ -124,6 +124,18 @@ public class Zombie extends Monster {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.drownedMaxHealth);
+     }
+
+    public boolean jockeyOnlyBaby() {
+        return level.purpurConfig.zombieJockeyOnlyBaby;
+    }
+
+    public double jockeyChance() {
+        return level.purpurConfig.zombieJockeyChance;
+    }
+
+    public boolean jockeyTryExistingChickens() {
+        return level.purpurConfig.zombieJockeyTryExistingChickens;
+    }
+     // Purpur end
+ 
+     @Override
+@@ -540,19 +552,20 @@ public class Zombie extends Monster {
+         if (object instanceof Zombie.ZombieGroupData) {
+             Zombie.ZombieGroupData entityzombie_groupdatazombie = (Zombie.ZombieGroupData) object;
+ 
+-            if (entityzombie_groupdatazombie.isBaby) {
+-                this.setBaby(true);
+            // Purpur start
+            if (!jockeyOnlyBaby() || entityzombie_groupdatazombie.isBaby) {
+                this.setBaby(entityzombie_groupdatazombie.isBaby);
+                 if (entityzombie_groupdatazombie.canSpawnJockey) {
+-                    if ((double) world.getRandom().nextFloat() < 0.05D) {
+-                        List<Chicken> list = world.getEntitiesOfClass(Chicken.class, this.getBoundingBox().inflate(5.0D, 3.0D, 5.0D), EntitySelector.ENTITY_NOT_BEING_RIDDEN);
+                    if ((double) world.getRandom().nextFloat() < jockeyChance()) {
+                        List<Chicken> list = jockeyTryExistingChickens() ? world.getEntitiesOfClass(Chicken.class, this.getBoundingBox().inflate(5.0D, 3.0D, 5.0D), EntitySelector.ENTITY_NOT_BEING_RIDDEN) : java.util.Collections.emptyList();
+                        // Purpur end
+ 
+                         if (!list.isEmpty()) {
+                             Chicken entitychicken = (Chicken) list.get(0);
+ 
+                             entitychicken.setChickenJockey(true);
+                             this.startRiding(entitychicken);
+-                        }
+-                    } else if ((double) world.getRandom().nextFloat() < 0.05D) {
+                        } else { // Purpur
+                         Chicken entitychicken1 = (Chicken) EntityType.CHICKEN.create(this.level);
+ 
+                         entitychicken1.moveTo(this.getX(), this.getY(), this.getZ(), this.getYRot(), 0.0F);
+@@ -560,6 +573,7 @@ public class Zombie extends Monster {
+                         entitychicken1.setChickenJockey(true);
+                         this.startRiding(entitychicken1);
+                         world.addFreshEntity(entitychicken1, CreatureSpawnEvent.SpawnReason.MOUNT); // CraftBukkit
+                        } // Purpur
+                     }
+                 }
+             }
+diff --git a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+index 1c39e1ccbe8d7d3393d32babf01f045004f60bd3..36f748fb4b4e6e0c3a39ab3f9c11bf178aced7df 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+++ b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+@@ -104,6 +104,21 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder {
+     protected void randomizeReinforcementsChance() {
+         this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.SPAWN_REINFORCEMENTS_CHANCE).setBaseValue(this.random.nextDouble() * this.level.purpurConfig.zombieVillagerSpawnReinforcements);
+     }
+
+    @Override
+    public boolean jockeyOnlyBaby() {
+        return level.purpurConfig.zombieVillagerJockeyOnlyBaby;
+    }
+
+    @Override
+    public double jockeyChance() {
+        return level.purpurConfig.zombieVillagerJockeyChance;
+    }
+
+    @Override
+    public boolean jockeyTryExistingChickens() {
+        return level.purpurConfig.zombieVillagerJockeyTryExistingChickens;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
+index 43e8eac09accc1f5f9d4b821ccff1a7a92b24121..eb8b111faffbd3143465ed531e86ea572f53fdea 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
+++ b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
+@@ -79,6 +79,21 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.zombifiedPiglinMaxHealth);
+     }
+
+    @Override
+    public boolean jockeyOnlyBaby() {
+        return level.purpurConfig.zombifiedPiglinJockeyOnlyBaby;
+    }
+
+    @Override
+    public double jockeyChance() {
+        return level.purpurConfig.zombifiedPiglinJockeyChance;
+    }
+
+    @Override
+    public boolean jockeyTryExistingChickens() {
+        return level.purpurConfig.zombifiedPiglinJockeyTryExistingChickens;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7dd9e436b50019bb16a61314cf6798b6a5b2580b..9b87f29de86fe2b312622082705709479433f357 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -565,6 +565,9 @@ public class PurpurWorldConfig {
+     public boolean drownedControllable = true;
+     public double drownedMaxHealth = 20.0D;
+     public double drownedSpawnReinforcements = 0.1D;
+    public boolean drownedJockeyOnlyBaby = true;
+    public double drownedJockeyChance = 0.05D;
+    public boolean drownedJockeyTryExistingChickens = true;
+     private void drownedSettings() {
+         drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable);
+         drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater);
+@@ -576,6 +579,9 @@ public class PurpurWorldConfig {
+         }
+         drownedMaxHealth = getDouble("mobs.drowned.attributes.max_health", drownedMaxHealth);
+         drownedSpawnReinforcements = getDouble("mobs.drowned.attributes.spawn_reinforcements", drownedSpawnReinforcements);
+        drownedJockeyOnlyBaby = getBoolean("mobs.drowned.jockey.only-babies", drownedJockeyOnlyBaby);
+        drownedJockeyChance = getDouble("mobs.drowned.jockey.chance", drownedJockeyChance);
+        drownedJockeyTryExistingChickens = getBoolean("mobs.drowned.jockey.try-existing-chickens", drownedJockeyTryExistingChickens);
+     }
+ 
+     public boolean elderGuardianRidable = false;
+@@ -813,6 +819,9 @@ public class PurpurWorldConfig {
+     public boolean huskControllable = true;
+     public double huskMaxHealth = 20.0D;
+     public double huskSpawnReinforcements = 0.1D;
+    public boolean huskJockeyOnlyBaby = true;
+    public double huskJockeyChance = 0.05D;
+    public boolean huskJockeyTryExistingChickens = true;
+     private void huskSettings() {
+         huskRidable = getBoolean("mobs.husk.ridable", huskRidable);
+         huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater);
+@@ -824,6 +833,9 @@ public class PurpurWorldConfig {
+         }
+         huskMaxHealth = getDouble("mobs.husk.attributes.max_health", huskMaxHealth);
+         huskSpawnReinforcements = getDouble("mobs.husk.attributes.spawn_reinforcements", huskSpawnReinforcements);
+        huskJockeyOnlyBaby = getBoolean("mobs.husk.jockey.only-babies", huskJockeyOnlyBaby);
+        huskJockeyChance = getDouble("mobs.husk.jockey.chance", huskJockeyChance);
+        huskJockeyTryExistingChickens = getBoolean("mobs.husk.jockey.try-existing-chickens", huskJockeyTryExistingChickens);
+     }
+ 
+     public boolean illusionerRidable = false;
+@@ -1619,6 +1631,9 @@ public class PurpurWorldConfig {
+     public boolean zombieControllable = true;
+     public double zombieMaxHealth = 20.0D;
+     public double zombieSpawnReinforcements = 0.1D;
+    public boolean zombieJockeyOnlyBaby = true;
+    public double zombieJockeyChance = 0.05D;
+    public boolean zombieJockeyTryExistingChickens = true;
+     private void zombieSettings() {
+         zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable);
+         zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater);
+@@ -1630,6 +1645,9 @@ public class PurpurWorldConfig {
+         }
+         zombieMaxHealth = getDouble("mobs.zombie.attributes.max_health", zombieMaxHealth);
+         zombieSpawnReinforcements = getDouble("mobs.zombie.attributes.spawn_reinforcements", zombieSpawnReinforcements);
+        zombieJockeyOnlyBaby = getBoolean("mobs.zombie.jockey.only-babies", zombieJockeyOnlyBaby);
+        zombieJockeyChance = getDouble("mobs.zombie.jockey.chance", zombieJockeyChance);
+        zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens);
+     }
+ 
+     public boolean zombieHorseRidableInWater = false;
+@@ -1664,6 +1682,9 @@ public class PurpurWorldConfig {
+     public boolean zombieVillagerControllable = true;
+     public double zombieVillagerMaxHealth = 20.0D;
+     public double zombieVillagerSpawnReinforcements = 0.1D;
+    public boolean zombieVillagerJockeyOnlyBaby = true;
+    public double zombieVillagerJockeyChance = 0.05D;
+    public boolean zombieVillagerJockeyTryExistingChickens = true;
+     private void zombieVillagerSettings() {
+         zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable);
+         zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater);
+@@ -1675,6 +1696,9 @@ public class PurpurWorldConfig {
+         }
+         zombieVillagerMaxHealth = getDouble("mobs.zombie_villager.attributes.max_health", zombieVillagerMaxHealth);
+         zombieVillagerSpawnReinforcements = getDouble("mobs.zombie_villager.attributes.spawn_reinforcements", zombieVillagerSpawnReinforcements);
+        zombieVillagerJockeyOnlyBaby = getBoolean("mobs.zombie_villager.jockey.only-babies", zombieVillagerJockeyOnlyBaby);
+        zombieVillagerJockeyChance = getDouble("mobs.zombie_villager.jockey.chance", zombieVillagerJockeyChance);
+        zombieVillagerJockeyTryExistingChickens = getBoolean("mobs.zombie_villager.jockey.try-existing-chickens", zombieVillagerJockeyTryExistingChickens);
+     }
+ 
+     public boolean zombifiedPiglinRidable = false;
+@@ -1682,6 +1706,9 @@ public class PurpurWorldConfig {
+     public boolean zombifiedPiglinControllable = true;
+     public double zombifiedPiglinMaxHealth = 20.0D;
+     public double zombifiedPiglinSpawnReinforcements = 0.0D;
+    public boolean zombifiedPiglinJockeyOnlyBaby = true;
+    public double zombifiedPiglinJockeyChance = 0.05D;
+    public boolean zombifiedPiglinJockeyTryExistingChickens = true;
+     private void zombifiedPiglinSettings() {
+         zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable);
+         zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater);
+@@ -1693,5 +1720,8 @@ public class PurpurWorldConfig {
+         }
+         zombifiedPiglinMaxHealth = getDouble("mobs.zombified_piglin.attributes.max_health", zombifiedPiglinMaxHealth);
+         zombifiedPiglinSpawnReinforcements = getDouble("mobs.zombified_piglin.attributes.spawn_reinforcements", zombifiedPiglinSpawnReinforcements);
+        zombifiedPiglinJockeyOnlyBaby = getBoolean("mobs.zombified_piglin.jockey.only-babies", zombifiedPiglinJockeyOnlyBaby);
+        zombifiedPiglinJockeyChance = getDouble("mobs.zombified_piglin.jockey.chance", zombifiedPiglinJockeyChance);
+        zombifiedPiglinJockeyTryExistingChickens = getBoolean("mobs.zombified_piglin.jockey.try-existing-chickens", zombifiedPiglinJockeyTryExistingChickens);
+     }
+ }
--- a/patches/unapplied/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch
+++ b/patches/unapplied/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch
@@ -0,0 +1,283 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 9 May 2019 18:26:06 -0500
+Subject: [PATCH] Phantoms attracted to crystals and crystals shoot phantoms
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+index d8c4f36ae0e65c6d0398fac80c93b78646bdf6a4..f8863cabad1bd0c3c2c62b8e17612d9559237d68 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java
+@@ -31,6 +31,12 @@ public class EndCrystal extends Entity {
+     private static final EntityDataAccessor<Boolean> DATA_SHOW_BOTTOM = SynchedEntityData.defineId(EndCrystal.class, EntityDataSerializers.BOOLEAN);
+     public int time;
+     public boolean generatedByDragonFight = false; // Paper - Fix invulnerable end crystals
+    // Purpur start
+    private net.minecraft.world.entity.monster.Phantom targetPhantom;
+    private int phantomBeamTicks = 0;
+    private int phantomDamageCooldown = 0;
+    private int idleCooldown = 0;
+    // Purpur end
+ 
+     public EndCrystal(EntityType<? extends EndCrystal> type, Level world) {
+         super(type, world);
+@@ -80,7 +86,50 @@ public class EndCrystal extends Entity {
+             // Paper end
+         }
+ 
+        // Purpur start
+        if (level.purpurConfig.phantomAttackedByCrystalRadius <= 0 || --idleCooldown > 0) {
+            return; // on cooldown
+        }
+
+        if (targetPhantom == null) {
+            for (net.minecraft.world.entity.monster.Phantom phantom : level.getEntitiesOfClass(net.minecraft.world.entity.monster.Phantom.class, getBoundingBox().inflate(level.purpurConfig.phantomAttackedByCrystalRadius))) {
+                if (phantom.hasLineOfSight(this)) {
+                    attackPhantom(phantom);
+                    break;
+                }
+            }
+        } else {
+            setBeamTarget(new BlockPos(targetPhantom).offset(0, -2, 0));
+            if (--phantomBeamTicks > 0 && targetPhantom.isAlive()) {
+                phantomDamageCooldown--;
+                if (targetPhantom.hasLineOfSight(this)) {
+                    if (phantomDamageCooldown <= 0) {
+                        phantomDamageCooldown = 20;
+                        targetPhantom.hurt(DamageSource.indirectMagic(this, this), level.purpurConfig.phantomAttackedByCrystalDamage);
+                    }
+                } else {
+                    forgetPhantom(); // no longer in sight
+                }
+            } else {
+                forgetPhantom(); // attacked long enough
+            }
+        }
+    }
+
+    private void attackPhantom(net.minecraft.world.entity.monster.Phantom phantom) {
+        phantomDamageCooldown = 0;
+        phantomBeamTicks = 60;
+        targetPhantom = phantom;
+    }
+
+    private void forgetPhantom() {
+        targetPhantom = null;
+        setBeamTarget(null);
+        phantomBeamTicks = 0;
+        phantomDamageCooldown = 0;
+        idleCooldown = 60;
+     }
+    // Purpur end
+ 
+     @Override
+     protected void addAdditionalSaveData(CompoundTag nbt) {
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+index f4c14777f912451e4316c0a3b5006fad83b0b98d..843c5bdc58a09aadab8d90f254e61a5cebe6388f 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+@@ -49,6 +49,7 @@ public class Phantom extends FlyingMob implements Enemy {
+     Vec3 moveTargetPoint;
+     BlockPos anchorPoint;
+     Phantom.AttackPhase attackPhase;
+    Vec3 crystalPosition; // Purpur
+ 
+     public Phantom(EntityType<? extends Phantom> type, Level world) {
+         super(type, world);
+@@ -131,6 +132,24 @@ public class Phantom extends FlyingMob implements Enemy {
+         }
+         return value;
+     }
+
+    @Override
+    protected net.minecraft.world.level.storage.loot.LootContext.Builder createLootContext(boolean causedByPlayer, DamageSource source) {
+        boolean dropped = false;
+        if (lastHurtByPlayer == null && source.getEntity() instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal) {
+            if (random.nextInt(5) < 1) {
+                dropped = spawnAtLocation(new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Items.PHANTOM_MEMBRANE)) != null;
+            }
+        }
+        if (!dropped) {
+            return super.createLootContext(causedByPlayer, source);
+        }
+        return new net.minecraft.world.level.storage.loot.LootContext.Builder((net.minecraft.server.level.ServerLevel) level);
+    }
+
+    public boolean isCirclingCrystal() {
+        return crystalPosition != null;
+    }
+     // Purpur end
+ 
+     @Override
+@@ -145,11 +164,17 @@ public class Phantom extends FlyingMob implements Enemy {
+ 
+     @Override
+     protected void registerGoals() {
+-        this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+-        this.goalSelector.addGoal(1, new Phantom.PhantomAttackStrategyGoal());
+-        this.goalSelector.addGoal(2, new Phantom.PhantomSweepAttackGoal());
+-        this.goalSelector.addGoal(3, new Phantom.PhantomCircleAroundAnchorGoal());
+-        this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+        // Purpur start
+        this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+        if (level.purpurConfig.phantomOrbitCrystalRadius > 0) {
+            this.goalSelector.addGoal(1, new FindCrystalGoal(this));
+            this.goalSelector.addGoal(2, new OrbitCrystalGoal(this));
+        }
+        this.goalSelector.addGoal(3, new Phantom.PhantomAttackStrategyGoal());
+        this.goalSelector.addGoal(4, new Phantom.PhantomSweepAttackGoal());
+        this.goalSelector.addGoal(5, new Phantom.PhantomCircleAroundAnchorGoal());
+        this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this));
+        // Purpur end
+         this.targetSelector.addGoal(1, new Phantom.PhantomAttackPlayerTargetGoal());
+     }
+ 
+@@ -343,6 +368,124 @@ public class Phantom extends FlyingMob implements Enemy {
+         private AttackPhase() {}
+     }
+ 
+    // Purpur start
+    class FindCrystalGoal extends Goal {
+        private final Phantom phantom;
+        private net.minecraft.world.entity.boss.enderdragon.EndCrystal crystal;
+        private Comparator<net.minecraft.world.entity.boss.enderdragon.EndCrystal> comparator;
+
+        FindCrystalGoal(Phantom phantom) {
+            this.phantom = phantom;
+            this.comparator = Comparator.comparingDouble(phantom::distanceToSqr);
+            this.setFlags(EnumSet.of(Flag.LOOK));
+        }
+
+        @Override
+        public boolean canUse() {
+            double range = maxTargetRange();
+            List<net.minecraft.world.entity.boss.enderdragon.EndCrystal> crystals = level.getEntitiesOfClass(net.minecraft.world.entity.boss.enderdragon.EndCrystal.class, phantom.getBoundingBox().inflate(range));
+            if (crystals.isEmpty()) {
+                return false;
+            }
+            crystals.sort(comparator);
+            crystal = crystals.get(0);
+            if (phantom.distanceToSqr(crystal) > range * range) {
+                crystal = null;
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            if (crystal == null || !crystal.isAlive()) {
+                return false;
+            }
+            double range = maxTargetRange();
+            return phantom.distanceToSqr(crystal) <= (range * range) * 2;
+        }
+
+        @Override
+        public void start() {
+            phantom.crystalPosition = new Vec3(crystal.getX(), crystal.getY() + (phantom.random.nextInt(10) + 10), crystal.getZ());
+        }
+
+        @Override
+        public void stop() {
+            crystal = null;
+            phantom.crystalPosition = null;
+            super.stop();
+        }
+
+        private double maxTargetRange() {
+            return phantom.level.purpurConfig.phantomOrbitCrystalRadius;
+        }
+    }
+
+    class OrbitCrystalGoal extends Goal {
+        private final Phantom phantom;
+        private float offset;
+        private float radius;
+        private float verticalChange;
+        private float direction;
+
+        OrbitCrystalGoal(Phantom phantom) {
+            this.phantom = phantom;
+            this.setFlags(EnumSet.of(Flag.MOVE));
+        }
+
+        @Override
+        public boolean canUse() {
+            return phantom.isCirclingCrystal();
+        }
+
+        @Override
+        public void start() {
+            this.radius = 5.0F + phantom.random.nextFloat() * 10.0F;
+            this.verticalChange = -4.0F + phantom.random.nextFloat() * 9.0F;
+            this.direction = phantom.random.nextBoolean() ? 1.0F : -1.0F;
+            updateOffset();
+        }
+
+        @Override
+        public void tick() {
+            if (phantom.random.nextInt(350) == 0) {
+                this.verticalChange = -4.0F + phantom.random.nextFloat() * 9.0F;
+            }
+            if (phantom.random.nextInt(250) == 0) {
+                ++this.radius;
+                if (this.radius > 15.0F) {
+                    this.radius = 5.0F;
+                    this.direction = -this.direction;
+                }
+            }
+            if (phantom.random.nextInt(450) == 0) {
+                this.offset = phantom.random.nextFloat() * 2.0F * 3.1415927F;
+                updateOffset();
+            }
+            if (phantom.moveTargetPoint.distanceToSqr(phantom.getX(), phantom.getY(), phantom.getZ()) < 4.0D) {
+                updateOffset();
+            }
+            if (phantom.moveTargetPoint.y < phantom.getY() && !phantom.level.isEmptyBlock(new BlockPos(phantom).below(1))) {
+                this.verticalChange = Math.max(1.0F, this.verticalChange);
+                updateOffset();
+            }
+            if (phantom.moveTargetPoint.y > phantom.getY() && !phantom.level.isEmptyBlock(new BlockPos(phantom).above(1))) {
+                this.verticalChange = Math.min(-1.0F, this.verticalChange);
+                updateOffset();
+            }
+        }
+
+        private void updateOffset() {
+            this.offset += this.direction * 15.0F * 0.017453292F;
+            phantom.moveTargetPoint = phantom.crystalPosition.add(
+                    this.radius * Mth.cos(this.offset),
+                    -4.0F + this.verticalChange,
+                    this.radius * Mth.sin(this.offset));
+        }
+    }
+    // Purpur end
+
+     private class PhantomMoveControl extends org.purpurmc.purpur.controller.FlyingMoveControllerWASD { // Purpur
+ 
+         private float speed = 0.1F;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9b87f29de86fe2b312622082705709479433f357..d1057f80a7816dc553ddb9b825e65f35764514a0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1031,6 +1031,9 @@ public class PurpurWorldConfig {
+     public String phantomAttackDamage = "6 + size";
+     public Map<Integer, Double> phantomMaxHealthCache = new HashMap<>();
+     public Map<Integer, Double> phantomAttackDamageCache = new HashMap<>();
+    public double phantomAttackedByCrystalRadius = 0.0D;
+    public float phantomAttackedByCrystalDamage = 1.0F;
+    public double phantomOrbitCrystalRadius = 0.0D;
+     private void phantomSettings() {
+         phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable);
+         phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater);
+@@ -1052,6 +1055,9 @@ public class PurpurWorldConfig {
+         phantomAttackDamage = getString("mobs.phantom.attributes.attack_damage", phantomAttackDamage);
+         phantomMaxHealthCache.clear();
+         phantomAttackDamageCache.clear();
+        phantomAttackedByCrystalRadius = getDouble("mobs.phantom.attacked-by-crystal-range", phantomAttackedByCrystalRadius);
+        phantomAttackedByCrystalDamage = (float) getDouble("mobs.phantom.attacked-by-crystal-damage", phantomAttackedByCrystalDamage);
+        phantomOrbitCrystalRadius = getDouble("mobs.phantom.orbit-crystal-radius", phantomOrbitCrystalRadius);
+     }
+ 
+     public boolean pigRidable = false;
--- a/patches/unapplied/0074-Add-phantom-spawning-options.patch
+++ b/patches/unapplied/0074-Add-phantom-spawning-options.patch
@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 3 Jul 2020 00:03:52 -0500
+Subject: [PATCH] Add phantom spawning options
+
+
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+index 1e21d6cf2f03219fb2b7217c9a72bdd83c2146f7..dad5d3c754395b39e96be1e35a99c8bf4b1c573c 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -41,8 +41,8 @@ public class PhantomSpawner implements CustomSpawner {
+             if (this.nextTick > 0) {
+                 return 0;
+             } else {
+-                this.nextTick += (60 + random.nextInt(60)) * 20;
+-                if (world.getSkyDarken() < 5 && world.dimensionType().hasSkyLight()) {
+                this.nextTick += world.purpurConfig.phantomSpawnDelayMin + world.random.nextInt(world.purpurConfig.phantomSpawnDelayMax - world.purpurConfig.phantomSpawnDelayMin + 1); // Purpur
+                if (world.getSkyDarken() < world.purpurConfig.phantomSpawnMinSkyDarkness && world.dimensionType().hasSkyLight()) { // Purpur
+                     return 0;
+                 } else {
+                     int i = 0;
+@@ -54,22 +54,22 @@ public class PhantomSpawner implements CustomSpawner {
+                         if (!entityhuman.isSpectator() && (!world.paperConfig.phantomIgnoreCreative || !entityhuman.isCreative())) { // Paper
+                             BlockPos blockposition = entityhuman.blockPosition();
+ 
+-                            if (!world.dimensionType().hasSkyLight() || blockposition.getY() >= world.getSeaLevel() && world.canSeeSky(blockposition)) {
+                            if (!world.dimensionType().hasSkyLight() || (!world.purpurConfig.phantomSpawnOnlyAboveSeaLevel || blockposition.getY() >= world.getSeaLevel()) && (!world.purpurConfig.phantomSpawnOnlyWithVisibleSky || world.canSeeSky(blockposition))) { // Purpur
+                                 DifficultyInstance difficultydamagescaler = world.getCurrentDifficultyAt(blockposition);
+ 
+-                                if (difficultydamagescaler.isHarderThan(random.nextFloat() * 3.0F)) {
+                                if (difficultydamagescaler.isHarderThan(random.nextFloat() * (float) world.purpurConfig.phantomSpawnLocalDifficultyChance)) { // Purpur
+                                     ServerStatsCounter serverstatisticmanager = ((ServerPlayer) entityhuman).getStats();
+                                     int j = Mth.clamp(serverstatisticmanager.getValue(Stats.CUSTOM.get(Stats.TIME_SINCE_REST)), (int) 1, Integer.MAX_VALUE);
+                                     boolean flag2 = true;
+ 
+-                                    if (random.nextInt(j) >= 72000) {
+-                                        BlockPos blockposition1 = blockposition.above(20 + random.nextInt(15)).east(-10 + random.nextInt(21)).south(-10 + random.nextInt(21));
+                                    if (random.nextInt(j) >= world.purpurConfig.phantomSpawnMinTimeSinceSlept) { // Purpur
+                                        BlockPos blockposition1 = blockposition.above(world.purpurConfig.phantomSpawnMinOverhead + random.nextInt(world.purpurConfig.phantomSpawnMaxOverhead - world.purpurConfig.phantomSpawnMinOverhead + 1)).east(-world.purpurConfig.phantomSpawnOverheadRadius + random.nextInt(world.purpurConfig.phantomSpawnOverheadRadius * 2 + 1)).south(-world.purpurConfig.phantomSpawnOverheadRadius + random.nextInt(world.purpurConfig.phantomSpawnOverheadRadius * 2 + 1)); // Purpur
+                                         BlockState iblockdata = world.getBlockState(blockposition1);
+                                         FluidState fluid = world.getFluidState(blockposition1);
+ 
+                                         if (NaturalSpawner.isValidEmptySpawnBlock(world, blockposition1, iblockdata, fluid, EntityType.PHANTOM)) {
+                                             SpawnGroupData groupdataentity = null;
+-                                            int k = 1 + random.nextInt(difficultydamagescaler.getDifficulty().getId() + 1);
+                                            int k = world.purpurConfig.phantomSpawnMinPerAttempt + world.random.nextInt((world.purpurConfig.phantomSpawnMaxPerAttempt < 0 ? difficultydamagescaler.getDifficulty().getId() : world.purpurConfig.phantomSpawnMaxPerAttempt - world.purpurConfig.phantomSpawnMinPerAttempt) + 1); // Purpur
+ 
+                                             for (int l = 0; l < k; ++l) {
+                                                 // Paper start
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d1057f80a7816dc553ddb9b825e65f35764514a0..47c6d378380ff9345be4bd6dd06fe52e3e23162d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1034,6 +1034,18 @@ public class PurpurWorldConfig {
+     public double phantomAttackedByCrystalRadius = 0.0D;
+     public float phantomAttackedByCrystalDamage = 1.0F;
+     public double phantomOrbitCrystalRadius = 0.0D;
+    public int phantomSpawnDelayMin = 1200;
+    public int phantomSpawnDelayMax = 2400;
+    public int phantomSpawnMinSkyDarkness = 5;
+    public boolean phantomSpawnOnlyAboveSeaLevel = true;
+    public boolean phantomSpawnOnlyWithVisibleSky = true;
+    public double phantomSpawnLocalDifficultyChance = 3.0D;
+    public int phantomSpawnMinTimeSinceSlept = 72000;
+    public int phantomSpawnMinOverhead = 20;
+    public int phantomSpawnMaxOverhead = 35;
+    public int phantomSpawnOverheadRadius = 10;
+    public int phantomSpawnMinPerAttempt = 1;
+    public int phantomSpawnMaxPerAttempt = -1;
+     private void phantomSettings() {
+         phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable);
+         phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater);
+@@ -1058,6 +1070,18 @@ public class PurpurWorldConfig {
+         phantomAttackedByCrystalRadius = getDouble("mobs.phantom.attacked-by-crystal-range", phantomAttackedByCrystalRadius);
+         phantomAttackedByCrystalDamage = (float) getDouble("mobs.phantom.attacked-by-crystal-damage", phantomAttackedByCrystalDamage);
+         phantomOrbitCrystalRadius = getDouble("mobs.phantom.orbit-crystal-radius", phantomOrbitCrystalRadius);
+        phantomSpawnDelayMin = getInt("mobs.phantom.spawn.delay.min", phantomSpawnDelayMin);
+        phantomSpawnDelayMax = getInt("mobs.phantom.spawn.delay.max", phantomSpawnDelayMax);
+        phantomSpawnMinSkyDarkness = getInt("mobs.phantom.spawn.min-sky-darkness", phantomSpawnMinSkyDarkness);
+        phantomSpawnOnlyAboveSeaLevel = getBoolean("mobs.phantom.spawn.only-above-sea-level", phantomSpawnOnlyAboveSeaLevel);
+        phantomSpawnOnlyWithVisibleSky = getBoolean("mobs.phantom.spawn.only-with-visible-sky", phantomSpawnOnlyWithVisibleSky);
+        phantomSpawnLocalDifficultyChance = getDouble("mobs.phantom.spawn.local-difficulty-chance", phantomSpawnLocalDifficultyChance);
+        phantomSpawnMinTimeSinceSlept = getInt("mobs.phantom.spawn.min-time-since-slept", phantomSpawnMinTimeSinceSlept);
+        phantomSpawnMinOverhead = getInt("mobs.phantom.spawn.overhead.min", phantomSpawnMinOverhead);
+        phantomSpawnMaxOverhead = getInt("mobs.phantom.spawn.overhead.max", phantomSpawnMaxOverhead);
+        phantomSpawnOverheadRadius = getInt("mobs.phantom.spawn.overhead.radius", phantomSpawnOverheadRadius);
+        phantomSpawnMinPerAttempt = getInt("mobs.phantom.spawn.per-attempt.min", phantomSpawnMinPerAttempt);
+        phantomSpawnMaxPerAttempt = getInt("mobs.phantom.spawn.per-attempt.max", phantomSpawnMaxPerAttempt);
+     }
+ 
+     public boolean pigRidable = false;
--- a/patches/unapplied/0075-Implement-bed-explosion-options.patch
+++ b/patches/unapplied/0075-Implement-bed-explosion-options.patch
@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 4 Jul 2020 13:12:43 -0500
+Subject: [PATCH] Implement bed explosion options
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/BedBlock.java b/src/main/java/net/minecraft/world/level/block/BedBlock.java
+index 20c0030d566012146021613325c6a979f392740e..340e5dee8bf5d8a865c19a8fe63399ae08bf3612 100644
+--- a/src/main/java/net/minecraft/world/level/block/BedBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BedBlock.java
+@@ -96,7 +96,7 @@ public class BedBlock extends HorizontalDirectionalBlock implements EntityBlock
+                     world.removeBlock(blockposition1, false);
+                 }
+ 
+-                world.explode((Entity) null, DamageSource.badRespawnPointExplosion(), (ExplosionDamageCalculator) null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, 5.0F, true, Explosion.BlockInteraction.DESTROY);
+                if (world.purpurConfig.bedExplode) world.explode((Entity) null, DamageSource.badRespawnPointExplosion(), null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, (float) world.purpurConfig.bedExplosionPower, world.purpurConfig.bedExplosionFire, world.purpurConfig.bedExplosionEffect); // Purpur
+                 return InteractionResult.SUCCESS;
+             } else if ((Boolean) state.getValue(BedBlock.OCCUPIED)) {
+                 if (!this.kickVillagerOutOfBed(world, pos)) {
+@@ -145,7 +145,7 @@ public class BedBlock extends HorizontalDirectionalBlock implements EntityBlock
+                     world.removeBlock(blockposition1, false);
+                 }
+ 
+-                world.explode((Entity) null, DamageSource.badRespawnPointExplosion(), (ExplosionDamageCalculator) null, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, 5.0F, true, Explosion.BlockInteraction.DESTROY);
+                if (world.purpurConfig.bedExplode) world.explode((Entity) null, DamageSource.badRespawnPointExplosion(), null, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, (float) world.purpurConfig.bedExplosionPower, world.purpurConfig.bedExplosionFire, world.purpurConfig.bedExplosionEffect); // Purpur
+                 return InteractionResult.SUCCESS;
+             }
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d6744436fbac28e3e6486a6d36f20e20a7d99d3e..f4588e514e60bb244c789b162b8503c236950a3b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -287,6 +287,22 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean bedExplode = true;
+    public double bedExplosionPower = 5.0D;
+    public boolean bedExplosionFire = true;
+    public Explosion.BlockInteraction bedExplosionEffect = Explosion.BlockInteraction.DESTROY;
+    private void bedSettings() {
+        bedExplode = getBoolean("blocks.bed.explode", bedExplode);
+        bedExplosionPower = getDouble("blocks.bed.explosion-power", bedExplosionPower);
+        bedExplosionFire = getBoolean("blocks.bed.explosion-fire", bedExplosionFire);
+        try {
+            bedExplosionEffect = Explosion.BlockInteraction.valueOf(getString("blocks.bed.explosion-effect", bedExplosionEffect.name()));
+        } catch (IllegalArgumentException e) {
+            log(Level.SEVERE, "Unknown value for `blocks.bed.explosion-effect`! Using default of `DESTROY`");
+            bedExplosionEffect = Explosion.BlockInteraction.DESTROY;
+        }
+    }
+
+     public boolean dispenserApplyCursedArmor = true;
+     private void dispenserSettings() {
+         dispenserApplyCursedArmor = getBoolean("blocks.dispenser.apply-cursed-to-armor-slots", dispenserApplyCursedArmor);
--- a/patches/unapplied/0076-Implement-respawn-anchor-explosion-options.patch
+++ b/patches/unapplied/0076-Implement-respawn-anchor-explosion-options.patch
@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 4 Jul 2020 13:23:19 -0500
+Subject: [PATCH] Implement respawn anchor explosion options
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java b/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java
+index 491ad2098e982f3c947fcae6f258f0b1aa44a562..39b3d9ce9fbaa7854d81b304f22ee1935c62d3f3 100644
+--- a/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java
+@@ -124,7 +124,7 @@ public class RespawnAnchorBlock extends Block {
+                 return pos.equals(explodedPos) && bl2 ? Optional.of(Blocks.WATER.getExplosionResistance()) : super.getBlockExplosionResistance(explosion, world, pos, blockState, fluidState);
+             }
+         };
+-        world.explode((Entity)null, DamageSource.badRespawnPointExplosion(), explosionDamageCalculator, (double)explodedPos.getX() + 0.5D, (double)explodedPos.getY() + 0.5D, (double)explodedPos.getZ() + 0.5D, 5.0F, true, Explosion.BlockInteraction.DESTROY);
+        if (world.purpurConfig.respawnAnchorExplode) world.explode(null, DamageSource.badRespawnPointExplosion(), explosionDamageCalculator, (double) explodedPos.getX() + 0.5D, (double) explodedPos.getY() + 0.5D, (double) explodedPos.getZ() + 0.5D, (float) world.purpurConfig.respawnAnchorExplosionPower, world.purpurConfig.respawnAnchorExplosionFire, world.purpurConfig.respawnAnchorExplosionEffect); // Purpur
+     }
+ 
+     public static boolean canSetSpawn(Level world) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 300404c79b0f47219e3a641f75a935cbac9d194a..d6f6cf7e17d9cd5b1398aab8e2b9b6df75fea02e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -324,6 +324,22 @@ public class PurpurWorldConfig {
+         lavaSpeedNotNether = getInt("blocks.lava.speed.not-nether", lavaSpeedNotNether);
+     }
+ 
+    public boolean respawnAnchorExplode = true;
+    public double respawnAnchorExplosionPower = 5.0D;
+    public boolean respawnAnchorExplosionFire = true;
+    public Explosion.BlockInteraction respawnAnchorExplosionEffect = Explosion.BlockInteraction.DESTROY;
+    private void respawnAnchorSettings() {
+        respawnAnchorExplode = getBoolean("blocks.respawn_anchor.explode", respawnAnchorExplode);
+        respawnAnchorExplosionPower = getDouble("blocks.respawn_anchor.explosion-power", respawnAnchorExplosionPower);
+        respawnAnchorExplosionFire = getBoolean("blocks.respawn_anchor.explosion-fire", respawnAnchorExplosionFire);
+        try {
+            respawnAnchorExplosionEffect = Explosion.BlockInteraction.valueOf(getString("blocks.respawn_anchor.explosion-effect", respawnAnchorExplosionEffect.name()));
+        } catch (IllegalArgumentException e) {
+            log(Level.SEVERE, "Unknown value for `blocks.respawn_anchor.explosion-effect`! Using default of `DESTROY`");
+            respawnAnchorExplosionEffect = Explosion.BlockInteraction.DESTROY;
+        }
+    }
+
+     public boolean signRightClickEdit = false;
+     private void signSettings() {
+         signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
--- a/patches/unapplied/0077-Add-allow-water-in-end-world-option.patch
+++ b/patches/unapplied/0077-Add-allow-water-in-end-world-option.patch
@@ -0,0 +1,85 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 5 Jul 2020 23:40:16 -0500
+Subject: [PATCH] Add allow water in end world option
+
+
+diff --git a/src/main/java/net/minecraft/world/item/BucketItem.java b/src/main/java/net/minecraft/world/item/BucketItem.java
+index a3f04f66c66f40068792da3ef0e75e7df102b0e0..e4ee273568502f4cf4d85c5d50d5d63ca4beb12e 100644
+--- a/src/main/java/net/minecraft/world/item/BucketItem.java
+++ b/src/main/java/net/minecraft/world/item/BucketItem.java
+@@ -166,7 +166,7 @@ public class BucketItem extends Item implements DispensibleContainerItem {
+             // CraftBukkit end
+             if (!flag1) {
+                 return movingobjectpositionblock != null && this.emptyContents(entityhuman, world, movingobjectpositionblock.getBlockPos().relative(movingobjectpositionblock.getDirection()), (BlockHitResult) null, enumdirection, clicked, itemstack, enumhand); // CraftBukkit // Paper
+-            } else if (world.dimensionType().ultraWarm() && this.content.is(FluidTags.WATER)) {
+            } else if ((world.isNether() || (world.isTheEnd() && !org.purpurmc.purpur.PurpurConfig.allowWaterPlacementInTheEnd)) && this.content.is(FluidTags.WATER)) { // Purpur
+                 int i = blockposition.getX();
+                 int j = blockposition.getY();
+                 int k = blockposition.getZ();
+@@ -174,7 +174,7 @@ public class BucketItem extends Item implements DispensibleContainerItem {
+                 world.playSound(entityhuman, blockposition, SoundEvents.FIRE_EXTINGUISH, SoundSource.BLOCKS, 0.5F, 2.6F + (world.random.nextFloat() - world.random.nextFloat()) * 0.8F);
+ 
+                 for (int l = 0; l < 8; ++l) {
+-                    world.addParticle(ParticleTypes.LARGE_SMOKE, (double) i + Math.random(), (double) j + Math.random(), (double) k + Math.random(), 0.0D, 0.0D, 0.0D);
+                    ((ServerLevel) world).sendParticles(null, ParticleTypes.LARGE_SMOKE, (double) i + Math.random(), (double) j + Math.random(), (double) k + Math.random(), 1, 0.0D, 0.0D, 0.0D, 0.0D, true); // Purpur
+                 }
+ 
+                 return true;
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 46ed6eeee93c6dc45a43229294d1d161aac5ed24..a0b5ecc76144d3f8291e85ea9b76b9f8bf849f5d 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1615,4 +1615,14 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         return null;
+     }
+     // Paper end
+
+    // Purpur start
+    public boolean isNether() {
+        return getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER;
+    }
+
+    public boolean isTheEnd() {
+        return getWorld().getEnvironment() == org.bukkit.World.Environment.THE_END;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/IceBlock.java b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+index 2676cddca511ea775766cec0001269407599df6e..1dacd2e3a9340420c9b4443cc2f8a3c6e889e18e 100644
+--- a/src/main/java/net/minecraft/world/level/block/IceBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+@@ -26,7 +26,7 @@ public class IceBlock extends HalfTransparentBlock {
+     public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack stack) {
+         super.playerDestroy(world, player, pos, state, blockEntity, stack);
+         if (EnchantmentHelper.getItemEnchantmentLevel(Enchantments.SILK_TOUCH, stack) == 0) {
+-            if (world.dimensionType().ultraWarm()) {
+            if (world.isNether() || (world.isTheEnd() && !org.purpurmc.purpur.PurpurConfig.allowWaterPlacementInTheEnd)) { // Purpur
+                 world.removeBlock(pos, false);
+                 return;
+             }
+@@ -54,7 +54,7 @@ public class IceBlock extends HalfTransparentBlock {
+             return;
+         }
+         // CraftBukkit end
+-        if (world.dimensionType().ultraWarm()) {
+        if (world.isNether() || (world.isTheEnd() && !org.purpurmc.purpur.PurpurConfig.allowWaterPlacementInTheEnd)) { // Purpur
+             world.removeBlock(pos, false);
+         } else {
+             world.setBlockAndUpdate(pos, Blocks.WATER.defaultBlockState());
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index e49c2c16f6130eb1343d49d5a3972f505155aba2..e63ae0cd672f162566c8edad0b2376cab907898a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -237,6 +237,11 @@ public class PurpurConfig {
+         enderChestPermissionRows = getBoolean("settings.blocks.ender_chest.use-permissions-for-rows", enderChestPermissionRows);
+     }
+ 
+    public static boolean allowWaterPlacementInTheEnd = true;
+    private static void allowWaterPlacementInEnd() {
+        allowWaterPlacementInTheEnd = getBoolean("settings.allow-water-placement-in-the-end", allowWaterPlacementInTheEnd);
+    }
+
+     public static boolean loggerSuppressInitLegacyMaterialError = false;
+     public static boolean loggerSuppressIgnoredAdvancementWarnings = false;
+     public static boolean loggerSuppressUnrecognizedRecipeErrors = false;
--- a/patches/unapplied/0078-Allow-color-codes-in-books.patch
+++ b/patches/unapplied/0078-Allow-color-codes-in-books.patch
@@ -0,0 +1,76 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Tue, 3 Nov 2020 01:25:06 -0600
+Subject: [PATCH] Allow color codes in books
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 1c380b6954edb6806a1b3bfc66e1b6a19c0fd219..bab75482e1be354f66ef34144d15e628fb118309 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1241,13 +1241,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+                 itemstack1.setTag(nbttagcompound.copy());
+             }
+ 
+            // Purpur start
+            boolean hasPerm = getCraftPlayer().hasPermission("purpur.book.color.edit") || getCraftPlayer().hasPermission("purpur.book.color.sign"); // Purpur
+             itemstack1.addTagElement("author", StringTag.valueOf(this.player.getName().getString()));
+             if (this.player.isTextFilteringEnabled()) {
+-                itemstack1.addTagElement("title", StringTag.valueOf(title.getFiltered()));
+                itemstack1.addTagElement("title", StringTag.valueOf(color(title.getFiltered(), hasPerm)));
+             } else {
+-                itemstack1.addTagElement("filtered_title", StringTag.valueOf(title.getFiltered()));
+-                itemstack1.addTagElement("title", StringTag.valueOf(title.getRaw()));
+                itemstack1.addTagElement("filtered_title", StringTag.valueOf(color(title.getFiltered(), hasPerm)));
+                itemstack1.addTagElement("title", StringTag.valueOf(color(title.getRaw(), hasPerm)));
+             }
+            // Purpur end
+ 
+             this.updateBookPages(pages, (s) -> {
+                 return Component.Serializer.toJson(new TextComponent(s));
+@@ -1259,10 +1262,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+     private void updateBookPages(List<TextFilter.FilteredText> list, UnaryOperator<String> unaryoperator, ItemStack itemstack, int slot, ItemStack handItem) { // CraftBukkit
+         ListTag nbttaglist = new ListTag();
+ 
+        // Purpur start
+        boolean hasPerm = getCraftPlayer().hasPermission("purpur.book.color.edit");
+         if (this.player.isTextFilteringEnabled()) {
+-            Stream<StringTag> stream = list.stream().map((itextfilter_a) -> { // CraftBukkit - decompile error
+-                return StringTag.valueOf((String) unaryoperator.apply(itextfilter_a.getFiltered()));
+            Stream<StringTag> stream = list.stream().map(s -> color(s.getFiltered(), hasPerm, false)).map((s) -> { // CraftBukkit - decompile error
+                return StringTag.valueOf((String) unaryoperator.apply(s));
+             });
+            // Purpur end
+ 
+             Objects.requireNonNull(nbttaglist);
+             stream.forEach(nbttaglist::add);
+@@ -1272,10 +1278,10 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+ 
+             for (int j = list.size(); i < j; ++i) {
+                 TextFilter.FilteredText itextfilter_a = (TextFilter.FilteredText) list.get(i);
+-                String s = itextfilter_a.getRaw();
+                String s = color(itextfilter_a.getRaw(), hasPerm, false);
+ 
+                 nbttaglist.add(StringTag.valueOf((String) unaryoperator.apply(s)));
+-                String s1 = itextfilter_a.getFiltered();
+                String s1 = color(itextfilter_a.getFiltered(), hasPerm, false);
+ 
+                 if (!s.equals(s1)) {
+                     nbttagcompound.putString(String.valueOf(i), (String) unaryoperator.apply(s1));
+@@ -1291,6 +1297,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+         this.player.getInventory().setItem(slot, CraftEventFactory.handleEditBookEvent(player, slot, handItem, itemstack)); // CraftBukkit // Paper - Don't ignore result (see other callsite for handleEditBookEvent)
+     }
+ 
+    // Purpur start
+    private String color(String str, boolean hasPerm) {
+        return color(str, hasPerm, true);
+    }
+
+    private String color(String str, boolean hasPerm, boolean parseHex) {
+        return hasPerm ? org.bukkit.ChatColor.color(str, parseHex) : str;
+    }
+    // Purpur end
+
+     @Override
+     public void handleEntityTagQuery(ServerboundEntityTagQuery packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
--- a/patches/unapplied/0079-Entity-lifespan.patch
+++ b/patches/unapplied/0079-Entity-lifespan.patch
@@ -0,0 +1,112 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 11 Jul 2020 19:41:34 -0500
+Subject: [PATCH] Entity lifespan
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index bab75482e1be354f66ef34144d15e628fb118309..0a7d748e0279a1fd7bb97051732ea1843510087b 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2531,6 +2531,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+             double d0 = 36.0D;
+ 
+             if (this.player.distanceToSqr(entity) < 36.0D) {
+                if (entity instanceof Mob mob) mob.ticksSinceLastInteraction = 0; // Purpur
+                 packet.dispatch(new ServerboundInteractPacket.Handler() {
+                     private void performInteraction(InteractionHand enumhand, ServerGamePacketListenerImpl.EntityInteraction playerconnection_a, PlayerInteractEntityEvent event) { // CraftBukkit
+                         ItemStack itemstack = ServerGamePacketListenerImpl.this.player.getItemInHand(enumhand).copy();
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index e1a13fadcf83e84c89a1bfc6d4e4f13f2299ffa5..8f53dd70d815493148709fbdff29a85924d12d00 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -129,6 +129,7 @@ public abstract class Mob extends LivingEntity {
+     private BlockPos restrictCenter;
+     private float restrictRadius;
+ 
+    public int ticksSinceLastInteraction; // Purpur
+     public boolean aware = true; // CraftBukkit
+ 
+     protected Mob(EntityType<? extends Mob> type, Level world) {
+@@ -285,6 +286,7 @@ public abstract class Mob extends LivingEntity {
+                 entityliving = null;
+             }
+         }
+        if (entityliving instanceof ServerPlayer) this.ticksSinceLastInteraction = 0; // Purpur
+         this.target = entityliving;
+         return true;
+         // CraftBukkit end
+@@ -329,9 +331,29 @@ public abstract class Mob extends LivingEntity {
+             this.playAmbientSound();
+         }
+ 
+        incrementTicksSinceLastInteraction(); // Purpur
+         this.level.getProfiler().pop();
+     }
+ 
+    // Purpur start
+    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();
+        }
+    }
+    // Purpur end
+
+     @Override
+     protected void playHurtSound(DamageSource source) {
+         this.resetAmbientSoundTime();
+@@ -515,6 +537,7 @@ public abstract class Mob extends LivingEntity {
+         }
+ 
+         nbt.putBoolean("Bukkit.Aware", this.aware); // CraftBukkit
+        nbt.putInt("Purpur.ticksSinceLastInteraction", this.ticksSinceLastInteraction); // Purpur
+     }
+ 
+     @Override
+@@ -585,6 +608,11 @@ public abstract class Mob extends LivingEntity {
+             this.aware = nbt.getBoolean("Bukkit.Aware");
+         }
+         // CraftBukkit end
+        // Purpur start
+        if (nbt.contains("Purpur.ticksSinceLastInteraction")) {
+            this.ticksSinceLastInteraction = nbt.getInt("Purpur.ticksSinceLastInteraction");
+        }
+        // Purpur end
+     }
+ 
+     @Override
+@@ -1614,6 +1642,7 @@ public abstract class Mob extends LivingEntity {
+             this.setLastHurtMob(target);
+         }
+ 
+        if (target instanceof ServerPlayer) this.ticksSinceLastInteraction = 0; // Purpur
+         return flag;
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d6f6cf7e17d9cd5b1398aab8e2b9b6df75fea02e..d25af1733601d26b6d2173837a0a5948ae01a6d4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -124,6 +124,11 @@ public class PurpurWorldConfig {
+         elytraDamagePerTridentBoost = getInt("gameplay-mechanics.elytra.damage-per-boost.trident", elytraDamagePerTridentBoost);
+     }
+ 
+    public int entityLifeSpan = 0;
+    private void entitySettings() {
+        entityLifeSpan = getInt("gameplay-mechanics.entity-lifespan", entityLifeSpan);
+    }
+
+     public List<Item> itemImmuneToCactus = new ArrayList<>();
+     public List<Item> itemImmuneToExplosion = new ArrayList<>();
+     public List<Item> itemImmuneToFire = new ArrayList<>();
--- a/patches/unapplied/0080-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch
+++ b/patches/unapplied/0080-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch
@@ -0,0 +1,77 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Mon, 13 Jul 2020 11:40:00 -0500
+Subject: [PATCH] Add option to teleport to spawn if outside world border
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 5fa846764b2d253a68efd83ca3ef53ae5bac8d43..aa7cb900de2d3a1c3f420da9ce7c5dba314f653f 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -2545,4 +2545,26 @@ public class ServerPlayer extends Player {
+     // CraftBukkit end
+ 
+     public final int getViewDistance() { throw new UnsupportedOperationException("Use PlayerChunkLoader"); } // Paper - placeholder
+
+    // Purpur start
+    public void teleport(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 = ((CraftWorld) to.getWorld()).getHandle();
+        if (this.level == toLevel) {
+            this.connection.teleport(to);
+        } else {
+            this.server.getPlayerList().respawn(this, toLevel, true, to, !toLevel.paperConfig.disableTeleportationSuffocationCheck);
+        }
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 68de664f6d8eee93b963425969c278edde326757..a358f68c893e95013a21aecd83d44fcab26e30e4 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -45,6 +45,7 @@ import net.minecraft.network.syncher.EntityDataAccessor;
+ import net.minecraft.network.syncher.EntityDataSerializers;
+ import net.minecraft.network.syncher.SynchedEntityData;
+ import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MCUtil;
+ import net.minecraft.server.level.ServerChunkCache;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+@@ -409,6 +410,7 @@ public abstract class LivingEntity extends Entity {
+                     double d1 = this.level.getWorldBorder().getDamagePerBlock();
+ 
+                     if (d1 > 0.0D) {
+                        if (level.purpurConfig.teleportIfOutsideBorder && this instanceof ServerPlayer) { ((ServerPlayer) this).teleport(MCUtil.toLocation(level, ((ServerLevel) level).getSharedSpawnPos())); return; } // Purpur
+                         this.hurt(DamageSource.IN_WALL, (float) Math.max(1, Mth.floor(-d0 * d1)));
+                     }
+                 }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d25af1733601d26b6d2173837a0a5948ae01a6d4..a9a3f13a64cd7d9152f65285a5f5f48f5a31b7a3 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -243,6 +243,7 @@ public class PurpurWorldConfig {
+     public boolean playerInvulnerableWhileAcceptingResourcePack = false;
+     public String playerDeathExpDropEquation = "expLevel * 7";
+     public int playerDeathExpDropMax = 100;
+    public boolean teleportIfOutsideBorder = false;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -258,6 +259,7 @@ public class PurpurWorldConfig {
+         playerInvulnerableWhileAcceptingResourcePack = getBoolean("gameplay-mechanics.player.invulnerable-while-accepting-resource-pack", playerInvulnerableWhileAcceptingResourcePack);
+         playerDeathExpDropEquation = getString("gameplay-mechanics.player.exp-dropped-on-death.equation", playerDeathExpDropEquation);
+         playerDeathExpDropMax = getInt("gameplay-mechanics.player.exp-dropped-on-death.maximum", playerDeathExpDropMax);
+        teleportIfOutsideBorder = getBoolean("gameplay-mechanics.player.teleport-if-outside-border", teleportIfOutsideBorder);
+     }
+ 
+     public boolean silkTouchEnabled = false;
--- a/patches/unapplied/0081-Squid-EAR-immunity.patch
+++ b/patches/unapplied/0081-Squid-EAR-immunity.patch
@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Mon, 13 Jul 2020 13:49:41 -0500
+Subject: [PATCH] Squid EAR immunity
+
+
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a9a3f13a64cd7d9152f65285a5f5f48f5a31b7a3..e480e61419a9b83e98fcd0ba8a949c20a241c949 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1410,6 +1410,7 @@ public class PurpurWorldConfig {
+     public boolean squidRidable = false;
+     public boolean squidControllable = true;
+     public double squidMaxHealth = 10.0D;
+    public boolean squidImmuneToEAR = true;
+     private void squidSettings() {
+         squidRidable = getBoolean("mobs.squid.ridable", squidRidable);
+         squidControllable = getBoolean("mobs.squid.controllable", squidControllable);
+@@ -1419,6 +1420,7 @@ public class PurpurWorldConfig {
+             set("mobs.squid.attributes.max_health", oldValue);
+         }
+         squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth);
+        squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR);
+     }
+ 
+     public boolean spiderRidable = false;
+diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
+index 06467a5af27a9afeba383c4f9704f5106827af97..3b67e9a9e0a0dc8ca19ea7b20c676fae3cf64a11 100644
+--- a/src/main/java/org/spigotmc/ActivationRange.java
+++ b/src/main/java/org/spigotmc/ActivationRange.java
+@@ -15,6 +15,7 @@ import net.minecraft.world.entity.ambient.AmbientCreature;
+ import net.minecraft.world.entity.animal.Animal;
+ import net.minecraft.world.entity.animal.Bee;
+ import net.minecraft.world.entity.animal.Sheep;
+import net.minecraft.world.entity.animal.Squid;
+ import net.minecraft.world.entity.animal.WaterAnimal;
+ import net.minecraft.world.entity.animal.horse.Llama;
+ import net.minecraft.world.entity.boss.EnderDragonPart;
+@@ -391,6 +392,7 @@ public class ActivationRange
+      */
+     public static boolean checkIfActive(Entity entity)
+     {
+        if (entity.level.purpurConfig.squidImmuneToEAR && entity instanceof Squid) return true; // Purpur
+         // Never safe to skip fireworks or entities not yet added to chunk
+         if ( entity instanceof FireworkRocketEntity ) {
+             return true;
--- a/patches/unapplied/0082-Phantoms-burn-in-light.patch
+++ b/patches/unapplied/0082-Phantoms-burn-in-light.patch
@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: draycia <lonelyyordle@gmail.com>
+Date: Sun, 12 Apr 2020 20:41:59 -0700
+Subject: [PATCH] Phantoms burn in light
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+index 843c5bdc58a09aadab8d90f254e61a5cebe6388f..e5305246287739232d6b7873a17884bffdf03514 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+@@ -50,6 +50,7 @@ public class Phantom extends FlyingMob implements Enemy {
+     BlockPos anchorPoint;
+     Phantom.AttackPhase attackPhase;
+     Vec3 crystalPosition; // Purpur
+    private static final net.minecraft.world.item.crafting.Ingredient TORCH = net.minecraft.world.item.crafting.Ingredient.of(net.minecraft.world.item.Items.TORCH, net.minecraft.world.item.Items.SOUL_TORCH); // Purpur
+ 
+     public Phantom(EntityType<? extends Phantom> type, Level world) {
+         super(type, world);
+@@ -247,8 +248,12 @@ public class Phantom extends FlyingMob implements Enemy {
+ 
+     @Override
+     public void aiStep() {
+-        if (this.isAlive() && shouldBurnInDay && this.isSunBurnTick()) { // Paper - Configurable Burning
+-            if (getRider() == null || !this.isControllable()) // Purpur
+        // Purpur start
+        boolean burnFromDaylight = this.shouldBurnInDay && this.level.purpurConfig.phantomBurnInDaylight;
+        boolean burnFromLightSource = this.level.purpurConfig.phantomBurnInLight > 0 && this.level.getMaxLocalRawBrightness(blockPosition()) >= this.level.purpurConfig.phantomBurnInLight;
+        if (this.isAlive() && (burnFromDaylight || burnFromLightSource)) { // Paper - Configurable Burning
+            if (getRider() == null || !this.isControllable())
+            // Purpur end
+             this.setSecondsOnFire(8);
+         }
+ 
+@@ -652,6 +657,12 @@ public class Phantom extends FlyingMob implements Enemy {
+                 return false;
+             } else if (!entityliving.isAlive()) {
+                 return false;
+            // Purpur start
+            } else if (level.purpurConfig.phantomBurnInLight > 0 && level.getLightEmission(new BlockPos(Phantom.this)) >= level.purpurConfig.phantomBurnInLight) {
+                return false;
+            } else if (level.purpurConfig.phantomIgnorePlayersWithTorch && (TORCH.test(entityliving.getItemInHand(net.minecraft.world.InteractionHand.MAIN_HAND)) || TORCH.test(entityliving.getItemInHand(net.minecraft.world.InteractionHand.OFF_HAND)))) {
+                return false;
+            // Purpur end
+             } else {
+                 if (entityliving instanceof Player) {
+                     Player entityhuman = (Player) entityliving;
+@@ -797,6 +808,7 @@ public class Phantom extends FlyingMob implements Enemy {
+                 this.nextScanTick = reducedTickDelay(60);
+                 List<Player> list = Phantom.this.level.getNearbyPlayers(this.attackTargeting, Phantom.this, Phantom.this.getBoundingBox().inflate(16.0D, 64.0D, 16.0D));
+ 
+                if (level.purpurConfig.phantomIgnorePlayersWithTorch) list.removeIf(human -> TORCH.test(human.getItemInHand(net.minecraft.world.InteractionHand.MAIN_HAND)) || TORCH.test(human.getItemInHand(net.minecraft.world.InteractionHand.OFF_HAND)));// Purpur
+                 if (!list.isEmpty()) {
+                     list.sort(Comparator.comparing((Entity e) -> { return e.getY(); }).reversed()); // CraftBukkit - decompile error
+                     Iterator iterator = list.iterator();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index e480e61419a9b83e98fcd0ba8a949c20a241c949..249368f0808871eafa8b3dfd48f631a8d55a74f0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1085,6 +1085,9 @@ public class PurpurWorldConfig {
+     public int phantomSpawnOverheadRadius = 10;
+     public int phantomSpawnMinPerAttempt = 1;
+     public int phantomSpawnMaxPerAttempt = -1;
+    public int phantomBurnInLight = 0;
+    public boolean phantomIgnorePlayersWithTorch = false;
+    public boolean phantomBurnInDaylight = true;
+     private void phantomSettings() {
+         phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable);
+         phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater);
+@@ -1121,6 +1124,9 @@ public class PurpurWorldConfig {
+         phantomSpawnOverheadRadius = getInt("mobs.phantom.spawn.overhead.radius", phantomSpawnOverheadRadius);
+         phantomSpawnMinPerAttempt = getInt("mobs.phantom.spawn.per-attempt.min", phantomSpawnMinPerAttempt);
+         phantomSpawnMaxPerAttempt = getInt("mobs.phantom.spawn.per-attempt.max", phantomSpawnMaxPerAttempt);
+        phantomBurnInLight = getInt("mobs.phantom.burn-in-light", phantomBurnInLight);
+        phantomBurnInDaylight = getBoolean("mobs.phantom.burn-in-daylight", phantomBurnInDaylight);
+        phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch);
+     }
+ 
+     public boolean pigRidable = false;
--- a/patches/unapplied/0083-Configurable-villager-breeding.patch
+++ b/patches/unapplied/0083-Configurable-villager-breeding.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: draycia <lonelyyordle@gmail.com>
+Date: Tue, 31 Mar 2020 23:48:55 -0700
+Subject: [PATCH] Configurable villager breeding
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 2c99eda984bd147e5ce7d32dd11b818d8b8561aa..094fd4289bc42df6af6740acacd4f51ab6b668e0 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -774,7 +774,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     public boolean canBreed() {
+-        return this.foodLevel + this.countFoodPointsInInventory() >= 12 && this.getAge() == 0;
+        return level.purpurConfig.villagerCanBreed && this.foodLevel + this.countFoodPointsInInventory() >= 12 && this.getAge() == 0;
+     }
+ 
+     private boolean hungry() {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 249368f0808871eafa8b3dfd48f631a8d55a74f0..2784edf4fb34f90e46ca693427e8861e15fb97bc 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1563,6 +1563,7 @@ public class PurpurWorldConfig {
+     public boolean villagerCanBeLeashed = false;
+     public int villagerSpawnIronGolemRadius = 0;
+     public int villagerSpawnIronGolemLimit = 0;
+    public boolean villagerCanBreed = true;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1579,6 +1580,7 @@ public class PurpurWorldConfig {
+         villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+         villagerSpawnIronGolemRadius = getInt("mobs.villager.spawn-iron-golem.radius", villagerSpawnIronGolemRadius);
+         villagerSpawnIronGolemLimit = getInt("mobs.villager.spawn-iron-golem.limit", villagerSpawnIronGolemLimit);
+        villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed);
+     }
+ 
+     public boolean vindicatorRidable = false;
--- a/patches/unapplied/0084-Redstone-deactivates-spawners.patch
+++ b/patches/unapplied/0084-Redstone-deactivates-spawners.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: draycia <lonelyyordle@gmail.com>
+Date: Tue, 14 Apr 2020 00:35:12 -0700
+Subject: [PATCH] Redstone deactivates spawners
+
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 03726227fdd60e9cf77213d50184abff438e01ef..76979991d2ded84161e8a0fc72cbb2d2c3c6c55e 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -52,6 +52,7 @@ public abstract class BaseSpawner {
+     }
+ 
+     public boolean isNearPlayer(Level world, BlockPos pos) {
+        if (world.purpurConfig.spawnerDeactivateByRedstone && world.hasNeighborSignal(pos)) return false; // Purpur
+         return world.isAffectsSpawningPlayerNearby((double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, (double) this.requiredPlayerRange); // Paper
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ce4d44d130ee3ed5b6925090ffa2b2d8da9c221b..4e7edce9874038b375a92a4e01d9233ecc7a10c1 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -352,6 +352,11 @@ public class PurpurWorldConfig {
+         signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
+     }
+ 
+    public boolean spawnerDeactivateByRedstone = false;
+    private void spawnerSettings() {
+        spawnerDeactivateByRedstone = getBoolean("blocks.spawner.deactivate-by-redstone", spawnerDeactivateByRedstone);
+    }
+
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;
--- a/patches/unapplied/0085-Totems-work-in-inventory.patch
+++ b/patches/unapplied/0085-Totems-work-in-inventory.patch
@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: draycia <lonelyyordle@gmail.com>
+Date: Wed, 29 Apr 2020 00:45:58 -0700
+Subject: [PATCH] Totems work in inventory
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index ccecf12fa8c5a498f8a7ced421e1084c8f04c194..e39d333c10d74be81da173622b5e033bfde9cf3a 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1521,6 +1521,19 @@ public abstract class LivingEntity extends Entity {
+                 }
+             }
+ 
+            // Purpur start
+            if (level.purpurConfig.totemOfUndyingWorksInInventory && this instanceof ServerPlayer && (itemstack == null || itemstack.getItem() != Items.TOTEM_OF_UNDYING)) {
+                ServerPlayer player = (ServerPlayer) this;
+                for (ItemStack item : player.getInventory().items) {
+                    if (item.getItem() == Items.TOTEM_OF_UNDYING) {
+                        itemstack1 = item;
+                        itemstack = item.cloneItemStack(false);
+                        break;
+                    }
+                }
+            }
+            // Purpur end
+
+             EntityResurrectEvent event = new EntityResurrectEvent((org.bukkit.entity.LivingEntity) this.getBukkitEntity());
+             event.setCancelled(itemstack == null);
+             this.level.getCraftServer().getPluginManager().callEvent(event);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 32035757b505e32a09f887e7cf0943764e38c63b..7159461ec4b4563d3fd15c12f7900b70f643592f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -244,6 +244,7 @@ public class PurpurWorldConfig {
+     public String playerDeathExpDropEquation = "expLevel * 7";
+     public int playerDeathExpDropMax = 100;
+     public boolean teleportIfOutsideBorder = false;
+    public boolean totemOfUndyingWorksInInventory = false;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -260,6 +261,7 @@ public class PurpurWorldConfig {
+         playerDeathExpDropEquation = getString("gameplay-mechanics.player.exp-dropped-on-death.equation", playerDeathExpDropEquation);
+         playerDeathExpDropMax = getInt("gameplay-mechanics.player.exp-dropped-on-death.maximum", playerDeathExpDropMax);
+         teleportIfOutsideBorder = getBoolean("gameplay-mechanics.player.teleport-if-outside-border", teleportIfOutsideBorder);
+        totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+     }
+ 
+     public boolean silkTouchEnabled = false;
--- a/patches/unapplied/0086-Add-vindicator-johnny-spawn-chance.patch
+++ b/patches/unapplied/0086-Add-vindicator-johnny-spawn-chance.patch
@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Jul 2020 19:38:21 -0500
+Subject: [PATCH] Add vindicator johnny spawn chance
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
+index ff62f5ed29a826c4dd53eb6fe04f5aa27de62619..acd4e282841708d7ef0145757899e355a6410a4a 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
+@@ -7,6 +7,7 @@ import java.util.function.Predicate;
+ import javax.annotation.Nullable;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.sounds.SoundEvent;
+ import net.minecraft.sounds.SoundEvents;
+@@ -151,6 +152,12 @@ public class Vindicator extends AbstractIllager {
+         ((GroundPathNavigation) this.getNavigation()).setCanOpenDoors(true);
+         this.populateDefaultEquipmentSlots(difficulty);
+         this.populateDefaultEquipmentEnchantments(difficulty);
+        // Purpur start
+        Level level = world.getMinecraftWorld();
+        if (level.purpurConfig.vindicatorJohnnySpawnChance > 0D && random.nextDouble() <= level.purpurConfig.vindicatorJohnnySpawnChance) {
+            setCustomName(new TranslatableComponent("Johnny"));
+        }
+        // Purpur end
+         return groupdataentity1;
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7159461ec4b4563d3fd15c12f7900b70f643592f..48f8f0447d4612c15b3a9c53b74c593a608bc352 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1594,6 +1594,7 @@ public class PurpurWorldConfig {
+     public boolean vindicatorRidableInWater = false;
+     public boolean vindicatorControllable = true;
+     public double vindicatorMaxHealth = 24.0D;
+    public double vindicatorJohnnySpawnChance = 0D;
+     private void vindicatorSettings() {
+         vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable);
+         vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater);
+@@ -1604,6 +1605,7 @@ public class PurpurWorldConfig {
+             set("mobs.vindicator.attributes.max_health", oldValue);
+         }
+         vindicatorMaxHealth = getDouble("mobs.vindicator.attributes.max_health", vindicatorMaxHealth);
+        vindicatorJohnnySpawnChance = getDouble("mobs.vindicator.johnny.spawn-chance", vindicatorJohnnySpawnChance);
+     }
+ 
+     public boolean wanderingTraderRidable = false;
--- a/patches/unapplied/0087-Add-option-to-disable-certain-block-updates.patch
+++ b/patches/unapplied/0087-Add-option-to-disable-certain-block-updates.patch
@@ -0,0 +1,146 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 4 Aug 2020 17:11:58 -0500
+Subject: [PATCH] Add option to disable certain block updates
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java b/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+index 2c29c125edac43cdf13da8eababe60fb7a87df15..28c84432d0125dad414e623a317f665bdf7f438f 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+@@ -21,6 +21,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (org.purpurmc.purpur.PurpurConfig.disableChorusPlantUpdates) return this.defaultBlockState(); // Purpur
+         return this.getStateForPlacement(ctx.getLevel(), ctx.getClickedPos());
+     }
+ 
+@@ -36,6 +37,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (org.purpurmc.purpur.PurpurConfig.disableChorusPlantUpdates) return state; // Purpur
+         if (!state.canSurvive(world, pos)) {
+             world.scheduleTick(pos, this, 1);
+             return super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+diff --git a/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java b/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+index 3c6d97b51c6fec130b80e5965afa2c49d48843c9..b456cb8efd8f0be8a6860c82462ce9bdde3a8383 100644
+--- a/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+@@ -22,29 +22,65 @@ public class HugeMushroomBlock extends Block {
+ 
+     public HugeMushroomBlock(BlockBehaviour.Properties settings) {
+         super(settings);
+-        this.registerDefaultState(this.stateDefinition.any().setValue(NORTH, Boolean.valueOf(true)).setValue(EAST, Boolean.valueOf(true)).setValue(SOUTH, Boolean.valueOf(true)).setValue(WEST, Boolean.valueOf(true)).setValue(UP, Boolean.valueOf(true)).setValue(DOWN, Boolean.valueOf(true)));
+        // Purpur start
+        this.registerDefaultState(this.stateDefinition.any()
+                .setValue(NORTH, true)
+                .setValue(EAST, true)
+                .setValue(SOUTH, true)
+                .setValue(WEST, true)
+                .setValue(UP, true)
+                .setValue(DOWN, true));
+        // Purpur end
+     }
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (org.purpurmc.purpur.PurpurConfig.disableMushroomBlockUpdates) return this.defaultBlockState(); // Purpur
+         BlockGetter blockGetter = ctx.getLevel();
+         BlockPos blockPos = ctx.getClickedPos();
+-        return this.defaultBlockState().setValue(DOWN, Boolean.valueOf(!blockGetter.getBlockState(blockPos.below()).is(this))).setValue(UP, Boolean.valueOf(!blockGetter.getBlockState(blockPos.above()).is(this))).setValue(NORTH, Boolean.valueOf(!blockGetter.getBlockState(blockPos.north()).is(this))).setValue(EAST, Boolean.valueOf(!blockGetter.getBlockState(blockPos.east()).is(this))).setValue(SOUTH, Boolean.valueOf(!blockGetter.getBlockState(blockPos.south()).is(this))).setValue(WEST, Boolean.valueOf(!blockGetter.getBlockState(blockPos.west()).is(this)));
+        // Purpur start
+        return this.defaultBlockState()
+                .setValue(DOWN, this != blockGetter.getBlockStateIfLoaded(blockPos.below()).getBlock())
+                .setValue(UP, this != blockGetter.getBlockStateIfLoaded(blockPos.above()).getBlock())
+                .setValue(NORTH, this != blockGetter.getBlockStateIfLoaded(blockPos.north()).getBlock())
+                .setValue(EAST, this != blockGetter.getBlockStateIfLoaded(blockPos.east()).getBlock())
+                .setValue(SOUTH, this != blockGetter.getBlockStateIfLoaded(blockPos.south()).getBlock())
+                .setValue(WEST, this != blockGetter.getBlockStateIfLoaded(blockPos.west()).getBlock());
+        // Purpur end
+     }
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (org.purpurmc.purpur.PurpurConfig.disableMushroomBlockUpdates) return state; // Purpur
+         return neighborState.is(this) ? state.setValue(PROPERTY_BY_DIRECTION.get(direction), Boolean.valueOf(false)) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+     }
+ 
+     @Override
+     public BlockState rotate(BlockState state, Rotation rotation) {
+-        return state.setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.NORTH)), state.getValue(NORTH)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.SOUTH)), state.getValue(SOUTH)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.EAST)), state.getValue(EAST)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.WEST)), state.getValue(WEST)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.UP)), state.getValue(UP)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.DOWN)), state.getValue(DOWN));
+        // Purpur start
+        if (org.purpurmc.purpur.PurpurConfig.disableMushroomBlockUpdates) return state;
+        return state
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.NORTH)), state.getValue(NORTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.SOUTH)), state.getValue(SOUTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.EAST)), state.getValue(EAST))
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.WEST)), state.getValue(NORTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.UP)), state.getValue(UP))
+                .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.DOWN)), state.getValue(DOWN));
+        // Purpur end
+     }
+ 
+     @Override
+     public BlockState mirror(BlockState state, Mirror mirror) {
+-        return state.setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.NORTH)), state.getValue(NORTH)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.SOUTH)), state.getValue(SOUTH)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.EAST)), state.getValue(EAST)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.WEST)), state.getValue(WEST)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.UP)), state.getValue(UP)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.DOWN)), state.getValue(DOWN));
+        // Purpur start
+        if (org.purpurmc.purpur.PurpurConfig.disableMushroomBlockUpdates) return state;
+        return state
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.NORTH)), state.getValue(NORTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.SOUTH)), state.getValue(SOUTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.EAST)), state.getValue(EAST))
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.WEST)), state.getValue(NORTH))
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.UP)), state.getValue(UP))
+                .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.DOWN)), state.getValue(DOWN));
+        // Purpur end
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/NoteBlock.java b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+index 0e106bcc1f882877a5e444a2621466c6e4696d42..3992a8dc75ece5f32acde7e229ca1ab5c6bdf70f 100644
+--- a/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+@@ -34,11 +34,13 @@ public class NoteBlock extends Block {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (org.purpurmc.purpur.PurpurConfig.disableNoteBlockUpdates) return this.defaultBlockState(); // Purpur
+         return (BlockState) this.defaultBlockState().setValue(NoteBlock.INSTRUMENT, NoteBlockInstrument.byState(ctx.getLevel().getBlockState(ctx.getClickedPos().below())));
+     }
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (org.purpurmc.purpur.PurpurConfig.disableNoteBlockUpdates) return state; // Purpur
+         return direction == Direction.DOWN ? (BlockState) state.setValue(NoteBlock.INSTRUMENT, NoteBlockInstrument.byState(neighborState)) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+     }
+ 
+@@ -52,6 +54,7 @@ public class NoteBlock extends Block {
+                 state = world.getBlockState(pos); // CraftBukkit - SPIGOT-5617: update in case changed in event
+             }
+ 
+            if (!org.purpurmc.purpur.PurpurConfig.disableNoteBlockUpdates) // Purpur
+             world.setBlock(pos, (BlockState) state.setValue(NoteBlock.POWERED, flag1), 3);
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index e63ae0cd672f162566c8edad0b2376cab907898a..190e738ad33ca98aebda0d7b43dfdef8d7bea0cc 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -242,6 +242,15 @@ public class PurpurConfig {
+         allowWaterPlacementInTheEnd = getBoolean("settings.allow-water-placement-in-the-end", allowWaterPlacementInTheEnd);
+     }
+ 
+    public static boolean disableMushroomBlockUpdates = false;
+    public static boolean disableNoteBlockUpdates = false;
+    public static boolean disableChorusPlantUpdates = false;
+    private static void blockUpdatesSettings() {
+        disableMushroomBlockUpdates = getBoolean("settings.blocks.disable-mushroom-updates", disableMushroomBlockUpdates);
+        disableNoteBlockUpdates = getBoolean("settings.blocks.disable-note-block-updates", disableNoteBlockUpdates);
+        disableChorusPlantUpdates = getBoolean("settings.blocks.disable-chorus-plant-updates", disableChorusPlantUpdates);
+    }
+
+     public static boolean loggerSuppressInitLegacyMaterialError = false;
+     public static boolean loggerSuppressIgnoredAdvancementWarnings = false;
+     public static boolean loggerSuppressUnrecognizedRecipeErrors = false;
--- a/patches/unapplied/0088-Dispensers-place-anvils-option.patch
+++ b/patches/unapplied/0088-Dispensers-place-anvils-option.patch
@@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 4 Aug 2020 21:11:03 -0500
+Subject: [PATCH] Dispensers place anvils option
+
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index 4b151444f8d7ed26dc87c9ae55fa8a14a8d84ed7..93f7c056085bbc269ebc764c99fef1a3d2d96d49 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -50,6 +50,7 @@ import net.minecraft.world.item.SpawnEggItem;
+ import net.minecraft.world.item.alchemy.PotionUtils;
+ import net.minecraft.world.item.alchemy.Potions;
+ import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.AnvilBlock;
+ import net.minecraft.world.level.block.BaseFireBlock;
+ import net.minecraft.world.level.block.BeehiveBlock;
+ import net.minecraft.world.level.block.Block;
+@@ -1106,6 +1107,23 @@ public interface DispenseItemBehavior {
+                 }
+             }
+         });
+        // Purpur start
+        DispenserBlock.registerBehavior(Items.ANVIL, (new OptionalDispenseItemBehavior() {
+            @Override
+            public ItemStack execute(BlockSource dispenser, ItemStack stack) {
+                Level level = dispenser.getLevel();
+                if (!level.purpurConfig.dispenserPlaceAnvils) return super.execute(dispenser, stack);
+                Direction facing = dispenser.getBlockState().getValue(DispenserBlock.FACING);
+                BlockPos pos = dispenser.getPos().relative(facing);
+                BlockState state = level.getBlockState(pos);
+                if (state.isAir()) {
+                    level.setBlockAndUpdate(pos, Blocks.ANVIL.defaultBlockState().setValue(AnvilBlock.FACING, facing.getAxis() == Direction.Axis.Y ? Direction.NORTH : facing.getClockWise()));
+                    stack.shrink(1);
+                }
+                return stack;
+            }
+        }));
+        // Purpur end
+     }
+ 
+     static void setEntityPokingOutOfBlock(BlockSource pointer, Entity entity, Direction direction) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 48f8f0447d4612c15b3a9c53b74c593a608bc352..e6b649f80931a70e40d1949d964df52ef6517cef 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -313,8 +313,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean dispenserApplyCursedArmor = true;
+    public boolean dispenserPlaceAnvils = false;
+     private void dispenserSettings() {
+         dispenserApplyCursedArmor = getBoolean("blocks.dispenser.apply-cursed-to-armor-slots", dispenserApplyCursedArmor);
+        dispenserPlaceAnvils = getBoolean("blocks.dispenser.place-anvils", dispenserPlaceAnvils);
+     }
+ 
+     public boolean farmlandGetsMoistFromBelow = false;
--- a/patches/unapplied/0089-Allow-anvil-colors.patch
+++ b/patches/unapplied/0089-Allow-anvil-colors.patch
@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 4 Aug 2020 22:08:23 -0500
+Subject: [PATCH] Allow anvil colors
+
+
+diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+index a88efd9b435349ae00c4152f09d87ebf4f724659..c26b3f3aec680a92c1361f47b1aa3968f31ffaa5 100644
+--- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+@@ -3,6 +3,9 @@ package net.minecraft.world.inventory;
+ import com.mojang.logging.LogUtils;
+ import java.util.Iterator;
+ import java.util.Map;
+
+import io.papermc.paper.adventure.PaperAdventure;
+import net.kyori.adventure.text.format.TextDecoration;
+ import net.minecraft.nbt.IntTag;
+ import net.minecraft.network.chat.TextComponent;
+ import net.minecraft.network.protocol.game.ClientboundContainerSetDataPacket;
+@@ -276,6 +279,17 @@ public class AnvilMenu extends ItemCombinerMenu {
+             } else if (!this.itemName.equals(itemstack.getHoverName().getString())) {
+                 b1 = 1;
+                 i += b1;
+                // Purpur start
+                if (player != null && player.level.purpurConfig.anvilAllowColors && player.getBukkitEntity().hasPermission("purpur.anvil.color")) {
+                    final net.kyori.adventure.text.Component renameTextComponent;
+                    if (itemName.startsWith("&r") && player.getBukkitEntity().hasPermission("purpur.anvil.remove_italics")) {
+                        renameTextComponent = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().deserialize(itemName.substring(2)).decoration(TextDecoration.ITALIC, false);
+                    } else {
+                        renameTextComponent = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().deserialize(itemName);
+                    }
+                    itemstack1.setHoverName(PaperAdventure.asVanilla(renameTextComponent));
+                } else
+                // Purpur end
+                 itemstack1.setHoverName(new TextComponent(this.itemName));
+             }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index e6b649f80931a70e40d1949d964df52ef6517cef..6319654f2560a1d035d13b2a1ada30c91c4d9cdb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -296,6 +296,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
+    public boolean anvilAllowColors = false;
+    private void anvilSettings() {
+        anvilAllowColors = getBoolean("blocks.anvil.allow-colors", anvilAllowColors);
+    }
+
+     public boolean bedExplode = true;
+     public double bedExplosionPower = 5.0D;
+     public boolean bedExplosionFire = true;
--- a/patches/unapplied/0090-Add-option-to-disable-dolphin-treasure-searching.patch
+++ b/patches/unapplied/0090-Add-option-to-disable-dolphin-treasure-searching.patch
@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 8 Aug 2020 16:11:51 -0500
+Subject: [PATCH] Add option to disable dolphin treasure searching
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+index 5dfc40bd19c556a5bc481ab9bdcbd19887e7e5c9..4970823d6bed593a646b3b074fcaf53fd4afadb2 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+@@ -486,6 +486,7 @@ public class Dolphin extends WaterAnimal {
+ 
+         @Override
+         public boolean canUse() {
+            if (this.dolphin.level.purpurConfig.dolphinDisableTreasureSearching) return false; // Purpur
+             return this.dolphin.gotFish() && this.dolphin.getAirSupply() >= 100 && this.dolphin.level.getWorld().canGenerateStructures(); // MC-151364, SPIGOT-5494: hangs if generate-structures=false
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 6319654f2560a1d035d13b2a1ada30c91c4d9cdb..8d31e240e3d275e228c6d8c1107a609c3bf04729 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -575,6 +575,7 @@ public class PurpurWorldConfig {
+     public float dolphinSpitSpeed = 1.0F;
+     public float dolphinSpitDamage = 2.0F;
+     public double dolphinMaxHealth = 10.0D;
+    public boolean dolphinDisableTreasureSearching = false;
+     private void dolphinSettings() {
+         dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable);
+         dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable);
+@@ -587,6 +588,7 @@ public class PurpurWorldConfig {
+             set("mobs.dolphin.attributes.max_health", oldValue);
+         }
+         dolphinMaxHealth = getDouble("mobs.dolphin.attributes.max_health", dolphinMaxHealth);
+        dolphinDisableTreasureSearching = getBoolean("mobs.dolphin.disable-treasure-searching", dolphinDisableTreasureSearching);
+     }
+ 
+     public boolean donkeyRidableInWater = false;
--- a/patches/unapplied/0091-Short-enderman-height.patch
+++ b/patches/unapplied/0091-Short-enderman-height.patch
@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 10 Aug 2020 21:46:22 -0500
+Subject: [PATCH] Short enderman height
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index e26faaf10a9250d1ab3cd5c3ed98702112b6dd29..262ed82130b3ee8b110698e31f3a4bc78dac1ec1 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -282,7 +282,8 @@ public class EntityType<T extends Entity> implements EntityTypeTest<Entity, T> {
+     private Component description;
+     @Nullable
+     private ResourceLocation lootTable;
+-    private final EntityDimensions dimensions;
+    private EntityDimensions dimensions; // Purpur - remove final
+    public void setDimensions(EntityDimensions dimensions) { this.dimensions = dimensions; } // Purpur
+ 
+     private static <T extends Entity> EntityType<T> register(String id, EntityType.Builder type) { // CraftBukkit - decompile error
+         return (EntityType) Registry.register(Registry.ENTITY_TYPE, id, (EntityType<T>) type.build(id)); // CraftBukkit - decompile error
+diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+index b5fce127d74ac5958758bfa39551e3e1f33cbc85..c4f5d033e381aa501fd689a297fb40c713f12c2a 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -409,6 +409,7 @@ public class EnderMan extends Monster implements NeutralMob {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else if (getRider() != null && this.isControllable()) { return super.hurt(source, amount); // Purpur - no teleporting on damage
+        } else if (org.purpurmc.purpur.PurpurConfig.endermanShortHeight && source == DamageSource.IN_WALL) { return false; // Purpur - no suffocation damage if short height
+         } else if (source instanceof IndirectEntityDamageSource) {
+             Entity entity = source.getDirectEntity();
+             boolean flag;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 190e738ad33ca98aebda0d7b43dfdef8d7bea0cc..9dcc7247cf6a8b1bab66db0c80384f99d13aa669 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -237,6 +237,12 @@ public class PurpurConfig {
+         enderChestPermissionRows = getBoolean("settings.blocks.ender_chest.use-permissions-for-rows", enderChestPermissionRows);
+     }
+ 
+    public static boolean endermanShortHeight = false;
+    private static void entitySettings() {
+        endermanShortHeight = getBoolean("settings.entity.enderman.short-height", endermanShortHeight);
+        if (endermanShortHeight) EntityType.ENDERMAN.setDimensions(EntityDimensions.scalable(0.6F, 1.9F));
+    }
+
+     public static boolean allowWaterPlacementInTheEnd = true;
+     private static void allowWaterPlacementInEnd() {
+         allowWaterPlacementInTheEnd = getBoolean("settings.allow-water-placement-in-the-end", allowWaterPlacementInTheEnd);
--- a/patches/unapplied/0092-Stop-squids-floating-on-top-of-water.patch
+++ b/patches/unapplied/0092-Stop-squids-floating-on-top-of-water.patch
@@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Thu, 13 Aug 2020 04:00:26 -0500
+Subject: [PATCH] Stop squids floating on top of water
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 1e9fa0c362d8d2ea6c8da68f266a54dcf35782fb..57cc2597d6e3ed5c00b7befe13409b9b359e9023 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3962,6 +3962,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         this.yRotO = this.getYRot();
+     }
+ 
+    // Purpur start
+    public AABB getAxisForFluidCheck() {
+        return this.getBoundingBox().deflate(0.001D);
+    }
+    // Purpur end
+
+     public boolean updateFluidHeightAndDoFluidPushing(TagKey<Fluid> tag, double speed) {
+         if (false && this.touchingUnloadedChunk()) { // Pufferfish - cost of a lookup here is the same cost as below, so skip
+             return false;
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Squid.java b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+index 99248a9e2769a573839b199150da312d33344f95..709aaa9dc834d91219ce1087d8f89ef5bf3d915c 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+@@ -80,6 +80,12 @@ public class Squid extends WaterAnimal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.squidMaxHealth);
+     }
+
+    @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
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/phys/AABB.java b/src/main/java/net/minecraft/world/phys/AABB.java
+index 68cc6f2a78a06293a29317fda72ab3ee79b3533a..cfb2e46b34b2982d6724f18214557fc80cf4adfa 100644
+--- a/src/main/java/net/minecraft/world/phys/AABB.java
+++ b/src/main/java/net/minecraft/world/phys/AABB.java
+@@ -367,4 +367,10 @@ public class AABB {
+     public static AABB ofSize(Vec3 center, double dx, double dy, double dz) {
+         return new AABB(center.x - dx / 2.0D, center.y - dy / 2.0D, center.z - dz / 2.0D, center.x + dx / 2.0D, center.y + dy / 2.0D, center.z + dz / 2.0D);
+     }
+
+    // Purpur - tuinity added method
+    public final AABB offsetY(double dy) {
+        return new AABB(this.minX, this.minY + dy, this.minZ, this.maxX, this.maxY + dy, this.maxZ);
+    }
+    // Purpur
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 8d31e240e3d275e228c6d8c1107a609c3bf04729..b631a21ee4eb646d86532dd11784bd7c705eb3ee 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1433,6 +1433,7 @@ public class PurpurWorldConfig {
+     public boolean squidControllable = true;
+     public double squidMaxHealth = 10.0D;
+     public boolean squidImmuneToEAR = true;
+    public double squidOffsetWaterCheck = 0.0D;
+     private void squidSettings() {
+         squidRidable = getBoolean("mobs.squid.ridable", squidRidable);
+         squidControllable = getBoolean("mobs.squid.controllable", squidControllable);
+@@ -1443,6 +1444,7 @@ public class PurpurWorldConfig {
+         }
+         squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth);
+         squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR);
+        squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck);
+     }
+ 
+     public boolean spiderRidable = false;
--- a/patches/unapplied/0093-Crying-obsidian-valid-for-portal-frames.patch
+++ b/patches/unapplied/0093-Crying-obsidian-valid-for-portal-frames.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 17 Aug 2020 17:34:33 -0500
+Subject: [PATCH] Crying obsidian valid for portal frames
+
+
+diff --git a/src/main/java/net/minecraft/world/level/portal/PortalShape.java b/src/main/java/net/minecraft/world/level/portal/PortalShape.java
+index 3414f3190e1a760c602613e82e551e797c3aa575..5368376c126f3b629c0448f937c140abb402ef43 100644
+--- a/src/main/java/net/minecraft/world/level/portal/PortalShape.java
+++ b/src/main/java/net/minecraft/world/level/portal/PortalShape.java
+@@ -30,7 +30,7 @@ public class PortalShape {
+     private static final int MIN_HEIGHT = 3;
+     public static final int MAX_HEIGHT = 21;
+     private static final BlockBehaviour.StatePredicate FRAME = (iblockdata, iblockaccess, blockposition) -> {
+-        return iblockdata.is(Blocks.OBSIDIAN);
+        return iblockdata.is(Blocks.OBSIDIAN) || (org.purpurmc.purpur.PurpurConfig.cryingObsidianValidForPortalFrame && iblockdata.is(Blocks.CRYING_OBSIDIAN)); // Purpur
+     };
+     private final LevelAccessor level;
+     private final Direction.Axis axis;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 9dcc7247cf6a8b1bab66db0c80384f99d13aa669..1cd8358c3d9f96073224846143516097aeb8fd23 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -205,6 +205,7 @@ public class PurpurConfig {
+     public static int barrelRows = 3;
+     public static boolean enderChestSixRows = false;
+     public static boolean enderChestPermissionRows = false;
+    public static boolean cryingObsidianValidForPortalFrame = false;
+     private static void blockSettings() {
+         if (version < 3) {
+             boolean oldValue = getBoolean("settings.barrel.packed-barrels", true);
+@@ -235,6 +236,7 @@ public class PurpurConfig {
+         enderChestSixRows = getBoolean("settings.blocks.ender_chest.six-rows", enderChestSixRows);
+         org.bukkit.event.inventory.InventoryType.ENDER_CHEST.setDefaultSize(enderChestSixRows ? 54 : 27);
+         enderChestPermissionRows = getBoolean("settings.blocks.ender_chest.use-permissions-for-rows", enderChestPermissionRows);
+        cryingObsidianValidForPortalFrame = getBoolean("settings.blocks.crying_obsidian.valid-for-portal-frame", cryingObsidianValidForPortalFrame);
+     }
+ 
+     public static boolean endermanShortHeight = false;
--- a/patches/unapplied/0094-Entities-can-use-portals-configuration.patch
+++ b/patches/unapplied/0094-Entities-can-use-portals-configuration.patch
@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 17 Aug 2020 19:32:05 -0500
+Subject: [PATCH] Entities can use portals configuration
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 57cc2597d6e3ed5c00b7befe13409b9b359e9023..3ee9202676d3add9054fbd72bbbf1e44afd2597d 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2785,7 +2785,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     public void handleInsidePortal(BlockPos pos) {
+         if (this.isOnPortalCooldown()) {
+             this.setPortalCooldown();
+-        } else {
+        } else if (level.purpurConfig.entitiesCanUsePortals || this instanceof ServerPlayer) { // Purpur
+             if (!this.level.isClientSide && !pos.equals(this.portalEntrancePos)) {
+                 this.portalEntrancePos = pos.immutable();
+             }
+@@ -3451,7 +3451,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+ 
+     public boolean canChangeDimensions() {
+-        return isAlive() && valid; // Paper
+        return isAlive() && valid && (level.purpurConfig.entitiesCanUsePortals || this instanceof ServerPlayer); // Paper // Purpur
+     }
+ 
+     public float getBlockExplosionResistance(Explosion explosion, BlockGetter world, BlockPos pos, BlockState blockState, FluidState fluidState, float max) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b631a21ee4eb646d86532dd11784bd7c705eb3ee..f6d4be9b81b82e7ae46f7694b824a06b3f6272ed 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -97,6 +97,7 @@ public class PurpurWorldConfig {
+     public boolean useBetterMending = false;
+     public boolean boatEjectPlayersOnLand = false;
+     public boolean disableDropsOnCrammingDeath = false;
+    public boolean entitiesCanUsePortals = true;
+     public boolean milkCuresBadOmen = true;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+@@ -105,6 +106,7 @@ public class PurpurWorldConfig {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+        entitiesCanUsePortals = getBoolean("gameplay-mechanics.entities-can-use-portals", entitiesCanUsePortals);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
+         voidDamageHeight = getDouble("gameplay-mechanics.void-damage-height", voidDamageHeight);
--- a/patches/unapplied/0095-LivingEntity-broadcastItemBreak.patch
+++ b/patches/unapplied/0095-LivingEntity-broadcastItemBreak.patch
@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 17 Aug 2020 21:50:39 -0500
+Subject: [PATCH] LivingEntity#broadcastItemBreak
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 1dcfe129ec3633de67404ab5ab72cdcee31d3d9d..eb61eab2b7be4f99b827a0e206db23a858fa2119 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -931,5 +931,11 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     public void setSafeFallDistance(float safeFallDistance) {
+         getHandle().safeFallDistance = safeFallDistance;
+     }
+
+    @Override
+    public void broadcastItemBreak(org.bukkit.inventory.EquipmentSlot slot) {
+        if (slot == null) return;
+        getHandle().broadcastBreakEvent(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot));
+    }
+     // Purpur end
+ }
--- a/patches/unapplied/0096-Customizable-wither-health-and-healing.patch
+++ b/patches/unapplied/0096-Customizable-wither-health-and-healing.patch
@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Thu, 20 Aug 2020 17:38:12 -0700
+Subject: [PATCH] Customizable wither health and healing
+
+Adds the ability to customize the health of the wither, as well as the amount that it heals, and how often.
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+index 5fdbbf376947e4efd85f02ae978c56de62a0610b..a8698975b368b27c0bb1cab4e0b83d69e773fc6b 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+@@ -519,8 +519,10 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+                 }
+             }
+ 
+-            if (this.tickCount % 20 == 0) {
+-                this.heal(1.0F, EntityRegainHealthEvent.RegainReason.REGEN); // CraftBukkit
+            // Purpur start - customizable heal rate and amount
+            if (this.tickCount % level.purpurConfig.witherHealthRegenDelay == 0) {
+                this.heal(level.purpurConfig.witherHealthRegenAmount, EntityRegainHealthEvent.RegainReason.REGEN); // CraftBukkit
+                // Purpur end
+             }
+ 
+             this.bossEvent.setProgress(this.getHealth() / this.getMaxHealth());
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f6d4be9b81b82e7ae46f7694b824a06b3f6272ed..2a226f91d7afe0489adb4dbe94d69e6fc8e6e4e4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1662,6 +1662,8 @@ public class PurpurWorldConfig {
+     public boolean witherControllable = true;
+     public double witherMaxY = 320D;
+     public double witherMaxHealth = 300.0D;
+    public float witherHealthRegenAmount = 1.0f;
+    public int witherHealthRegenDelay = 20;
+     private void witherSettings() {
+         witherRidable = getBoolean("mobs.wither.ridable", witherRidable);
+         witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater);
+@@ -1677,6 +1679,8 @@ public class PurpurWorldConfig {
+             set("mobs.wither.attributes.max_health", oldValue);
+         }
+         witherMaxHealth = getDouble("mobs.wither.attributes.max_health", witherMaxHealth);
+        witherHealthRegenAmount = (float) getDouble("mobs.wither.health-regen-amount", witherHealthRegenAmount);
+        witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay);
+     }
+ 
+     public boolean witherSkeletonRidable = false;
--- a/patches/unapplied/0097-Allow-toggling-special-MobSpawners-per-world.patch
+++ b/patches/unapplied/0097-Allow-toggling-special-MobSpawners-per-world.patch
@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sat, 22 Aug 2020 20:47:11 -0700
+Subject: [PATCH] Allow toggling special MobSpawners per world
+
+In vanilla, these are all hardcoded on for world type 0 (overworld) and hardcoded off for every other world type. Default config behaviour matches this.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index ac233f1f6a645a927631efdda15aee91040705d8..40d5196cbb3567d642925cd7f0d2924884c46347 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -498,7 +498,24 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         this.dragonParts = new Int2ObjectOpenHashMap();
+         this.tickTime = flag1;
+         this.server = minecraftserver;
+-        this.customSpawners = list;
+        // Purpur start - enable/disable MobSpawners per world
+        this.customSpawners = Lists.newArrayList();
+        if (purpurConfig.phantomSpawning) {
+            customSpawners.add(new net.minecraft.world.level.levelgen.PhantomSpawner());
+        }
+        if (purpurConfig.patrolSpawning) {
+            customSpawners.add(new net.minecraft.world.level.levelgen.PatrolSpawner());
+        }
+        if (purpurConfig.catSpawning) {
+            customSpawners.add(new net.minecraft.world.entity.npc.CatSpawner());
+        }
+        if (purpurConfig.villageSiegeSpawning) {
+            customSpawners.add(new net.minecraft.world.entity.ai.village.VillageSiege());
+        }
+        if (purpurConfig.villagerTraderSpawning) {
+            customSpawners.add(new net.minecraft.world.entity.npc.WanderingTraderSpawner(iworlddataserver));
+        }
+        // Purpur end
+         // CraftBukkit start
+         this.serverLevelData = (PrimaryLevelData) iworlddataserver;
+         this.serverLevelData.setWorld(this);
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+index 4e478c30714a8e4cd95f02e73615d166836d1e4b..17fc1e07069546cdd3a7bd35e900e4c35ed43fd5 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+@@ -5,6 +5,7 @@ import java.util.Optional;
+ import java.util.Random;
+ import javax.annotation.Nullable;
+ import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.network.chat.Component;
+ import net.minecraft.server.level.ServerLevel;
+@@ -160,7 +161,17 @@ public class WanderingTraderSpawner implements CustomSpawner {
+             int k = pos.getX() + this.random.nextInt(range * 2) - range;
+             int l = pos.getZ() + this.random.nextInt(range * 2) - range;
+             int i1 = world.getHeight(Heightmap.Types.WORLD_SURFACE, k, l);
+-            BlockPos blockposition2 = new BlockPos(k, i1, l);
+            // Purpur start - allow traders to spawn below nether roof
+            BlockPos.MutableBlockPos blockposition2 = new BlockPos.MutableBlockPos(k, i1, l);
+            if (world.dimensionType().hasCeiling()) {
+                do {
+                    blockposition2.relative(Direction.DOWN);
+                } while (!world.getBlockState(blockposition2).isAir());
+                do {
+                    blockposition2.relative(Direction.DOWN);
+                } while (world.getBlockState(blockposition2).isAir() && blockposition2.getY() > 0);
+            }
+            // Purpur end
+ 
+             if (NaturalSpawner.isSpawnPositionOk(SpawnPlacements.Type.ON_GROUND, world, blockposition2, EntityType.WANDERING_TRADER)) {
+                 blockposition1 = blockposition2;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 2a226f91d7afe0489adb4dbe94d69e6fc8e6e4e4..923110da6494664fef30fd20a7d9282eaac825f9 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -68,6 +68,12 @@ public class PurpurWorldConfig {
+         return PurpurConfig.config.getBoolean("world-settings." + worldName + "." + path, PurpurConfig.config.getBoolean("world-settings.default." + path));
+     }
+ 
+    private boolean getBoolean(String path, Predicate<Boolean> predicate) {
+        String val = getString(path, "default").toLowerCase();
+        Boolean bool = BooleanUtils.toBooleanObject(val, "true", "false", "default");
+        return predicate.test(bool);
+    }
+
+     private double getDouble(String path, double def) {
+         PurpurConfig.config.addDefault("world-settings.default." + path, def);
+         return PurpurConfig.config.getDouble("world-settings." + worldName + "." + path, PurpurConfig.config.getDouble("world-settings.default." + path));
+@@ -236,6 +242,21 @@ public class PurpurWorldConfig {
+         }
+     }
+ 
+    public boolean catSpawning;
+    public boolean patrolSpawning;
+    public boolean phantomSpawning;
+    public boolean villagerTraderSpawning;
+    public boolean villageSiegeSpawning;
+    private void mobSpawnerSettings() {
+        // values of "default" or null will default to true only if the world environment is normal (aka overworld)
+        Predicate<Boolean> predicate = (bool) -> (bool != null && bool) || (bool == null && environment == World.Environment.NORMAL);
+        catSpawning = getBoolean("gameplay-mechanics.mob-spawning.village-cats", predicate);
+        patrolSpawning = getBoolean("gameplay-mechanics.mob-spawning.raid-patrols", predicate);
+        phantomSpawning = getBoolean("gameplay-mechanics.mob-spawning.phantoms", predicate);
+        villagerTraderSpawning = getBoolean("gameplay-mechanics.mob-spawning.wandering-traders", predicate);
+        villageSiegeSpawning = getBoolean("gameplay-mechanics.mob-spawning.village-sieges", predicate);
+    }
+
+     public boolean idleTimeoutKick = true;
+     public boolean idleTimeoutTickNearbyEntities = true;
+     public boolean idleTimeoutCountAsSleeping = false;
--- a/patches/unapplied/0098-Raid-cooldown-setting.patch
+++ b/patches/unapplied/0098-Raid-cooldown-setting.patch
@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Thu, 27 Aug 2020 13:48:52 -0700
+Subject: [PATCH] Raid cooldown setting
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raids.java b/src/main/java/net/minecraft/world/entity/raid/Raids.java
+index 17b24f57cc5d63f99eb999cfe3e2362758fe0f4f..95e5ae32e23781cfc1443542dc1ff40ab28eb7be 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raids.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raids.java
+@@ -28,6 +28,7 @@ import net.minecraft.world.phys.Vec3;
+ public class Raids extends SavedData {
+ 
+     private static final String RAID_FILE_ID = "raids";
+    public final Map<java.util.UUID, Integer> playerCooldowns = Maps.newHashMap();
+     public final Map<Integer, Raid> raidMap = Maps.newHashMap();
+     private final ServerLevel level;
+     private int nextAvailableID;
+@@ -45,6 +46,17 @@ public class Raids extends SavedData {
+ 
+     public void tick() {
+         ++this.tick;
+        // Purpur start
+        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
+         Iterator iterator = this.raidMap.values().iterator();
+ 
+         while (iterator.hasNext()) {
+@@ -128,10 +140,15 @@ public class Raids extends SavedData {
+ 
+                 if (flag) {
+                     // CraftBukkit start
+-                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callRaidTriggerEvent(raid, player)) {
+                    if ((level.purpurConfig.raidCooldownSeconds != 0 && playerCooldowns.containsKey(player.getUUID())) || !org.bukkit.craftbukkit.event.CraftEventFactory.callRaidTriggerEvent(raid, player)) { // Purpur
+                         player.removeEffect(MobEffects.BAD_OMEN);
+                         return null;
+                     }
+                    // Purpur start
+                    if (level.purpurConfig.raidCooldownSeconds != 0) {
+                        playerCooldowns.put(player.getUUID(), level.purpurConfig.raidCooldownSeconds);
+                    }
+                    // Purpur end
+ 
+                     if (!this.raidMap.containsKey(raid.getId())) {
+                         this.raidMap.put(raid.getId(), raid);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 923110da6494664fef30fd20a7d9282eaac825f9..347ce89d5ece52cde057e269ace2225bc1462032 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -108,6 +108,7 @@ public class PurpurWorldConfig {
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+    public int raidCooldownSeconds = 0;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+@@ -117,6 +118,7 @@ public class PurpurWorldConfig {
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
+         voidDamageHeight = getDouble("gameplay-mechanics.void-damage-height", voidDamageHeight);
+         voidDamageDealt = getDouble("gameplay-mechanics.void-damage-dealt", voidDamageDealt);
+        raidCooldownSeconds = getInt("gameplay-mechanics.raid-cooldown-seconds", raidCooldownSeconds);
+     }
+ 
+     public int elytraDamagePerSecond = 1;
--- a/patches/unapplied/0099-Despawn-rate-config-options-per-projectile-type.patch
+++ b/patches/unapplied/0099-Despawn-rate-config-options-per-projectile-type.patch
@@ -0,0 +1,348 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Mon, 14 Sep 2020 10:09:05 -0700
+Subject: [PATCH] Despawn rate config options per projectile type
+
+Default values of -1 respect vanilla behaviour.
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+index 53d0024daf6963ac4dab575666b0d6a74a39a958..c5cbcf8d6b26bbb7712d3a72f8313f600dfc7c11 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -62,7 +62,7 @@ public abstract class AbstractArrow extends Projectile {
+     protected int inGroundTime;
+     public AbstractArrow.Pickup pickup;
+     public int shakeTime;
+-    public int life;
+    // public int life; // Purpur - moved to Projectile
+     private double baseDamage;
+     public int knockback;
+     private SoundEvent soundEvent;
+@@ -333,12 +333,28 @@ public abstract class AbstractArrow extends Projectile {
+ 
+     }
+ 
+-    protected void tickDespawn() {
+-        ++this.life;
+-        if (this.life >= (pickup == Pickup.CREATIVE_ONLY ? level.paperConfig.creativeArrowDespawnRate : (pickup == Pickup.DISALLOWED ? level.paperConfig.nonPlayerArrowDespawnRate : ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)))) { // Spigot // Paper - TODO: Extract this to init?
+-            this.discard();
+    // Purpur start
+    protected int getPurpurDespawnRate() {
+        if (pickup == Pickup.CREATIVE_ONLY) {
+            return level.paperConfig.creativeArrowDespawnRate;
+        }
+        if (pickup == Pickup.DISALLOWED) {
+            return level.paperConfig.nonPlayerArrowDespawnRate;
+         }
+        if (this instanceof ThrownTrident) {
+            return level.spigotConfig.tridentDespawnRate;
+        }
+        return level.spigotConfig.arrowDespawnRate;
+    }
+ 
+    // Arrow despawn ticking is handled differently
+    protected boolean shouldAlwaysTickDespawn() {
+        return false;
+    };
+    // Purpur end
+
+    protected void tickDespawn() {
+        tickDespawnCounter(); // Purpur
+     }
+ 
+     private void resetPiercedEntities() {
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+index 6afe37e42d88701af38df5793a9ea9d7d2cda5c5..1de27407c92d496715899fcafb3794df9f5ef6cd 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+@@ -81,4 +81,11 @@ public class DragonFireball extends AbstractHurtingProjectile {
+     protected boolean shouldBurn() {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.dragonFireballDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+index 5a062a19bb2fc427c9391bb4731f071719b72c52..001d252763a689351a4df2ef830b3abb85a09e16 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+@@ -358,4 +358,11 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
+     public boolean isAttackable() {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.fireworkDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+index 3789a0db398766f0fbc9e5ac5bf4228a0a0dac88..475ff3c62796306694c76ca5315cd27d2cbe8fbe 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+@@ -661,4 +661,11 @@ public class FishingHook extends Projectile {
+ 
+         private OpenWaterType() {}
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.fishingHookDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java b/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java
+index 5237b699e000b4fed99be39b0a7e2daab9c8bf42..e69213b43c8aa5a7c04add7a87482d531fbf52d2 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java
+@@ -77,4 +77,11 @@ public class LargeFireball extends Fireball {
+         }
+ 
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.largeFireballDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/LlamaSpit.java b/src/main/java/net/minecraft/world/entity/projectile/LlamaSpit.java
+index 1a945a32c3d3705a318ebca72a365931a8c001b7..c7fdcfae1ba823046fdfe78aa97b4a7ab20c086d 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/LlamaSpit.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/LlamaSpit.java
+@@ -100,4 +100,11 @@ public class LlamaSpit extends Projectile {
+ 
+         this.setDeltaMovement(d0, d1, d2);
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.llamaSpitDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+index 0c7d31c7ffd603e54fb19010331ad220c7b15627..878757f6b5034ed54198102cf8d48ace580f856f 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -33,6 +33,7 @@ public abstract class Projectile extends Entity {
+     public Entity cachedOwner;
+     private boolean leftOwner;
+     private boolean hasBeenShot;
+    public int life; // Purpur - moved from AbstractArrow
+ 
+     // CraftBukkit start
+     protected boolean hitCancelled = false;
+@@ -72,6 +73,23 @@ public abstract class Projectile extends Entity {
+     }
+     // Pufferfish start
+ 
+    // Purpur start
+    protected final void tickDespawnCounter() {
+        if (this.getPurpurDespawnRate() != -1) {
+            ++this.life;
+            if (this.life >= this.getPurpurDespawnRate()) {
+                this.discard();
+            }
+        }
+    }
+
+    protected abstract int getPurpurDespawnRate();
+
+    protected boolean shouldAlwaysTickDespawn() {
+        return true;
+    };
+    // Purpur end
+
+     public void setOwner(@Nullable Entity entity) {
+         if (entity != null) {
+             this.ownerUUID = entity.getUUID();
+@@ -148,6 +166,8 @@ public abstract class Projectile extends Entity {
+             this.leftOwner = this.checkLeftOwner();
+         }
+ 
+        if (this.shouldAlwaysTickDespawn()) tickDespawnCounter(); // Purpur
+
+         super.tick();
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ShulkerBullet.java b/src/main/java/net/minecraft/world/entity/projectile/ShulkerBullet.java
+index a4591e4dc1a277a2fd0a323f3b54a107fd6598c8..ca0133bcb82df8112b63c7aef3670a8970676ef9 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ShulkerBullet.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ShulkerBullet.java
+@@ -62,6 +62,13 @@ public class ShulkerBullet extends Projectile {
+         projectileSource = (org.bukkit.entity.LivingEntity) owner.getBukkitEntity(); // CraftBukkit
+     }
+ 
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.shulkerBulletDespawnRate;
+    }
+    // Purpur end
+
+     // CraftBukkit start
+     public Entity getTarget() {
+         return this.finalTarget;
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java b/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java
+index 58354671480ce3e677790eb5bebc64a20b36e43d..226b33921c90ca3904a7397a68dc8169948f8faa 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java
+@@ -98,4 +98,11 @@ public class SmallFireball extends Fireball {
+     public boolean hurt(DamageSource source, float amount) {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.smallFireballDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Snowball.java b/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+index a725851060f13e734dbd2fbf8c83c9e1af57a8b7..ed2f039c4042861bcfa2e41d8281eefd37daa9fa 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+@@ -67,4 +67,11 @@ public class Snowball extends ThrowableItemProjectile {
+         }
+ 
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.snowballDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
+index 77941e3981e49cf5662b3e3c86a9c419080b17c8..8c6243aab556c993b43ab52e216bcb0a70d1a686 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
+@@ -107,4 +107,11 @@ public class ThrownEgg extends ThrowableItemProjectile {
+     protected Item getDefaultItem() {
+         return Items.EGG;
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.eggDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+index 23f77dfc6df93ef6a70e14a7e410263d39fae2cb..22d5f5aac2f4c7ce8f490d4851ef3d637a9c7d06 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+@@ -121,4 +121,11 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+ 
+         return super.changeDimension(destination);
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.enderPearlDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+index dcbbff3a8dfcac869f07025e0e8e3d9c47956093..d6b522aa7c7ce87caf55f91ee9d661e055506c01 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+@@ -56,4 +56,11 @@ public class ThrownExperienceBottle extends ThrowableItemProjectile {
+         }
+ 
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.expBottleDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java
+index fee09e6ff72cf1da389d5811dd005642cd50a5b4..0f387c4f6fb49c5266feeec3504a4ec7c870ba37 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java
+@@ -305,4 +305,11 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
+         }
+ 
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.potionDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java b/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java
+index 2867e841e73a3edfdeb83af9d96e0d0cd4116a68..8613008090a9d7cf5cd7c2a598f2c725b5b0cdc6 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java
+@@ -136,4 +136,11 @@ public class WitherSkull extends AbstractHurtingProjectile {
+     protected boolean shouldBurn() {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    protected int getPurpurDespawnRate() {
+        return this.level.purpurConfig.witherSkullDespawnRate;
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 347ce89d5ece52cde057e269ace2225bc1462032..8847f78505aa4a9646a3d48a6c8b013bfff9c71f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -289,6 +289,35 @@ public class PurpurWorldConfig {
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+     }
+ 
+    public int dragonFireballDespawnRate = -1;
+    public int eggDespawnRate = -1;
+    public int enderPearlDespawnRate = -1;
+    public int expBottleDespawnRate = -1;
+    public int fireworkDespawnRate = -1;
+    public int fishingHookDespawnRate = -1;
+    public int largeFireballDespawnRate = -1;
+    public int llamaSpitDespawnRate = -1;
+    public int potionDespawnRate = -1;
+    public int shulkerBulletDespawnRate = -1;
+    public int smallFireballDespawnRate = -1;
+    public int snowballDespawnRate = -1;
+    public int witherSkullDespawnRate = -1;
+    private void projectileDespawnRateSettings() {
+        dragonFireballDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.dragon_fireball", dragonFireballDespawnRate);
+        eggDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.egg", eggDespawnRate);
+        enderPearlDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.ender_pearl", enderPearlDespawnRate);
+        expBottleDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.experience_bottle", expBottleDespawnRate);
+        fireworkDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.firework_rocket", fireworkDespawnRate);
+        fishingHookDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.fishing_bobber", fishingHookDespawnRate);
+        largeFireballDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.fireball", largeFireballDespawnRate);
+        llamaSpitDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.llama_spit", llamaSpitDespawnRate);
+        potionDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.potion", potionDespawnRate);
+        shulkerBulletDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.shulker_bullet", shulkerBulletDespawnRate);
+        smallFireballDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.small_fireball", smallFireballDespawnRate);
+        snowballDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.snowball", snowballDespawnRate);
+        witherSkullDespawnRate = getInt("gameplay-mechanics.projectile-despawn-rates.wither_skull", witherSkullDespawnRate);
+    }
+
+     public boolean silkTouchEnabled = false;
+     public String silkTouchSpawnerName = "<reset><white>Spawner";
+     public List<String> silkTouchSpawnerLore = new ArrayList<>();
--- a/patches/unapplied/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch
+++ b/patches/unapplied/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch
@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: nitricspace <nitricspace@users.noreply.github.com>
+Date: Mon, 21 Sep 2020 23:19:43 +0100
+Subject: [PATCH] Add option to disable zombie aggressiveness towards villagers
+ when lagging
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
+index 181abe014baba9ac51064c003381281a8fa43fe4..cfd1dcec3efcd4caf2431cbda99bc9f15d39ed69 100644
+--- a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
+++ b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
+@@ -135,6 +135,10 @@ public class MobGoalHelper {
+     static {
+         // TODO these kinda should be checked on each release, in case obfuscation changes
+         deobfuscationMap.put("abstract_skeleton_1", "abstract_skeleton_melee");
+        // Purpur start
+        deobfuscationMap.put("zombie_1", "zombie_attack_villager");
+        deobfuscationMap.put("drowned_1", "drowned_attack_villager");
+        // Purpur end
+ 
+         ignored.add("goal_selector_1");
+         ignored.add("goal_selector_2");
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+index d966175c84ebb4d9054b8368d14243823d242f80..346c274e81be8541b61c66a0a0574811ddf59ff9 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+@@ -120,7 +120,19 @@ public class Drowned extends Zombie implements RangedAttackMob {
+         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0D));
+         this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[]{Drowned.class})).setAlertOthers(ZombifiedPiglin.class));
+         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::okTarget));
+-        if (this.level.spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Paper
+        // Purpur start
+        if ( level.spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<AbstractVillager>(this, AbstractVillager.class, false) { // Spigot
+            @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
+         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));
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+index c28d0b6ba64a6f7b6aa4ea2df11f10d8a2371718..3cea172a1a54b34f5fbd62ace84661da429c44d6 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+@@ -154,7 +154,19 @@ public class Zombie extends Monster {
+         this.goalSelector.addGoal(7, new WaterAvoidingRandomStrollGoal(this, 1.0D));
+         this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[0])).setAlertOthers(ZombifiedPiglin.class));
+         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, true));
+-        if ( level.spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Spigot
+        // Purpur start
+        if ( level.spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<AbstractVillager>(this, AbstractVillager.class, false) { // Spigot
+            @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
+         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
+         this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR));
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 8847f78505aa4a9646a3d48a6c8b013bfff9c71f..f3a4634ccd0a92dfbd2991da0695f4cfb5259d1d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1791,6 +1791,7 @@ public class PurpurWorldConfig {
+     public boolean zombieJockeyOnlyBaby = true;
+     public double zombieJockeyChance = 0.05D;
+     public boolean zombieJockeyTryExistingChickens = true;
+    public boolean zombieAggressiveTowardsVillagerWhenLagging = true;
+     private void zombieSettings() {
+         zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable);
+         zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater);
+@@ -1805,6 +1806,7 @@ public class PurpurWorldConfig {
+         zombieJockeyOnlyBaby = getBoolean("mobs.zombie.jockey.only-babies", zombieJockeyOnlyBaby);
+         zombieJockeyChance = getDouble("mobs.zombie.jockey.chance", zombieJockeyChance);
+         zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens);
+        zombieAggressiveTowardsVillagerWhenLagging = getBoolean("mobs.zombie.aggressive-towards-villager-when-lagging", zombieAggressiveTowardsVillagerWhenLagging);
+     }
+ 
+     public boolean zombieHorseRidableInWater = false;
--- a/patches/unapplied/0101-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch
+++ b/patches/unapplied/0101-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch
@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 3 Oct 2020 17:40:52 -0500
+Subject: [PATCH] Add predicate to recipe's ExactChoice ingredient
+
+
+diff --git a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
+index 8f35445477507bbec3c0cb1dccfd888316951595..2db1b0ec1b4595b80adafd19f398fbcc037c4f72 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
+++ b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
+@@ -38,6 +38,7 @@ public final class Ingredient implements Predicate<ItemStack> {
+     @Nullable
+     private IntList stackingIds;
+     public boolean exact; // CraftBukkit
+    public Predicate<org.bukkit.inventory.ItemStack> predicate;
+ 
+     public Ingredient(Stream<? extends Ingredient.Value> entries) {
+         this.values = (Ingredient.Value[]) entries.toArray((i) -> {
+@@ -69,6 +70,12 @@ public final class Ingredient implements Predicate<ItemStack> {
+             if (this.itemStacks.length == 0) {
+                 return itemstack.isEmpty();
+             } else {
+                // Purpur start
+                if (predicate != null) {
+                    return predicate.test(itemstack.asBukkitCopy());
+                }
+                // Purpur end
+
+                 ItemStack[] aitemstack = this.itemStacks;
+                 int i = aitemstack.length;
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java
+index 71486c08db28caf89f2366e082f6f6fab5609b71..eb893920e2520f6be1d13d9235cb0d326e4b05f8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java
+@@ -27,6 +27,7 @@ public interface CraftRecipe extends Recipe {
+         } else if (bukkit instanceof RecipeChoice.ExactChoice) {
+             stack = new Ingredient(((RecipeChoice.ExactChoice) bukkit).getChoices().stream().map((mat) -> new net.minecraft.world.item.crafting.Ingredient.ItemValue(CraftItemStack.asNMSCopy(mat))));
+             stack.exact = true;
+            stack.predicate = ((RecipeChoice.ExactChoice) bukkit).getPredicate(); // Purpur
+         } else {
+             throw new IllegalArgumentException("Unknown recipe stack instance " + bukkit);
+         }
--- a/patches/unapplied/0102-Flying-squids-Oh-my.patch
+++ b/patches/unapplied/0102-Flying-squids-Oh-my.patch
@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 4 Oct 2020 12:00:42 -0500
+Subject: [PATCH] Flying squids! Oh my!
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/GlowSquid.java b/src/main/java/net/minecraft/world/entity/GlowSquid.java
+index 9734ed30af10832fbbede43848fd82591320d1ce..ad93a0516391761f6275c2c04cc63f7f20101ba4 100644
+--- a/src/main/java/net/minecraft/world/entity/GlowSquid.java
+++ b/src/main/java/net/minecraft/world/entity/GlowSquid.java
+@@ -43,6 +43,11 @@ public class GlowSquid extends Squid {
+     public void initAttributes() {
+         this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.glowSquidMaxHealth);
+     }
+
+    @Override
+    public boolean canFly() {
+        return this.level.purpurConfig.glowSquidsCanFly;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Squid.java b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+index 709aaa9dc834d91219ce1087d8f89ef5bf3d915c..4850960c7c4f38c7d81b8945f8c87504d5ccd0d0 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+@@ -86,6 +86,15 @@ public class Squid extends WaterAnimal {
+         // Stops squids from floating just over the water
+         return super.getAxisForFluidCheck().offsetY(level.purpurConfig.squidOffsetWaterCheck);
+     }
+
+    public boolean canFly() {
+        return this.level.purpurConfig.squidsCanFly;
+    }
+
+    @Override
+    public boolean isInWater() {
+        return this.wasTouchingWater || canFly();
+    }
+     // Purpur end
+ 
+     @Override
+@@ -160,6 +169,7 @@ public class Squid extends WaterAnimal {
+         }
+ 
+         if (this.isInWaterOrBubble()) {
+            if (canFly()) setNoGravity(!wasTouchingWater); // Purpur
+             if (this.tentacleMovement < 3.1415927F) {
+                 float f = this.tentacleMovement / 3.1415927F;
+ 
+@@ -319,7 +329,7 @@ public class Squid extends WaterAnimal {
+ 
+             if (i > 100) {
+                 this.squid.setMovementVector(0.0F, 0.0F, 0.0F);
+-            } 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
+                 float f = this.squid.getRandom().nextFloat() * 6.2831855F;
+                 float f1 = Mth.cos(f) * 0.2F;
+                 float f2 = -0.1F + this.squid.getRandom().nextFloat() * 0.2F;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f3a4634ccd0a92dfbd2991da0695f4cfb5259d1d..8e7a6bba0da7c9d9376ed4a0510255e58a07ed64 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -852,10 +852,12 @@ public class PurpurWorldConfig {
+     public boolean glowSquidRidable = false;
+     public boolean glowSquidControllable = true;
+     public double glowSquidMaxHealth = 10.0D;
+    public boolean glowSquidsCanFly = false;
+     private void glowSquidSettings() {
+         glowSquidRidable = getBoolean("mobs.glow_squid.ridable", glowSquidRidable);
+         glowSquidControllable = getBoolean("mobs.glow_squid.controllable", glowSquidControllable);
+         glowSquidMaxHealth = getDouble("mobs.glow_squid.attributes.max_health", glowSquidMaxHealth);
+        glowSquidsCanFly = getBoolean("mobs.glow_squid.can-fly", glowSquidsCanFly);
+     }
+ 
+     public boolean goatRidable = false;
+@@ -1488,6 +1490,7 @@ public class PurpurWorldConfig {
+     public double squidMaxHealth = 10.0D;
+     public boolean squidImmuneToEAR = true;
+     public double squidOffsetWaterCheck = 0.0D;
+    public boolean squidsCanFly = false;
+     private void squidSettings() {
+         squidRidable = getBoolean("mobs.squid.ridable", squidRidable);
+         squidControllable = getBoolean("mobs.squid.controllable", squidControllable);
+@@ -1499,6 +1502,7 @@ public class PurpurWorldConfig {
+         squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth);
+         squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR);
+         squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck);
+        squidsCanFly = getBoolean("mobs.squid.can-fly", squidsCanFly);
+     }
+ 
+     public boolean spiderRidable = false;
--- a/patches/unapplied/0103-Infinity-bow-settings.patch
+++ b/patches/unapplied/0103-Infinity-bow-settings.patch
@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 4 Oct 2020 19:08:53 -0500
+Subject: [PATCH] Infinity bow settings
+
+
+diff --git a/src/main/java/net/minecraft/world/item/BowItem.java b/src/main/java/net/minecraft/world/item/BowItem.java
+index 08d597db1a5345a343777a01427655e6bf2c926b..33df0ca406dc8321b76b393f317bbd1c8ebe6366 100644
+--- a/src/main/java/net/minecraft/world/item/BowItem.java
+++ b/src/main/java/net/minecraft/world/item/BowItem.java
+@@ -38,7 +38,7 @@ public class BowItem extends ProjectileWeaponItem implements Vanishable {
+                 float f = BowItem.getPowerForTime(j);
+ 
+                 if ((double) f >= 0.1D) {
+-                    boolean flag1 = flag && itemstack1.is(Items.ARROW);
+                    boolean flag1 = flag && ((itemstack1.is(Items.ARROW) && world.purpurConfig.infinityWorksWithNormalArrows) || (itemstack1.is(Items.TIPPED_ARROW) && world.purpurConfig.infinityWorksWithTippedArrows) || (itemstack1.is(Items.SPECTRAL_ARROW) && world.purpurConfig.infinityWorksWithSpectralArrows)); // Purpur                    if (!world.isClientSide) {
+ 
+                     if (!world.isClientSide) {
+                         ArrowItem itemarrow = (ArrowItem) (itemstack1.getItem() instanceof ArrowItem ? itemstack1.getItem() : Items.ARROW);
+@@ -132,7 +132,7 @@ public class BowItem extends ProjectileWeaponItem implements Vanishable {
+         ItemStack itemstack = user.getItemInHand(hand);
+         boolean flag = !user.getProjectile(itemstack).isEmpty();
+ 
+-        if (!user.getAbilities().instabuild && !flag) {
+        if (!(world.purpurConfig.infinityWorksWithoutArrows && EnchantmentHelper.getItemEnchantmentLevel(Enchantments.INFINITY_ARROWS, itemstack) > 0) && !user.getAbilities().instabuild && !flag) { // Purpur
+             return InteractionResultHolder.fail(itemstack);
+         } else {
+             user.startUsingItem(hand);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 99f99096c773ddc14f4abe5a17ebe4c88d298c8d..de8d17bc900190b20e56e9002b936ec0ca16bd26 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -139,6 +139,17 @@ public class PurpurWorldConfig {
+         entityLifeSpan = getInt("gameplay-mechanics.entity-lifespan", entityLifeSpan);
+     }
+ 
+    public boolean infinityWorksWithoutArrows = false;
+    public boolean infinityWorksWithNormalArrows = true;
+    public boolean infinityWorksWithSpectralArrows = false;
+    public boolean infinityWorksWithTippedArrows = false;
+    private void infinityArrowsSettings() {
+        infinityWorksWithoutArrows = getBoolean("gameplay-mechanics.infinity-bow.works-without-arrows", infinityWorksWithoutArrows);
+        infinityWorksWithNormalArrows = getBoolean("gameplay-mechanics.infinity-bow.normal-arrows", infinityWorksWithNormalArrows);
+        infinityWorksWithSpectralArrows = getBoolean("gameplay-mechanics.infinity-bow.spectral-arrows", infinityWorksWithSpectralArrows);
+        infinityWorksWithTippedArrows = getBoolean("gameplay-mechanics.infinity-bow.tipped-arrows", infinityWorksWithTippedArrows);
+    }
+
+     public List<Item> itemImmuneToCactus = new ArrayList<>();
+     public List<Item> itemImmuneToExplosion = new ArrayList<>();
+     public List<Item> itemImmuneToFire = new ArrayList<>();
--- a/patches/unapplied/0104-Stonecutter-damage.patch
+++ b/patches/unapplied/0104-Stonecutter-damage.patch
@@ -0,0 +1,128 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 5 Oct 2020 12:15:14 -0500
+Subject: [PATCH] Stonecutter damage
+
+
+diff --git a/src/main/java/net/minecraft/world/damagesource/DamageSource.java b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+index 67e559d63c543ff716d610cb04ff9426cc20ae00..9125deb86b856bcb5e1cd779773522e2fa4cb5f9 100644
+--- a/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+++ b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+@@ -39,6 +39,14 @@ public class DamageSource {
+     public static final DamageSource FREEZE = (new DamageSource("freeze")).bypassArmor();
+     public static final DamageSource FALLING_STALACTITE = (new DamageSource("fallingStalactite")).damageHelmet();
+     public static final DamageSource STALAGMITE = (new DamageSource("stalagmite")).bypassArmor().setIsFall();
+    // Purpur start
+    public static final DamageSource STONECUTTER = (new DamageSource("stonecutter") {
+        @Override
+        public Component getLocalizedDeathMessage(LivingEntity entity) {
+            return getLocalizedDeathMessage(org.purpurmc.purpur.PurpurConfig.deathMsgStonecutter, entity);
+        }
+    }).bypassArmor();
+    // Purpur end
+     private boolean damageHelmet;
+     private boolean bypassArmor;
+     private boolean bypassInvul;
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 3ee9202676d3add9054fbd72bbbf1e44afd2597d..f582265ec9dc5349183cbd5c6b1e3f2658166c02 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1078,7 +1078,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+                 }
+                 // CraftBukkit end
+ 
+-                if (this.onGround && !this.isSteppingCarefully()) {
+                if (this.onGround && (!this.isSteppingCarefully() || (block == Blocks.STONECUTTER && level.purpurConfig.stonecutterDamage > 0.0F))) {
+                     block.stepOn(this.level, blockposition, iblockdata, this);
+                 }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/StonecutterBlock.java b/src/main/java/net/minecraft/world/level/block/StonecutterBlock.java
+index ec1c04f354236af24e137865b3b311ab8eb29ac4..7d3e7c5f8f9946c35384cf18a43efbcf62952228 100644
+--- a/src/main/java/net/minecraft/world/level/block/StonecutterBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/StonecutterBlock.java
+@@ -93,4 +93,16 @@ public class StonecutterBlock extends Block {
+     public boolean isPathfindable(BlockState state, BlockGetter world, BlockPos pos, PathComputationType type) {
+         return false;
+     }
+
+    // Purpur start
+    @Override
+    public void stepOn(Level level, BlockPos pos, BlockState state, net.minecraft.world.entity.Entity entity) {
+        if (level.purpurConfig.stonecutterDamage > 0.0F && entity instanceof net.minecraft.world.entity.LivingEntity) {
+            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = level.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
+            entity.hurt(net.minecraft.world.damagesource.DamageSource.STONECUTTER, level.purpurConfig.stonecutterDamage);
+            org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = null;
+        }
+        super.stepOn(level, pos, state, entity);
+    }
+    // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java b/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
+index c7926d45c32a739b32d2b97b1ed2f8b89fb18620..c9428be93926c01584deb1f4b3d572fcfe60ac4c 100644
+--- a/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
+++ b/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
+@@ -467,7 +467,7 @@ public class WalkNodeEvaluator extends NodeEvaluator {
+                             return BlockPathTypes.DANGER_CACTUS;
+                         }
+ 
+-                        if (blockState.is(Blocks.SWEET_BERRY_BUSH)) {
+                        if (blockState.is(Blocks.SWEET_BERRY_BUSH) || blockState.is(Blocks.STONECUTTER)) {
+                             return BlockPathTypes.DANGER_OTHER;
+                         }
+ 
+@@ -499,7 +499,7 @@ public class WalkNodeEvaluator extends NodeEvaluator {
+                 return BlockPathTypes.POWDER_SNOW;
+             } else if (blockState.is(Blocks.CACTUS)) {
+                 return BlockPathTypes.DAMAGE_CACTUS;
+-            } else if (blockState.is(Blocks.SWEET_BERRY_BUSH)) {
+            } else if (blockState.is(Blocks.SWEET_BERRY_BUSH) || blockState.is(Blocks.STONECUTTER)) {
+                 return BlockPathTypes.DAMAGE_OTHER;
+             } else if (blockState.is(Blocks.HONEY_BLOCK)) {
+                 return BlockPathTypes.STICKY_HONEY;
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 97108c2317a38e11d45fdbef448dca5cb3ddad1c..066c40a8a0e5d13fc39c5283b54fe424b8822f4f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1052,6 +1052,10 @@ public class CraftEventFactory {
+                 cause = DamageCause.MAGIC;
+             } else if (source == DamageSource.IN_FIRE) {
+                 cause = DamageCause.FIRE;
+            // Purpur start
+            } else if (source == DamageSource.STONECUTTER) {
+                cause = DamageCause.CONTACT;
+            // Purpur end
+             } else {
+                 throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, damager, source.msgId));
+             }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 1cd8358c3d9f96073224846143516097aeb8fd23..4b3c590f0f1231e164e8664f21a14c1b39d73842 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -187,6 +187,11 @@ public class PurpurConfig {
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+     }
+ 
+    public static String deathMsgStonecutter = "<player> has sawed themself in half";
+    private static void deathMessages() {
+        deathMsgStonecutter = getString("settings.messages.death-message.stonecutter", deathMsgStonecutter);
+    }
+
+     public static String serverModName = "Purpur";
+     private static void serverModName() {
+         serverModName = getString("settings.server-mod-name", serverModName);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index adeb059fd44b411b972cf8886900069d71568478..95667821b8f01ae31c62f0811aed67453b60df4b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -431,6 +431,11 @@ public class PurpurWorldConfig {
+         spawnerDeactivateByRedstone = getBoolean("blocks.spawner.deactivate-by-redstone", spawnerDeactivateByRedstone);
+     }
+ 
+    public float stonecutterDamage = 0.0F;
+    private void stonecutterSettings() {
+        stonecutterDamage = (float) getDouble("blocks.stonecutter.damage", stonecutterDamage);
+    }
+
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;
--- a/patches/unapplied/0105-Configurable-daylight-cycle.patch
+++ b/patches/unapplied/0105-Configurable-daylight-cycle.patch
@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 10 Oct 2020 14:29:55 -0500
+Subject: [PATCH] Configurable daylight cycle
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTimePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTimePacket.java
+index 689ad22925b2561f7c8db961743eb1f821dbb25f..fa3c960992cc240161817e54659d83fed259f2fe 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTimePacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTimePacket.java
+@@ -5,7 +5,7 @@ import net.minecraft.network.protocol.Packet;
+ 
+ public class ClientboundSetTimePacket implements Packet<ClientGamePacketListener> {
+     private final long gameTime;
+-    private final long dayTime;
+    private long dayTime; public void setDayTime(long dayTime) { this.dayTime = dayTime; } // Purpur
+ 
+     public ClientboundSetTimePacket(long time, long timeOfDay, boolean doDaylightCycle) {
+         this.gameTime = time % 192000; // Paper - fix guardian beam
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index d54e88162fbfe03de3f607d7fb10c9ed0bf311c4..9d156683ee46eb168048b90dd1819ae3dd87e408 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1570,7 +1570,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             long worldTime = world.getGameTime();
+             final ClientboundSetTimePacket worldPacket = new ClientboundSetTimePacket(worldTime, dayTime, doDaylight);
+             for (Player entityhuman : world.players()) {
+-                if (!(entityhuman instanceof ServerPlayer) || (tickCount + entityhuman.getId()) % 20 != 0) {
+                if (!(entityhuman instanceof ServerPlayer) || (!world.isForceTime() && (tickCount + entityhuman.getId()) % 20 != 0)) { // Purpur
+                     continue;
+                 }
+                 ServerPlayer entityplayer = (ServerPlayer) entityhuman;
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 40d5196cbb3567d642925cd7f0d2924884c46347..09800a0c113e1e70ad773e55bd370e7b3c36d463 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -202,6 +202,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     private final StructureFeatureManager structureFeatureManager;
+     private final StructureCheck structureCheck;
+     private final boolean tickTime;
+    private double preciseTime; // Purpur
+    private boolean forceTime; // Purpur
+     // Paper start - execute chunk tasks mid tick
+     public long lastMidTickExecuteFailure;
+     // Paper end - execute chunk tasks mid tick
+@@ -566,6 +568,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
+ 
+         this.asyncChunkTaskManager = new com.destroystokyo.paper.io.chunk.ChunkTaskManager(this); // Paper
+        this.preciseTime = this.serverLevelData.getDayTime(); // Purpur
+     }
+ 
+     public void setWeatherParameters(int clearDuration, int rainDuration, boolean raining, boolean thundering) {
+@@ -734,6 +737,13 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             this.serverLevelData.setGameTime(i);
+             this.serverLevelData.getScheduledEvents().tick(this.server, i);
+             if (this.levelData.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)) {
+                // Purpur start
+                int incrementTicks = isDay() ? this.purpurConfig.daytimeTicks : this.purpurConfig.nighttimeTicks;
+                if (incrementTicks != 12000) {
+                    this.preciseTime += 12000 / (double) incrementTicks;
+                    this.setDayTime(this.preciseTime);
+                } else
+                // Purpur end
+                 this.setDayTime(this.levelData.getDayTime() + 1L);
+             }
+ 
+@@ -742,7 +752,21 @@ public class ServerLevel extends Level implements WorldGenLevel {
+ 
+     public void setDayTime(long timeOfDay) {
+         this.serverLevelData.setDayTime(timeOfDay);
+        // Purpur start
+        this.preciseTime = timeOfDay;
+        this.forceTime = false;
+     }
+    public void setDayTime(double i) {
+        this.serverLevelData.setDayTime((long) i);
+        this.forceTime = true;
+        // Purpur end
+    }
+
+    // Purpur start
+    public boolean isForceTime() {
+        return this.forceTime;
+    }
+    // Purpur end
+ 
+     public void tickCustomSpawners(boolean spawnMonsters, boolean spawnAnimals) {
+         Iterator iterator = this.customSpawners.iterator();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 95667821b8f01ae31c62f0811aed67453b60df4b..f6961d623c5718638c75e2a8775ffcbed65e9bdc 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -121,6 +121,13 @@ public class PurpurWorldConfig {
+         raidCooldownSeconds = getInt("gameplay-mechanics.raid-cooldown-seconds", raidCooldownSeconds);
+     }
+ 
+    public int daytimeTicks = 12000;
+    public int nighttimeTicks = 12000;
+    private void daytimeCycleSettings() {
+        daytimeTicks = getInt("gameplay-mechanics.daylight-cycle-ticks.daytime", daytimeTicks);
+        nighttimeTicks = getInt("gameplay-mechanics.daylight-cycle-ticks.nighttime", nighttimeTicks);
+    }
+
+     public int elytraDamagePerSecond = 1;
+     public double elytraDamageMultiplyBySpeed = 0;
+     public boolean elytraIgnoreUnbreaking = false;
--- a/patches/unapplied/0106-Allow-infinite-and-mending-enchantments-together.patch
+++ b/patches/unapplied/0106-Allow-infinite-and-mending-enchantments-together.patch
@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 13 Oct 2020 20:04:33 -0500
+Subject: [PATCH] Allow infinite and mending enchantments together
+
+
+diff --git a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+index 3aece8245060dd1ba269c08d226c84247a6f0a83..5cebd7c16b82eea9dbf39c51c671bacb7a974d5c 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+++ b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+@@ -24,6 +24,6 @@ public class ArrowInfiniteEnchantment extends Enchantment {
+ 
+     @Override
+     public boolean checkCompatibility(Enchantment other) {
+-        return other instanceof MendingEnchantment ? false : super.checkCompatibility(other);
+        return other instanceof MendingEnchantment ? org.purpurmc.purpur.PurpurConfig.allowInfinityMending : super.checkCompatibility(other);
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 437d2a45f66c2f0f6304365fbc238c24c1571a9f..245239c45cac3340db4e3ab908df91cfec607e3d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -244,6 +244,16 @@ public class PurpurConfig {
+         cryingObsidianValidForPortalFrame = getBoolean("settings.blocks.crying_obsidian.valid-for-portal-frame", cryingObsidianValidForPortalFrame);
+     }
+ 
+    public static boolean allowInfinityMending = false;
+    private static void enchantmentSettings() {
+        if (version < 5) {
+            boolean oldValue = getBoolean("settings.enchantment.allow-infinite-and-mending-together", false);
+            set("settings.enchantment.allow-infinity-and-mending-together", oldValue);
+            set("settings.enchantment.allow-infinite-and-mending-together", null);
+        }
+        allowInfinityMending = getBoolean("settings.enchantment.allow-infinity-and-mending-together", allowInfinityMending);
+    }
+
+     public static boolean endermanShortHeight = false;
+     private static void entitySettings() {
+         endermanShortHeight = getBoolean("settings.entity.enderman.short-height", endermanShortHeight);
--- a/patches/unapplied/0107-Furnace-uses-lava-from-underneath.patch
+++ b/patches/unapplied/0107-Furnace-uses-lava-from-underneath.patch
@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 19 Oct 2020 15:14:01 -0500
+Subject: [PATCH] Furnace uses lava from underneath
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+index 888e1f2bc6ea4ddbbcc5466f177233f25b290459..99c207457ec9d1a1b7d9e7becfcc8aae383e93ae 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+@@ -42,6 +42,7 @@ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.block.AbstractFurnaceBlock;
+ import net.minecraft.world.level.block.Blocks;
+ import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.FluidState;
+ import net.minecraft.world.phys.Vec3;
+ // CraftBukkit start
+ import org.bukkit.craftbukkit.block.CraftBlock;
+@@ -324,6 +325,22 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+ 
+         ItemStack itemstack = (ItemStack) blockEntity.items.get(1);
+ 
+        // Purpur start
+        boolean usedLavaFromUnderneath = false;
+        if (world.purpurConfig.furnaceUseLavaFromUnderneath && !blockEntity.isLit() && itemstack.isEmpty() && !blockEntity.items.get(0).isEmpty() && world.getGameTime() % 20 == 0) {
+            BlockPos below = blockEntity.getBlockPos().below();
+            BlockState belowState = world.getBlockStateIfLoaded(below);
+            if (belowState != null && belowState.is(Blocks.LAVA)) {
+                FluidState fluidState = belowState.getFluidState();
+                if (fluidState != null && fluidState.isSource()) {
+                    world.setBlock(below, Blocks.AIR.defaultBlockState(), 3);
+                    itemstack = Items.LAVA_BUCKET.getDefaultInstance();
+                    usedLavaFromUnderneath = true;
+                }
+            }
+        }
+        // Purpur end
+
+         if (!blockEntity.isLit() && (itemstack.isEmpty() || ((ItemStack) blockEntity.items.get(0)).isEmpty())) {
+             if (!blockEntity.isLit() && blockEntity.cookingProgress > 0) {
+                 blockEntity.cookingProgress = Mth.clamp(blockEntity.cookingProgress - 2, (int) 0, blockEntity.cookingTotalTime);
+@@ -399,6 +416,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+             setChanged(world, pos, state);
+         }
+ 
+        if (usedLavaFromUnderneath) blockEntity.items.set(1, ItemStack.EMPTY); // Purpur
+     }
+ 
+     private static boolean canBurn(@Nullable Recipe<?> recipe, NonNullList<ItemStack> slots, int count) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f6961d623c5718638c75e2a8775ffcbed65e9bdc..5e19075f9244ba96f2420273139c520b1c11f613 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -401,6 +401,17 @@ public class PurpurWorldConfig {
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+     }
+ 
+    public boolean furnaceUseLavaFromUnderneath = false;
+    private void furnaceSettings() {
+        if (PurpurConfig.version < 17) {
+            furnaceUseLavaFromUnderneath = getBoolean("blocks.furnace.infinite-fuel", furnaceUseLavaFromUnderneath);
+            boolean oldValue = getBoolean("blocks.furnace.infinite-fuel", furnaceUseLavaFromUnderneath);
+            set("blocks.furnace.infinite-fuel", null);
+            set("blocks.furnace.use-lava-from-underneath", oldValue);
+        }
+        furnaceUseLavaFromUnderneath = getBoolean("blocks.furnace.use-lava-from-underneath", furnaceUseLavaFromUnderneath);
+    }
+
+     public boolean lavaInfinite = false;
+     public int lavaInfiniteRequiredSources = 2;
+     public int lavaSpeedNether = 10;
--- a/patches/unapplied/0108-Arrows-should-not-reset-despawn-counter.patch
+++ b/patches/unapplied/0108-Arrows-should-not-reset-despawn-counter.patch
@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Wed, 4 Nov 2020 13:12:50 -0600
+Subject: [PATCH] Arrows should not reset despawn counter
+
+This prevents keeping arrows alive indefinitely (such as when the block
+the arrow is stuck in gets removed, like a piston head going up/down)
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+index c5cbcf8d6b26bbb7712d3a72f8313f600dfc7c11..50b531cdaa26af8e06007552fc18cabddbd5f0de 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -321,7 +321,7 @@ public abstract class AbstractArrow extends Projectile {
+         Vec3 vec3d = this.getDeltaMovement();
+ 
+         this.setDeltaMovement(vec3d.multiply((double) (this.random.nextFloat() * 0.2F), (double) (this.random.nextFloat() * 0.2F), (double) (this.random.nextFloat() * 0.2F)));
+-        this.life = 0;
+        // this.life = 0; // Purpur - do not reset despawn counter
+     }
+ 
+     @Override
--- a/patches/unapplied/0109-Ability-to-re-add-farmland-mechanics-from-Alpha.patch
+++ b/patches/unapplied/0109-Ability-to-re-add-farmland-mechanics-from-Alpha.patch
@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yive <admin@yive.me>
+Date: Sat, 14 Nov 2020 08:06:20 -0800
+Subject: [PATCH] Ability to re-add farmland mechanics from Alpha
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FarmBlock.java b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+index f9c363a9148d30b1ecc8f744a7eaa131a9fd1428..c61e8887e697806378686b3b1ffca2b154d1a074 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -112,6 +112,14 @@ public class FarmBlock extends Block {
+                 return;
+             }
+ 
+            // Purpur start
+            if (world.purpurConfig.farmlandAlpha) {
+                Block block = world.getBlockState(pos.below()).getBlock();
+                if (block instanceof FenceBlock || block instanceof WallBlock) {
+                    return;
+                }
+            }
+            // Purpur end
+             if (CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {
+                 return;
+             }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 5e19075f9244ba96f2420273139c520b1c11f613..4616d5d99e08a9be8ccbee3c67046dc3226b1d7b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -397,8 +397,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean farmlandGetsMoistFromBelow = false;
+    public boolean farmlandAlpha = false;
+     private void farmlandSettings() {
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+        farmlandAlpha = getBoolean("blocks.farmland.use-alpha-farmland", farmlandAlpha);
+     }
+ 
+     public boolean furnaceUseLavaFromUnderneath = false;
--- a/patches/unapplied/0110-Add-adjustable-breeding-cooldown-to-config.patch
+++ b/patches/unapplied/0110-Add-adjustable-breeding-cooldown-to-config.patch
@@ -0,0 +1,128 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: montlikadani <montlikada@gmail.com>
+Date: Fri, 13 Nov 2020 17:52:40 +0100
+Subject: [PATCH] Add adjustable breeding cooldown to config
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+index 3f57ad6cbf29ebe1ac3781368c4f57efc9640aa4..fe00672e0231fd1e9fdb91c86d3e76bf505ee15f 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+@@ -151,7 +151,7 @@ public abstract class Animal extends AgeableMob {
+         if (this.isFood(itemstack)) {
+             int i = this.getAge();
+ 
+-            if (!this.level.isClientSide && i == 0 && this.canFallInLove()) {
+            if (!this.level.isClientSide && i == 0 && this.canFallInLove() && (this.level.purpurConfig.animalBreedingCooldownSeconds <= 0 || !this.level.hasBreedingCooldown(player.getUUID(), this.getClass()))) { // Purpur
+                 this.usePlayerItem(player, hand, itemstack);
+                 this.setInLove(player);
+                 this.gameEvent(GameEvent.MOB_INTERACT, this.eyeBlockPosition());
+@@ -240,6 +240,14 @@ public abstract class Animal extends AgeableMob {
+             if (entityplayer == null && other.getLoveCause() != null) {
+                 entityplayer = other.getLoveCause();
+             }
+            // Purpur start
+            if (entityplayer != null && world.purpurConfig.animalBreedingCooldownSeconds > 0) {
+                if (world.hasBreedingCooldown(entityplayer.getUUID(), this.getClass())) {
+                    return;
+                }
+                world.addBreedingCooldown(entityplayer.getUUID(), this.getClass());
+            }
+            // Purpur end
+             // CraftBukkit start - call EntityBreedEvent
+             entityageable.setBaby(true);
+             entityageable.moveTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F);
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index f0d382fdafdf97a0f5cced19f9a6bfa9e817c889..40e01ed99a129a6a14f9c5cc29f046bd23d198cb 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -183,6 +183,49 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+     // Paper end - fix and optimise world upgrading
+ 
+    // Purpur start
+    private com.google.common.cache.Cache<BreedingCooldownPair, Object> playerBreedingCooldowns;
+
+    private com.google.common.cache.Cache<BreedingCooldownPair, Object> getNewBreedingCooldownCache() {
+        return com.google.common.cache.CacheBuilder.newBuilder().expireAfterWrite(this.purpurConfig.animalBreedingCooldownSeconds, java.util.concurrent.TimeUnit.SECONDS).build();
+    }
+
+    public void resetBreedingCooldowns() {
+        this.playerBreedingCooldowns = this.getNewBreedingCooldownCache();
+    }
+
+    public boolean hasBreedingCooldown(java.util.UUID player, Class<? extends net.minecraft.world.entity.animal.Animal> animalType) { // Purpur
+        return this.playerBreedingCooldowns.getIfPresent(new BreedingCooldownPair(player, animalType)) != null;
+    }
+
+    public void addBreedingCooldown(java.util.UUID player, Class<? extends net.minecraft.world.entity.animal.Animal> animalType) {
+        this.playerBreedingCooldowns.put(new BreedingCooldownPair(player, animalType), new Object());
+    }
+
+    private static final class BreedingCooldownPair {
+        private final java.util.UUID playerUUID;
+        private final Class<? extends net.minecraft.world.entity.animal.Animal> animalType;
+
+        public BreedingCooldownPair(java.util.UUID playerUUID, Class<? extends net.minecraft.world.entity.animal.Animal> animalType) {
+            this.playerUUID = playerUUID;
+            this.animalType = animalType;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            BreedingCooldownPair that = (BreedingCooldownPair) o;
+            return playerUUID.equals(that.playerUUID) && animalType.equals(that.animalType);
+        }
+
+        @Override
+        public int hashCode() {
+            return java.util.Objects.hash(playerUUID, animalType);
+        }
+    }
+    // Purpur end
+
+     public CraftWorld getWorld() {
+         return this.world;
+     }
+@@ -276,6 +319,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot
+         this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), this.spigotConfig); // Paper
+         this.purpurConfig = new org.purpurmc.purpur.PurpurWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), env); // Purpur
+        this.playerBreedingCooldowns = this.getNewBreedingCooldownCache(); // Purpur
+         this.generator = gen;
+         this.world = new CraftWorld((ServerLevel) this, gen, biomeProvider, env);
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 4616d5d99e08a9be8ccbee3c67046dc3226b1d7b..54ae2e855d2572a788d852d17a998311691687a0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -109,6 +109,7 @@ public class PurpurWorldConfig {
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+     public int raidCooldownSeconds = 0;
+    public int animalBreedingCooldownSeconds = 0;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+@@ -119,6 +120,7 @@ public class PurpurWorldConfig {
+         voidDamageHeight = getDouble("gameplay-mechanics.void-damage-height", voidDamageHeight);
+         voidDamageDealt = getDouble("gameplay-mechanics.void-damage-dealt", voidDamageDealt);
+         raidCooldownSeconds = getInt("gameplay-mechanics.raid-cooldown-seconds", raidCooldownSeconds);
+        animalBreedingCooldownSeconds = getInt("gameplay-mechanics.animal-breeding-cooldown-seconds", animalBreedingCooldownSeconds);
+     }
+ 
+     public int daytimeTicks = 12000;
+diff --git a/src/main/java/org/purpurmc/purpur/command/PurpurCommand.java b/src/main/java/org/purpurmc/purpur/command/PurpurCommand.java
+index afdf04f8b22ad0b7c0b41675e44687b49c2f86d6..2621e54879e9ab0029a875f1d09eee67878b90d5 100644
+--- a/src/main/java/org/purpurmc/purpur/command/PurpurCommand.java
+++ b/src/main/java/org/purpurmc/purpur/command/PurpurCommand.java
+@@ -49,6 +49,7 @@ public class PurpurCommand extends Command {
+             PurpurConfig.init((File) console.options.valueOf("purpur-settings"));
+             for (ServerLevel level : console.getAllLevels()) {
+                 level.purpurConfig.init();
+                level.resetBreedingCooldowns();
+             }
+             console.server.reloadCount++;
+ 
--- a/patches/unapplied/0111-Make-entity-breeding-times-configurable.patch
+++ b/patches/unapplied/0111-Make-entity-breeding-times-configurable.patch
@@ -0,0 +1,858 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sun, 15 Nov 2020 02:18:15 -0800
+Subject: [PATCH] Make entity breeding times configurable
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerMakeLove.java b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerMakeLove.java
+index d51ab5e4dc93b805bf51f752542f53b2a97fdb20..dcc5d55a3274de1b2b22eab2ab7bf2c0ca013249 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerMakeLove.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerMakeLove.java
+@@ -119,8 +119,10 @@ public class VillagerMakeLove extends Behavior<Villager> {
+                 return Optional.empty();
+             }
+             // CraftBukkit end
+-            parent.setAge(6000);
+-            partner.setAge(6000);
+            // Purpur start
+            parent.setAge(world.purpurConfig.villagerBreedingTicks);
+            partner.setAge(world.purpurConfig.villagerBreedingTicks);
+            // Purpur end
+             world.addFreshEntityWithPassengers(entityvillager2, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.BREEDING); // CraftBukkit - added SpawnReason
+             world.broadcastEntityEvent(entityvillager2, (byte) 12);
+             return Optional.of(entityvillager2);
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+index fe00672e0231fd1e9fdb91c86d3e76bf505ee15f..5771737891b17956a4964a112099f4313e2e55d4 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+@@ -40,6 +40,7 @@ public abstract class Animal extends AgeableMob {
+     @Nullable
+     public UUID loveCause;
+     public ItemStack breedItem; // CraftBukkit - Add breedItem variable
+    public abstract int getPurpurBreedTime(); // Purpur
+ 
+     protected Animal(EntityType<? extends Animal> type, Level world) {
+         super(type, world);
+@@ -264,8 +265,10 @@ public abstract class Animal extends AgeableMob {
+                 CriteriaTriggers.BRED_ANIMALS.trigger(entityplayer, this, other, entityageable);
+             }
+ 
+-            this.setAge(6000);
+-            other.setAge(6000);
+            // Purpur start
+            this.setAge(this.getPurpurBreedTime());
+            other.setAge(other.getPurpurBreedTime());
+            // Purpur end
+             this.resetLove();
+             other.resetLove();
+             world.addFreshEntityWithPassengers(entityageable, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.BREEDING); // CraftBukkit - added SpawnReason
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+index 9245baa69aefee786c442e3b46a323a9c7f22eea..3b272c0e3710885fa0a4ef9b39bfa8874a972e0d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+@@ -218,6 +218,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.beeMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.beeBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+index 81b63da3bca3e3942ed037fad15ad8f883fc0c82..b3df26d3e957f93987d48878a3f320db5e9b229e 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -152,6 +152,11 @@ public class Cat extends TamableAnimal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.catMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.catBreedingTicks;
+    }
+     // Purpur end
+ 
+     public ResourceLocation getResourceLocation() {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Chicken.java b/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+index ad1b52f93e45e1d42c7b31aefe879a692d782ffc..839cb9ff15132f3461317c5ead7c486a0b6fe5e0 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+@@ -75,6 +75,11 @@ public class Chicken extends Animal {
+             this.getAttribute(Attributes.ATTACK_DAMAGE).setBaseValue(2.0D);
+         }
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.chickenBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Cow.java b/src/main/java/net/minecraft/world/entity/animal/Cow.java
+index 732c560383da3b8a270139758f29734d73b775be..b063a74327e51b3cd27427426b92ef687c59c94b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cow.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cow.java
+@@ -62,6 +62,11 @@ public class Cow extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.cowMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.cowBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index 4b42d8047f70d23eed09b6210b447ae2a272af0a..8a73267128c7e165651b97cd46f65f9cd373a1ea 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -183,6 +183,11 @@ public class Fox extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.foxMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.foxBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+@@ -967,8 +972,10 @@ public class Fox extends Animal {
+                     CriteriaTriggers.BRED_ANIMALS.trigger(entityplayer2, this.animal, this.partner, entityfox);
+                 }
+ 
+-                this.animal.setAge(6000);
+-                this.partner.setAge(6000);
+                // Purpur start
+                this.animal.setAge(this.animal.getPurpurBreedTime());
+                this.partner.setAge(this.partner.getPurpurBreedTime());
+                // Purpur end
+                 this.animal.resetLove();
+                 this.partner.resetLove();
+                 worldserver.addFreshEntityWithPassengers(entityfox, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.BREEDING); // CraftBukkit - added SpawnReason
+diff --git a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+index d4237fce253b2414337344b327250c1db2b19dfa..d7c68775fc39222be66bc82e0e7a1b0ae3238f7a 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+@@ -84,6 +84,11 @@ public class MushroomCow extends Cow implements Shearable {
+     public void initAttributes() {
+         this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.mooshroomMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.mooshroomBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+index a90c3e0c9f0064690bd17e5b132fbcfb360fa6b2..0719a17e886b6525d7ed091f1759eed12a945034 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+@@ -88,6 +88,11 @@ public class Ocelot extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.ocelotMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.ocelotBreedingTicks;
+    }
+     // Purpur end
+ 
+     public boolean isTrusting() {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Panda.java b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+index bcbf20728b4c9a181771984c54af742f07fd9855..83fdc33da473c8ddf69bb20125bf38f6801f8fce 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+@@ -137,6 +137,11 @@ public class Panda extends Animal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.pandaMaxHealth);
+         setAttributes();
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.pandaBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Parrot.java b/src/main/java/net/minecraft/world/entity/animal/Parrot.java
+index 91b8117238e76c00d758180df5cfd70ae76ace22..1539668c100352f7e8980f3b9db02b6fb979299b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Parrot.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Parrot.java
+@@ -189,6 +189,11 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.parrotMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return 6000;
+    }
+     // Purpur end
+ 
+     @Nullable
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Pig.java b/src/main/java/net/minecraft/world/entity/animal/Pig.java
+index 7787d30ad7bb9aa6041c369a368deb382c9554c2..93f670fe1512ec18272c2e4d71735bcbdbc87eda 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Pig.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Pig.java
+@@ -84,6 +84,11 @@ public class Pig extends Animal implements ItemSteerable, Saddleable {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.pigMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.pigBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+index b370a0c392f69a1b42a4908ae012ee4c6bf6984d..0f4a0e50e701c3fb75536e0b6d7821046e7f8f66 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+++ b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+@@ -118,6 +118,11 @@ public class PolarBear extends Animal implements NeutralMob {
+             return this.isInLove() && bear.isInLove();
+         }
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.polarBearBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+index 5b30a1d34d7efb1a5c86ae187027313fec1fd700..8d44949c54f9cba0848b4f7b82c573325c134d9d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+@@ -141,6 +141,11 @@ public class Rabbit extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.rabbitMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.rabbitBreedingTicks;
+    }
+     // Purpur end
+ 
+     // CraftBukkit start - code from constructor
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Sheep.java b/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+index 9d6765e2bd6bfdd39728bdd14cabbe4bf33d96ac..86f398fc79dcc5dd24a61483d292e228dd6ab83b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+@@ -136,6 +136,11 @@ public class Sheep extends Animal implements Shearable {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.sheepMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.sheepBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+index 54ad776603158f101c0199395f70dadb80301a8d..e3bf2c2bc16bc03c17d90f2ce1620c6b895e9bf7 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+@@ -104,6 +104,11 @@ public class Turtle extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.turtleMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.turtleBreedingTicks;
+    }
+     // Purpur end
+ 
+     public void setHomePos(BlockPos pos) {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Wolf.java b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+index 6312284ee33eef280a51392d7e0ba8d2ae3c9d5e..702a4b674013a455d179d88d3931f6c216c1ca89 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -127,6 +127,11 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.wolfMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.wolfBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+index c194c215ec742dd5a527af98ef7d8a707193921a..0f38b65d490cde61cfc256719f91cc0a955b4080 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+@@ -124,6 +124,11 @@ public class Axolotl extends Animal implements LerpingModel, Bucketable {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.axolotlMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.axolotlBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+index c5a86e91465e725fd11d19fd668c1ba6bbe981ac..a697a094679c61e357177bc22e628c347b39a4d9 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+@@ -89,6 +89,11 @@ public class Goat extends Animal {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.goatMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.goatBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java b/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java
+index f0da5d107ddb2987ccc89f880ddba5e79fadf0c5..113b6d80885717d59c8fefab07afe68779f0051d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java
+@@ -35,6 +35,11 @@ public class Donkey extends AbstractChestedHorse {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.donkeyMovementSpeedMin, this.level.purpurConfig.donkeyMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.donkeyBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java b/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java
+index 9f7203608e15fdce1bfbaf419838768763d61378..2c5cb1b759a0b6e0233345da5a968288ec338837 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java
+@@ -59,6 +59,11 @@ public class Horse extends AbstractHorse {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.horseMovementSpeedMin, this.level.purpurConfig.horseMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.horseBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+index 93c6e0d538dfa796b5a5b4f57d3f76fa2eef77ab..5553cffdbaf308c543d0afed467acd3e6a0f8956 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+@@ -131,6 +131,11 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.llamaMovementSpeedMin, this.level.purpurConfig.llamaMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.llamaBreedingTicks;
+    }
+     // Purpur end
+ 
+     public boolean isTraderLlama() {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java b/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java
+index 1ba32a3ba56974425762026026d1e5ba21540b3b..88e61572f5dd8d05fadab131046f74bd8131f42b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java
+@@ -34,6 +34,11 @@ public class Mule extends AbstractChestedHorse {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.muleMovementSpeedMin, this.level.purpurConfig.muleMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.muleBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java
+index 3c3be1a40f04def3f2ffb6567fa5be0581b5608d..e7910b0bbb061f524909757dab4c7e59c0dc40c9 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java
+@@ -50,6 +50,11 @@ public class SkeletonHorse extends AbstractHorse {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.skeletonHorseMovementSpeedMin, this.level.purpurConfig.skeletonHorseMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return 6000;
+    }
+     // Purpur end
+ 
+     public static AttributeSupplier.Builder createAttributes() {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java b/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java
+index 89f3c480d2e8cc28bb26fcd65a5a51a652e7365a..bdb71283d402656a3da6dd699d4cd6a5c935e541 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java
+@@ -62,6 +62,11 @@ public class TraderLlama extends Llama {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.traderLlamaMovementSpeedMin, this.level.purpurConfig.traderLlamaMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.traderLlamaBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java
+index 48b72eb4051d612648a1978b38299c0c37a3a289..b6d9ba8dd5694952ca2eba54726ac5e587175250 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java
+@@ -47,6 +47,11 @@ public class ZombieHorse extends AbstractHorse {
+     public double generateRandomSpeed() {
+         return generateRandomSpeed(this.level.purpurConfig.zombieHorseMovementSpeedMin, this.level.purpurConfig.zombieHorseMovementSpeedMax);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return 6000;
+    }
+     // Purpur end
+ 
+     public static AttributeSupplier.Builder createAttributes() {
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Strider.java b/src/main/java/net/minecraft/world/entity/monster/Strider.java
+index e3f7816bb261c7772d86bd117ce30a53e77f44d1..0046bc4f7a1fb7bb40da955570d56c7cb87aa687 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Strider.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java
+@@ -116,6 +116,11 @@ public class Strider extends Animal implements ItemSteerable, Saddleable {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.striderMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.striderBreedingTicks;
+    }
+     // Purpur end
+ 
+     public static boolean checkStriderSpawnRules(EntityType<Strider> type, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) {
+diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
+index 65e6fbd8077777c63908f9faf6e387d28c86e808..5f879e65f3a6c0fea3e962716b61651fd54bcf6d 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
+++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
+@@ -87,6 +87,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.hoglinMaxHealth);
+     }
+
+    @Override
+    public int getPurpurBreedTime() {
+        return this.level.purpurConfig.hoglinBreedingTicks;
+    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 54ae2e855d2572a788d852d17a998311691687a0..662167abae0bfd964fb08741b4660ba3db068eca 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -486,10 +486,12 @@ public class PurpurWorldConfig {
+     public boolean axolotlRidable = false;
+     public boolean axolotlControllable = true;
+     public double axolotlMaxHealth = 14.0D;
+    public int axolotlBreedingTicks = 6000;
+     private void axolotlSettings() {
+         axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable);
+         axolotlControllable = getBoolean("mobs.axolotl.controllable", axolotlControllable);
+         axolotlMaxHealth = getDouble("mobs.axolotl.attributes.max_health", axolotlMaxHealth);
+        axolotlBreedingTicks = getInt("mobs.axolotl.breeding-delay-ticks", axolotlBreedingTicks);
+     }
+ 
+     public boolean batRidable = false;
+@@ -522,6 +524,7 @@ public class PurpurWorldConfig {
+     public boolean beeControllable = true;
+     public double beeMaxY = 320D;
+     public double beeMaxHealth = 10.0D;
+    public int beeBreedingTicks = 6000;
+     private void beeSettings() {
+         beeRidable = getBoolean("mobs.bee.ridable", beeRidable);
+         beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater);
+@@ -533,6 +536,7 @@ public class PurpurWorldConfig {
+             set("mobs.bee.attributes.max_health", oldValue);
+         }
+         beeMaxHealth = getDouble("mobs.bee.attributes.max_health", beeMaxHealth);
+        beeBreedingTicks = getInt("mobs.bee.breeding-delay-ticks", beeBreedingTicks);
+     }
+ 
+     public boolean blazeRidable = false;
+@@ -560,6 +564,7 @@ public class PurpurWorldConfig {
+     public int catSpawnDelay = 1200;
+     public int catSpawnSwampHutScanRange = 16;
+     public int catSpawnVillageScanRange = 48;
+    public int catBreedingTicks = 6000;
+     private void catSettings() {
+         catRidable = getBoolean("mobs.cat.ridable", catRidable);
+         catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater);
+@@ -573,6 +578,7 @@ public class PurpurWorldConfig {
+         catSpawnDelay = getInt("mobs.cat.spawn-delay", catSpawnDelay);
+         catSpawnSwampHutScanRange = getInt("mobs.cat.scan-range-for-other-cats.swamp-hut", catSpawnSwampHutScanRange);
+         catSpawnVillageScanRange = getInt("mobs.cat.scan-range-for-other-cats.village", catSpawnVillageScanRange);
+        catBreedingTicks = getInt("mobs.cat.breeding-delay-ticks", catBreedingTicks);
+     }
+ 
+     public boolean caveSpiderRidable = false;
+@@ -596,6 +602,7 @@ public class PurpurWorldConfig {
+     public boolean chickenControllable = true;
+     public double chickenMaxHealth = 4.0D;
+     public boolean chickenRetaliate = false;
+    public int chickenBreedingTicks = 6000;
+     private void chickenSettings() {
+         chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable);
+         chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater);
+@@ -607,6 +614,7 @@ public class PurpurWorldConfig {
+         }
+         chickenMaxHealth = getDouble("mobs.chicken.attributes.max_health", chickenMaxHealth);
+         chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate);
+        chickenBreedingTicks = getInt("mobs.chicken.breeding-delay-ticks", chickenBreedingTicks);
+     }
+ 
+     public boolean codRidable = false;
+@@ -628,6 +636,7 @@ public class PurpurWorldConfig {
+     public boolean cowControllable = true;
+     public double cowMaxHealth = 10.0D;
+     public int cowFeedMushrooms = 0;
+    public int cowBreedingTicks = 6000;
+     private void cowSettings() {
+         cowRidable = getBoolean("mobs.cow.ridable", cowRidable);
+         cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater);
+@@ -639,6 +648,7 @@ public class PurpurWorldConfig {
+         }
+         cowMaxHealth = getDouble("mobs.cow.attributes.max_health", cowMaxHealth);
+         cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms);
+        cowBreedingTicks = getInt("mobs.cow.breeding-delay-ticks", cowBreedingTicks);
+     }
+ 
+     public boolean creeperRidable = false;
+@@ -690,6 +700,7 @@ public class PurpurWorldConfig {
+     public double donkeyJumpStrengthMax = 0.5D;
+     public double donkeyMovementSpeedMin = 0.175D;
+     public double donkeyMovementSpeedMax = 0.175D;
+    public int donkeyBreedingTicks = 6000;
+     private void donkeySettings() {
+         donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater);
+         if (PurpurConfig.version < 10) {
+@@ -705,6 +716,7 @@ public class PurpurWorldConfig {
+         donkeyJumpStrengthMax = getDouble("mobs.donkey.attributes.jump_strength.max", donkeyJumpStrengthMax);
+         donkeyMovementSpeedMin = getDouble("mobs.donkey.attributes.movement_speed.min", donkeyMovementSpeedMin);
+         donkeyMovementSpeedMax = getDouble("mobs.donkey.attributes.movement_speed.max", donkeyMovementSpeedMax);
+        donkeyBreedingTicks = getInt("mobs.donkey.breeding-delay-ticks", donkeyBreedingTicks);
+     }
+ 
+     public boolean drownedRidable = false;
+@@ -824,6 +836,7 @@ public class PurpurWorldConfig {
+     public boolean foxControllable = true;
+     public double foxMaxHealth = 10.0D;
+     public boolean foxTypeChangesWithTulips = false;
+    public int foxBreedingTicks = 6000;
+     private void foxSettings() {
+         foxRidable = getBoolean("mobs.fox.ridable", foxRidable);
+         foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater);
+@@ -835,6 +848,7 @@ public class PurpurWorldConfig {
+         }
+         foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth);
+         foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips);
+        foxBreedingTicks = getInt("mobs.fox.breeding-delay-ticks", foxBreedingTicks);
+     }
+ 
+     public boolean ghastRidable = false;
+@@ -902,11 +916,13 @@ public class PurpurWorldConfig {
+     public boolean goatRidableInWater = false;
+     public boolean goatControllable = true;
+     public double goatMaxHealth = 10.0D;
+    public int goatBreedingTicks = 6000;
+     private void goatSettings() {
+         goatRidable = getBoolean("mobs.goat.ridable", goatRidable);
+         goatRidableInWater = getBoolean("mobs.goat.ridable-in-water", goatRidableInWater);
+         goatControllable = getBoolean("mobs.goat.controllable", goatControllable);
+         goatMaxHealth = getDouble("mobs.goat.attributes.max_health", goatMaxHealth);
+        goatBreedingTicks = getInt("mobs.goat.breeding-delay-ticks", goatBreedingTicks);
+     }
+ 
+     public boolean guardianRidable = false;
+@@ -927,6 +943,7 @@ public class PurpurWorldConfig {
+     public boolean hoglinRidableInWater = false;
+     public boolean hoglinControllable = true;
+     public double hoglinMaxHealth = 40.0D;
+    public int hoglinBreedingTicks = 6000;
+     private void hoglinSettings() {
+         hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable);
+         hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater);
+@@ -937,6 +954,7 @@ public class PurpurWorldConfig {
+             set("mobs.hoglin.attributes.max_health", oldValue);
+         }
+         hoglinMaxHealth = getDouble("mobs.hoglin.attributes.max_health", hoglinMaxHealth);
+        hoglinBreedingTicks = getInt("mobs.hoglin.breeding-delay-ticks", hoglinBreedingTicks);
+     }
+ 
+     public boolean horseRidableInWater = false;
+@@ -946,6 +964,7 @@ public class PurpurWorldConfig {
+     public double horseJumpStrengthMax = 1.0D;
+     public double horseMovementSpeedMin = 0.1125D;
+     public double horseMovementSpeedMax = 0.3375D;
+    public int horseBreedingTicks = 6000;
+     private void horseSettings() {
+         horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater);
+         if (PurpurConfig.version < 10) {
+@@ -961,6 +980,7 @@ public class PurpurWorldConfig {
+         horseJumpStrengthMax = getDouble("mobs.horse.attributes.jump_strength.max", horseJumpStrengthMax);
+         horseMovementSpeedMin = getDouble("mobs.horse.attributes.movement_speed.min", horseMovementSpeedMin);
+         horseMovementSpeedMax = getDouble("mobs.horse.attributes.movement_speed.max", horseMovementSpeedMax);
+        horseBreedingTicks = getInt("mobs.horse.breeding-delay-ticks", horseBreedingTicks);
+     }
+ 
+     public boolean huskRidable = false;
+@@ -1038,6 +1058,7 @@ public class PurpurWorldConfig {
+     public double llamaJumpStrengthMax = 0.5D;
+     public double llamaMovementSpeedMin = 0.175D;
+     public double llamaMovementSpeedMax = 0.175D;
+    public int llamaBreedingTicks = 6000;
+     private void llamaSettings() {
+         llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable);
+         llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater);
+@@ -1055,6 +1076,7 @@ public class PurpurWorldConfig {
+         llamaJumpStrengthMax = getDouble("mobs.llama.attributes.jump_strength.max", llamaJumpStrengthMax);
+         llamaMovementSpeedMin = getDouble("mobs.llama.attributes.movement_speed.min", llamaMovementSpeedMin);
+         llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax);
+        llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks);
+     }
+ 
+     public boolean magmaCubeRidable = false;
+@@ -1083,6 +1105,7 @@ public class PurpurWorldConfig {
+     public boolean mooshroomRidableInWater = false;
+     public boolean mooshroomControllable = true;
+     public double mooshroomMaxHealth = 10.0D;
+    public int mooshroomBreedingTicks = 6000;
+     private void mooshroomSettings() {
+         mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable);
+         mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater);
+@@ -1093,6 +1116,7 @@ public class PurpurWorldConfig {
+             set("mobs.mooshroom.attributes.max_health", oldValue);
+         }
+         mooshroomMaxHealth = getDouble("mobs.mooshroom.attributes.max_health", mooshroomMaxHealth);
+        mooshroomBreedingTicks = getInt("mobs.mooshroom.breeding-delay-ticks", mooshroomBreedingTicks);
+     }
+ 
+     public boolean muleRidableInWater = false;
+@@ -1102,6 +1126,7 @@ public class PurpurWorldConfig {
+     public double muleJumpStrengthMax = 0.5D;
+     public double muleMovementSpeedMin = 0.175D;
+     public double muleMovementSpeedMax = 0.175D;
+    public int muleBreedingTicks = 6000;
+     private void muleSettings() {
+         muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater);
+         if (PurpurConfig.version < 10) {
+@@ -1117,12 +1142,14 @@ public class PurpurWorldConfig {
+         muleJumpStrengthMax = getDouble("mobs.mule.attributes.jump_strength.max", muleJumpStrengthMax);
+         muleMovementSpeedMin = getDouble("mobs.mule.attributes.movement_speed.min", muleMovementSpeedMin);
+         muleMovementSpeedMax = getDouble("mobs.mule.attributes.movement_speed.max", muleMovementSpeedMax);
+        muleBreedingTicks = getInt("mobs.mule.breeding-delay-ticks", muleBreedingTicks);
+     }
+ 
+     public boolean ocelotRidable = false;
+     public boolean ocelotRidableInWater = false;
+     public boolean ocelotControllable = true;
+     public double ocelotMaxHealth = 10.0D;
+    public int ocelotBreedingTicks = 6000;
+     private void ocelotSettings() {
+         ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable);
+         ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater);
+@@ -1133,12 +1160,14 @@ public class PurpurWorldConfig {
+             set("mobs.ocelot.attributes.max_health", oldValue);
+         }
+         ocelotMaxHealth = getDouble("mobs.ocelot.attributes.max_health", ocelotMaxHealth);
+        ocelotBreedingTicks = getInt("mobs.ocelot.breeding-delay-ticks", ocelotBreedingTicks);
+     }
+ 
+     public boolean pandaRidable = false;
+     public boolean pandaRidableInWater = false;
+     public boolean pandaControllable = true;
+     public double pandaMaxHealth = 20.0D;
+    public int pandaBreedingTicks = 6000;
+     private void pandaSettings() {
+         pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable);
+         pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater);
+@@ -1149,6 +1178,7 @@ public class PurpurWorldConfig {
+             set("mobs.panda.attributes.max_health", oldValue);
+         }
+         pandaMaxHealth = getDouble("mobs.panda.attributes.max_health", pandaMaxHealth);
+        pandaBreedingTicks = getInt("mobs.panda.breeding-delay-ticks", pandaBreedingTicks);
+     }
+ 
+     public boolean parrotRidable = false;
+@@ -1244,6 +1274,7 @@ public class PurpurWorldConfig {
+     public boolean pigControllable = true;
+     public double pigMaxHealth = 10.0D;
+     public boolean pigGiveSaddleBack = false;
+    public int pigBreedingTicks = 6000;
+     private void pigSettings() {
+         pigRidable = getBoolean("mobs.pig.ridable", pigRidable);
+         pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater);
+@@ -1255,6 +1286,7 @@ public class PurpurWorldConfig {
+         }
+         pigMaxHealth = getDouble("mobs.pig.attributes.max_health", pigMaxHealth);
+         pigGiveSaddleBack = getBoolean("mobs.pig.give-saddle-back", pigGiveSaddleBack);
+        pigBreedingTicks = getInt("mobs.pig.breeding-delay-ticks", pigBreedingTicks);
+     }
+ 
+     public boolean piglinRidable = false;
+@@ -1311,6 +1343,7 @@ public class PurpurWorldConfig {
+     public double polarBearMaxHealth = 30.0D;
+     public String polarBearBreedableItemString = "";
+     public Item polarBearBreedableItem = null;
+    public int polarBearBreedingTicks = 6000;
+     private void polarBearSettings() {
+         polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable);
+         polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater);
+@@ -1324,6 +1357,7 @@ public class PurpurWorldConfig {
+         polarBearBreedableItemString = getString("mobs.polar_bear.breedable-item", polarBearBreedableItemString);
+         Item item = Registry.ITEM.get(new ResourceLocation(polarBearBreedableItemString));
+         if (item != Items.AIR) polarBearBreedableItem = item;
+        polarBearBreedingTicks = getInt("mobs.polar_bear.breeding-delay-ticks", polarBearBreedingTicks);
+     }
+ 
+     public boolean pufferfishRidable = false;
+@@ -1346,6 +1380,7 @@ public class PurpurWorldConfig {
+     public double rabbitMaxHealth = 3.0D;
+     public double rabbitNaturalToast = 0.0D;
+     public double rabbitNaturalKiller = 0.0D;
+    public int rabbitBreedingTicks = 6000;
+     private void rabbitSettings() {
+         rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable);
+         rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater);
+@@ -1358,6 +1393,7 @@ public class PurpurWorldConfig {
+         rabbitMaxHealth = getDouble("mobs.rabbit.attributes.max_health", rabbitMaxHealth);
+         rabbitNaturalToast = getDouble("mobs.rabbit.spawn-toast-chance", rabbitNaturalToast);
+         rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller);
+        rabbitBreedingTicks = getInt("mobs.rabbit.breeding-delay-ticks", rabbitBreedingTicks);
+     }
+ 
+     public boolean ravagerRidable = false;
+@@ -1394,6 +1430,7 @@ public class PurpurWorldConfig {
+     public boolean sheepRidableInWater = false;
+     public boolean sheepControllable = true;
+     public double sheepMaxHealth = 8.0D;
+    public int sheepBreedingTicks = 6000;
+     private void sheepSettings() {
+         sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable);
+         sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater);
+@@ -1404,6 +1441,7 @@ public class PurpurWorldConfig {
+             set("mobs.sheep.attributes.max_health", oldValue);
+         }
+         sheepMaxHealth = getDouble("mobs.sheep.attributes.max_health", sheepMaxHealth);
+        sheepBreedingTicks = getInt("mobs.sheep.breeding-delay-ticks", sheepBreedingTicks);
+     }
+ 
+     public boolean shulkerRidable = false;
+@@ -1579,6 +1617,7 @@ public class PurpurWorldConfig {
+     public boolean striderRidableInWater = false;
+     public boolean striderControllable = true;
+     public double striderMaxHealth = 20.0D;
+    public int striderBreedingTicks = 6000;
+     private void striderSettings() {
+         striderRidable = getBoolean("mobs.strider.ridable", striderRidable);
+         striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater);
+@@ -1589,6 +1628,7 @@ public class PurpurWorldConfig {
+             set("mobs.strider.attributes.max_health", oldValue);
+         }
+         striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth);
+        striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks);
+     }
+ 
+     public boolean traderLlamaRidable = false;
+@@ -1600,6 +1640,7 @@ public class PurpurWorldConfig {
+     public double traderLlamaJumpStrengthMax = 0.5D;
+     public double traderLlamaMovementSpeedMin = 0.175D;
+     public double traderLlamaMovementSpeedMax = 0.175D;
+    public int traderLlamaBreedingTicks = 6000;
+     private void traderLlamaSettings() {
+         traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable);
+         traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater);
+@@ -1617,6 +1658,7 @@ public class PurpurWorldConfig {
+         traderLlamaJumpStrengthMax = getDouble("mobs.trader_llama.attributes.jump_strength.max", traderLlamaJumpStrengthMax);
+         traderLlamaMovementSpeedMin = getDouble("mobs.trader_llama.attributes.movement_speed.min", traderLlamaMovementSpeedMin);
+         traderLlamaMovementSpeedMax = getDouble("mobs.trader_llama.attributes.movement_speed.max", traderLlamaMovementSpeedMax);
+        traderLlamaBreedingTicks = getInt("mobs.trader_llama.breeding-delay-ticks", traderLlamaBreedingTicks);
+     }
+ 
+     public boolean tropicalFishRidable = false;
+@@ -1637,6 +1679,7 @@ public class PurpurWorldConfig {
+     public boolean turtleRidableInWater = false;
+     public boolean turtleControllable = true;
+     public double turtleMaxHealth = 30.0D;
+    public int turtleBreedingTicks = 6000;
+     private void turtleSettings() {
+         turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable);
+         turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater);
+@@ -1647,6 +1690,7 @@ public class PurpurWorldConfig {
+             set("mobs.turtle.attributes.max_health", oldValue);
+         }
+         turtleMaxHealth = getDouble("mobs.turtle.attributes.max_health", turtleMaxHealth);
+        turtleBreedingTicks = getInt("mobs.turtle.breeding-delay-ticks", turtleBreedingTicks);
+     }
+ 
+     public boolean vexRidable = false;
+@@ -1678,6 +1722,7 @@ public class PurpurWorldConfig {
+     public int villagerSpawnIronGolemRadius = 0;
+     public int villagerSpawnIronGolemLimit = 0;
+     public boolean villagerCanBreed = true;
+    public int villagerBreedingTicks = 6000;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1695,6 +1740,7 @@ public class PurpurWorldConfig {
+         villagerSpawnIronGolemRadius = getInt("mobs.villager.spawn-iron-golem.radius", villagerSpawnIronGolemRadius);
+         villagerSpawnIronGolemLimit = getInt("mobs.villager.spawn-iron-golem.limit", villagerSpawnIronGolemLimit);
+         villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed);
+        villagerBreedingTicks = getInt("mobs.villager.breeding-delay-ticks", villagerBreedingTicks);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1797,6 +1843,7 @@ public class PurpurWorldConfig {
+     public boolean wolfRidableInWater = false;
+     public boolean wolfControllable = true;
+     public double wolfMaxHealth = 8.0D;
+    public int wolfBreedingTicks = 6000;
+     private void wolfSettings() {
+         wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable);
+         wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater);
+@@ -1807,6 +1854,7 @@ public class PurpurWorldConfig {
+             set("mobs.wolf.attributes.max_health", oldValue);
+         }
+         wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth);
+        wolfBreedingTicks = getInt("mobs.wolf.breeding-delay-ticks", wolfBreedingTicks);
+     }
+ 
+     public boolean zoglinRidable = false;
--- a/patches/unapplied/0112-Apply-display-names-from-item-forms-of-entities-to-e.patch
+++ b/patches/unapplied/0112-Apply-display-names-from-item-forms-of-entities-to-e.patch
@@ -0,0 +1,174 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Tue, 17 Nov 2020 03:23:48 -0800
+Subject: [PATCH] Apply display names from item forms of entities to entities
+ and vice versa
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+index dc1630a1a769f848059f576c3d1220a216b5465c..50370dc8697569a4e5cf8ec3714d227a59357d64 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -596,7 +596,13 @@ public class ArmorStand extends LivingEntity {
+     }
+ 
+     private void brokenByPlayer(DamageSource damageSource) {
+-        drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(new ItemStack(Items.ARMOR_STAND))); // CraftBukkit - add to drops
+        // Purpur start
+        final ItemStack armorStand = new ItemStack(Items.ARMOR_STAND);
+        if (this.level.purpurConfig.persistentDroppableEntityDisplayNames && this.hasCustomName()) {
+            armorStand.setHoverName(this.getCustomName());
+        }
+        drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(armorStand)); // CraftBukkit - add to drops
+        // Purpur end
+         this.brokenByAnything(damageSource);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+index f134a2e68d50fba021b19fac4c75fb35d0e252c6..37133b573d41f1ce67cf1fe6ae7429c52b9bbd0a 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -265,7 +265,13 @@ public class ItemFrame extends HangingEntity {
+                 }
+ 
+                 if (alwaysDrop) {
+-                    this.spawnAtLocation(this.getFrameItemStack());
+                    // Purpur start
+                    final ItemStack itemFrame = this.getFrameItemStack();
+                    if (this.level.purpurConfig.persistentDroppableEntityDisplayNames && this.hasCustomName()) {
+                        itemFrame.setHoverName(this.getCustomName());
+                    }
+                    this.spawnAtLocation(itemFrame);
+                    // Purpur end
+                 }
+ 
+                 if (!itemstack.isEmpty()) {
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/Painting.java b/src/main/java/net/minecraft/world/entity/decoration/Painting.java
+index 359f6cf63319ad9f125cdea848852def8a1ec1c8..b5ff43e866c3c43085e91b38c31c4845682e7555 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/Painting.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/Painting.java
+@@ -102,7 +102,13 @@ public class Painting extends HangingEntity {
+                 }
+             }
+ 
+-            this.spawnAtLocation(Items.PAINTING);
+            // Purpur start
+            final ItemStack painting = new ItemStack(Items.PAINTING);
+            if (this.level.purpurConfig.persistentDroppableEntityDisplayNames && this.hasCustomName()) {
+                painting.setHoverName(this.getCustomName());
+            }
+            this.spawnAtLocation(painting);
+            // Purpur end
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+index e4febdebc760f9babd77c55e87acccdc1625f0a5..04f9ef39aa4c27200c4c55c50f6eabc0f420cf80 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+++ b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+@@ -207,7 +207,13 @@ public class Boat extends Entity {
+                 }
+                 // CraftBukkit end
+                 if (!flag && this.level.getGameRules().getBoolean(GameRules.RULE_DOENTITYDROPS)) {
+-                    this.spawnAtLocation((ItemLike) this.getDropItem());
+                    // Purpur start
+                    final ItemStack boat = new ItemStack(this.getDropItem());
+                    if (this.level.purpurConfig.persistentDroppableEntityDisplayNames && this.hasCustomName()) {
+                        boat.setHoverName(this.getCustomName());
+                    }
+                    this.spawnAtLocation(boat);
+                    // Purpur end
+                 }
+ 
+                 this.discard();
+diff --git a/src/main/java/net/minecraft/world/item/ArmorStandItem.java b/src/main/java/net/minecraft/world/item/ArmorStandItem.java
+index 3344e3f8ed0fe56217aae7ad9ed32ed4cc19bd07..623627e411ec4ca8168748bfa42e432133612309 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorStandItem.java
+++ b/src/main/java/net/minecraft/world/item/ArmorStandItem.java
+@@ -60,6 +60,14 @@ public class ArmorStandItem extends Item {
+                         return InteractionResult.FAIL;
+                     }
+                     // CraftBukkit end
+                    // Purpur start
+                    if (world.purpurConfig.persistentDroppableEntityDisplayNames && itemstack.hasCustomHoverName()) {
+                        entityarmorstand.setCustomName(itemstack.getHoverName());
+                        if (world.purpurConfig.armorstandSetNameVisible) {
+                            entityarmorstand.setCustomNameVisible(true);
+                        }
+                    }
+                    // Purpur end
+                     worldserver.addFreshEntityWithPassengers(entityarmorstand);
+                     world.playSound((Player) null, entityarmorstand.getX(), entityarmorstand.getY(), entityarmorstand.getZ(), SoundEvents.ARMOR_STAND_PLACE, SoundSource.BLOCKS, 0.75F, 0.8F);
+                     world.gameEvent(context.getPlayer(), GameEvent.ENTITY_PLACE, (Entity) entityarmorstand);
+diff --git a/src/main/java/net/minecraft/world/item/BoatItem.java b/src/main/java/net/minecraft/world/item/BoatItem.java
+index 8c590da15b2dbca867efaaadcc3db3bb8309d444..49fe3a66dd3660b94d450dfd408de13a31f5e94d 100644
+--- a/src/main/java/net/minecraft/world/item/BoatItem.java
+++ b/src/main/java/net/minecraft/world/item/BoatItem.java
+@@ -67,6 +67,11 @@ public class BoatItem extends Item {
+ 
+                 entityboat.setType(this.type);
+                 entityboat.setYRot(user.getYRot());
+                // Purpur start
+                if (world.purpurConfig.persistentDroppableEntityDisplayNames && itemstack.hasCustomHoverName()) {
+                    entityboat.setCustomName(itemstack.getHoverName());
+                }
+                // Purpur end
+                 if (!world.noCollision(entityboat, entityboat.getBoundingBox())) {
+                     return InteractionResultHolder.fail(itemstack);
+                 } else {
+diff --git a/src/main/java/net/minecraft/world/item/HangingEntityItem.java b/src/main/java/net/minecraft/world/item/HangingEntityItem.java
+index 0284201b0bb0f5c9a4a2393cf0d83e8e21262df3..1f46a2be362ed5f60a7ca75916fe7bd491e90db7 100644
+--- a/src/main/java/net/minecraft/world/item/HangingEntityItem.java
+++ b/src/main/java/net/minecraft/world/item/HangingEntityItem.java
+@@ -40,7 +40,7 @@ public class HangingEntityItem extends Item {
+             return InteractionResult.FAIL;
+         } else {
+             Level world = context.getLevel();
+-            Object object;
+            Entity object; // Purpur
+ 
+             if (this.type == EntityType.PAINTING) {
+                 object = new Painting(world, blockposition1, enumdirection);
+@@ -58,6 +58,11 @@ public class HangingEntityItem extends Item {
+ 
+             if (nbttagcompound != null) {
+                 EntityType.updateCustomEntityTag(world, entityhuman, (Entity) object, nbttagcompound);
+                // Purpur start
+                if (world.purpurConfig.persistentDroppableEntityDisplayNames && itemstack.hasCustomHoverName()) {
+                    object.setCustomName(itemstack.getHoverName());
+                }
+                // Purpur end
+             }
+ 
+             if (((HangingEntity) object).survives()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 662167abae0bfd964fb08741b4660ba3db068eca..bb21296b581ba3674425d32665d8a1f30063e177 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -96,8 +96,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public float armorstandStepHeight = 0.0F;
+    public boolean armorstandSetNameVisible = false;
+     private void armorstandSettings() {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+        armorstandSetNameVisible = getBoolean("gameplay-mechanics.armorstand.set-name-visible-when-placing-with-custom-name", armorstandSetNameVisible);
+     }
+ 
+     public boolean useBetterMending = false;
+@@ -105,6 +107,7 @@ public class PurpurWorldConfig {
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean entitiesCanUsePortals = true;
+     public boolean milkCuresBadOmen = true;
+    public boolean persistentDroppableEntityDisplayNames = false;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+@@ -116,6 +119,7 @@ public class PurpurWorldConfig {
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         entitiesCanUsePortals = getBoolean("gameplay-mechanics.entities-can-use-portals", entitiesCanUsePortals);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+        persistentDroppableEntityDisplayNames = getBoolean("gameplay-mechanics.persistent-droppable-entity-display-names", persistentDroppableEntityDisplayNames);
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);
+         voidDamageHeight = getDouble("gameplay-mechanics.void-damage-height", voidDamageHeight);
+         voidDamageDealt = getDouble("gameplay-mechanics.void-damage-dealt", voidDamageDealt);
--- a/patches/unapplied/0113-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch
+++ b/patches/unapplied/0113-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Tue, 17 Nov 2020 13:12:09 -0800
+Subject: [PATCH] Set name visible when using a Name Tag on an Armor Stand
+
+
+diff --git a/src/main/java/net/minecraft/world/item/NameTagItem.java b/src/main/java/net/minecraft/world/item/NameTagItem.java
+index 623f78c078fb3aa2665d7e8a37672438227bce6b..500c69e555c7247e20ef8cc59d83415578f44427 100644
+--- a/src/main/java/net/minecraft/world/item/NameTagItem.java
+++ b/src/main/java/net/minecraft/world/item/NameTagItem.java
+@@ -24,6 +24,7 @@ public class NameTagItem extends Item {
+                 if (!event.callEvent()) return InteractionResult.PASS;
+                 LivingEntity newEntityLiving = ((org.bukkit.craftbukkit.entity.CraftLivingEntity) event.getEntity()).getHandle();
+                 newEntityLiving.setCustomName(event.getName() != null ? PaperAdventure.asVanilla(event.getName()) : null);
+                if (user.level.purpurConfig.armorstandFixNametags && entity instanceof net.minecraft.world.entity.decoration.ArmorStand) entity.setCustomNameVisible(true); // Purpur
+                 if (event.isPersistent() && newEntityLiving instanceof Mob) {
+                     ((Mob) newEntityLiving).setPersistenceRequired();
+                 // Paper end
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f0ec5498b5a814f644cb105dc3e6ec927d0dffe4..1dfd19712d883935dc59123d1b2468ed42453152 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -97,9 +97,11 @@ public class PurpurWorldConfig {
+ 
+     public float armorstandStepHeight = 0.0F;
+     public boolean armorstandSetNameVisible = false;
+    public boolean armorstandFixNametags = false;
+     private void armorstandSettings() {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+         armorstandSetNameVisible = getBoolean("gameplay-mechanics.armorstand.set-name-visible-when-placing-with-custom-name", armorstandSetNameVisible);
+        armorstandFixNametags = getBoolean("gameplay-mechanics.armorstand.fix-nametags", armorstandFixNametags);
+     }
+ 
+     public boolean useBetterMending = false;
--- a/patches/unapplied/0114-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch
+++ b/patches/unapplied/0114-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch
@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sun, 22 Nov 2020 22:17:53 -0800
+Subject: [PATCH] Add config for allowing Endermen to despawn even while
+ holding a block
+
+This should help to reduce the amount of dirt, gravel, grass, and etc.
+that Endermen like to randomly place all over the world.
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+index 7b41dc359ae3ba49511717172619d2f7b58f02bf..018d94c3540bf6241d57fe915b5037978601dc2d 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -473,7 +473,7 @@ public class EnderMan extends Monster implements NeutralMob {
+ 
+     @Override
+     public boolean requiresCustomPersistence() {
+-        return super.requiresCustomPersistence() || this.getCarriedBlock() != null;
+        return super.requiresCustomPersistence() || (!this.level.purpurConfig.endermanDespawnEvenWithBlock && this.getCarriedBlock() != null); // Purpur
+     }
+ 
+     private static class EndermanFreezeWhenLookedAt extends Goal {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b087f61d16656df5050691ee194d94063e0de054..c5051a9d495853c6abe025c34f6a08f0a55b110c 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -792,6 +792,7 @@ public class PurpurWorldConfig {
+     public boolean endermanControllable = true;
+     public double endermanMaxHealth = 40.0D;
+     public boolean endermanAllowGriefing = true;
+    public boolean endermanDespawnEvenWithBlock = false;
+     private void endermanSettings() {
+         endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
+         endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
+@@ -803,6 +804,7 @@ public class PurpurWorldConfig {
+         }
+         endermanMaxHealth = getDouble("mobs.enderman.attributes.max_health", endermanMaxHealth);
+         endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing);
+        endermanDespawnEvenWithBlock = getBoolean("mobs.enderman.can-despawn-with-held-block", endermanDespawnEvenWithBlock);
+     }
+ 
+     public boolean endermiteRidable = false;
--- a/patches/unapplied/0115-Add-configurable-snowball-damage.patch
+++ b/patches/unapplied/0115-Add-configurable-snowball-damage.patch
@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 24 Nov 2020 05:32:02 -0600
+Subject: [PATCH] Add configurable snowball damage
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Snowball.java b/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+index ed2f039c4042861bcfa2e41d8281eefd37daa9fa..d5d84893c77b4e60a19032d765d76bfd24cbbb2b 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+@@ -54,7 +54,7 @@ public class Snowball extends ThrowableItemProjectile {
+     protected void onHitEntity(EntityHitResult entityHitResult) {
+         super.onHitEntity(entityHitResult);
+         Entity entity = entityHitResult.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
+         entity.hurt(DamageSource.thrown(this, this.getOwner()), (float)i);
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b2c3bc12d5d0f4342a684bc14d5b00bcd309716d..cafa9168b688ba141b96ba0a243048b5a00841cd 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -315,6 +315,11 @@ public class PurpurWorldConfig {
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+     }
+ 
+    public int snowballDamage = -1;
+    private void snowballSettings() {
+        snowballDamage = getInt("gameplay-mechanics.projectile-damage.snowball", snowballDamage);
+    }
+
+     public int dragonFireballDespawnRate = -1;
+     public int eggDespawnRate = -1;
+     public int enderPearlDespawnRate = -1;
--- a/patches/unapplied/0116-Changeable-Mob-Left-Handed-Chance.patch
+++ b/patches/unapplied/0116-Changeable-Mob-Left-Handed-Chance.patch
@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Mon, 30 Nov 2020 11:40:11 -0500
+Subject: [PATCH] Changeable Mob Left Handed Chance
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 8f53dd70d815493148709fbdff29a85924d12d00..079bfd97262cec9084d3491b3dd68f1506274f43 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1226,7 +1226,7 @@ public abstract class Mob extends LivingEntity {
+     @Nullable
+     public SpawnGroupData finalizeSpawn(ServerLevelAccessor world, DifficultyInstance difficulty, MobSpawnType spawnReason, @Nullable SpawnGroupData entityData, @Nullable CompoundTag entityNbt) {
+         this.getAttribute(Attributes.FOLLOW_RANGE).addPermanentModifier(new AttributeModifier("Random spawn bonus", this.random.nextGaussian() * 0.05D, AttributeModifier.Operation.MULTIPLY_BASE));
+-        if (this.random.nextFloat() < 0.05F) {
+        if (this.random.nextFloat() < world.getLevel().purpurConfig.entityLeftHandedChance) { // Purpur
+             this.setLeftHanded(true);
+         } else {
+             this.setLeftHanded(false);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 63212c3d00a4aabb9f14b50016f43aa9e1f10249..367ce7f6003be23ffe2228e26365cb894089d4b4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -150,8 +150,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public int entityLifeSpan = 0;
+    public float entityLeftHandedChance = 0.05f;
+     private void entitySettings() {
+         entityLifeSpan = getInt("gameplay-mechanics.entity-lifespan", entityLifeSpan);
+        entityLeftHandedChance = (float) getDouble("gameplay-mechanics.entity-left-handed-chance", entityLeftHandedChance);
+     }
+ 
+     public boolean infinityWorksWithoutArrows = false;
--- a/patches/unapplied/0117-Add-boat-fall-damage-config.patch
+++ b/patches/unapplied/0117-Add-boat-fall-damage-config.patch
@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 30 Nov 2020 19:36:35 -0600
+Subject: [PATCH] Add boat fall damage config
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 10806ceb46832aa80ffaa1df45c7ec0d1c112dd7..b5beb009479ad743be64ae48b278d0864e163ed4 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1023,7 +1023,16 @@ public class ServerPlayer extends Player {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else {
+-            if (source == DamageSource.FALL && getRootVehicle() instanceof net.minecraft.world.entity.vehicle.AbstractMinecart && level.purpurConfig.minecartControllable && !level.purpurConfig.minecartControllableFallDamage) return false; // Purpur
+            // Purpur start
+            if (source == DamageSource.FALL) {
+                if (getRootVehicle() instanceof net.minecraft.world.entity.vehicle.AbstractMinecart && level.purpurConfig.minecartControllable && !level.purpurConfig.minecartControllableFallDamage) {
+                    return false;
+                }
+                if (getRootVehicle() instanceof net.minecraft.world.entity.vehicle.Boat && !level.purpurConfig.boatsDoFallDamage) {
+                    return false;
+                }
+            }
+            // Purpur end
+             boolean flag = this.server.isDedicatedServer() && this.isPvpAllowed() && "fall".equals(source.msgId);
+ 
+             if (!flag && isSpawnInvulnerable() && source != DamageSource.OUT_OF_WORLD) { // Purpur
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 367ce7f6003be23ffe2228e26365cb894089d4b4..2c0ac3fa1ce94c3b09dd55aa901e9e986ffb4338 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -106,6 +106,7 @@ public class PurpurWorldConfig {
+ 
+     public boolean useBetterMending = false;
+     public boolean boatEjectPlayersOnLand = false;
+    public boolean boatsDoFallDamage = true;
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean entitiesCanUsePortals = true;
+     public boolean milkCuresBadOmen = true;
+@@ -118,6 +119,7 @@ public class PurpurWorldConfig {
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
+         boatEjectPlayersOnLand = getBoolean("gameplay-mechanics.boat.eject-players-on-land", boatEjectPlayersOnLand);
+        boatsDoFallDamage = getBoolean("gameplay-mechanics.boat.do-fall-damage", boatsDoFallDamage);
+         disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
+         entitiesCanUsePortals = getBoolean("gameplay-mechanics.entities-can-use-portals", entitiesCanUsePortals);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
--- a/patches/unapplied/0118-Snow-Golem-rate-of-fire-config.patch
+++ b/patches/unapplied/0118-Snow-Golem-rate-of-fire-config.patch
@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Simon Gardling <titaniumtown@gmail.com>
+Date: Tue, 1 Dec 2020 16:50:36 -0500
+Subject: [PATCH] Snow Golem rate of fire config
+
+The formula used to determine the amount of ticks between shots is:
+    ((sqrt(distanceToTarget) / snowGolemAttackDistance) / snowGolemSnowBallModifer) * (maxShootIntervalTicks - minShootIntervalTicks) + minShootIntervalTicks
+
+If min-shoot-interval-ticks and max-shoot-interval-ticks are both set to
+0, snow golems won't shoot any snowballs.
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+index 921215712cba59273da4387b5b4b2f3f5c9da6e2..d5f4166e3148d1a15ed1f04069ac0b4f5d09ebdc 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+++ b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+@@ -79,7 +79,7 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+-        this.goalSelector.addGoal(1, new RangedAttackGoal(this, 1.25D, 20, 10.0F));
+        this.goalSelector.addGoal(1, new RangedAttackGoal(this, level.purpurConfig.snowGolemAttackDistance, level.purpurConfig.snowGolemSnowBallMin, level.purpurConfig.snowGolemSnowBallMax, level.purpurConfig.snowGolemSnowBallModifier)); // Purpur
+         this.goalSelector.addGoal(2, new WaterAvoidingRandomStrollGoal(this, 1.0D, 1.0000001E-5F));
+         this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 6.0F));
+         this.goalSelector.addGoal(4, new RandomLookAroundGoal(this));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 2c0ac3fa1ce94c3b09dd55aa901e9e986ffb4338..50f4fe8b85a7e7fbb536f93b1c10132711aa5ded 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1563,6 +1563,10 @@ public class PurpurWorldConfig {
+     public double snowGolemMaxHealth = 4.0D;
+     public boolean snowGolemDropsPumpkin = true;
+     public boolean snowGolemPutPumpkinBack = false;
+    public int snowGolemSnowBallMin = 20;
+    public int snowGolemSnowBallMax = 20;
+    public float snowGolemSnowBallModifier = 10.0F;
+    public double snowGolemAttackDistance = 1.25D;
+     private void snowGolemSettings() {
+         snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable);
+         snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater);
+@@ -1576,6 +1580,10 @@ public class PurpurWorldConfig {
+         snowGolemMaxHealth = getDouble("mobs.snow_golem.attributes.max_health", snowGolemMaxHealth);
+         snowGolemDropsPumpkin = getBoolean("mobs.snow_golem.drop-pumpkin-when-sheared", snowGolemDropsPumpkin);
+         snowGolemPutPumpkinBack = getBoolean("mobs.snow_golem.pumpkin-can-be-added-back", snowGolemPutPumpkinBack);
+        snowGolemSnowBallMin = getInt("mobs.snow_golem.min-shoot-interval-ticks", snowGolemSnowBallMin);
+        snowGolemSnowBallMax = getInt("mobs.snow_golem.max-shoot-interval-ticks", snowGolemSnowBallMax);
+        snowGolemSnowBallModifier = (float) getDouble("mobs.snow_golem.snow-ball-modifier", snowGolemSnowBallModifier);
+        snowGolemAttackDistance = getDouble("mobs.snow_golem.attack-distance", snowGolemAttackDistance);
+     }
+ 
+     public boolean squidRidable = false;
--- a/patches/unapplied/0119-EMC-Configurable-disable-give-dropping.patch
+++ b/patches/unapplied/0119-EMC-Configurable-disable-give-dropping.patch
@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 14 Jan 2016 00:49:14 -0500
+Subject: [PATCH] EMC - Configurable disable give dropping
+
+Modified version of a patch by Aikar from EMC. Adds a config option in
+purpur.yml to disable the /give command from dropping items on the
+floor when a player's inventory is full.
+
+diff --git a/src/main/java/net/minecraft/server/commands/GiveCommand.java b/src/main/java/net/minecraft/server/commands/GiveCommand.java
+index a60a84d5df0b05cf35668df8c5f08b811bc42a9f..a2751744517634700131ccfb0a2617557b4d42f2 100644
+--- a/src/main/java/net/minecraft/server/commands/GiveCommand.java
+++ b/src/main/java/net/minecraft/server/commands/GiveCommand.java
+@@ -57,6 +57,7 @@ public class GiveCommand {
+                     boolean flag = entityplayer.getInventory().add(itemstack);
+                     ItemEntity entityitem;
+ 
+                    if (org.purpurmc.purpur.PurpurConfig.disableGiveCommandDrops) continue; // Purpur - add config option for toggling give command dropping
+                     if (flag && itemstack.isEmpty()) {
+                         itemstack.setCount(1);
+                         entityitem = entityplayer.drop(itemstack, false, false, false); // SPIGOT-2942: Add boolean to call event
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index e57dab3abf5162dbe77cb2ba89b2ebabeae3895d..bd4c8c087b5468e5cde5e2cc017ae6187aef51bb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -207,6 +207,11 @@ public class PurpurConfig {
+         useAlternateKeepAlive = getBoolean("settings.use-alternate-keepalive", useAlternateKeepAlive);
+     }
+ 
+    public static boolean disableGiveCommandDrops = false;
+    private static void disableGiveCommandDrops() {
+        disableGiveCommandDrops = getBoolean("settings.disable-give-dropping", disableGiveCommandDrops);
+    }
+
+     public static int barrelRows = 3;
+     public static boolean enderChestSixRows = false;
+     public static boolean enderChestPermissionRows = false;
--- a/patches/unapplied/0120-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch
+++ b/patches/unapplied/0120-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch
@@ -0,0 +1,206 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sat, 5 Dec 2020 01:20:16 -0800
+Subject: [PATCH] Option for Villager Clerics to farm Nether Wart
+
+Adds an option so that Villagers with the Cleric profession are able to
+farm Nether Wart. Reimplemented based on a feature of the carpet-extra
+mod.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/HarvestFarmland.java b/src/main/java/net/minecraft/world/entity/ai/behavior/HarvestFarmland.java
+index 35d6951cf30c929f34853599aef76adcd8757946..fdfa36d3e148e8638109acaf4a0ea8a577985b61 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/HarvestFarmland.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/HarvestFarmland.java
+@@ -33,6 +33,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+     private long nextOkStartTime;
+     private int timeWorkedSoFar;
+     private final List<BlockPos> validFarmlandAroundVillager = Lists.newArrayList();
+    private boolean clericWartFarmer = false; // Purpur
+ 
+     public HarvestFarmland() {
+         super(ImmutableMap.of(MemoryModuleType.LOOK_TARGET, MemoryStatus.VALUE_ABSENT, MemoryModuleType.WALK_TARGET, MemoryStatus.VALUE_ABSENT, MemoryModuleType.SECONDARY_JOB_SITE, MemoryStatus.VALUE_PRESENT));
+@@ -41,9 +42,10 @@ public class HarvestFarmland extends Behavior<Villager> {
+     protected boolean checkExtraStartConditions(ServerLevel world, Villager entity) {
+         if (!world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
+             return false;
+-        } else if (entity.getVillagerData().getProfession() != VillagerProfession.FARMER) {
+        } else if (entity.getVillagerData().getProfession() != VillagerProfession.FARMER && !(world.purpurConfig.villagerClericsFarmWarts && entity.getVillagerData().getProfession() == VillagerProfession.CLERIC)) { // Purpur
+             return false;
+         } else {
+            if (!this.clericWartFarmer && entity.getVillagerData().getProfession() == VillagerProfession.CLERIC) this.clericWartFarmer = true; // Purpur
+             BlockPos.MutableBlockPos blockposition_mutableblockposition = entity.blockPosition().mutable();
+ 
+             this.validFarmlandAroundVillager.clear();
+@@ -74,6 +76,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+         Block block = iblockdata.getBlock();
+         Block block1 = world.getBlockState(pos.below()).getBlock();
+ 
+        if (this.clericWartFarmer) return block == Blocks.NETHER_WART && iblockdata.getValue(net.minecraft.world.level.block.NetherWartBlock.AGE) == 3 || iblockdata.isAir() && block1 == Blocks.SOUL_SAND; // Purpur
+         return block instanceof CropBlock && ((CropBlock) block).isMaxAge(iblockdata) || iblockdata.isAir() && block1 instanceof FarmBlock;
+     }
+ 
+@@ -99,7 +102,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+                 Block block = iblockdata.getBlock();
+                 Block block1 = worldserver.getBlockState(this.aboveFarmlandPos.below()).getBlock();
+ 
+-                if (block instanceof CropBlock && ((CropBlock) block).isMaxAge(iblockdata)) {
+                if (block instanceof CropBlock && ((CropBlock) block).isMaxAge(iblockdata) && !this.clericWartFarmer || this.clericWartFarmer && block == Blocks.NETHER_WART && iblockdata.getValue(net.minecraft.world.level.block.NetherWartBlock.AGE) == 3) { // Purpur
+                     // CraftBukkit start
+                     if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entityvillager, this.aboveFarmlandPos, Blocks.AIR.defaultBlockState()).isCancelled()) {
+                         worldserver.destroyBlock(this.aboveFarmlandPos, true, entityvillager);
+@@ -107,7 +110,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+                     // CraftBukkit end
+                 }
+ 
+-                if (iblockdata.isAir() && block1 instanceof FarmBlock && entityvillager.hasFarmSeeds()) {
+                if (iblockdata.isAir() && (block1 instanceof FarmBlock && !this.clericWartFarmer || this.clericWartFarmer && block1 == Blocks.SOUL_SAND) && entityvillager.hasFarmSeeds()) { // Purpur
+                     SimpleContainer inventorysubcontainer = entityvillager.getInventory();
+ 
+                     for (int j = 0; j < inventorysubcontainer.getContainerSize(); ++j) {
+@@ -117,6 +120,14 @@ public class HarvestFarmland extends Behavior<Villager> {
+                         if (!itemstack.isEmpty()) {
+                             // CraftBukkit start
+                             Block planted = null;
+                            // Purpur start
+                            if (this.clericWartFarmer) {
+                                if (itemstack.getItem() == Items.NETHER_WART) {
+                                    planted = Blocks.NETHER_WART;
+                                    flag = true;
+                                }
+                            } else
+                            // Purpur end
+                             if (itemstack.is(Items.WHEAT_SEEDS)) {
+                                 planted = Blocks.WHEAT;
+                                 flag = true;
+@@ -140,7 +151,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+                         }
+ 
+                         if (flag) {
+-                            worldserver.playSound((Player) null, (double) this.aboveFarmlandPos.getX(), (double) this.aboveFarmlandPos.getY(), (double) this.aboveFarmlandPos.getZ(), SoundEvents.CROP_PLANTED, SoundSource.BLOCKS, 1.0F, 1.0F);
+                            worldserver.playSound((Player) null, (double) this.aboveFarmlandPos.getX(), (double) this.aboveFarmlandPos.getY(), (double) this.aboveFarmlandPos.getZ(), this.clericWartFarmer ? SoundEvents.NETHER_WART_PLANTED : SoundEvents.CROP_PLANTED, SoundSource.BLOCKS, 1.0F, 1.0F); // Purpur
+                             itemstack.shrink(1);
+                             if (itemstack.isEmpty()) {
+                                 inventorysubcontainer.setItem(j, ItemStack.EMPTY);
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/TradeWithVillager.java b/src/main/java/net/minecraft/world/entity/ai/behavior/TradeWithVillager.java
+index 1150a541a270a3ce5c69895f5385800aa44c22f4..808da0b75fcf492a76c692e312aa33ef6fc90c03 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/TradeWithVillager.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/TradeWithVillager.java
+@@ -56,6 +56,12 @@ public class TradeWithVillager extends Behavior<Villager> {
+                 throwHalfStack(villager, ImmutableSet.of(Items.WHEAT), villager2);
+             }
+ 
+            // Purpur start
+            if (serverLevel.purpurConfig.villagerClericsFarmWarts && serverLevel.purpurConfig.villagerClericFarmersThrowWarts && villager.getVillagerData().getProfession() == VillagerProfession.CLERIC && villager.getInventory().countItem(Items.NETHER_WART) > Items.NETHER_WART.getMaxStackSize() / 2) {
+                throwHalfStack(villager, ImmutableSet.of(Items.NETHER_WART), villager2);
+            }
+            // Purpur end
+
+             if (!this.trades.isEmpty() && villager.getInventory().hasAnyOf(this.trades)) {
+                 throwHalfStack(villager, this.trades, villager2);
+             }
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
+index 70a3db78c4913c14f39ddee39e5fcdd0e741c971..1763764662e061d1f8de74b65de7fb5cc1caac5c 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
+@@ -23,8 +23,13 @@ public class VillagerGoalPackages {
+     }
+ 
+     public static ImmutableList<Pair<Integer, ? extends Behavior<? super Villager>>> getWorkPackage(VillagerProfession profession, float speed) {
+        // Purpur start
+        return getWorkPackage(profession, speed, false);
+    }
+    public static ImmutableList<Pair<Integer, ? extends Behavior<? super Villager>>> getWorkPackage(VillagerProfession profession, float speed, boolean clericsFarmWarts) {
+        // Purpur end
+         WorkAtPoi workAtPoi;
+-        if (profession == VillagerProfession.FARMER) {
+        if (profession == VillagerProfession.FARMER || (clericsFarmWarts && profession == VillagerProfession.CLERIC)) { // Purpur
+             workAtPoi = new WorkAtComposter();
+         } else {
+             workAtPoi = new WorkAtPoi();
+diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
+index b615dc2a2127f0874775d1707e96edfb4d95b987..72ae6b3282aac806ae11b87024ee940eec8fbe91 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
+++ b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
+@@ -22,6 +22,13 @@ public class SecondaryPoiSensor extends Sensor<Villager> {
+ 
+     @Override
+     protected void doTick(ServerLevel world, Villager entity) {
+        // Purpur start - make sure clerics don't wander to soul sand when the option is off
+        Brain<?> brain = entity.getBrain();
+        if (!world.purpurConfig.villagerClericsFarmWarts && entity.getVillagerData().getProfession() == net.minecraft.world.entity.npc.VillagerProfession.CLERIC) {
+            brain.eraseMemory(MemoryModuleType.SECONDARY_JOB_SITE);
+            return;
+        }
+        // Purpur end
+         ResourceKey<Level> resourceKey = world.dimension();
+         BlockPos blockPos = entity.blockPosition();
+         List<GlobalPos> list = Lists.newArrayList();
+@@ -38,7 +45,7 @@ public class SecondaryPoiSensor extends Sensor<Villager> {
+             }
+         }
+ 
+-        Brain<?> brain = entity.getBrain();
+        //Brain<?> brain = entity.getBrain(); // Purpur - moved up
+         if (!list.isEmpty()) {
+             brain.setMemory(MemoryModuleType.SECONDARY_JOB_SITE, list);
+         } else {
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 094fd4289bc42df6af6740acacd4f51ab6b668e0..bbb8dde583b1a40c305bb110313e7121ad354dc3 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -224,7 +224,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+             brain.addActivity(Activity.PLAY, VillagerGoalPackages.getPlayPackage(0.5F));
+         } else {
+             brain.setSchedule(Schedule.VILLAGER_DEFAULT);
+-            brain.addActivityWithConditions(Activity.WORK, VillagerGoalPackages.getWorkPackage(villagerprofession, 0.5F), ImmutableSet.of(Pair.of(MemoryModuleType.JOB_SITE, MemoryStatus.VALUE_PRESENT)));
+            brain.addActivityWithConditions(Activity.WORK, VillagerGoalPackages.getWorkPackage(villagerprofession, 0.5F, this.level.purpurConfig.villagerClericsFarmWarts), ImmutableSet.of(Pair.of(MemoryModuleType.JOB_SITE, MemoryStatus.VALUE_PRESENT))); // Purpur
+         }
+ 
+         brain.addActivity(Activity.CORE, VillagerGoalPackages.getCorePackage(villagerprofession, 0.5F));
+@@ -989,6 +989,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+     }
+ 
+     public boolean hasFarmSeeds() {
+        // Purpur start
+        if (this.level.purpurConfig.villagerClericsFarmWarts && this.getVillagerData().getProfession() == VillagerProfession.CLERIC) {
+            return this.getInventory().hasAnyOf(ImmutableSet.of(Items.NETHER_WART));
+        }
+        // Purpur end
+         return this.getInventory().hasAnyOf(ImmutableSet.of(Items.WHEAT_SEEDS, Items.POTATO, Items.CARROT, Items.BEETROOT_SEEDS));
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java b/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java
+index 901fc6520d58a5fa5f2cf1b4fa78fec6008aa409..9050cd25663c71197c597aac0ab2e6121b76b13b 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java
+++ b/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java
+@@ -17,7 +17,7 @@ public class VillagerProfession {
+     public static final VillagerProfession ARMORER = register("armorer", PoiType.ARMORER, SoundEvents.VILLAGER_WORK_ARMORER);
+     public static final VillagerProfession BUTCHER = register("butcher", PoiType.BUTCHER, SoundEvents.VILLAGER_WORK_BUTCHER);
+     public static final VillagerProfession CARTOGRAPHER = register("cartographer", PoiType.CARTOGRAPHER, SoundEvents.VILLAGER_WORK_CARTOGRAPHER);
+-    public static final VillagerProfession CLERIC = register("cleric", PoiType.CLERIC, SoundEvents.VILLAGER_WORK_CLERIC);
+    public static final VillagerProfession CLERIC = register("cleric", PoiType.CLERIC, ImmutableSet.of(Items.NETHER_WART), ImmutableSet.of(Blocks.SOUL_SAND), SoundEvents.VILLAGER_WORK_CLERIC); // Purpur
+     public static final VillagerProfession FARMER = register("farmer", PoiType.FARMER, ImmutableSet.of(Items.WHEAT, Items.WHEAT_SEEDS, Items.BEETROOT_SEEDS, Items.BONE_MEAL), ImmutableSet.of(Blocks.FARMLAND), SoundEvents.VILLAGER_WORK_FARMER);
+     public static final VillagerProfession FISHERMAN = register("fisherman", PoiType.FISHERMAN, SoundEvents.VILLAGER_WORK_FISHERMAN);
+     public static final VillagerProfession FLETCHER = register("fletcher", PoiType.FLETCHER, SoundEvents.VILLAGER_WORK_FLETCHER);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 50f4fe8b85a7e7fbb536f93b1c10132711aa5ded..0b7125bf5abf54b4d87de846a583ca3f20f9774f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1748,6 +1748,8 @@ public class PurpurWorldConfig {
+     public int villagerSpawnIronGolemLimit = 0;
+     public boolean villagerCanBreed = true;
+     public int villagerBreedingTicks = 6000;
+    public boolean villagerClericsFarmWarts = false;
+    public boolean villagerClericFarmersThrowWarts = true;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1766,6 +1768,8 @@ public class PurpurWorldConfig {
+         villagerSpawnIronGolemLimit = getInt("mobs.villager.spawn-iron-golem.limit", villagerSpawnIronGolemLimit);
+         villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed);
+         villagerBreedingTicks = getInt("mobs.villager.breeding-delay-ticks", villagerBreedingTicks);
+        villagerClericsFarmWarts = getBoolean("mobs.villager.clerics-farm-warts", villagerClericsFarmWarts);
+        villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts);
+     }
+ 
+     public boolean vindicatorRidable = false;
--- a/Show More
+++ b/Show More