first 50 patches done

patches/unapplied/server/0002-Fix-pufferfish-issues.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Sun, 12 Jun 2022 09:18:57 -0500
+Subject: [PATCH] Fix pufferfish issues
+
+
+diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
+index 0dd3374468e05f7a312ba5856b9cf8a4787dfa59..960c0555a001fe63de78d77d5ea47d08a520d029 100644
+--- a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
++++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java
+@@ -224,7 +224,7 @@ public class PufferfishConfig {
+     public static int activationDistanceMod;
+ 
+     private static void dynamicActivationOfBrains() throws IOException {
+-        dearEnabled = getBoolean("dab.enabled", "activation-range.enabled", true);
++        dearEnabled = getBoolean("dab.enabled", "activation-range.enabled", false); // Purpur
+         startDistance = getInt("dab.start-distance", "activation-range.start-distance", 12,
+                 "This value determines how far away an entity has to be",
+                 "from the player to start being effected by DEAR.");
+@@ -268,7 +268,7 @@ public class PufferfishConfig {
+     
+     public static boolean throttleInactiveGoalSelectorTick;
+ 	private static void inactiveGoalSelectorThrottle() {
+-		throttleInactiveGoalSelectorTick = getBoolean("inactive-goal-selector-throttle", "inactive-goal-selector-disable", true,
++		throttleInactiveGoalSelectorTick = getBoolean("inactive-goal-selector-throttle", "inactive-goal-selector-disable", false, // Purpur
+ 				"Throttles the AI goal selector in entity inactive ticks.",
+ 				"This can improve performance by a few percent, but has minor gameplay implications.");
+ 	}
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index eac31c3fcc9161711328588ac852fcae1116d8ef..dbb59969cf55eda997588f4c3ef7dc899ea619bb 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -948,7 +948,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     }
+     // Paper start - optimise random block ticking
+     private final BlockPos.MutableBlockPos chunkTickMutablePosition = new BlockPos.MutableBlockPos();
+-    // private final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(); // Pufferfish - moved to super
++    private final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(this.random.nextLong()); public net.minecraft.util.RandomSource getThreadUnsafeRandom() { return this.randomTickRandom; } // Pufferfish - moved to super // Purpur - dont break ABI
+     // Paper end
+ 
+     private int currentIceAndSnowTick = 0; protected void resetIceAndSnowTick() { this.currentIceAndSnowTick = this.randomTickRandom.nextInt(16); } // Pufferfish
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 30d8ec75203adc677e5fb91d9538baf52a0684ad..5eca99fbd23ff0d35607bd185b011d6f9a30d0f0 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -273,7 +273,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+ 
+     public abstract ResourceKey<LevelStem> getTypeKey();
+ 
+-    protected final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(java.util.concurrent.ThreadLocalRandom.current().nextLong()); public net.minecraft.util.RandomSource getThreadUnsafeRandom() { return this.randomTickRandom; } // Pufferfish - move thread unsafe random initialization // Pufferfish - getter
++    //protected final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(java.util.concurrent.ThreadLocalRandom.current().nextLong()); public net.minecraft.util.RandomSource getThreadUnsafeRandom() { return this.randomTickRandom; } // Pufferfish - move thread unsafe random initialization // Pufferfish - getter // Purpur - dont break ABI
+ 
+     // Pufferfish start - ensure these get inlined
+     private final int minBuildHeight, minSection, height, maxBuildHeight, maxSection;
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 3eeb1f0eac76efe9b7c24f6d5787018c7842d07a..dbb0593a6feb60216379bde6720ca16f3ca827ae 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -125,7 +125,7 @@ public class LevelChunk extends ChunkAccess {
+         this.blockTicks = blockTickScheduler;
+         this.fluidTicks = fluidTickScheduler;
+ 
+-        this.lightningTick = this.level.getThreadUnsafeRandom().nextInt(100000) << 1; // Pufferfish - initialize lightning tick
++        this.lightningTick = java.util.concurrent.ThreadLocalRandom.current().nextInt(100000) << 1; // Pufferfish - initialize lightning tick // Purpur - any random will do
+     }
+ 
+     // CraftBukkit start

patches/unapplied/server/0051-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 9ed3354296746e1c50d55bca8c07fd4946255795..137b08608b2f19aa609c5e1ef47d9b964c47e109 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1315,6 +1315,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+         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, hand, !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 91a44381a822ce4dc543401a930d32c8d4a5a7eb..50925ab7d719ae3323d7456df03a3d2ab3481bfd 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -184,6 +184,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.villagerMaxHealth);
+     }
+ 
++    @Override
++    public boolean canBeLeashed(Player player) {
++        return level().purpurConfig.villagerCanBeLeashed && !this.isLeashed();
++    }
++
+     @Override
+     public Brain<Villager> getBrain() {
+         return (Brain<Villager>) super.getBrain(); // CraftBukkit - decompile error
+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 509bde6c02d9e74158da7a134fbdda1603cb3ec0..7413f90dfcb68476f7d514607f38a8965dfa6fd0 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
++++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -88,6 +88,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+         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();
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index e2667728ea44292ae05e80f1a27ed3edb36db7b1..ab42f93a621759a86c7e9eba14cb32b156d4f106 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1440,6 +1440,7 @@ public class PurpurWorldConfig {
+     public boolean villagerControllable = true;
+     public double villagerMaxHealth = 20.0D;
+     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);
+@@ -1451,6 +1452,7 @@ public class PurpurWorldConfig {
+         }
+         villagerMaxHealth = getDouble("mobs.villager.attributes.max_health", villagerMaxHealth);
+         villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
++        villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1474,6 +1476,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);
+@@ -1485,6 +1488,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 wardenRidable = false;

patches/unapplied/server/0052-Implement-infinite-liquids.patch

@@ -0,0 +1,96 @@
+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 7d56693102ee558fe784e3a9b9fdcff4b7ad57b9..485bbec4b52f126393332d5cad2d97c2a220f91a 100644
+--- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+@@ -227,7 +227,7 @@ public abstract class FlowingFluid extends Fluid {
+             }
+         }
+ 
+-        if (this.canConvertToSource(world) && j >= 2) {
++        if (this.canConvertToSource(world) && j >= getRequiredSources(world)) {
+             BlockState iblockdata2 = world.getBlockState(pos.below());
+             FluidState fluid1 = iblockdata2.getFluidState();
+ 
+@@ -325,6 +325,12 @@ public abstract class FlowingFluid extends Fluid {
+ 
+     protected abstract boolean canConvertToSource(Level world);
+ 
++    // Purpur start
++    protected int getRequiredSources(Level level) {
++        return 2;
++    }
++    // Purpur end
++
+     protected void spreadTo(LevelAccessor world, BlockPos pos, BlockState state, Direction direction, FluidState fluidState) {
+         if (state.getBlock() instanceof LiquidBlockContainer) {
+             ((LiquidBlockContainer) state.getBlock()).placeLiquid(world, pos, state, 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 72f8b72c6436ca3b8eaeb39c7d3efe2c1462ae1d..3706ebc551413401b0e6a9a0b1c2e3257d1337c1 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,13 @@ public abstract class LavaFluid extends FlowingFluid {
+         world.levelEvent(1501, pos, 0);
+     }
+ 
++    // Purpur start
++    @Override
++    protected int getRequiredSources(Level level) {
++        return level.purpurConfig.lavaInfiniteRequiredSources;
++    }
++    // Purpur end
++
+     @Override
+     protected boolean canConvertToSource(Level world) {
+         return world.getGameRules().getBoolean(GameRules.RULE_LAVA_SOURCE_CONVERSION);
+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 82e85fbbd45244d02df90fa00c9046e7f51275a2..ec6c63075306f9e5389e83641d2c8a82369ddc6b 100644
+--- a/src/main/java/net/minecraft/world/level/material/WaterFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+@@ -64,6 +64,13 @@ public abstract class WaterFluid extends FlowingFluid {
+         return world.getGameRules().getBoolean(GameRules.RULE_WATER_SOURCE_CONVERSION);
+     }
+ 
++    // Purpur start
++    @Override
++    protected int getRequiredSources(Level level) {
++        return level.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 ab42f93a621759a86c7e9eba14cb32b156d4f106..e72a61c0e3aeb9758245101621a5aa286f5f5658 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -225,6 +225,11 @@ public class PurpurWorldConfig {
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+     }
+ 
++    public int lavaInfiniteRequiredSources = 2;
++    private void lavaSettings() {
++        lavaInfiniteRequiredSources = getInt("blocks.lava.infinite-required-sources", lavaInfiniteRequiredSources);
++    }
++
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;
+@@ -234,6 +239,11 @@ public class PurpurWorldConfig {
+         turtleEggsBreakFromMinecarts = getBoolean("blocks.turtle_egg.break-from-minecarts", turtleEggsBreakFromMinecarts);
+     }
+ 
++    public int waterInfiniteRequiredSources = 2;
++    private void waterSources() {
++        waterInfiniteRequiredSources = getInt("blocks.water.infinite-required-sources", waterInfiniteRequiredSources);
++    }
++
+     public boolean babiesAreRidable = true;
+     public boolean untamedTamablesAreRidable = true;
+     public boolean useNightVisionWhenRiding = false;

patches/unapplied/server/0053-Make-lava-flow-speed-configurable.patch

@@ -0,0 +1,36 @@
+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 3706ebc551413401b0e6a9a0b1c2e3257d1337c1..b77cdbd8a7395e8442081c6a2b14695d62c9ef03 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 e72a61c0e3aeb9758245101621a5aa286f5f5658..bb5877d6feec92e87c13e33abfda48507201d08e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -226,8 +226,12 @@ public class PurpurWorldConfig {
+     }
+ 
+     public int lavaInfiniteRequiredSources = 2;
++    public int lavaSpeedNether = 10;
++    public int lavaSpeedNotNether = 30;
+     private void lavaSettings() {
+         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 turtleEggsBreakFromExpOrbs = true;

patches/unapplied/server/0054-Add-player-death-exp-control-options.patch

@@ -0,0 +1,55 @@
+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 7b39cb5346925c14f3f144d622ca7e5855420aa6..fa2a0cc24bbe31abd49ce0f3f41bab2aa5d9c81f 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1998,9 +1998,19 @@ public abstract class Player extends LivingEntity {
+     @Override
+     public int getExperienceReward() {
+         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 {
++                toDrop = Math.round(((Number) scriptEngine.eval("let expLevel = " + experienceLevel + "; " +
++                        "let expTotal = " + totalExperience + "; " +
++                        "let exp = " + experienceProgress + "; " +
++                        level().purpurConfig.playerDeathExpDropEquation)).floatValue());
++            } catch (javax.script.ScriptException e) {
++                e.printStackTrace();
++                toDrop = experienceLevel * 7;
++            }
++            return Math.min(toDrop, level().purpurConfig.playerDeathExpDropMax);
++            // 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 bb5877d6feec92e87c13e33abfda48507201d08e..183a4e0192679d04555215c234dfefbc39dfe02e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -173,6 +173,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);
+@@ -186,6 +188,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;

patches/unapplied/server/0055-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 acce1d46d6bce9b052126c76bc1f36264df39e71..5b9ddcab26a4c962dae104c44d65d623c036c8fd 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -915,7 +915,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+ 
+     public void checkBelowWorld() {
+         // 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
+             && this.level.paperConfig().environment.netherCeilingVoidDamageHeight.test(v -> this.getY() >= v)
+             && (!(this instanceof Player player) || !player.getAbilities().invulnerable))) {
+             // 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 bb8ba67c7a4a4c7a641e103bd20cbc0a01dc66b2..c32a8c4b8a75f524b0f99ada0bba6de40c0aa732 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -2500,7 +2500,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     @Override
+     protected void onBelowWorld() {
+-        this.hurt(this.damageSources().fellOutOfWorld(), 4.0F);
++        this.hurt(this.damageSources().fellOutOfWorld(), (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 183a4e0192679d04555215c234dfefbc39dfe02e..a559ab65bc3f2d78d79e22b0e70afb6affd1d6a3 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -98,10 +98,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;

patches/unapplied/server/0056-Add-canSaveToDisk-to-Entity.patch

@@ -0,0 +1,85 @@
+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 5b9ddcab26a4c962dae104c44d65d623c036c8fd..01a1534ec503e9aaea7befdba86f452128f8863d 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -493,6 +493,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         return false;
+     }
+ 
++    public boolean canSaveToDisk() {
++        return true;
++    }
++
+     public final boolean hardCollides() {
+         return this.hardCollides;
+     }
+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 937f57d8af629c4e913d7ccabf6adab15f91d3d0..f40ab9d5b18c189ba9b572e49243640bd44362d1 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/WitherSkull.java
+@@ -115,6 +115,11 @@ public class WitherSkull extends AbstractHurtingProjectile {
+         return target != this.getRider() && super.canHitEntity(target);
+     }
+ 
++    @Override
++    public boolean canSaveToDisk() {
++        return false;
++    }
++
+     @Override
+     public boolean isPickable() {
+         return false;
+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 060e064625969610539dbf969ce773b877a7c579..32cd9df202704cdfb8fa06aaf0e738d483054feb 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
+@@ -112,6 +112,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
+         entities.forEach((entity) -> { // diff here: use entities parameter
++            if (!entity.canSaveToDisk()) return; // Purpur
+             // Paper start
+             final EntityType<?> entityType = entity.getType();
+             final int saveLimit = level.paperConfig().chunks.entityPerChunkSaveLimit.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 af057c1d7fd74f3dd806c5ce7f8b0ad06cab7b8e..ce614ae6b1fa0b31c1ee8dacb69134bb20c949f4 100644
+--- a/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java
++++ b/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java
+@@ -35,6 +35,13 @@ public class DolphinSpit extends LlamaSpit {
+                 dolphin.getZ() + (double) (dolphin.getBbWidth() + 1.0F) * 0.5D * (double) Mth.cos(dolphin.yBodyRot * 0.017453292F));
+     }
+ 
++    // Purpur start
++    @Override
++    public boolean canSaveToDisk() {
++        return false;
++    }
++    // Purpur end
++
+     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 1fd6412e332ea8ee82b19c108e113624e51d764b..ea8b928b6d82689e71bbcc39ab497491072dfba6 100644
+--- a/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java
++++ b/src/main/java/org/purpurmc/purpur/entity/PhantomFlames.java
+@@ -38,6 +38,13 @@ public class PhantomFlames extends LlamaSpit {
+                 phantom.getZ() + (double) (phantom.getBbWidth() + 1.0F) * 0.5D * (double) Mth.cos(phantom.yBodyRot * 0.017453292F));
+     }
+ 
++    // Purpur start
++    @Override
++    public boolean canSaveToDisk() {
++        return false;
++    }
++    // Purpur end
++
+     public void tick() {
+         super_tick();
+ 

patches/unapplied/server/0057-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 137b08608b2f19aa609c5e1ef47d9b964c47e109..2023ae88e6cb0565f8fe7b525dfe84279bf90dd6 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -65,6 +65,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;
+@@ -1173,6 +1174,12 @@ public abstract class Mob extends LivingEntity implements Targeting {
+ 
+     }
+ 
++    // 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 d7a0cbde8f8c99276307502674c71463fbe7e89c..3500c56cb85d8c76b2acd77976d374eaf487b3b3 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorItem.java
++++ b/src/main/java/net/minecraft/world/item/ArmorItem.java
+@@ -60,7 +60,7 @@ public class ArmorItem extends Item implements Equipable {
+             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.copyWithCount(1); // Paper - shrink below and single item in event
+             // 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 a559ab65bc3f2d78d79e22b0e70afb6affd1d6a3..a42f39fc79c6ab632ae9df59e76a719665fa4d88 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -228,6 +228,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);

patches/unapplied/server/0058-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 35aeba4e8430e6419caa9db4a0b931a994228618..cb8443c9bc902741dfe6746baca9129214ab503b 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+@@ -541,6 +541,7 @@ public class Boat extends Entity implements VariantHolder<Boat.Type> {
+ 
+             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 a42f39fc79c6ab632ae9df59e76a719665fa4d88..d935bc8e47b31ff8ec66cd3c6a5b19450b4684d5 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -95,12 +95,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);

patches/unapplied/server/0059-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 eca634792d2a7cc649675e3394e84dbaf1453905..2bd576849403bc2cfae298c2210616192ddc38db 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
++++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -331,7 +331,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 d138660e459b2d09ba9dd7ae2bf3da499d9ae25c..7ad1f9119991a7ef2c1c00d846729f39c2652849 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -584,6 +584,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 ecf640b00007a386290f8dfe9935a8aa610079fd..2048899f8e4c8211e8dde0d11148d647678009fa 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java
++++ b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentHelper.java
+@@ -278,6 +278,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 d935bc8e47b31ff8ec66cd3c6a5b19450b4684d5..9e4428db0ffa0f1b0e0ae11af903d3449c782ee4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -95,6 +95,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;
+@@ -102,6 +103,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);

patches/unapplied/server/0060-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 eda8479d26d5ccbb516adc6c483c1c8366375ddd..4cadfd50a0c465ab8d809b91b9a999943385bc8a 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 final io.papermc.paper.configuration.PaperConfigurations paperConfigurations;
+     public static long currentTickLong = 0L; // Paper
+@@ -1048,6 +1048,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);
+@@ -1148,13 +1149,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 98c4b8356dc26cf220dddb5ec319751b81601991..9bf5facac29591b7f6d5cfb7abb5a7bf6e9d382b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2874,6 +2874,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 bf970bf3356a914459c2d6db93537ce2d32c7e18..08221c7256f41ca511a4a61ffb2b979325aebee9 100644
+--- a/src/main/java/org/spigotmc/TicksPerSecondCommand.java
++++ b/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+@@ -39,7 +39,7 @@ public class TicksPerSecondCommand extends Command
+         }
+ 
+         net.kyori.adventure.text.TextComponent.Builder builder = net.kyori.adventure.text.Component.text();
+-        builder.append(net.kyori.adventure.text.Component.text("TPS from last 1m, 5m, 15m: ", net.kyori.adventure.text.format.NamedTextColor.GOLD));
++        builder.append(net.kyori.adventure.text.Component.text("TPS from last 5s, 1m, 5m, 15m: ", net.kyori.adventure.text.format.NamedTextColor.GOLD));
+         builder.append(net.kyori.adventure.text.Component.join(net.kyori.adventure.text.JoinConfiguration.commas(true), tpsAvg));
+         sender.sendMessage(builder.asComponent());
+         if (args.length > 0 && args[0].equals("mem") && sender.hasPermission("bukkit.command.tpsmemory")) {

patches/unapplied/server/0061-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 9af671ceadea7000cc9fceefec6624151e8a0e88..e8a22e82d47ffd77170b72a4a409db9751e09bbc 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3523,7 +3523,16 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                     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 82b0bda3e35ec2157a477e1a17b2b46baadc97d9..0fc45b1048a1c4e0dc2bd1ae0437eecbe113cf96 100644
+--- a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
++++ b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+@@ -15,6 +15,7 @@ import net.minecraft.util.ByIdMap;
+ 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;
+@@ -69,6 +70,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 7ad1f9119991a7ef2c1c00d846729f39c2652849..34068bd89cb4c111e468d85fb01e51d99efb3349 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -613,7 +613,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) {
+@@ -668,6 +668,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 8078f127ff4b6e0aafb5804b9c02e237f79445b5..06c2f30b77a2c8aecc65e0c305f643d53798f364 100644
+--- a/src/main/java/net/minecraft/world/item/TridentItem.java
++++ b/src/main/java/net/minecraft/world/item/TridentItem.java
+@@ -130,6 +130,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.onGround()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9e4428db0ffa0f1b0e0ae11af903d3449c782ee4..abecd27fab86cb5c16b3d42d5f499caa1976bd45 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -112,6 +112,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;

patches/unapplied/server/0062-Item-entity-immunities.patch

@@ -0,0 +1,172 @@
+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/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index 8ab959dd588b5154b63e133b2e937fa2d0ab8e52..fb11b020d52988360562db23d8568e5ef37e21c8 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -70,7 +70,7 @@ public class ServerEntity {
+     @Nullable
+     private List<SynchedEntityData.DataValue<?>> trackedDataValues;
+     // 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 d39f31e7cf315c7cdc1daab28164380e44dd8341..028b83b8e835cfdad19ae9edad76c524b98ead7f 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
++++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -56,6 +56,12 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     public boolean canMobPickup = true; // Paper
+     private int despawnRate = -1; // Paper
+     public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // 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);
+@@ -346,7 +352,16 @@ public class ItemEntity extends Entity implements TraceableEntity {
+ 
+     @Override
+     public boolean hurt(DamageSource source, float amount) {
+-        if (this.isInvulnerableTo(source)) {
++        // Purpur start
++        if (
++            (immuneToCactus && source.is(net.minecraft.world.damagesource.DamageTypes.CACTUS)) ||
++            (immuneToFire && (source.is(DamageTypeTags.IS_FIRE) || source.is(net.minecraft.world.damagesource.DamageTypes.ON_FIRE) || source.is(net.minecraft.world.damagesource.DamageTypes.IN_FIRE))) ||
++            (immuneToLightning && source.is(net.minecraft.world.damagesource.DamageTypes.LIGHTNING_BOLT)) ||
++            (immuneToExplosion && source.is(DamageTypeTags.IS_EXPLOSION))
++        ) {
++            return false;
++        } else if (this.isInvulnerableTo(source)) {
++        // Purpur end
+             return false;
+         } else if (!this.getItem().isEmpty() && this.getItem().is(Items.NETHER_STAR) && source.is(DamageTypeTags.IS_EXPLOSION)) {
+             return false;
+@@ -549,6 +564,12 @@ public class ItemEntity extends Entity implements TraceableEntity {
+         // com.google.common.base.Preconditions.checkArgument(!stack.isEmpty(), "Cannot drop air"); // CraftBukkit // Paper - Remove check
+         this.getEntityData().set(ItemEntity.DATA_ITEM, stack);
+         this.despawnRate = this.level().paperConfig().entities.spawning.altItemDespawnRate.enabled ? this.level().paperConfig().entities.spawning.altItemDespawnRate.items.getOrDefault(stack.getItem(), this.level().spigotConfig.itemDespawnRate) : this.level().spigotConfig.itemDespawnRate; // Paper
++        // 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 5e83fabb20bc2b0668cbf48530053ca1bb9092f3..8fcee0e426cd598ddfd7e12df4382d57d2016780 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+@@ -154,4 +154,46 @@ public class CraftItem extends CraftEntity implements Item {
+     public String toString() {
+         return "CraftItem";
+     }
++
++    // 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 abecd27fab86cb5c16b3d42d5f499caa1976bd45..9639202024f79c8ed57207445380ef017cfeaea6 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -125,6 +125,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("*")) {
++                BuiltInRegistries.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToCactus.add(item));
++                return;
++            }
++            Item item = BuiltInRegistries.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("*")) {
++                BuiltInRegistries.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToExplosion.add(item));
++                return;
++            }
++            Item item = BuiltInRegistries.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("*")) {
++                BuiltInRegistries.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToFire.add(item));
++                return;
++            }
++            Item item = BuiltInRegistries.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("*")) {
++                BuiltInRegistries.ITEM.stream().filter(item -> item != Items.AIR).forEach((item) -> itemImmuneToLightning.add(item));
++                return;
++            }
++            Item item = BuiltInRegistries.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;

patches/unapplied/server/0063-Add-ping-command.patch

@@ -0,0 +1,77 @@
+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 147fcbdd784f06fe23138b20aef82f92ba154998..aadc9fc53b0f495664d90c40f30f9a128c3b4c95 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -224,6 +224,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 4905358e2a1939bfba963bda3fcf914721dfac45..a74932163207506e779c941c819eb663b98bd18c 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -179,6 +179,7 @@ public class PurpurConfig {
+     public static boolean afkBroadcastUseDisplayName = false;
+     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);
+@@ -186,6 +187,7 @@ public class PurpurConfig {
+         afkBroadcastUseDisplayName = getBoolean("settings.messages.afk-broadcast-use-display-name", afkBroadcastUseDisplayName);
+         afkTabListPrefix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix)));
+         afkTabListSuffix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(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..179727c6b3171c040d1aaf069525f61a9a2d54d9
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/command/PingCommand.java
+@@ -0,0 +1,33 @@
++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, "bukkit.command.ping"))
++                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
++                .then(Commands.argument("targets", EntityArgument.players())
++                        .requires(listener -> listener.hasPermission(2, "bukkit.command.ping.other"))
++                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
++                )
++        );
++    }
++
++    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();
++    }
++}

patches/unapplied/server/0064-Add-demo-command.patch

@@ -0,0 +1,79 @@
+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 aadc9fc53b0f495664d90c40f30f9a128c3b4c95..54f9dd8d666b2b45190681f4362fce457e8e8ef2 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -224,6 +224,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 a74932163207506e779c941c819eb663b98bd18c..235db276a07017bf89e6311a0b84291e8a0af06b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -179,6 +179,7 @@ public class PurpurConfig {
+     public static boolean afkBroadcastUseDisplayName = false;
+     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);
+@@ -187,6 +188,7 @@ public class PurpurConfig {
+         afkBroadcastUseDisplayName = getBoolean("settings.messages.afk-broadcast-use-display-name", afkBroadcastUseDisplayName);
+         afkTabListPrefix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix)));
+         afkTabListSuffix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(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..235f3cd89f675b70a6152a00534608c0902f19fd
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/command/DemoCommand.java
+@@ -0,0 +1,35 @@
++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, "bukkit.command.demo"))
++                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
++                .then(Commands.argument("targets", EntityArgument.players())
++                        .requires(listener -> listener.hasPermission(2, "bukkit.command.demo.other"))
++                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
++                )
++        );
++    }
++
++    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();
++    }
++}

patches/unapplied/server/0065-Add-credits-command.patch

@@ -0,0 +1,79 @@
+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 54f9dd8d666b2b45190681f4362fce457e8e8ef2..e5b1b6ad32c48a4ba13b4930954fad18669677ad 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -224,6 +224,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 235db276a07017bf89e6311a0b84291e8a0af06b..8e99128759e555cdef0efe9cea1b3b36f2c3fda9 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -179,6 +179,7 @@ public class PurpurConfig {
+     public static boolean afkBroadcastUseDisplayName = false;
+     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() {
+@@ -188,6 +189,7 @@ public class PurpurConfig {
+         afkBroadcastUseDisplayName = getBoolean("settings.messages.afk-broadcast-use-display-name", afkBroadcastUseDisplayName);
+         afkTabListPrefix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(getString("settings.messages.afk-tab-list-prefix", afkTabListPrefix)));
+         afkTabListSuffix = MiniMessage.miniMessage().serialize(MiniMessage.miniMessage().deserialize(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..40d2fab4a9728ac90c36e30c130f3116b7025d11
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/command/CreditsCommand.java
+@@ -0,0 +1,35 @@
++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, "bukkit.command.credits"))
++                .executes((context) -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
++                .then(Commands.argument("targets", EntityArgument.players())
++                        .requires(listener -> listener.hasPermission(2, "bukkit.command.credits.other"))
++                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
++                )
++        );
++    }
++
++    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();
++    }
++}

patches/unapplied/server/0066-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 3cde608a222ab2ef2b5fc7f543e97ba71e440ea9..6ec7d0f5e525f9e04b6fa0fb6d4da5fcc22fe653 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+@@ -95,6 +95,21 @@ public class Drowned extends Zombie implements RangedAttackMob {
+         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;
++    }
++
+     @Override
+     protected void addBehaviourGoals() {
+         this.goalSelector.addGoal(1, new Drowned.DrownedGoToWaterGoal(this, 1.0D));
+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 5f801b2a7d8a69a38b8e10471a29f813c8d828ad..7e46ebc5c99f018cada50f491200e4fe7b7098d7 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Husk.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Husk.java
+@@ -49,6 +49,21 @@ public class Husk extends Zombie {
+         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;
++    }
++
+     public static boolean checkHuskSpawnRules(EntityType<Husk> type, ServerLevelAccessor world, MobSpawnType spawnReason, BlockPos pos, RandomSource random) {
+         return checkMonsterSpawnRules(type, world, spawnReason, pos, random) && (spawnReason == MobSpawnType.SPAWNER || world.canSeeSky(pos));
+     }
+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 b3a31549179760388bc2958b4339848d1f0b293d..b2b04d7b7bbc400fb66cac385fa754d4fb47c7d9 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+@@ -128,6 +128,18 @@ public class Zombie extends Monster {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.zombieMaxHealth);
+     }
+ 
++    public boolean jockeyOnlyBaby() {
++        return level().purpurConfig.zombieJockeyOnlyBaby;
++    }
++
++    public double jockeyChance() {
++        return level().purpurConfig.zombieJockeyChance;
++    }
++
++    public boolean jockeyTryExistingChickens() {
++        return level().purpurConfig.zombieJockeyTryExistingChickens;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+@@ -551,19 +563,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) randomsource.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) randomsource.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) randomsource.nextFloat() < 0.05D) {
++                        } else { // Purpur
+                         Chicken entitychicken1 = (Chicken) EntityType.CHICKEN.create(this.level());
+ 
+                         if (entitychicken1 != null) {
+@@ -573,6 +586,7 @@ public class Zombie extends Monster {
+                             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 c89680f83275169728f923e70a17cb88d4480f01..6f3667751e430ff6020a9a26f82a25e4ec043ce6 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
++++ b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+@@ -106,6 +106,21 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder {
+         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;
++    }
++
+     @Override
+     protected void defineSynchedData() {
+         super.defineSynchedData();
+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 8f22bfcde4bb8ad73794f2b98b156113e5a2a6c9..3d61b27c23d90e87fdfc8c170eafc116716ac047 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
++++ b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
+@@ -85,6 +85,21 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob {
+         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;
++    }
++
+     @Override
+     public void setPersistentAngerTarget(@Nullable UUID angryAt) {
+         this.persistentAngerTarget = angryAt;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9639202024f79c8ed57207445380ef017cfeaea6..c74027c71eecf76512d5737b496d98a6cffb5eab 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -592,6 +592,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);
+@@ -603,6 +606,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;
+@@ -851,6 +857,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);
+@@ -862,6 +871,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;
+@@ -1678,6 +1690,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);
+@@ -1689,6 +1704,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;
+@@ -1723,6 +1741,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);
+@@ -1734,6 +1755,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;
+@@ -1741,6 +1765,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);
+@@ -1752,5 +1779,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);
+     }
+ }

patches/unapplied/server/0067-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch

@@ -0,0 +1,282 @@
+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 ffc5b68c4246a7111845230a75552bb15875a209..ef0098e46bda8abc456f2bb5929d874c6aeb8698 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
+@@ -30,6 +30,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);
+@@ -79,7 +85,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(targetPhantom.damageSources().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 961300cb8bcc7b0aff476a435aa33e713bd520a6..86df67578334a4743909c748213c2e1ed5d19bd9 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;
+     public BlockPos anchorPoint;
+     Phantom.AttackPhase attackPhase;
++    Vec3 crystalPosition; // Purpur
+ 
+     public Phantom(EntityType<? extends Phantom> type, Level world) {
+         super(type, world);
+@@ -116,6 +117,23 @@ public class Phantom extends FlyingMob implements Enemy {
+         level().addFreshEntity(flames);
+         return true;
+     }
++
++    @Override
++    protected void dropFromLootTable(DamageSource damageSource, boolean causedByPlayer) {
++        boolean dropped = false;
++        if (lastHurtByPlayer == null && damageSource.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) {
++            super.dropFromLootTable(damageSource, causedByPlayer);
++        }
++    }
++
++    public boolean isCirclingCrystal() {
++        return crystalPosition != null;
++    }
+     // Purpur end
+ 
+     @Override
+@@ -130,11 +148,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());
+     }
+ 
+@@ -348,6 +372,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 c74027c71eecf76512d5737b496d98a6cffb5eab..49af5d8feae2b267a12273a91ee637c7a6e7021e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1069,6 +1069,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);
+@@ -1090,6 +1093,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;

patches/unapplied/server/0068-Add-phantom-spawning-options.patch

@@ -0,0 +1,71 @@
+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 dfeb3e336e06ef01f5401a362755030db942bb07..f74c5eda91a3d521763ec7bc33f23e0c62458cc2 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -49,7 +49,7 @@ public class PhantomSpawner implements CustomSpawner {
+                 int spawnAttemptMaxSeconds = world.paperConfig().entities.behavior.phantomsSpawnAttemptMaxSeconds;
+                 this.nextTick += (spawnAttemptMinSeconds + randomsource.nextInt(spawnAttemptMaxSeconds - spawnAttemptMinSeconds + 1)) * 20;
+                 // Paper end
+-                if (world.getSkyDarken() < 5 && world.dimensionType().hasSkyLight()) {
++                if (world.getSkyDarken() < world.purpurConfig.phantomSpawnMinSkyDarkness && world.dimensionType().hasSkyLight()) { // Purpur
+                     return 0;
+                 } else {
+                     int i = 0;
+@@ -61,10 +61,10 @@ public class PhantomSpawner implements CustomSpawner {
+                         if (!entityplayer.isSpectator() && (!world.paperConfig().entities.behavior.phantomsDoNotSpawnOnCreativePlayers || !entityplayer.isCreative())) { // Paper
+                             BlockPos blockposition = entityplayer.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(randomsource.nextFloat() * 3.0F)) {
++                                if (difficultydamagescaler.isHarderThan(randomsource.nextFloat() * (float) world.purpurConfig.phantomSpawnLocalDifficultyChance)) { // Purpur
+                                     ServerStatsCounter serverstatisticmanager = entityplayer.getStats();
+                                     int j = Mth.clamp(serverstatisticmanager.getValue(Stats.CUSTOM.get(Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE);
+                                     boolean flag2 = true;
+@@ -76,7 +76,7 @@ public class PhantomSpawner implements CustomSpawner {
+ 
+                                         if (NaturalSpawner.isValidEmptySpawnBlock(world, blockposition1, iblockdata, fluid, EntityType.PHANTOM)) {
+                                             SpawnGroupData groupdataentity = null;
+-                                            int k = 1 + randomsource.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 49af5d8feae2b267a12273a91ee637c7a6e7021e..fb1e819bf55623408a134bf334099c425609765d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1072,6 +1072,12 @@ public class PurpurWorldConfig {
+     public double phantomAttackedByCrystalRadius = 0.0D;
+     public float phantomAttackedByCrystalDamage = 1.0F;
+     public double phantomOrbitCrystalRadius = 0.0D;
++    public int phantomSpawnMinSkyDarkness = 5;
++    public boolean phantomSpawnOnlyAboveSeaLevel = true;
++    public boolean phantomSpawnOnlyWithVisibleSky = true;
++    public double phantomSpawnLocalDifficultyChance = 3.0D;
++    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);
+@@ -1096,6 +1102,12 @@ 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);
++        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);
++        phantomSpawnMinPerAttempt = getInt("mobs.phantom.spawn.per-attempt.min", phantomSpawnMinPerAttempt);
++        phantomSpawnMaxPerAttempt = getInt("mobs.phantom.spawn.per-attempt.max", phantomSpawnMaxPerAttempt);
+     }
+ 
+     public boolean pigRidable = false;

patches/unapplied/server/0069-Implement-bed-explosion-options.patch

@@ -0,0 +1,60 @@
+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 d40500f9a807cab0b2fb6fa9032f33f4fb74c895..e8405a57fb88e63b63baaf00645c417633bdc0f2 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
+ 
+                 Vec3 vec3d = pos.getCenter();
+ 
+-                world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), (ExplosionDamageCalculator) null, vec3d, 5.0F, true, Level.ExplosionInteraction.BLOCK);
++                if (world.purpurConfig.bedExplode) world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), (ExplosionDamageCalculator) null, vec3d, (float) world.purpurConfig.bedExplosionPower, world.purpurConfig.bedExplosionFire, world.purpurConfig.bedExplosionEffect); // Purpur
+                 return InteractionResult.SUCCESS;
+             } else if ((Boolean) state.getValue(BedBlock.OCCUPIED)) {
+                 if (!BedBlock.canSetSpawn(world)) return this.explodeBed(state, world, pos); // Paper - check explode first
+@@ -149,7 +149,7 @@ public class BedBlock extends HorizontalDirectionalBlock implements EntityBlock
+ 
+                 Vec3 vec3d = blockposition.getCenter();
+ 
+-                world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), (ExplosionDamageCalculator) null, vec3d, 5.0F, true, Level.ExplosionInteraction.BLOCK);
++                if (world.purpurConfig.bedExplode) world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), (ExplosionDamageCalculator) null, vec3d, (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 fb1e819bf55623408a134bf334099c425609765d..ab4f4de26a6752b54f35b1aeec657c1d2be3ecdb 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -288,6 +288,27 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
++    public boolean bedExplode = true;
++    public double bedExplosionPower = 5.0D;
++    public boolean bedExplosionFire = true;
++    public net.minecraft.world.level.Level.ExplosionInteraction bedExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++    private void bedSettings() {
++        if (PurpurConfig.version < 31) {
++            if ("DESTROY".equals(getString("blocks.bed.explosion-effect", bedExplosionEffect.name()))) {
++                set("blocks.bed.explosion-effect", "BLOCK");
++            }
++        }
++        bedExplode = getBoolean("blocks.bed.explode", bedExplode);
++        bedExplosionPower = getDouble("blocks.bed.explosion-power", bedExplosionPower);
++        bedExplosionFire = getBoolean("blocks.bed.explosion-fire", bedExplosionFire);
++        try {
++            bedExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.valueOf(getString("blocks.bed.explosion-effect", bedExplosionEffect.name()));
++        } catch (IllegalArgumentException e) {
++            log(Level.SEVERE, "Unknown value for `blocks.bed.explosion-effect`! Using default of `BLOCK`");
++            bedExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++        }
++    }
++
+     public boolean dispenserApplyCursedArmor = true;
+     private void dispenserSettings() {
+         dispenserApplyCursedArmor = getBoolean("blocks.dispenser.apply-cursed-to-armor-slots", dispenserApplyCursedArmor);

patches/unapplied/server/0070-Implement-respawn-anchor-explosion-options.patch

@@ -0,0 +1,51 @@
+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 2ed78cf83c0ae66a6ddba1ff307da89a24b0d0a8..ae17d6a54fad0bd2d71d306f418b5ced2f11b863 100644
+--- a/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/RespawnAnchorBlock.java
+@@ -141,7 +141,7 @@ public class RespawnAnchorBlock extends Block {
+         };
+         Vec3 vec3d = explodedPos.getCenter();
+ 
+-        world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), explosiondamagecalculator, vec3d, 5.0F, true, Level.ExplosionInteraction.BLOCK); // Paper
++        if (world.purpurConfig.respawnAnchorExplode)world.explode((Entity) null, world.damageSources().badRespawnPointExplosion(vec3d, explodedBlockState), explosiondamagecalculator, vec3d, (float) world.purpurConfig.respawnAnchorExplosionPower, world.purpurConfig.respawnAnchorExplosionFire, world.purpurConfig.respawnAnchorExplosionEffect); // Paper // 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 ab4f4de26a6752b54f35b1aeec657c1d2be3ecdb..dc7666906fb04bf8f1df54ac81e04d8ad76a893b 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -328,6 +328,27 @@ 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 net.minecraft.world.level.Level.ExplosionInteraction respawnAnchorExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++    private void respawnAnchorSettings() {
++        if (PurpurConfig.version < 31) {
++            if ("DESTROY".equals(getString("blocks.respawn_anchor.explosion-effect", respawnAnchorExplosionEffect.name()))) {
++                set("blocks.respawn_anchor.explosion-effect", "BLOCK");
++            }
++        }
++        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 = net.minecraft.world.level.Level.ExplosionInteraction.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 `BLOCK`");
++            respawnAnchorExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++        }
++    }
++
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;

patches/unapplied/server/0071-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 578c3db52dda4c169b5ea615a4ce4a79f15a4cad..0bd98b802f246a3f6061f716d470a4797b28d59d 100644
+--- a/src/main/java/net/minecraft/world/item/BucketItem.java
++++ b/src/main/java/net/minecraft/world/item/BucketItem.java
+@@ -164,7 +164,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
+-            } else if (world.dimensionType().ultraWarm() && this.content.is(FluidTags.WATER)) {
++            } else if ((world.dimensionType().ultraWarm() || (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();
+@@ -172,7 +172,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 f8615d9714ac6a9c83d881d6d89b1182a0f0d835..155f43ebf708031d5f3148282d30dca27192e926 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1586,4 +1586,14 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         }
+     }
+     // 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 04089e6f7d6e3d532b00585870283922b6be5246..61e6d14abd54ecd5e43a5459f8daa7d86adedf44 100644
+--- a/src/main/java/net/minecraft/world/level/block/IceBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+@@ -33,7 +33,7 @@ public class IceBlock extends HalfTransparentBlock {
+     public void afterDestroy(Level world, BlockPos pos, ItemStack tool) {
+         // Paper end
+         if (EnchantmentHelper.getItemEnchantmentLevel(Enchantments.SILK_TOUCH, tool) == 0) {
+-            if (world.dimensionType().ultraWarm()) {
++            if (world.isNether() || (world.isTheEnd() && !org.purpurmc.purpur.PurpurConfig.allowWaterPlacementInTheEnd)) { // Purpur
+                 world.removeBlock(pos, false);
+                 return;
+             }
+@@ -61,7 +61,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, IceBlock.meltsInto());
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index d98e16bc47d3bc458281956bf538f4a37bd0f4b7..387da71594b75a43100790e8e8d69d9246598537 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -244,6 +244,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;

patches/unapplied/server/0072-Allow-color-codes-in-books.patch

@@ -0,0 +1,77 @@
+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 317342df5d3afe65e09853fd9ffe4aca127152d2..970c711a6631cf3e16ca09704452b32b68672ce9 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1359,13 +1359,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                 itemstack1.setTag(nbttagcompound.copy());
+             }
+ 
++            // Purpur start
++            boolean hasPerm = getCraftPlayer().hasPermission("purpur.book.color.edit") || getCraftPlayer().hasPermission("purpur.book.color.sign");
+             itemstack1.addTagElement("author", StringTag.valueOf(this.player.getName().getString()));
+             if (this.player.isTextFilteringEnabled()) {
+-                itemstack1.addTagElement("title", StringTag.valueOf(title.filteredOrEmpty()));
++                itemstack1.addTagElement("title", StringTag.valueOf(color(title.filteredOrEmpty(), hasPerm)));
+             } else {
+-                itemstack1.addTagElement("filtered_title", StringTag.valueOf(title.filteredOrEmpty()));
+-                itemstack1.addTagElement("title", StringTag.valueOf(title.raw()));
++                itemstack1.addTagElement("filtered_title", StringTag.valueOf(color(title.filteredOrEmpty(), hasPerm)));
++                itemstack1.addTagElement("title", StringTag.valueOf(color(title.raw(), hasPerm)));
+             }
++            // Purpur end
+ 
+             this.updateBookPages(pages, (s) -> {
+                 return Component.Serializer.toJson(Component.literal(s));
+@@ -1377,10 +1380,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     private void updateBookPages(List<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((filteredtext) -> { // CraftBukkit - decompile error
+-                return StringTag.valueOf((String) unaryoperator.apply(filteredtext.filteredOrEmpty()));
++            Stream<StringTag> stream = list.stream().map(s -> color(s.filteredOrEmpty(), hasPerm, false)).map((s) -> { // CraftBukkit - decompile error
++                return StringTag.valueOf((String) unaryoperator.apply(s));
+             });
++            // Purpur end
+ 
+             Objects.requireNonNull(nbttaglist);
+             stream.forEach(nbttaglist::add);
+@@ -1390,11 +1396,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+             for (int j = list.size(); i < j; ++i) {
+                 FilteredText filteredtext = (FilteredText) list.get(i);
+-                String s = filteredtext.raw();
++                String s = color(filteredtext.raw(), hasPerm, false); // Purpur
+ 
+                 nbttaglist.add(StringTag.valueOf((String) unaryoperator.apply(s)));
+                 if (filteredtext.isFiltered()) {
+-                    nbttagcompound.putString(String.valueOf(i), (String) unaryoperator.apply(filteredtext.filteredOrEmpty()));
++                    nbttagcompound.putString(String.valueOf(i), (String) unaryoperator.apply((String) color(filteredtext.filteredOrEmpty(), hasPerm, false))); // Purpur
+                 }
+             }
+ 
+@@ -1407,6 +1413,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+         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.serverLevel());

patches/unapplied/server/0073-Entity-lifespan.patch

@@ -0,0 +1,111 @@
+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 2387d9d9373120794721cc65401d2635e84bab93..16aefb8b214a61f7b6f32d78f9e05870b8e2699f 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2901,6 +2901,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+             AABB axisalignedbb = entity.getBoundingBox();
+ 
+             if (axisalignedbb.distanceToSqr(this.player.getEyePosition()) < ServerGamePacketListenerImpl.MAX_INTERACTION_DISTANCE) {
++                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);
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 2023ae88e6cb0565f8fe7b525dfe84279bf90dd6..049a6b2186ff31ac9a815ac501b75488e2e19266 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -133,6 +133,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+     private BlockPos restrictCenter;
+     private float restrictRadius;
+ 
++    public int ticksSinceLastInteraction; // Purpur
+     public boolean aware = true; // CraftBukkit
+ 
+     protected Mob(EntityType<? extends Mob> type, Level world) {
+@@ -323,6 +324,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+                 entityliving = null;
+             }
+         }
++        if (entityliving instanceof ServerPlayer) this.ticksSinceLastInteraction = 0; // Purpur
+         this.target = entityliving;
+         return true;
+         // CraftBukkit end
+@@ -370,8 +372,28 @@ public abstract class Mob extends LivingEntity implements Targeting {
+         }
+ 
+         this.level().getProfiler().pop();
++        incrementTicksSinceLastInteraction(); // Purpur
+     }
+ 
++    // 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();
+@@ -561,6 +583,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+         }
+ 
+         nbt.putBoolean("Bukkit.Aware", this.aware); // CraftBukkit
++        nbt.putInt("Purpur.ticksSinceLastInteraction", this.ticksSinceLastInteraction); // Purpur
+     }
+ 
+     @Override
+@@ -631,6 +654,11 @@ public abstract class Mob extends LivingEntity implements Targeting {
+             this.aware = nbt.getBoolean("Bukkit.Aware");
+         }
+         // CraftBukkit end
++        // Purpur start
++        if (nbt.contains("Purpur.ticksSinceLastInteraction")) {
++            this.ticksSinceLastInteraction = nbt.getInt("Purpur.ticksSinceLastInteraction");
++        }
++        // Purpur end
+     }
+ 
+     @Override
+@@ -1701,6 +1729,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+             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 dc7666906fb04bf8f1df54ac81e04d8ad76a893b..d315a4aac382462b1bd0d44b6b5a88552f663d36 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -125,6 +125,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<>();

patches/unapplied/server/0074-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch

@@ -0,0 +1,69 @@
+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 03b19d56e4f75d71f592f400f59c9becd39c4d4f..459f8bcf13ed759c40eff1ade5d9011ede8547c3 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -2764,4 +2764,26 @@ public class ServerPlayer extends Player {
+         return (CraftPlayer) super.getBukkitEntity();
+     }
+     // CraftBukkit end
++
++    // 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.internalTeleport(to.getX(), to.getY(), to.getZ(), to.getYaw(), to.getPitch(), java.util.EnumSet.noneOf(net.minecraft.world.entity.RelativeMovement.class));
++        } else {
++            this.server.getPlayerList().respawn(this, toLevel, true, to, !toLevel.paperConfig().environment.disableTeleportationSuffocationCheck, org.bukkit.event.player.PlayerRespawnEvent.RespawnReason.DEATH);
++        }
++    }
++    // 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 35e3cac34a6a508fbf3971cff9ac07db48ddeaae..8c0ef795691aa17e9522b2deda794bcdf38c64b6 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -427,6 +427,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                         double d1 = this.level().getWorldBorder().getDamagePerBlock();
+ 
+                         if (d1 > 0.0D) {
++                            if (level().purpurConfig.teleportIfOutsideBorder && this instanceof ServerPlayer serverPlayer) { serverPlayer.teleport(io.papermc.paper.util.MCUtil.toLocation(level(), ((ServerLevel) level()).getSharedSpawnPos())); return; } // Purpur
+                             this.hurt(this.damageSources().outOfBorder(), (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 d315a4aac382462b1bd0d44b6b5a88552f663d36..8fdbaa0cd95186b3b48aac1eb953e268554726e4 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 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);
+@@ -259,6 +260,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;

patches/unapplied/server/0075-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 8fdbaa0cd95186b3b48aac1eb953e268554726e4..adfb558d98990739b24e10c7bf941287d30737a0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1457,6 +1457,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);
+@@ -1466,6 +1467,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 12adaba78ec30e463963f99c0d78e844756143a1..79d027e517ce08443d86b877a55df24cc20d102b 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;
+@@ -397,6 +398,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;

patches/unapplied/server/0076-Phantoms-burn-in-light.patch

@@ -0,0 +1,77 @@
+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 86df67578334a4743909c748213c2e1ed5d19bd9..899a7d3989b51456600787ae09b1736f83bf9a65 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;
+     public BlockPos anchorPoint;
+     Phantom.AttackPhase attackPhase;
++    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
+     Vec3 crystalPosition; // Purpur
+ 
+     public Phantom(EntityType<? extends Phantom> type, Level world) {
+@@ -246,7 +247,12 @@ public class Phantom extends FlyingMob implements Enemy {
+ 
+     @Override
+     public void aiStep() {
+-        if (this.isAlive() && shouldBurnInDay && this.isSunBurnTick()) { // Paper - Configurable Burning
++        // 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
+             if (getRider() == null || !this.isControllable()) // Purpur
+             this.setSecondsOnFire(8);
+         }
+@@ -656,6 +662,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;
+@@ -801,6 +813,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 adfb558d98990739b24e10c7bf941287d30737a0..d6221af9b94530882a93c178d555dfc363f241ce 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1127,6 +1127,9 @@ public class PurpurWorldConfig {
+     public double phantomSpawnLocalDifficultyChance = 3.0D;
+     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);
+@@ -1157,6 +1160,9 @@ public class PurpurWorldConfig {
+         phantomSpawnLocalDifficultyChance = getDouble("mobs.phantom.spawn.local-difficulty-chance", phantomSpawnLocalDifficultyChance);
+         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;

patches/unapplied/server/0077-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 50925ab7d719ae3323d7456df03a3d2ab3481bfd..7d13a5308161d4093023b732bed7d06152f54737 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -785,7 +785,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     public boolean canBreed() {
+-        return this.foodLevel + this.countFoodPointsInInventory() >= 12 && !this.isSleeping() && this.getAge() == 0;
++        return this.level().purpurConfig.villagerCanBreed && this.foodLevel + this.countFoodPointsInInventory() >= 12 && !this.isSleeping() && this.getAge() == 0; // Purpur
+     }
+ 
+     private boolean hungry() {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d6221af9b94530882a93c178d555dfc363f241ce..b9873e66e91d596e17002a290027b0a9972a54fd 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1615,6 +1615,7 @@ public class PurpurWorldConfig {
+     public double villagerMaxHealth = 20.0D;
+     public boolean villagerFollowEmeraldBlock = false;
+     public boolean villagerCanBeLeashed = false;
++    public boolean villagerCanBreed = true;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1627,6 +1628,7 @@ public class PurpurWorldConfig {
+         villagerMaxHealth = getDouble("mobs.villager.attributes.max_health", villagerMaxHealth);
+         villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
+         villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
++        villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed);
+     }
+ 
+     public boolean vindicatorRidable = false;

patches/unapplied/server/0078-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 633500aefd515df5dadda3802b94079f75a03fa0..64d911bee1607880514061c75116d8672df8bb8f 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
++++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -55,6 +55,7 @@ public abstract class BaseSpawner {
+     }
+ 
+     public boolean isNearPlayer(Level world, BlockPos pos) {
++        if (world.purpurConfig.spawnerDeactivateByRedstone && world.hasNeighborSignal(pos)) return false; // Purpur
+         return world.hasNearbyAlivePlayerThatAffectsSpawning((double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, (double) this.requiredPlayerRange); // Paper - Affects Spawning API
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b9873e66e91d596e17002a290027b0a9972a54fd..10994174be125f8ce819d4d6e851178a72779ba1 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -356,6 +356,11 @@ public class PurpurWorldConfig {
+         }
+     }
+ 
++    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;

patches/unapplied/server/0079-Totems-work-in-inventory.patch

@@ -0,0 +1,49 @@
+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 29d523efe2222511c25c8d8a3eeff6adf2a2da0e..c75d3490dd475fc7c1bd4931841cc84888a23bac 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1594,6 +1594,18 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                 }
+             }
+ 
++            // Purpur start
++            if (level().purpurConfig.totemOfUndyingWorksInInventory && this instanceof ServerPlayer player && (itemstack == null || itemstack.getItem() != Items.TOTEM_OF_UNDYING) && player.getBukkitEntity().hasPermission("purpur.inventory_totem")) {
++                for (ItemStack item : player.getInventory().items) {
++                    if (item.getItem() == Items.TOTEM_OF_UNDYING) {
++                        itemstack1 = item;
++                        itemstack = item.copy();
++                        break;
++                    }
++                }
++            }
++            // Purpur end
++
+             org.bukkit.inventory.EquipmentSlot handSlot = (hand != null) ? org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand) : null;
+             EntityResurrectEvent event = new EntityResurrectEvent((org.bukkit.entity.LivingEntity) this.getBukkitEntity(), handSlot);
+             event.setCancelled(itemstack == null);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 10994174be125f8ce819d4d6e851178a72779ba1..9335574d7396da50fe027cb455847cfef6528436 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -245,6 +245,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);
+@@ -261,6 +262,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;

patches/unapplied/server/0080-Add-vindicator-johnny-spawn-chance.patch

@@ -0,0 +1,43 @@
+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 40858ac2a9b58108472748d0ef2c2fd5ef5cfd98..2a5b6b94b15bf066b5722e7a4f782bc87f9debf4 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
+@@ -154,6 +154,12 @@ public class Vindicator extends AbstractIllager {
+         RandomSource randomSource = world.getRandom();
+         this.populateDefaultEquipmentSlots(randomSource, difficulty);
+         this.populateDefaultEquipmentEnchantments(randomSource, difficulty);
++        // Purpur start
++        Level level = world.getMinecraftWorld();
++        if (level().purpurConfig.vindicatorJohnnySpawnChance > 0D && random.nextDouble() <= level().purpurConfig.vindicatorJohnnySpawnChance) {
++            setCustomName(Component.translatable("Johnny"));
++        }
++        // Purpur end
+         return spawnGroupData;
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9335574d7396da50fe027cb455847cfef6528436..1b7d8a8fc241e096fc4fd5b65d8444779d1deae5 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1642,6 +1642,7 @@ public class PurpurWorldConfig {
+     public boolean vindicatorRidableInWater = true;
+     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);
+@@ -1652,6 +1653,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;

patches/unapplied/server/0081-Dispensers-place-anvils-option.patch

@@ -0,0 +1,49 @@
+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 8c2750de3be202122ccf9923a9fa32fcb8bdb743..7961a69d3e70a8ae1d74c732cd97a9cbd824a8d0 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -1187,6 +1187,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(net.minecraft.world.level.block.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 1b7d8a8fc241e096fc4fd5b65d8444779d1deae5..0e473df153cfd9090b74b5fa2b5568220d61ae98 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -319,8 +319,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;

patches/unapplied/server/0082-Allow-anvil-colors.patch

@@ -0,0 +1,83 @@
+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 b500a04b8135604f0159a741b3d228c9e87b2a46..8a7c30e316db4960b0b62ca0e366c19febead214 100644
+--- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
++++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+@@ -294,6 +294,54 @@ public class AnvilMenu extends ItemCombinerMenu {
+                 if (!this.itemName.equals(itemstack.getHoverName().getString())) {
+                     b1 = 1;
+                     i += b1;
++                    // Purpur start
++                    if (this.player != null) {
++                        org.bukkit.craftbukkit.entity.CraftHumanEntity player = this.player.getBukkitEntity();
++                        String name = this.itemName;
++                        boolean removeItalics = false;
++                        if (player.hasPermission("purpur.anvil.remove_italics")) {
++                            if (name.startsWith("&r")) {
++                                name = name.substring(2);
++                                removeItalics = true;
++                            } else if (name.startsWith("<r>")) {
++                                name = name.substring(3);
++                                removeItalics = true;
++                            } else if (name.startsWith("<reset>")) {
++                                name = name.substring(7);
++                                removeItalics = true;
++                            }
++                        }
++                        if (this.player.level().purpurConfig.anvilAllowColors) {
++                            if (player.hasPermission("purpur.anvil.color")) {
++                                java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("(?i)&([0-9a-fr])").matcher(name);
++                                while (matcher.find()) {
++                                    String match = matcher.group(1);
++                                    name = name.replace("&" + match, "\u00a7" + match.toLowerCase(java.util.Locale.ROOT));
++                                }
++                                //name = name.replaceAll("(?i)&([0-9a-fr])", "\u00a7$1");
++                            }
++                            if (player.hasPermission("purpur.anvil.format")) {
++                                java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("(?i)&([k-or])").matcher(name);
++                                while (matcher.find()) {
++                                    String match = matcher.group(1);
++                                    name = name.replace("&" + match, "\u00a7" + match.toLowerCase(java.util.Locale.ROOT));
++                                }
++                                //name = name.replaceAll("(?i)&([l-or])", "\u00a7$1");
++                            }
++                        }
++                        net.kyori.adventure.text.Component component;
++                        if (this.player.level().purpurConfig.anvilColorsUseMiniMessage && player.hasPermission("purpur.anvil.minimessage")) {
++                            component = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage().deserialize(org.bukkit.ChatColor.stripColor(name));
++                        } else {
++                            component = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(name);
++                        }
++                        if (removeItalics) {
++                            component = component.decoration(net.kyori.adventure.text.format.TextDecoration.ITALIC, false);
++                        }
++                        itemstack1.setHoverName(io.papermc.paper.adventure.PaperAdventure.asVanilla(component));
++                    }
++                    else
++                    // Purpur end
+                     itemstack1.setHoverName(Component.literal(this.itemName));
+                 }
+             } else if (itemstack.hasCustomHoverName()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 0e473df153cfd9090b74b5fa2b5568220d61ae98..9344d7492585023f5de6db4e4c0cde41dc6c74cd 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -297,6 +297,13 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
++    public boolean anvilAllowColors = false;
++    public boolean anvilColorsUseMiniMessage;
++    private void anvilSettings() {
++        anvilAllowColors = getBoolean("blocks.anvil.allow-colors", anvilAllowColors);
++        anvilColorsUseMiniMessage = getBoolean("blocks.anvil.use-mini-message", anvilColorsUseMiniMessage);
++    }
++
+     public boolean bedExplode = true;
+     public double bedExplosionPower = 5.0D;
+     public boolean bedExplosionFire = true;

patches/unapplied/server/0083-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 89e3dbfddc739f97fdb6ec9a5714530f03cc7092..079fd78528377ee4236fb2e7189a5f0fc5ec4fb3 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+@@ -485,6 +485,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;
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9344d7492585023f5de6db4e4c0cde41dc6c74cd..d230e75bebc1817c171cdd93a1634512d652ceea 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -614,6 +614,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);
+@@ -626,6 +627,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;

patches/unapplied/server/0084-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 08beb4c4dfcb0986cdebb4d0cacc25e4e9c17674..e413aa4650297ce2109beb6319f52fb476e291fe 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -308,7 +308,8 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+     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 final FeatureFlagSet requiredFeatures;
+ 
+     private static <T extends Entity> EntityType<T> register(String id, EntityType.Builder type) { // 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 74d1a0e8de36aaf11e844cc4f40e4c469d6269b4..3861f367ac01028139cc6db35fb9a1e20cb39457 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -433,6 +433,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.is(net.minecraft.world.damagesource.DamageTypes.IN_WALL)) { return false; // Purpur - no suffocation damage if short height
+         } else {
+             boolean flag = source.getDirectEntity() instanceof ThrownPotion;
+             boolean flag1;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 387da71594b75a43100790e8e8d69d9246598537..e813c87f4cc90fd31a4a48fcfffbe2b4407e5f5d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -244,6 +244,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);

patches/unapplied/server/0085-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 01a1534ec503e9aaea7befdba86f452128f8863d..6935e327b4c1580dae9fbf2279bde4af165f76ce 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -4349,6 +4349,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 913b66be2111da862e706d4978825c64cfe8b00b..f68c18b6645981126329b58379946308bbb8ccf8 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+@@ -75,6 +75,12 @@ public class Squid extends WaterAnimal {
+         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);
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new Squid.SquidRandomMovementGoal(this));
+diff --git a/src/main/java/net/minecraft/world/phys/AABB.java b/src/main/java/net/minecraft/world/phys/AABB.java
+index ffc76354ead6937daf366c3d87bcb51d3e4c47f5..5b98d42b5d6bc07265fbb017e51a6281c148436a 100644
+--- a/src/main/java/net/minecraft/world/phys/AABB.java
++++ b/src/main/java/net/minecraft/world/phys/AABB.java
+@@ -374,4 +374,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 d230e75bebc1817c171cdd93a1634512d652ceea..88225ba1bad1a20cbb7bcd56b0cd7424661712c3 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1482,6 +1482,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);
+@@ -1492,6 +1493,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;

patches/unapplied/server/0086-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 c461e0d04047db9c0c5ecc04063cebd38bf96ec2..e7554ec800f321e4e34c926c53f2375a8c3aa979 100644
+--- a/src/main/java/net/minecraft/world/level/portal/PortalShape.java
++++ b/src/main/java/net/minecraft/world/level/portal/PortalShape.java
+@@ -34,7 +34,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 static final float SAFE_TRAVEL_MAX_ENTITY_XY = 4.0F;
+     private static final double SAFE_TRAVEL_MAX_VERTICAL_DELTA = 1.0D;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index e813c87f4cc90fd31a4a48fcfffbe2b4407e5f5d..6470f383b6f044877f0a4d8c91119d0eae451b8f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -212,6 +212,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);
+@@ -242,6 +243,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;

patches/unapplied/server/0087-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 6935e327b4c1580dae9fbf2279bde4af165f76ce..105b093cd0353a45197615e9fcdf06e72a0aad00 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3063,7 +3063,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();
+             }
+@@ -3764,7 +3764,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+ 
+     public boolean canChangeDimensions() {
+-        return !this.isPassenger() && !this.isVehicle() && isAlive() && valid; // Paper
++        return !this.isPassenger() && !this.isVehicle() && 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 88225ba1bad1a20cbb7bcd56b0cd7424661712c3..300c3d8a8fc34e95e9ad620aa603e66aa6847ae2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -98,6 +98,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;
+@@ -106,6 +107,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);

patches/unapplied/server/0088-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 4ba5c78fa10c1e30962f30d97821fa105f804904..88fc33afb4a88d8c8b0a41331791f1ca87b8a8fd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1110,5 +1110,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
+ }

patches/unapplied/server/0089-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 e6d6341f895c763fee05db3a7a7e05a68b9d36e9..8796b779ac0550e32c7313b1280278de48070baf 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
+@@ -525,8 +525,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 300c3d8a8fc34e95e9ad620aa603e66aa6847ae2..32b2444c0e96d4ba53693764a4caf0b596ed947f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1721,6 +1721,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);
+@@ -1736,6 +1738,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;

patches/unapplied/server/0090-Allow-toggling-special-MobSpawners-per-world.patch

@@ -0,0 +1,99 @@
+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 11f92c1011a1accaf485e5785d2e9ebc8440406c..af57326c8d461d3c5d84f582d5bc6345c3c9367b 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -663,7 +663,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
+         this.serverLevelData = iworlddataserver;
+         ChunkGenerator chunkgenerator = worlddimension.generator();
+         // CraftBukkit start
+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 8385eb1d60f377da94e3178ab506feefb43563fd..a5443f92786427c42092aec8350e7ab37704db7a 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
++++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+@@ -159,7 +159,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(net.minecraft.core.Direction.DOWN);
++                } while (!world.getBlockState(blockposition2).isAir());
++                do {
++                    blockposition2.relative(net.minecraft.core.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 32b2444c0e96d4ba53693764a4caf0b596ed947f..e0447c62f0c5df368a3ea41d63f64e23ccb06271 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -69,6 +69,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));
+@@ -237,6 +243,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;

patches/unapplied/server/0091-Raid-cooldown-setting.patch

@@ -0,0 +1,70 @@
+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 41457c9f27b18fa2734a6cca297ec5186470e82f..94356e0541f8f4da68211fa533347cc97d4f3518 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()) {
+@@ -129,11 +141,13 @@ public class Raids extends SavedData {
+                 }
+ 
+                 if (flag) {
++                    if (level.purpurConfig.raidCooldownSeconds != 0 && playerCooldowns.containsKey(player.getUUID())) return null; // Purpur
+                     // CraftBukkit start
+                     if (!org.bukkit.craftbukkit.event.CraftEventFactory.callRaidTriggerEvent(raid, player)) {
+                         player.removeEffect(MobEffects.BAD_OMEN);
+                         return null;
+                     }
++                    if (level.purpurConfig.raidCooldownSeconds != 0) playerCooldowns.put(player.getUUID(), level.purpurConfig.raidCooldownSeconds); // Purpur
+ 
+                     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 e0447c62f0c5df368a3ea41d63f64e23ccb06271..f2db6143daf0ec578b224360273b8dc5ffa3bb43 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 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);
+@@ -118,6 +119,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;

patches/unapplied/server/0092-Despawn-rate-config-options-per-projectile-type.patch

@@ -0,0 +1,52 @@
+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
+
+This patch's implementation has been removed in favor of Pufferfish's entity-timeouts.
+The config remains for migration purposes.
+
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f2db6143daf0ec578b224360273b8dc5ffa3bb43..37bea4068461e0b2d3ded80529ca2a8c3e8473e2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -290,6 +290,39 @@ public class PurpurWorldConfig {
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+     }
+ 
++    private static boolean projectileDespawnRateSettingsMigrated = false;
++    private void projectileDespawnRateSettings() {
++        if (PurpurConfig.version < 28 && !projectileDespawnRateSettingsMigrated) {
++            migrateProjectileDespawnRateSettings(EntityType.DRAGON_FIREBALL);
++            migrateProjectileDespawnRateSettings(EntityType.EGG);
++            migrateProjectileDespawnRateSettings(EntityType.ENDER_PEARL);
++            migrateProjectileDespawnRateSettings(EntityType.EXPERIENCE_BOTTLE);
++            migrateProjectileDespawnRateSettings(EntityType.FIREWORK_ROCKET);
++            migrateProjectileDespawnRateSettings(EntityType.FISHING_BOBBER);
++            migrateProjectileDespawnRateSettings(EntityType.FIREBALL);
++            migrateProjectileDespawnRateSettings(EntityType.LLAMA_SPIT);
++            migrateProjectileDespawnRateSettings(EntityType.POTION);
++            migrateProjectileDespawnRateSettings(EntityType.SHULKER_BULLET);
++            migrateProjectileDespawnRateSettings(EntityType.SMALL_FIREBALL);
++            migrateProjectileDespawnRateSettings(EntityType.SNOWBALL);
++            migrateProjectileDespawnRateSettings(EntityType.WITHER_SKULL);
++            //PufferfishConfig.save();
++            set("gameplay-mechanics.projectile-despawn-rates", null);
++            // pufferfish's entity_timeout is a global config
++            // we only want to migrate values from the
++            // default world (first world loaded)
++            projectileDespawnRateSettingsMigrated = true;
++        }
++    }
++    private void migrateProjectileDespawnRateSettings(EntityType<?> type) {
++        //String pufferName = "entity_timeouts." + type.id.toUpperCase(Locale.ROOT);
++        //int value = getInt("gameplay-mechanics.projectile-despawn-rates." + type.id, -1);
++        //if (value != -1 && PufferfishConfig.getRawInt(pufferName, -1) == -1) {
++        //    PufferfishConfig.setInt(pufferName, value);
++        //    type.ttl = value;
++        //}
++    }
++
+     public boolean silkTouchEnabled = false;
+     public String silkTouchSpawnerName = "<reset><white>Monster Spawner";
+     public List<String> silkTouchSpawnerLore = new ArrayList<>();

patches/unapplied/server/0093-Add-option-to-disable-zombie-aggressiveness-towards-.patch

@@ -0,0 +1,91 @@
+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
+
+
+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 a08c00b8c0488d18be5e182f7892e5ab71d12247..338f693d098b6ab507c30f6411c9a952c34ba8e3 100644
+--- a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
+@@ -136,6 +136,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 6ec7d0f5e525f9e04b6fa0fb6d4da5fcc22fe653..64acb2e81ef65acb0d41db8b5f7c924c2e2a5e00 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 (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(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 b2b04d7b7bbc400fb66cac385fa754d4fb47c7d9..bd75aa78a7dd437d6fce79a6cb18298184affe75 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+@@ -156,7 +156,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 ( this.level().spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Spigot
++        // Purpur start
++        if ( this.level().spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(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 37bea4068461e0b2d3ded80529ca2a8c3e8473e2..6e38987900f04d1aaf7030b3562c8571f12bbbde 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1854,6 +1854,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);
+@@ -1868,6 +1869,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;

patches/unapplied/server/0094-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 cd7ea0c16f9ddcb84b5d7e8a2533e6e84f3879c7..3ca086418ad037c48775db73d2b9c410acf1e326 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
++++ b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
+@@ -39,6 +39,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) -> {
+@@ -64,6 +65,12 @@ public final class Ingredient implements Predicate<ItemStack> {
+         } else if (this.isEmpty()) {
+             return itemstack.isEmpty();
+         } else {
++            // Purpur start
++            if (predicate != null) {
++                return predicate.test(itemstack.asBukkitCopy());
++            }
++            // Purpur end
++
+             ItemStack[] aitemstack = this.getItems();
+             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 13d25d118eb4d3ef35a4cdfb9bbde9ed83f6c04b..553ecc9b5631ffc0848a798bb3295f16d1722c1f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java
+@@ -30,6 +30,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);
+         }

patches/unapplied/server/0095-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 730958dab7f074930cdccb88a89aa26e2b6a112b..b1ba0f24dd6f1ec4c60208564e4eb84bdcd457f4 100644
+--- a/src/main/java/net/minecraft/world/entity/GlowSquid.java
++++ b/src/main/java/net/minecraft/world/entity/GlowSquid.java
+@@ -41,6 +41,11 @@ public class GlowSquid extends Squid {
+         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;
++    }
++
+     @Override
+     protected ParticleOptions getInkParticle() {
+         return ParticleTypes.GLOW_SQUID_INK;
+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 f68c18b6645981126329b58379946308bbb8ccf8..80bdc93cba675d6c1286618f14fc33e0344c601f 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+@@ -81,6 +81,15 @@ public class Squid extends WaterAnimal {
+         return super.getAxisForFluidCheck().offsetY(level().purpurConfig.squidOffsetWaterCheck);
+     }
+ 
++    public boolean canFly() {
++        return this.level().purpurConfig.squidsCanFly;
++    }
++
++    @Override
++    public boolean isInWater() {
++        return this.wasTouchingWater || canFly();
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new Squid.SquidRandomMovementGoal(this));
+@@ -153,6 +162,7 @@ public class Squid extends WaterAnimal {
+         }
+ 
+         if (this.isInWaterOrBubble()) {
++            if (canFly()) setNoGravity(!wasTouchingWater); // Purpur
+             if (this.tentacleMovement < (float)Math.PI) {
+                 float f = this.tentacleMovement / (float)Math.PI;
+                 this.tentacleAngle = Mth.sin(f * f * (float)Math.PI) * (float)Math.PI * 0.25F;
+@@ -366,7 +376,7 @@ public class Squid extends WaterAnimal {
+             int i = this.squid.getNoActionTime();
+             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() * ((float)Math.PI * 2F);
+                 float g = Mth.cos(f) * 0.2F;
+                 float h = -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 6e38987900f04d1aaf7030b3562c8571f12bbbde..bc8ab431df81d52065b401cf9f5cf0d040c79905 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -906,10 +906,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;
+@@ -1541,6 +1543,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);
+@@ -1552,6 +1555,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;

patches/unapplied/server/0096-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 bc8ab431df81d52065b401cf9f5cf0d040c79905..ae3beab9a442477973bc8f9ccd47f479d7ddc9ee 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -140,6 +140,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<>();

patches/unapplied/server/0097-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 9ec6145fe04ec64bbee8ec6a837719caebdbc6f5..358d610ad020cada1bb83e393deeeaaec05a2791 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;
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 4cadfd50a0c465ab8d809b91b9a999943385bc8a..fd3a85a2b0e2dca36044535f8ff77fec63f73aee 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1532,7 +1532,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             long worldTime = level.getGameTime();
+             final ClientboundSetTimePacket worldPacket = new ClientboundSetTimePacket(worldTime, dayTime, doDaylight);
+             for (Player entityhuman : level.players()) {
+-                if (!(entityhuman instanceof ServerPlayer) || (tickCount + entityhuman.getId()) % 20 != 0) {
++                if (!(entityhuman instanceof ServerPlayer) || (!level.isForceTime() && (tickCount + entityhuman.getId()) % 20 != 0)) { // Purpur
+                     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 af57326c8d461d3c5d84f582d5bc6345c3c9367b..0e8452f6a8300992f397fb15db763304d72fe3b9 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -214,6 +214,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     private final StructureManager structureManager;
+     private final StructureCheck structureCheck;
+     private final boolean tickTime;
++    private double preciseTime; // Purpur
++    private boolean forceTime; // Purpur
+     private final RandomSequences randomSequences;
+     public long lastMidTickExecuteFailure; // Paper - execute chunk tasks mid tick
+ 
+@@ -750,6 +752,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+ 
+         this.chunkTaskScheduler = new io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler(this, io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler.workerThreads); // Paper - rewrite chunk system
+         this.entityLookup = new io.papermc.paper.chunk.system.entity.EntityLookup(this, new EntityCallbacks()); // Paper - rewrite chunk system
++        this.preciseTime = this.serverLevelData.getDayTime(); // Purpur
+     }
+ 
+     // Paper start
+@@ -933,6 +936,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);
+             }
+ 
+@@ -941,7 +951,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 ae3beab9a442477973bc8f9ccd47f479d7ddc9ee..a721eb79dc528ada6a08265bb1f2895c31f0386e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -122,6 +122,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;

patches/unapplied/server/0098-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 518d85a13c37a2f7d32ca0718323181048559986..2c4ce164ab3011f372ff1719c8d4a3331d8db55f 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
++++ b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+@@ -19,6 +19,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 6470f383b6f044877f0a4d8c91119d0eae451b8f..de1a9b08946005d1235264c7658b51bbdc2c47c2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -246,6 +246,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);

patches/unapplied/server/0099-Furnace-uses-lava-from-underneath.patch

@@ -0,0 +1,70 @@
+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 448fa4f4f200430d6ce3051763c7ceb697696146..ca2052804ad829a1528a9c5a0a792275beead113 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
+@@ -44,6 +44,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,21 @@ 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
+         boolean flag2 = !((ItemStack) blockEntity.items.get(0)).isEmpty();
+         boolean flag3 = !itemstack.isEmpty();
+ 
+@@ -409,6 +425,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+             setChanged(world, pos, state);
+         }
+ 
++        if (usedLavaFromUnderneath) blockEntity.items.set(1, ItemStack.EMPTY); // Purpur
+     }
+ 
+     private static boolean canBurn(RegistryAccess registryManager, @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 a721eb79dc528ada6a08265bb1f2895c31f0386e..5c478488da15171d70c1b4c01d7ca33698314032 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -413,6 +413,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 int lavaInfiniteRequiredSources = 2;
+     public int lavaSpeedNether = 10;
+     public int lavaSpeedNotNether = 30;

patches/unapplied/server/0100-Arrows-should-not-reset-despawn-counter.patch

@@ -0,0 +1,37 @@
+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 fa885337085348308604e50049ecc5bb52023884..e8773aa2e796ca4e3b9b7cf85c40906d16eb241d 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -312,7 +312,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;
++        if (this.level().purpurConfig.arrowMovementResetsDespawnCounter) this.life = 0; // Purpur - do not reset despawn counter
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 5c478488da15171d70c1b4c01d7ca33698314032..b996cafed3083c3d9604005a054f0b4511bbf383 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -101,6 +101,11 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
++    public boolean arrowMovementResetsDespawnCounter = true;
++    private void arrowSettings() {
++        arrowMovementResetsDespawnCounter = getBoolean("gameplay-mechanics.arrow.movement-resets-despawn-counter", arrowMovementResetsDespawnCounter);
++    }
++
+     public boolean useBetterMending = false;
+     public boolean boatEjectPlayersOnLand = false;
+     public boolean disableDropsOnCrammingDeath = false;

patches/unapplied/server/0101-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 1776906e886edd511bfbe96b8a345438a3cd66f8..7efae60a9a9269703a1fa7cd280b5b96557ec73e 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -115,6 +115,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())) {
+                 return;
+             }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b996cafed3083c3d9604005a054f0b4511bbf383..8a43f22c9bcd20d2c1efbc18bce827551af77309 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -414,8 +414,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;

patches/unapplied/server/0102-Add-adjustable-breeding-cooldown-to-config.patch

@@ -0,0 +1,137 @@
+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 c2f61ed153260692c96af4f20bc5b7d55cbbc380..43f01ce3064fdc0bb46beab6ea001942f1506200 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+@@ -154,7 +154,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);
+                 return InteractionResult.SUCCESS;
+@@ -236,12 +236,20 @@ public abstract class Animal extends AgeableMob {
+         AgeableMob entityageable = this.getBreedOffspring(world, other);
+ 
+         if (entityageable != null) {
+-            entityageable.setBaby(true);
+-            entityageable.moveTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F);
+-            // CraftBukkit start - call EntityBreedEvent
++            // Purpur start
+             ServerPlayer breeder = Optional.ofNullable(this.getLoveCause()).or(() -> {
+                 return Optional.ofNullable(other.getLoveCause());
+             }).orElse(null);
++            if (breeder != null && world.purpurConfig.animalBreedingCooldownSeconds > 0) {
++                if (world.hasBreedingCooldown(breeder.getUUID(), this.getClass())) {
++                    return;
++                }
++                world.addBreedingCooldown(breeder.getUUID(), this.getClass());
++            }
++            entityageable.setBaby(true);
++            entityageable.moveTo(this.getX(), this.getY(), this.getZ(), 0.0F, 0.0F);
++            // CraftBukkit start - call EntityBreedEvent
++            // Purpur end
+             int experience = this.getRandom().nextInt(7) + 1;
+             EntityBreedEvent entityBreedEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityBreedEvent(entityageable, this, other, breeder, this.breedItem, experience);
+             if (entityBreedEvent.isCancelled()) {
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index a4c45ee8a5c6e55a6f9abde401cc06f13bd0b018..84ac5db63a51d1490fcf625d10ed0952d671017e 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -194,6 +194,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;
+     }
+@@ -289,6 +332,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 = paperWorldConfigCreator.apply(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 8a43f22c9bcd20d2c1efbc18bce827551af77309..7bc980fee2727359a9a2ecc66f31f3569cf8491f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -115,6 +115,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);
+@@ -125,6 +126,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++;
+ 

patches/unapplied/server/0103-Make-entity-breeding-times-configurable.patch

@@ -0,0 +1,947 @@
+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 645d204fe2c727637a6a547aad7d4db1279628ae..8be2f612c9e8a64b0aad6bb54450cdfb12b3c19e 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
+@@ -127,8 +127,10 @@ public class VillagerMakeLove extends Behavior<Villager> {
+                 return Optional.empty();
+             }
+             // Move age setting down
+-            parent.setAge(6000);
+-            partner.setAge(6000);
++            // Purpur start
++            parent.setAge(world.purpurConfig.villagerBreedingTicks);
++            partner.setAge(world.purpurConfig.villagerBreedingTicks);
++            // Purpur end
+             world.addFreshEntityWithPassengers(entityvillager2, CreatureSpawnEvent.SpawnReason.BREEDING);
+             // CraftBukkit end
+             world.broadcastEntityEvent(entityvillager2, (byte) 12);
+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 43f01ce3064fdc0bb46beab6ea001942f1506200..8773b1072016a3bbf025959e9ab827704ec17fc6 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+@@ -42,6 +42,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);
+@@ -277,8 +278,10 @@ public abstract class Animal extends AgeableMob {
+             entityplayer.awardStat(Stats.ANIMALS_BRED);
+             CriteriaTriggers.BRED_ANIMALS.trigger(entityplayer, this, entityanimal, entityageable);
+         } // Paper
+-        this.setAge(6000);
+-        entityanimal.setAge(6000);
++        // Purpur start
++        this.setAge(this.getPurpurBreedTime());
++        entityanimal.setAge(entityanimal.getPurpurBreedTime());
++        // Purpur end
+         this.resetLove();
+         entityanimal.resetLove();
+         worldserver.broadcastEntityEvent(this, (byte) 18);
+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 e7f95639a442cf602fef0ed7aec0f5f96aa6fd92..fd917f72b4b4d4af1ae36feab38deac2657c95d4 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+@@ -476,6 +476,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.beeMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.beeBreedingTicks;
++    }
++
+     @Override
+     public int getRemainingPersistentAngerTime() {
+         return (Integer) this.entityData.get(Bee.DATA_REMAINING_ANGER_TIME);
+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 49a6ac765e71b311c91cbfd4cf9cde2daa729239..ffa2128b63e5e45c2a41e31a6b8b6e8df0bf9be4 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -127,6 +127,11 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.catMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.catBreedingTicks;
++    }
++
+     public ResourceLocation getResourceLocation() {
+         return this.getVariant().texture();
+     }
+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 0f49705e3c7adf033cee9d0746319885c830224f..86b910cbb8d0e19dc9ae53078e730495bf4a3b87 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Chicken.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Chicken.java
+@@ -79,6 +79,11 @@ public class Chicken extends Animal {
+         }
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.chickenBreedingTicks;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+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 28c7e240b7dd1957ccb6a45608b1d052a32dc18a..f9cce30eef4a5bffeb27c48a6c7ee361803560c5 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cow.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Cow.java
+@@ -66,6 +66,11 @@ public class Cow extends Animal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.cowMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.cowBreedingTicks;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+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 cedc4dac776dde310dbf1a22272ce54b14ca2c9e..2cf00af66b73e1891fadcabcf83307873cbed710 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -186,6 +186,11 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.foxMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.foxBreedingTicks;
++    }
++
+     @Override
+     protected void defineSynchedData() {
+         super.defineSynchedData();
+@@ -981,8 +986,10 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+                     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 b27c0f21354a78025f9d1664c560fb8799bced91..7fd50f60aab2fa49a8227f313352a2ee251904c8 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
++++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java
+@@ -85,6 +85,11 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder<Mushroo
+         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;
++    }
++
+     @Override
+     public float getWalkTargetValue(BlockPos pos, LevelReader world) {
+         return world.getBlockState(pos.below()).is(Blocks.MYCELIUM) ? 10.0F : world.getPathfindingCostFromLightLevels(pos);
+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 20da70182312f4c30e21528add44540ea2b60e42..11c1bebcf6751e4b2ce9b1f5d53ad0a54d7f0be9 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+@@ -90,6 +90,11 @@ public class Ocelot extends Animal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.ocelotMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.ocelotBreedingTicks;
++    }
++
+     public boolean isTrusting() {
+         return (Boolean) this.entityData.get(Ocelot.DATA_TRUSTING);
+     }
+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 81f502b19cfcfcd39f3d3b5754b6bce9c2645ccb..7052601a8a4253459c552c2d721c90f3fb36de10 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+@@ -143,6 +143,11 @@ public class Panda extends Animal {
+         setAttributes();
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.pandaBreedingTicks;
++    }
++
+     @Override
+     public boolean canTakeItem(ItemStack stack) {
+         EquipmentSlot enumitemslot = Mob.getEquipmentSlotForItem(stack);
+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 1e0d8d276ef5eb2cc11a1effb5808de7f8f211d5..8b349259676ab8c891bf019c93ea62f7a84c4866 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Parrot.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Parrot.java
+@@ -196,6 +196,11 @@ public class Parrot extends ShoulderRidingEntity implements VariantHolder<Parrot
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.parrotMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return 6000;
++    }
++
+     @Nullable
+     @Override
+     public SpawnGroupData finalizeSpawn(ServerLevelAccessor world, DifficultyInstance difficulty, MobSpawnType spawnReason, @Nullable SpawnGroupData entityData, @Nullable CompoundTag entityNbt) {
+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 ff98a81f7104bbaf67ed85b8ad0946edf2a8c368..921efb89b4acf34e5e90f9b8faae16fb3b1b5002 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Pig.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Pig.java
+@@ -86,6 +86,11 @@ public class Pig extends Animal implements ItemSteerable, Saddleable {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.pigMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.pigBreedingTicks;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(0, new FloatGoal(this));
+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 b2cf680e377f849a7cc17136ebca3cf33e34048c..0df9900ecf211f3a0bcfab6daa931fddf9bfd3c2 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
++++ b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java
+@@ -120,6 +120,11 @@ public class PolarBear extends Animal implements NeutralMob {
+         }
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.polarBearBreedingTicks;
++    }
++
+     @Nullable
+     @Override
+     public AgeableMob getBreedOffspring(ServerLevel world, AgeableMob entity) {
+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 6d5213d26dbd9d36c5cbe6056091d9e5c85e23c4..787391763cac2ae6ed9c178c44616b992849e819 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+@@ -142,6 +142,11 @@ public class Rabbit extends Animal implements VariantHolder<Rabbit.Variant> {
+     public void initAttributes() {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.rabbitMaxHealth);
+     }
++
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.rabbitBreedingTicks;
++    }
+     // Purpur end
+ 
+     @Override
+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 3d212b09258b9777079d4bc7ce950f529cdce69e..c3b79c109e895cb4460571c8816b210455126f1d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Sheep.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Sheep.java
+@@ -139,6 +139,11 @@ public class Sheep extends Animal implements Shearable {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.sheepMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.sheepBreedingTicks;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.eatBlockGoal = new EatBlockGoal(this);
+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 6ae82b6293f236fc926f411de2badc496b35399b..4a5cc7eaac2bc093a0f5a457b93b6f4560d739ca 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+@@ -105,6 +105,11 @@ public class Turtle extends Animal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.turtleMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.turtleBreedingTicks;
++    }
++
+     public void setHomePos(BlockPos pos) {
+         this.entityData.set(Turtle.HOME_POS, pos.immutable()); // Paper - called with mutablepos...
+     }
+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 1a27e811169a58515c796344ffa1bb3c46d1014a..d8c73365915e67b38292c96a9601f983f121bdf9 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -130,6 +130,11 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.wolfMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.wolfBreedingTicks;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new FloatGoal(this));
+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 e1c0c122dde56b8dd797d1278340260150025cf9..acf44bf3d22d7b2ac7a02b3167cf577403942908 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
+@@ -120,6 +120,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder<Axolo
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.axolotlMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.axolotlBreedingTicks;
++    }
++
+     @Override
+     public Map<String, Vector3f> getModelRotationValues() {
+         return this.modelRotationValues;
+diff --git a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+index 5ec8815cc69f5abe03a29224650edfb153c9f5d0..8073a3a0df7d75a29419303c85d7dadd9f94be99 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
++++ b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+@@ -89,6 +89,10 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Rider
+     public boolean dismountsUnderwater() {
+         return level().purpurConfig.useDismountsUnderwaterTag ? super.dismountsUnderwater() : !level().purpurConfig.camelRidableInWater;
+     }
++
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.camelBreedingTicks;
++    }
+     // Purpur end
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
+index f189e0493286d58fbe16a30912b3a1dc4cd4c3e5..840b61241c44e92b3053157492f4389f46179e81 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
+@@ -136,6 +136,10 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+     }
+     // Purpur end
+ 
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.frogBreedingTicks;
++    }
++
+     @Override
+     protected Brain.Provider<Frog> brainProvider() {
+         return Brain.provider(MEMORY_TYPES, SENSOR_TYPES);
+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 ec956339b02fc9da53563d67c0eeaa91a3c3a8ee..d7580f06f2f619cb283faa61bdd4e7cc127fc08b 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
+@@ -107,6 +107,11 @@ public class Goat extends Animal {
+     }
+     // Purpur end
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.goatBreedingTicks;
++    }
++
+     @Override
+     protected Brain.Provider<Goat> brainProvider() {
+         return Brain.provider(Goat.MEMORY_TYPES, Goat.SENSOR_TYPES);
+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 365273173e37e74470a1cf511334ea8cb25f8302..6932d0eafbeca9de80728c6b0ae42340d2297ad0 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
+@@ -37,6 +37,11 @@ public class Donkey extends AbstractChestedHorse {
+         return generateSpeed(this.level().purpurConfig.donkeyMovementSpeedMin, this.level().purpurConfig.donkeyMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.donkeyBreedingTicks;
++    }
++
+     @Override
+     protected SoundEvent getAmbientSound() {
+         return SoundEvents.DONKEY_AMBIENT;
+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 92339f5a07dcb6bf7eb1bce6d584464ebd8430b5..0251ded48eb5bdf96f0e67f6456aa15909c8a4ff 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
+@@ -62,6 +62,11 @@ public class Horse extends AbstractHorse implements VariantHolder<Variant> {
+         return generateSpeed(this.level().purpurConfig.horseMovementSpeedMin, this.level().purpurConfig.horseMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.horseBreedingTicks;
++    }
++
+     @Override
+     protected void randomizeAttributes(RandomSource random) {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue((double)generateMaxHealth(random::nextInt));
+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 72fe2dd69a9ae51e14ec91a83eac2dd74bd76cca..ad9d061979f5856cba9769b91357b3c75cd9a794 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
+@@ -138,6 +138,11 @@ public class Llama extends AbstractChestedHorse implements VariantHolder<Llama.V
+         return generateSpeed(this.level().purpurConfig.llamaMovementSpeedMin, this.level().purpurConfig.llamaMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.llamaBreedingTicks;
++    }
++
+     public boolean isTraderLlama() {
+         return false;
+     }
+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 abbeb305b2d09e9c4c02ade603adac5ceb34bdd0..1de48560ac5a1db8845c98c812b2e9f9eb972123 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
+@@ -36,6 +36,11 @@ public class Mule extends AbstractChestedHorse {
+         return generateSpeed(this.level().purpurConfig.muleMovementSpeedMin, this.level().purpurConfig.muleMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.muleBreedingTicks;
++    }
++
+     @Override
+     protected SoundEvent getAmbientSound() {
+         return SoundEvents.MULE_AMBIENT;
+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 33e30545c303e28a99249151891c7568bf1a164d..d80257183a4ecdb515e344adcf66b757aa576202 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 {
+         return generateSpeed(this.level().purpurConfig.skeletonHorseMovementSpeedMin, this.level().purpurConfig.skeletonHorseMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return 6000;
++    }
++
+     public static AttributeSupplier.Builder createAttributes() {
+         return createBaseHorseAttributes().add(Attributes.MAX_HEALTH, 15.0D).add(Attributes.MOVEMENT_SPEED, (double)0.2F);
+     }
+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 4abb9d5fedf63eba9dc3f716d44ea11806607af0..3632fcb124be8cf77d9bebf7b861a48196252ed0 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
+@@ -64,6 +64,11 @@ public class TraderLlama extends Llama {
+         return generateSpeed(this.level().purpurConfig.traderLlamaMovementSpeedMin, this.level().purpurConfig.traderLlamaMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.traderLlamaBreedingTicks;
++    }
++
+     @Override
+     public boolean isTraderLlama() {
+         return true;
+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 973c5045137850905126db91238dd8e59db7ddf6..cc821385394121dcd7a9f314fa34a3f540f113a6 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
+@@ -48,6 +48,11 @@ public class ZombieHorse extends AbstractHorse {
+         return generateSpeed(this.level().purpurConfig.zombieHorseMovementSpeedMin, this.level().purpurConfig.zombieHorseMovementSpeedMax);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return 6000;
++    }
++
+     public static AttributeSupplier.Builder createAttributes() {
+         return createBaseHorseAttributes().add(Attributes.MAX_HEALTH, 15.0D).add(Attributes.MOVEMENT_SPEED, (double)0.2F);
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java b/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+index e46751dacee17e81933345266049675d0b11ee49..3ab900c53469327b8d686da81ed5b4aaaddb7440 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
++++ b/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+@@ -112,6 +112,11 @@ public class Sniffer extends Animal {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.snifferMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.snifferBreedingTicks;
++    }
++
+     // CraftBukkit start - SPIGOT-7295: moved from constructor to appropriate location
+     @Override
+     protected void defineSynchedData() {
+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 eedfd4dffdc5586a0b50769b17c5515e5ccac916..93dca4758ed995373fe1585930f225604a4153fa 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Strider.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java
+@@ -122,6 +122,11 @@ public class Strider extends Animal implements ItemSteerable, Saddleable {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.striderMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.striderBreedingTicks;
++    }
++
+     public static boolean checkStriderSpawnRules(EntityType<Strider> type, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, RandomSource random) {
+         BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable();
+ 
+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 66f2695403a04c2e9540bf2ec290bf1cc5a377ca..bd72dc99752faca3180ecb165b11406ada1a564e 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
+@@ -89,6 +89,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase {
+         this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.hoglinMaxHealth);
+     }
+ 
++    @Override
++    public int getPurpurBreedTime() {
++        return this.level().purpurConfig.hoglinBreedingTicks;
++    }
++
+     @Override
+     public boolean canBeLeashed(Player player) {
+         return !this.isLeashed();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7bc980fee2727359a9a2ecc66f31f3569cf8491f..4df745bede2ecc5e9ee4129b980f9edfd8969d4f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -505,10 +505,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;
+@@ -548,6 +550,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);
+@@ -559,6 +562,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;
+@@ -586,6 +590,7 @@ public class PurpurWorldConfig {
+     public double camelJumpStrengthMax = 0.42D;
+     public double camelMovementSpeedMin = 0.09D;
+     public double camelMovementSpeedMax = 0.09D;
++    public int camelBreedingTicks = 6000;
+     private void camelSettings() {
+         camelRidableInWater = getBoolean("mobs.camel.ridable-in-water", camelRidableInWater);
+         camelMaxHealthMin = getDouble("mobs.camel.attributes.max_health.min", camelMaxHealthMin);
+@@ -594,6 +599,7 @@ public class PurpurWorldConfig {
+         camelJumpStrengthMax = getDouble("mobs.camel.attributes.jump_strength.max", camelJumpStrengthMax);
+         camelMovementSpeedMin = getDouble("mobs.camel.attributes.movement_speed.min", camelMovementSpeedMin);
+         camelMovementSpeedMax = getDouble("mobs.camel.attributes.movement_speed.max", camelMovementSpeedMax);
++        camelBreedingTicks = getInt("mobs.camel.breeding-delay-ticks", camelBreedingTicks);
+     }
+ 
+     public boolean catRidable = false;
+@@ -603,6 +609,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);
+@@ -616,6 +623,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;
+@@ -639,6 +647,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);
+@@ -650,6 +659,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;
+@@ -671,6 +681,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);
+@@ -682,6 +693,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;
+@@ -733,6 +745,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) {
+@@ -748,6 +761,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;
+@@ -867,6 +881,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);
+@@ -878,17 +893,20 @@ 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 frogRidable = false;
+     public boolean frogRidableInWater = true;
+     public boolean frogControllable = true;
+     public float frogRidableJumpHeight = 0.65F;
++    public int frogBreedingTicks = 6000;
+     private void frogSettings() {
+         frogRidable = getBoolean("mobs.frog.ridable", frogRidable);
+         frogRidableInWater = getBoolean("mobs.frog.ridable-in-water", frogRidableInWater);
+         frogControllable = getBoolean("mobs.frog.controllable", frogControllable);
+         frogRidableJumpHeight = (float) getDouble("mobs.frog.ridable-jump-height", frogRidableJumpHeight);
++        frogBreedingTicks = getInt("mobs.frog.breeding-delay-ticks", frogBreedingTicks);
+     }
+ 
+     public boolean ghastRidable = false;
+@@ -956,11 +974,13 @@ public class PurpurWorldConfig {
+     public boolean goatRidableInWater = true;
+     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;
+@@ -981,6 +1001,7 @@ public class PurpurWorldConfig {
+     public boolean hoglinRidableInWater = true;
+     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);
+@@ -991,6 +1012,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;
+@@ -1000,6 +1022,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) {
+@@ -1015,6 +1038,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;
+@@ -1092,6 +1116,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);
+@@ -1109,6 +1134,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;
+@@ -1137,6 +1163,7 @@ public class PurpurWorldConfig {
+     public boolean mooshroomRidableInWater = true;
+     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);
+@@ -1147,6 +1174,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;
+@@ -1156,6 +1184,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) {
+@@ -1171,12 +1200,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 = true;
+     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);
+@@ -1187,12 +1218,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 = true;
+     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);
+@@ -1203,6 +1236,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;
+@@ -1286,6 +1320,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);
+@@ -1297,6 +1332,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;
+@@ -1353,6 +1389,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);
+@@ -1366,6 +1403,7 @@ public class PurpurWorldConfig {
+         polarBearBreedableItemString = getString("mobs.polar_bear.breedable-item", polarBearBreedableItemString);
+         Item item = BuiltInRegistries.ITEM.get(new ResourceLocation(polarBearBreedableItemString));
+         if (item != Items.AIR) polarBearBreedableItem = item;
++        polarBearBreedingTicks = getInt("mobs.polar_bear.breeding-delay-ticks", polarBearBreedingTicks);
+     }
+ 
+     public boolean pufferfishRidable = false;
+@@ -1388,6 +1426,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);
+@@ -1400,6 +1439,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;
+@@ -1436,6 +1476,7 @@ public class PurpurWorldConfig {
+     public boolean sheepRidableInWater = true;
+     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);
+@@ -1446,6 +1487,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;
+@@ -1569,11 +1611,13 @@ public class PurpurWorldConfig {
+     public boolean snifferRidableInWater = true;
+     public boolean snifferControllable = true;
+     public double snifferMaxHealth = 14.0D;
++    public int snifferBreedingTicks = 6000;
+     private void snifferSettings() {
+         snifferRidable = getBoolean("mobs.sniffer.ridable", snifferRidable);
+         snifferRidableInWater = getBoolean("mobs.sniffer.ridable-in-water", snifferRidableInWater);
+         snifferControllable = getBoolean("mobs.sniffer.controllable", snifferControllable);
+         snifferMaxHealth = getDouble("mobs.sniffer.attributes.max_health", snifferMaxHealth);
++        snifferBreedingTicks = getInt("mobs.sniffer.breeding-delay-ticks", chickenBreedingTicks);
+     }
+ 
+     public boolean squidRidable = false;
+@@ -1632,6 +1676,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);
+@@ -1642,6 +1687,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 tadpoleRidable = false;
+@@ -1662,6 +1708,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);
+@@ -1679,6 +1726,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;
+@@ -1699,6 +1747,7 @@ public class PurpurWorldConfig {
+     public boolean turtleRidableInWater = true;
+     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);
+@@ -1709,6 +1758,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;
+@@ -1736,6 +1786,7 @@ public class PurpurWorldConfig {
+     public boolean villagerFollowEmeraldBlock = false;
+     public boolean villagerCanBeLeashed = false;
+     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);
+@@ -1749,6 +1800,7 @@ public class PurpurWorldConfig {
+         villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock);
+         villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+         villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed);
++        villagerBreedingTicks = getInt("mobs.villager.breeding-delay-ticks", villagerBreedingTicks);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1860,6 +1912,7 @@ public class PurpurWorldConfig {
+     public boolean wolfRidableInWater = true;
+     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);
+@@ -1870,6 +1923,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;

patches/unapplied/server/0104-Apply-display-names-from-item-forms-of-entities-to-e.patch

@@ -0,0 +1,168 @@
+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 5524a69952130ec38e151509ba7733459146d1b0..76222084727c269d376d0df5702204c0bdf59d81 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -606,7 +606,7 @@ public class ArmorStand extends LivingEntity {
+     private org.bukkit.event.entity.EntityDeathEvent brokenByPlayer(DamageSource damageSource) { // Paper
+         ItemStack itemstack = new ItemStack(Items.ARMOR_STAND);
+ 
+-        if (this.hasCustomName()) {
++        if (this.level().purpurConfig.persistentDroppableEntityDisplayNames && this.hasCustomName()) { // Purpur
+             itemstack.setHoverName(this.getCustomName());
+         }
+ 
+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 759ecd79534a7706f7d4a63eb9dacbefcfe54674..182faba889dc15a3500c5919cad8a5483a53033a 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -273,7 +273,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 d5784a19cec98eb199a51acd9e1f4de8c6bf7265..4b3a8e4a084585d56dd10a08405463b1a677368b 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/Painting.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/Painting.java
+@@ -159,7 +159,13 @@ public class Painting extends HangingEntity implements VariantHolder<Holder<Pain
+                 }
+             }
+ 
+-            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 2173bcd1686756fca85e819495145563fcf8b209..a7ab9e2284d4a1ae6f5601adc3dfac534bce26fc 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+@@ -223,7 +223,13 @@ public class Boat extends Entity implements VariantHolder<Boat.Type> {
+     }
+ 
+     protected void destroy(DamageSource source) {
+-        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
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/item/ArmorStandItem.java b/src/main/java/net/minecraft/world/item/ArmorStandItem.java
+index 7cffc64573008502bdd14ae4906fe51166b12fb3..1feafdbb48cf760cb6ebf95d5be2c32bdb1ad44f 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorStandItem.java
++++ b/src/main/java/net/minecraft/world/item/ArmorStandItem.java
+@@ -58,6 +58,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);
+                     entityarmorstand.gameEvent(GameEvent.ENTITY_PLACE, context.getPlayer());
+diff --git a/src/main/java/net/minecraft/world/item/BoatItem.java b/src/main/java/net/minecraft/world/item/BoatItem.java
+index aec7ac31a35b1cc81f40b3fbeb5cf95c0f2c8a6c..cbcd35e60a2c344c83978abf0b94c2120ff53dee 100644
+--- a/src/main/java/net/minecraft/world/item/BoatItem.java
++++ b/src/main/java/net/minecraft/world/item/BoatItem.java
+@@ -69,6 +69,11 @@ public class BoatItem extends Item {
+ 
+                 entityboat.setVariant(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 b2ad6d230de2c29f371178bccde1111c7532ee70..6667926519a0f1c151e53f59cce36e7417dfc1cd 100644
+--- a/src/main/java/net/minecraft/world/item/HangingEntityItem.java
++++ b/src/main/java/net/minecraft/world/item/HangingEntityItem.java
+@@ -48,7 +48,7 @@ public class HangingEntityItem extends Item {
+             return InteractionResult.FAIL;
+         } else {
+             Level world = context.getLevel();
+-            Object object;
++            Entity object; // Purpur
+ 
+             if (this.type == EntityType.PAINTING) {
+                 Optional<Painting> optional = Painting.create(world, blockposition1, enumdirection);
+@@ -72,6 +72,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 4df745bede2ecc5e9ee4129b980f9edfd8969d4f..f04861a5ca426b1c53b6d3ec4d3514bcaa9789a2 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -97,8 +97,10 @@ public class PurpurWorldConfig {
+     }
+ 
+     public float armorstandStepHeight = 0.0F;
++    public boolean armorstandSetNameVisible = true;
+     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 arrowMovementResetsDespawnCounter = true;
+@@ -111,6 +113,7 @@ public class PurpurWorldConfig {
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean entitiesCanUsePortals = true;
+     public boolean milkCuresBadOmen = true;
++    public boolean persistentDroppableEntityDisplayNames = true;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+@@ -122,6 +125,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);

patches/unapplied/server/0105-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 2941c16ef486345b57ab2dfcd26f0272285d3b5a..7cc6812bf6f2ba015f65fd1fc1eaac02dd0f53e2 100644
+--- a/src/main/java/net/minecraft/world/item/NameTagItem.java
++++ b/src/main/java/net/minecraft/world/item/NameTagItem.java
+@@ -20,6 +20,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 ? io.papermc.paper.adventure.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 f04861a5ca426b1c53b6d3ec4d3514bcaa9789a2..db678a5ee139920d51ba2fb179f1d01feab3c973 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -98,9 +98,11 @@ public class PurpurWorldConfig {
+ 
+     public float armorstandStepHeight = 0.0F;
+     public boolean armorstandSetNameVisible = true;
++    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 arrowMovementResetsDespawnCounter = true;

patches/unapplied/server/0106-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 3861f367ac01028139cc6db35fb9a1e20cb39457..f49cbb9fcd13afc10aa76ac80128162a902ae345 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -494,7 +494,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 db678a5ee139920d51ba2fb179f1d01feab3c973..6fdef95d12988207bb682ba165e135a94e505a58 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -837,6 +837,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);
+@@ -848,6 +849,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;

patches/unapplied/server/0107-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 718e120c9768cf716b32d3d652f53f1dda925168..b90cedad282e95a067aca176fafa9f72a726f520 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/Snowball.java
+@@ -53,7 +53,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(this.damageSources().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 6fdef95d12988207bb682ba165e135a94e505a58..e9778b0e02fb94eeea2e8c6e2680b6564b11d399 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -354,6 +354,11 @@ public class PurpurWorldConfig {
+         //}
+     }
+ 
++    public int snowballDamage = -1;
++    private void snowballSettings() {
++        snowballDamage = getInt("gameplay-mechanics.projectile-damage.snowball", snowballDamage);
++    }
++
+     public boolean silkTouchEnabled = false;
+     public String silkTouchSpawnerName = "<reset><white>Monster Spawner";
+     public List<String> silkTouchSpawnerLore = new ArrayList<>();

patches/unapplied/server/0108-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 049a6b2186ff31ac9a815ac501b75488e2e19266..50747e73ab0a37073e431db82d79b1ebc024d347 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1302,7 +1302,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+         RandomSource randomsource = world.getRandom();
+ 
+         this.getAttribute(Attributes.FOLLOW_RANGE).addPermanentModifier(new AttributeModifier("Random spawn bonus", randomsource.triangle(0.0D, 0.11485000000000001D), AttributeModifier.Operation.MULTIPLY_BASE));
+-        if (randomsource.nextFloat() < 0.05F) {
++        if (randomsource.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 e9778b0e02fb94eeea2e8c6e2680b6564b11d399..4968d157692e71c54be0fd76069ece3ba0294e5f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -156,8 +156,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;

patches/unapplied/server/0109-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 8ed1a18cd1b33e1776dbf3b2294ab633f243daae..8419775b8c2c6c8d246d0011d81f540cd09cb403 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1113,7 +1113,16 @@ public class ServerPlayer extends Player {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else {
+-            if (source.is(DamageTypeTags.IS_FALL) && getRootVehicle() instanceof net.minecraft.world.entity.vehicle.AbstractMinecart && level().purpurConfig.minecartControllable && !level().purpurConfig.minecartControllableFallDamage) return false; // Purpur
++            // Purpur start
++            if (source.is(DamageTypeTags.IS_FALL)) { // Purpur
++                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() && source.is(DamageTypeTags.IS_FALL);
+ 
+             if (!flag && isSpawnInvulnerable() && !source.is(DamageTypeTags.BYPASSES_INVULNERABILITY)) { // Purpur
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 4968d157692e71c54be0fd76069ece3ba0294e5f..e3dbb3d81494ecdcedd06e7e16cc17a2d4e15112 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -112,6 +112,7 @@ public class PurpurWorldConfig {
+ 
+     public boolean useBetterMending = false;
+     public boolean boatEjectPlayersOnLand = false;
++    public boolean boatsDoFallDamage = false;
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean entitiesCanUsePortals = true;
+     public boolean milkCuresBadOmen = true;
+@@ -124,6 +125,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);

patches/unapplied/server/0110-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 bd9dd01e9140c2ad0ab9859b9a455f73ab04a253..d3da7487f911ff791dca5f7b546dccda751fe44c 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 e3dbb3d81494ecdcedd06e7e16cc17a2d4e15112..7518f375450448b2f5aa71a999a2b213f78b7583 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1609,6 +1609,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);
+@@ -1622,6 +1626,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 snifferRidable = false;

patches/unapplied/server/0111-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 d601d287e94a59ff93b8a83a44dac02544d211df..0ff3b06a98b2f4514b2d861b92dd70fe678ae86c 100644
+--- a/src/main/java/net/minecraft/server/commands/GiveCommand.java
++++ b/src/main/java/net/minecraft/server/commands/GiveCommand.java
+@@ -59,6 +59,7 @@ public class GiveCommand {
+                     boolean flag = entityplayer.getInventory().add(itemstack1);
+                     ItemEntity entityitem;
+ 
++                    if (org.purpurmc.purpur.PurpurConfig.disableGiveCommandDrops) continue; // Purpur - add config option for toggling give command dropping
+                     if (flag && itemstack1.isEmpty()) {
+                         itemstack1.setCount(1);
+                         entityitem = entityplayer.drop(itemstack1, 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 de1a9b08946005d1235264c7658b51bbdc2c47c2..aaf96399f937fbca30f1ce5d64be4af265a4ed29 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -209,6 +209,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;

patches/unapplied/server/0112-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch

@@ -0,0 +1,197 @@
+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 d3a2a6dee2d83b3df0ddc521c080f7d72b709461..66a568e6803b91040f3933d4598c52fa518badab 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
+@@ -40,6 +40,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));
+@@ -48,9 +49,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();
+@@ -81,6 +83,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;
+     }
+ 
+@@ -106,20 +109,20 @@ public class HarvestFarmland extends Behavior<Villager> {
+                 Block block = iblockdata.getBlock();
+                 Block block1 = world.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
+                     if (CraftEventFactory.callEntityChangeBlockEvent(entity, this.aboveFarmlandPos, iblockdata.getFluidState().createLegacyBlock())) { // CraftBukkit // Paper - fix wrong block state
+                     world.destroyBlock(this.aboveFarmlandPos, true, entity);
+                     } // CraftBukkit
+                 }
+ 
+-                if (iblockdata.isAir() && block1 instanceof FarmBlock && entity.hasFarmSeeds()) {
++                if (iblockdata.isAir() && (block1 instanceof FarmBlock && !this.clericWartFarmer || this.clericWartFarmer && block1 == Blocks.SOUL_SAND) && entity.hasFarmSeeds()) { // Purpur
+                     SimpleContainer inventorysubcontainer = entity.getInventory();
+ 
+                     for (int j = 0; j < inventorysubcontainer.getContainerSize(); ++j) {
+                         ItemStack itemstack = inventorysubcontainer.getItem(j);
+                         boolean flag = false;
+ 
+-                        if (!itemstack.isEmpty() && itemstack.is(ItemTags.VILLAGER_PLANTABLE_SEEDS)) {
++                        if (!itemstack.isEmpty() && (itemstack.is(ItemTags.VILLAGER_PLANTABLE_SEEDS) || this.clericWartFarmer && itemstack.getItem() == net.minecraft.world.item.Items.NETHER_WART)) {
+                             Item item = itemstack.getItem();
+ 
+                             if (item instanceof BlockItem) {
+@@ -135,7 +138,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+                         }
+ 
+                         if (flag) {
+-                            world.playSound((Player) null, (double) this.aboveFarmlandPos.getX(), (double) this.aboveFarmlandPos.getY(), (double) this.aboveFarmlandPos.getZ(), SoundEvents.CROP_PLANTED, SoundSource.BLOCKS, 1.0F, 1.0F);
++                            world.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 3af715e2f3f3949af614a8fcebbc4a835d48ca49..ade1e411ea1f3b4c9a417265e77b0d6861b222f9 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(entity, ImmutableSet.of(Items.WHEAT), villager);
+             }
+ 
++            // Purpur start
++            if (world.purpurConfig.villagerClericsFarmWarts && world.purpurConfig.villagerClericFarmersThrowWarts && entity.getVillagerData().getProfession() == VillagerProfession.CLERIC && entity.getInventory().countItem(Items.NETHER_WART) > Items.NETHER_WART.getMaxStackSize() / 2) {
++                throwHalfStack(entity, ImmutableSet.of(Items.NETHER_WART), villager);
++            }
++            // Purpur end
++
+             if (!this.trades.isEmpty() && entity.getInventory().hasAnyOf(this.trades)) {
+                 throwHalfStack(entity, this.trades, villager);
+             }
+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 cd7a90ec1073b2b452ca70decefe6a594445003b..47672e48c1cae73cffe532d622b296343fc12ef0 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
+@@ -30,8 +30,13 @@ public class VillagerGoalPackages {
+     }
+ 
+     public static ImmutableList<Pair<Integer, ? extends BehaviorControl<? super Villager>>> getWorkPackage(VillagerProfession profession, float speed) {
++        // Purpur start
++        return getWorkPackage(profession, speed, false);
++    }
++    public static ImmutableList<Pair<Integer, ? extends BehaviorControl<? 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 cb1d91f9fe98f21c2afbe3894dfd9bca3bdd3ba6..d2703432af207c74ea8d298a784329c3219d2f13 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 7d13a5308161d4093023b732bed7d06152f54737..605171aedb4f54dcd16837ad1e36097653a26ab6 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -223,7 +223,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));
+@@ -978,6 +978,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     public boolean hasFarmSeeds() {
+         return this.getInventory().hasAnyMatching((itemstack) -> {
++            // Purpur start
++            if (this.level().purpurConfig.villagerClericsFarmWarts && this.getVillagerData().getProfession() == VillagerProfession.CLERIC) {
++                return itemstack.is(Items.NETHER_WART);
++            }
++            // Purpur end
+             return itemstack.is(ItemTags.VILLAGER_PLANTABLE_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 ac70c2c03241e73943bd517a8c69dd05e0873634..0318663a824d2a9515f867a075d148c3fcb1a907 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java
++++ b/src/main/java/net/minecraft/world/entity/npc/VillagerProfession.java
+@@ -26,7 +26,7 @@ public record VillagerProfession(String name, Predicate<Holder<PoiType>> heldJob
+     public static final VillagerProfession ARMORER = register("armorer", PoiTypes.ARMORER, SoundEvents.VILLAGER_WORK_ARMORER);
+     public static final VillagerProfession BUTCHER = register("butcher", PoiTypes.BUTCHER, SoundEvents.VILLAGER_WORK_BUTCHER);
+     public static final VillagerProfession CARTOGRAPHER = register("cartographer", PoiTypes.CARTOGRAPHER, SoundEvents.VILLAGER_WORK_CARTOGRAPHER);
+-    public static final VillagerProfession CLERIC = register("cleric", PoiTypes.CLERIC, SoundEvents.VILLAGER_WORK_CLERIC);
++    public static final VillagerProfession CLERIC = register("cleric", PoiTypes.CLERIC, ImmutableSet.of(Items.NETHER_WART), ImmutableSet.of(Blocks.SOUL_SAND), SoundEvents.VILLAGER_WORK_CLERIC); // Purpur
+     public static final VillagerProfession FARMER = register("farmer", PoiTypes.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", PoiTypes.FISHERMAN, SoundEvents.VILLAGER_WORK_FISHERMAN);
+     public static final VillagerProfession FLETCHER = register("fletcher", PoiTypes.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 7518f375450448b2f5aa71a999a2b213f78b7583..ab7a771a80d5288f79dca65fff3f984536d02d9a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1812,6 +1812,8 @@ public class PurpurWorldConfig {
+     public boolean villagerCanBeLeashed = false;
+     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);
+@@ -1826,6 +1828,8 @@ public class PurpurWorldConfig {
+         villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed);
+         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;

patches/unapplied/server/0113-Toggle-for-Zombified-Piglin-death-always-counting-as.patch

@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sat, 5 Dec 2020 02:34:22 -0800
+Subject: [PATCH] Toggle for Zombified Piglin death always counting as player
+ kill when angry
+
+In Vanilla (as of 1.16.4), when Zombified Piglins die while angry, it will
+count as a player kill regardless of whether a player has ever hit them,
+meaning they will drop XP. This is abused in Zombified Piglin farms where
+the player kills the entities through cramming, but they still drop XP due
+to the Piglin being angry, even though the player never hit them.
+
+This patch adds a toggle to disable this behavior.
+
+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 3d61b27c23d90e87fdfc8c170eafc116716ac047..67fd554cfd6b848ca1f2cf804ad4543ad2c88845 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
++++ b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java
+@@ -152,7 +152,7 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob {
+             this.maybeAlertOthers();
+         }
+ 
+-        if (this.isAngry()) {
++        if (this.isAngry() && this.level().purpurConfig.zombifiedPiglinCountAsPlayerKillWhenAngry) { // Purpur
+             this.lastHurtByPlayerTime = this.tickCount;
+         }
+ 
+@@ -207,7 +207,7 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob {
+             this.ticksUntilNextAlert = ZombifiedPiglin.ALERT_INTERVAL.sample(this.random);
+         }
+ 
+-        if (entityliving instanceof Player) {
++        if (entityliving instanceof Player && this.level().purpurConfig.zombifiedPiglinCountAsPlayerKillWhenAngry) { // Purpur
+             this.setLastHurtByPlayer((Player) entityliving);
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ab7a771a80d5288f79dca65fff3f984536d02d9a..b1d2c6b15c8d9977e8d8fcfe61485dab67cd9684 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2056,6 +2056,7 @@ public class PurpurWorldConfig {
+     public boolean zombifiedPiglinJockeyOnlyBaby = true;
+     public double zombifiedPiglinJockeyChance = 0.05D;
+     public boolean zombifiedPiglinJockeyTryExistingChickens = true;
++    public boolean zombifiedPiglinCountAsPlayerKillWhenAngry = true;
+     private void zombifiedPiglinSettings() {
+         zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable);
+         zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater);
+@@ -2070,5 +2071,6 @@ public class PurpurWorldConfig {
+         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);
++        zombifiedPiglinCountAsPlayerKillWhenAngry = getBoolean("mobs.zombified_piglin.count-as-player-kill-when-angry", zombifiedPiglinCountAsPlayerKillWhenAngry);
+     }
+ }

patches/unapplied/server/0114-Configurable-chance-for-wolves-to-spawn-rabid.patch

@@ -0,0 +1,244 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 8 Dec 2020 17:15:15 -0500
+Subject: [PATCH] Configurable chance for wolves to spawn rabid
+
+Configurable chance to spawn a wolf that is rabid.
+Rabid wolves attack all players, mobs, and animals.
+
+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 d8c73365915e67b38292c96a9601f983f121bdf9..f39b278bc520a4785e9fa472bccd836ad1daac85 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -10,6 +10,7 @@ import net.minecraft.network.syncher.EntityDataAccessor;
+ import net.minecraft.network.syncher.EntityDataSerializers;
+ import net.minecraft.network.syncher.SynchedEntityData;
+ import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.sounds.SoundEvent;
+ import net.minecraft.sounds.SoundEvents;
+ import net.minecraft.tags.BlockTags;
+@@ -17,9 +18,12 @@ import net.minecraft.util.Mth;
+ import net.minecraft.util.RandomSource;
+ import net.minecraft.util.TimeUtil;
+ import net.minecraft.util.valueproviders.UniformInt;
++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.effect.MobEffectInstance;
++import net.minecraft.world.effect.MobEffects;
+ import net.minecraft.world.entity.AgeableMob;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.entity.EntityDimensions;
+@@ -29,6 +33,7 @@ import net.minecraft.world.entity.Mob;
+ import net.minecraft.world.entity.MobSpawnType;
+ import net.minecraft.world.entity.NeutralMob;
+ import net.minecraft.world.entity.Pose;
++import net.minecraft.world.entity.SpawnGroupData;
+ import net.minecraft.world.entity.TamableAnimal;
+ import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+ import net.minecraft.world.entity.ai.attributes.Attributes;
+@@ -37,6 +42,7 @@ import net.minecraft.world.entity.ai.goal.BegGoal;
+ import net.minecraft.world.entity.ai.goal.BreedGoal;
+ import net.minecraft.world.entity.ai.goal.FloatGoal;
+ import net.minecraft.world.entity.ai.goal.FollowOwnerGoal;
++import net.minecraft.world.entity.ai.goal.Goal;
+ import net.minecraft.world.entity.ai.goal.LeapAtTargetGoal;
+ import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+ import net.minecraft.world.entity.ai.goal.MeleeAttackGoal;
+@@ -64,6 +70,7 @@ import net.minecraft.world.item.ItemStack;
+ import net.minecraft.world.item.Items;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.LevelAccessor;
++import net.minecraft.world.level.ServerLevelAccessor;
+ import net.minecraft.world.level.block.state.BlockState;
+ import net.minecraft.world.level.gameevent.GameEvent;
+ import net.minecraft.world.level.pathfinder.BlockPathTypes;
+@@ -84,6 +91,37 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+ 
+         return entitytypes == EntityType.SHEEP || entitytypes == EntityType.RABBIT || entitytypes == EntityType.FOX;
+     };
++    // Purpur start - rabid wolf spawn chance
++    private boolean isRabid = false;
++    private static final Predicate<LivingEntity> RABID_PREDICATE = entity -> entity instanceof ServerPlayer || entity instanceof Mob;
++    private final Goal PATHFINDER_VANILLA = new NonTameRandomTargetGoal<>(this, Animal.class, false, PREY_SELECTOR);
++    private final Goal PATHFINDER_RABID = new NonTameRandomTargetGoal<>(this, LivingEntity.class, false, RABID_PREDICATE);
++    private static final class AvoidRabidWolfGoal extends AvoidEntityGoal<Wolf> {
++        private final Wolf wolf;
++
++        public AvoidRabidWolfGoal(Wolf wolf, float distance, double minSpeed, double maxSpeed) {
++            super(wolf, Wolf.class, distance, minSpeed, maxSpeed);
++            this.wolf = wolf;
++        }
++
++        @Override
++        public boolean canUse() {
++            return super.canUse() && !this.wolf.isRabid() && this.toAvoid != null && this.toAvoid.isRabid(); // wolves which are not rabid run away from rabid wolves
++        }
++
++        @Override
++        public void start() {
++            this.wolf.setTarget(null);
++            super.start();
++        }
++
++        @Override
++        public void tick() {
++            this.wolf.setTarget(null);
++            super.tick();
++        }
++    }
++    // Purpur end
+     private static final float START_HEALTH = 8.0F;
+     private static final float TAME_HEALTH = 20.0F;
+     private float interestedAngle;
+@@ -135,6 +173,37 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         return this.level().purpurConfig.wolfBreedingTicks;
+     }
+ 
++    public boolean isRabid() {
++        return this.isRabid;
++    }
++
++    public void setRabid(boolean isRabid) {
++        this.isRabid = isRabid;
++        updatePathfinders(true);
++    }
++
++    public void updatePathfinders(boolean modifyEffects) {
++        this.targetSelector.removeGoal(PATHFINDER_VANILLA);
++        this.targetSelector.removeGoal(PATHFINDER_RABID);
++        if (this.isRabid) {
++            setTame(false);
++            setOwnerUUID(null);
++            this.targetSelector.addGoal(5, PATHFINDER_RABID);
++            if (modifyEffects) this.addEffect(new MobEffectInstance(MobEffects.CONFUSION, 1200));
++        } else {
++            this.targetSelector.addGoal(5, PATHFINDER_VANILLA);
++            this.stopBeingAngry();
++            if (modifyEffects) this.removeEffect(MobEffects.CONFUSION);
++        }
++    }
++
++    @Override
++    public SpawnGroupData finalizeSpawn(ServerLevelAccessor world, DifficultyInstance difficulty, MobSpawnType type, @Nullable SpawnGroupData data, @Nullable CompoundTag nbt) {
++        this.isRabid = world.getLevel().purpurConfig.wolfNaturalRabid > 0.0D && random.nextDouble() <= world.getLevel().purpurConfig.wolfNaturalRabid;
++        this.updatePathfinders(false);
++        return super.finalizeSpawn(world, difficulty, type, data, nbt);
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new FloatGoal(this));
+@@ -142,6 +211,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         this.goalSelector.addGoal(1, new Wolf.WolfPanicGoal(1.5D));
+         this.goalSelector.addGoal(2, new SitWhenOrderedToGoal(this));
+         this.goalSelector.addGoal(3, new Wolf.WolfAvoidEntityGoal<>(this, Llama.class, 24.0F, 1.5D, 1.5D));
++        this.goalSelector.addGoal(3, new AvoidRabidWolfGoal(this, 24.0F, 1.5D, 1.5D)); // Purpur
+         this.goalSelector.addGoal(4, new LeapAtTargetGoal(this, 0.4F));
+         this.goalSelector.addGoal(5, new MeleeAttackGoal(this, 1.0D, true));
+         this.goalSelector.addGoal(6, new FollowOwnerGoal(this, 1.0D, 10.0F, 2.0F, false));
+@@ -155,7 +225,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         this.targetSelector.addGoal(2, new OwnerHurtTargetGoal(this));
+         this.targetSelector.addGoal(3, (new HurtByTargetGoal(this, new Class[0])).setAlertOthers());
+         this.targetSelector.addGoal(4, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::isAngryAt));
+-        this.targetSelector.addGoal(5, new NonTameRandomTargetGoal<>(this, Animal.class, false, Wolf.PREY_SELECTOR));
++        // this.targetSelector.addGoal(5, new NonTameRandomTargetGoal<>(this, Animal.class, false, Wolf.PREY_SELECTOR)); // Purpur - moved to updatePathfinders()
+         this.targetSelector.addGoal(6, new NonTameRandomTargetGoal<>(this, Turtle.class, false, Turtle.BABY_ON_LAND_SELECTOR));
+         this.targetSelector.addGoal(7, new NearestAttackableTargetGoal<>(this, AbstractSkeleton.class, false));
+         this.targetSelector.addGoal(8, new ResetUniversalAngerTargetGoal<>(this, true));
+@@ -182,6 +252,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         super.addAdditionalSaveData(nbt);
+         nbt.putByte("CollarColor", (byte) this.getCollarColor().getId());
++        nbt.putBoolean("Purpur.IsRabid", this.isRabid); // Purpur
+         this.addPersistentAngerSaveData(nbt);
+     }
+ 
+@@ -191,6 +262,10 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         if (nbt.contains("CollarColor", 99)) {
+             this.setCollarColor(DyeColor.byId(nbt.getInt("CollarColor")));
+         }
++        // Purpur start
++        this.isRabid = nbt.getBoolean("Purpur.IsRabid");
++        this.updatePathfinders(false);
++        // Purpur end
+ 
+         this.readPersistentAngerSaveData(this.level(), nbt);
+     }
+@@ -235,6 +310,11 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+     public void tick() {
+         super.tick();
+         if (this.isAlive()) {
++            // Purpur start
++            if (this.age % 300 == 0 && this.isRabid()) {
++                this.addEffect(new MobEffectInstance(MobEffects.CONFUSION, 400));
++            }
++            // Purpur end
+             this.interestedAngleO = this.interestedAngle;
+             if (this.isInterested()) {
+                 this.interestedAngle += (1.0F - this.interestedAngle) * 0.4F;
+@@ -450,6 +530,19 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+             }
+ 
+             return InteractionResult.SUCCESS;
++        // Purpur start
++        } else if (this.level().purpurConfig.wolfMilkCuresRabies && itemstack.getItem() == Items.MILK_BUCKET && this.isRabid()) {
++            if (!player.isCreative()) {
++                player.setItemInHand(hand, new ItemStack(Items.BUCKET));
++            }
++            this.setRabid(false);
++            for (int i = 0; i < 10; ++i) {
++                ((ServerLevel) level()).sendParticles(((ServerLevel) level()).players(), null, ParticleTypes.HAPPY_VILLAGER,
++                        getX() + random.nextFloat(), getY() + (random.nextFloat() * 1.5), getZ() + random.nextFloat(), 1,
++                        random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, random.nextGaussian() * 0.05D, 0, true);
++            }
++            return InteractionResult.SUCCESS;
++        // Purpur end
+         } else {
+             return super.mobInteract(player, hand);
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWolf.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWolf.java
+index e16459c9cfcac790edd6d912750d32c68387cbbc..890938ad866e2c588f3f819230ba121b0b436401 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWolf.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWolf.java
+@@ -57,4 +57,16 @@ public class CraftWolf extends CraftTameableAnimal implements Wolf {
+     public void setInterested(boolean flag) {
+         this.getHandle().setIsInterested(flag);
+     }
++
++    // Purpur start
++    @Override
++    public boolean isRabid() {
++        return getHandle().isRabid();
++    }
++
++    @Override
++    public void setRabid(boolean isRabid) {
++        getHandle().setRabid(isRabid);
++    }
++    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b1d2c6b15c8d9977e8d8fcfe61485dab67cd9684..839f95b52f3ca44ea479d09b37f7b8aaa67f9672 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1941,6 +1941,8 @@ public class PurpurWorldConfig {
+     public boolean wolfRidableInWater = true;
+     public boolean wolfControllable = true;
+     public double wolfMaxHealth = 8.0D;
++    public boolean wolfMilkCuresRabies = true;
++    public double wolfNaturalRabid = 0.0D;
+     public int wolfBreedingTicks = 6000;
+     private void wolfSettings() {
+         wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable);
+@@ -1952,6 +1954,8 @@ public class PurpurWorldConfig {
+             set("mobs.wolf.attributes.max_health", oldValue);
+         }
+         wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth);
++        wolfMilkCuresRabies = getBoolean("mobs.wolf.milk-cures-rabid-wolves", wolfMilkCuresRabies);
++        wolfNaturalRabid = getDouble("mobs.wolf.spawn-rabid-chance", wolfNaturalRabid);
+         wolfBreedingTicks = getInt("mobs.wolf.breeding-delay-ticks", wolfBreedingTicks);
+     }
+ 

patches/unapplied/server/0115-Configurable-default-collar-color.patch

@@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Thu, 10 Dec 2020 13:43:28 -0500
+Subject: [PATCH] Configurable default collar color
+
+This allows for the server to set a default collar color when a wolf or cat is tamed.
+Resets to RED when the value is invalid.
+
+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 ffa2128b63e5e45c2a41e31a6b8b6e8df0bf9be4..956f125c9ae62537570bb9870be66872f3519f6a 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -345,6 +345,14 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
+         return Mth.lerp(tickDelta, this.relaxStateOneAmountO, this.relaxStateOneAmount);
+     }
+ 
++    // Purpur start
++    @Override
++    public void tame(Player player) {
++        setCollarColor(level().purpurConfig.catDefaultCollarColor);
++        super.tame(player);
++    }
++    // Purpur end
++
+     @Nullable
+     @Override
+     public Cat getBreedOffspring(ServerLevel world, AgeableMob entity) {
+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 f39b278bc520a4785e9fa472bccd836ad1daac85..8d71d0ad4bf8e0df8ded9ebce6f39e66dd632bb5 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -204,6 +204,12 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+         return super.finalizeSpawn(world, difficulty, type, data, nbt);
+     }
+ 
++    @Override
++    public void tame(Player player) {
++        setCollarColor(level().purpurConfig.wolfDefaultCollarColor);
++        super.tame(player);
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new FloatGoal(this));
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 839f95b52f3ca44ea479d09b37f7b8aaa67f9672..5ddb33b3f6811ddea949b08ed72e9355489b9167 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -625,6 +625,7 @@ public class PurpurWorldConfig {
+     public int catSpawnSwampHutScanRange = 16;
+     public int catSpawnVillageScanRange = 48;
+     public int catBreedingTicks = 6000;
++    public DyeColor catDefaultCollarColor = DyeColor.RED;
+     private void catSettings() {
+         catRidable = getBoolean("mobs.cat.ridable", catRidable);
+         catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater);
+@@ -639,6 +640,11 @@ public class PurpurWorldConfig {
+         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);
++        try {
++            catDefaultCollarColor = DyeColor.valueOf(getString("mobs.cat.default-collar-color", catDefaultCollarColor.name()));
++        } catch (IllegalArgumentException ignore) {
++            catDefaultCollarColor = DyeColor.RED;
++        }
+     }
+ 
+     public boolean caveSpiderRidable = false;
+@@ -1941,6 +1947,7 @@ public class PurpurWorldConfig {
+     public boolean wolfRidableInWater = true;
+     public boolean wolfControllable = true;
+     public double wolfMaxHealth = 8.0D;
++    public DyeColor wolfDefaultCollarColor = DyeColor.RED;
+     public boolean wolfMilkCuresRabies = true;
+     public double wolfNaturalRabid = 0.0D;
+     public int wolfBreedingTicks = 6000;
+@@ -1954,6 +1961,11 @@ public class PurpurWorldConfig {
+             set("mobs.wolf.attributes.max_health", oldValue);
+         }
+         wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth);
++        try {
++            wolfDefaultCollarColor = DyeColor.valueOf(getString("mobs.wolf.default-collar-color", wolfDefaultCollarColor.name()));
++        } catch (IllegalArgumentException ignore) {
++            wolfDefaultCollarColor = DyeColor.RED;
++        }
+         wolfMilkCuresRabies = getBoolean("mobs.wolf.milk-cures-rabid-wolves", wolfMilkCuresRabies);
+         wolfNaturalRabid = getDouble("mobs.wolf.spawn-rabid-chance", wolfNaturalRabid);
+         wolfBreedingTicks = getInt("mobs.wolf.breeding-delay-ticks", wolfBreedingTicks);

patches/unapplied/server/0116-Phantom-flames-on-swoop.patch

@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 12 Dec 2020 09:10:59 -0600
+Subject: [PATCH] Phantom flames on swoop
+
+
+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 899a7d3989b51456600787ae09b1736f83bf9a65..076a881412d40ce6a8f5e5f83f7598bfa08f199c 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+@@ -243,6 +243,7 @@ public class Phantom extends FlyingMob implements Enemy {
+             this.level().addParticle(ParticleTypes.MYCELIUM, this.getX() - (double) f2, this.getY() + (double) f4, this.getZ() - (double) f3, 0.0D, 0.0D, 0.0D);
+         }
+ 
++        if (level().purpurConfig.phantomFlamesOnSwoop && attackPhase == AttackPhase.SWOOP) shoot(); // Purpur
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 5ddb33b3f6811ddea949b08ed72e9355489b9167..d755e920048324ae17a08fee7546a4b2fb594f7c 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1303,6 +1303,7 @@ public class PurpurWorldConfig {
+     public int phantomBurnInLight = 0;
+     public boolean phantomIgnorePlayersWithTorch = false;
+     public boolean phantomBurnInDaylight = true;
++    public boolean phantomFlamesOnSwoop = false;
+     private void phantomSettings() {
+         phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable);
+         phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater);
+@@ -1336,6 +1337,7 @@ public class PurpurWorldConfig {
+         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);
++        phantomFlamesOnSwoop = getBoolean("mobs.phantom.flames-on-swoop", phantomFlamesOnSwoop);
+     }
+ 
+     public boolean pigRidable = false;

patches/unapplied/server/0117-Option-for-chests-to-open-even-with-a-solid-block-on.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sat, 12 Dec 2020 14:34:18 -0800
+Subject: [PATCH] Option for chests to open even with a solid block on top
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/ChestBlock.java b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+index 5e22d175b1048a58802cdf64ac70a8b56329e915..d81946b400f208c39941128ce823ff7709741c10 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+@@ -355,6 +355,7 @@ public class ChestBlock extends AbstractChestBlock<ChestBlockEntity> implements
+     }
+ 
+     private static boolean isBlockedChestByBlock(BlockGetter world, BlockPos pos) {
++        if (world instanceof Level && ((Level) world).purpurConfig.chestOpenWithBlockOnTop) return false; // Purpur
+         BlockPos blockposition1 = pos.above();
+ 
+         return world.getBlockState(blockposition1).isRedstoneConductor(world, blockposition1);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d755e920048324ae17a08fee7546a4b2fb594f7c..57cb484499525278fe2664ccba83503e9344a874 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -423,6 +423,11 @@ public class PurpurWorldConfig {
+         }
+     }
+ 
++    public boolean chestOpenWithBlockOnTop = false;
++    private void chestSettings() {
++        chestOpenWithBlockOnTop = getBoolean("blocks.chest.open-with-solid-block-on-top", chestOpenWithBlockOnTop);
++    }
++
+     public boolean dispenserApplyCursedArmor = true;
+     public boolean dispenserPlaceAnvils = false;
+     private void dispenserSettings() {

patches/unapplied/server/0118-Implement-TPSBar.patch

@@ -0,0 +1,467 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 12 Dec 2020 21:19:05 -0600
+Subject: [PATCH] Implement TPSBar
+
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index e5b1b6ad32c48a4ba13b4930954fad18669677ad..4e721dfca7559620d8ce65a6703f2089a839f4a0 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -227,6 +227,7 @@ public class Commands {
+             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
++            org.purpurmc.purpur.command.TPSBarCommand.register(this.dispatcher); // Purpur
+         }
+ 
+         if (environment.includeIntegrated) {
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index fd3a85a2b0e2dca36044535f8ff77fec63f73aee..d87e3a201d0fddd4c212de1de98ca2870e481149 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1022,6 +1022,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.safeShutdown(waitForShutdown, false);
+     }
+     public void safeShutdown(boolean waitForShutdown, boolean isRestarting) {
++        org.purpurmc.purpur.task.BossBarTask.stopAll(); // Purpur
+         this.isRestarting = isRestarting;
+         this.hasLoggedStop = true; // Paper
+         if (isDebugging()) io.papermc.paper.util.TraceUtil.dumpTraceForThread("Server stopped"); // Paper
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index f8e39a8d6bb1b910ac71931a51d8a36d49d30d10..8089e9ff60c6f7a5f06bbb46b53b07d6a588cea3 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -350,6 +350,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+             }
+ 
+             if (gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncMobSpawning) mobSpawnExecutor.start(); // Pufferfish
++            org.purpurmc.purpur.task.BossBarTask.startAll(); // Purpur
+             return true;
+         }
+     }
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index b72790d23165073cd7529262577cd89ce9e518dd..2e04d1b93dc0ca8b83697d5743250c47c98b81f5 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -280,6 +280,7 @@ public class ServerPlayer extends Player {
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - there are a lot of changes to do if we change all methods leading to the event
+     public boolean purpurClient = false; // Purpur
+     public boolean acceptingResourcePack = false; // Purpur
++    private boolean tpsBar = false; // Purpur
+ 
+     private final java.util.concurrent.atomic.AtomicReference<io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances> viewDistances = new java.util.concurrent.atomic.AtomicReference<>(new io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances(-1, -1, -1));
+     public io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+@@ -560,6 +561,7 @@ public class ServerPlayer extends Player {
+             }
+         }
+ 
++        if (nbt.contains("Purpur.TPSBar")) { this.tpsBar = nbt.getBoolean("Purpur.TPSBar"); } // Purpur
+     }
+ 
+     @Override
+@@ -626,6 +628,7 @@ public class ServerPlayer extends Player {
+         }
+         this.getBukkitEntity().setExtraData(nbt); // CraftBukkit
+ 
++        nbt.putBoolean("Purpur.TPSBar", this.tpsBar); // Purpur
+     }
+ 
+     // CraftBukkit start - World fallback code, either respawn location or global spawn
+@@ -2794,5 +2797,13 @@ public class ServerPlayer extends Player {
+             this.server.getPlayerList().respawn(this, toLevel, true, to, !toLevel.paperConfig().environment.disableTeleportationSuffocationCheck, org.bukkit.event.player.PlayerRespawnEvent.RespawnReason.DEATH);
+         }
+     }
++
++    public boolean tpsBar() {
++        return this.tpsBar;
++    }
++
++    public void tpsBar(boolean tpsBar) {
++        this.tpsBar = tpsBar;
++    }
+     // Purpur end
+ }
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 9cecf7d3e2f860f9de5dd13a352d8d7ed6f95266..9a60fa370f37179a7460b316d26e601197b478c7 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -484,6 +484,7 @@ public abstract class PlayerList {
+             scoreboard.addPlayerToTeam(player.getScoreboardName(), collideRuleTeam);
+         }
+         // Paper end
++        org.purpurmc.purpur.task.BossBarTask.addToAll(player); // Purpur
+         // CraftBukkit - Moved from above, added world
+         PlayerList.LOGGER.info("{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", player.getName().getString(), s1, player.getId(), worldserver1.serverLevelData.getLevelName(), player.getX(), player.getY(), player.getZ());
+     }
+@@ -593,6 +594,7 @@ public abstract class PlayerList {
+     }
+     public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer, net.kyori.adventure.text.Component leaveMessage) {
+         // Paper end
++        org.purpurmc.purpur.task.BossBarTask.removeFromAll(entityplayer.getBukkitEntity()); // Purpur
+         ServerLevel worldserver = entityplayer.serverLevel();
+ 
+         entityplayer.awardStat(Stats.LEAVE_GAME);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index aaf96399f937fbca30f1ce5d64be4af265a4ed29..61e3bce901bdbf111ffc06521b0e6d5369fce051 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -182,6 +182,7 @@ public class PurpurConfig {
+     public static String creditsCommandOutput = "<green>%s has been shown the end credits";
+     public static String demoCommandOutput = "<green>%s has been shown the demo screen";
+     public static String pingCommandOutput = "<green>%s's ping is %sms";
++    public static String tpsbarCommandOutput = "<green>Tpsbar toggled <onoff> for <target>";
+     private static void messages() {
+         cannotRideMob = getString("settings.messages.cannot-ride-mob", cannotRideMob);
+         afkBroadcastAway = getString("settings.messages.afk-broadcast-away", afkBroadcastAway);
+@@ -192,6 +193,7 @@ public class PurpurConfig {
+         creditsCommandOutput = getString("settings.messages.credits-command-output", creditsCommandOutput);
+         demoCommandOutput = getString("settings.messages.demo-command-output", demoCommandOutput);
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
++        tpsbarCommandOutput = getString("settings.messages.tpsbar-command-output", tpsbarCommandOutput);
+     }
+ 
+     public static String serverModName = "Purpur";
+@@ -214,6 +216,29 @@ public class PurpurConfig {
+         disableGiveCommandDrops = getBoolean("settings.disable-give-dropping", disableGiveCommandDrops);
+     }
+ 
++    public static String commandTPSBarTitle = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
++    public static BossBar.Overlay commandTPSBarProgressOverlay = BossBar.Overlay.NOTCHED_20;
++    public static TPSBarTask.FillMode commandTPSBarProgressFillMode = TPSBarTask.FillMode.MSPT;
++    public static BossBar.Color commandTPSBarProgressColorGood = BossBar.Color.GREEN;
++    public static BossBar.Color commandTPSBarProgressColorMedium = BossBar.Color.YELLOW;
++    public static BossBar.Color commandTPSBarProgressColorLow = BossBar.Color.RED;
++    public static String commandTPSBarTextColorGood = "<gradient:#55ff55:#00aa00><text></gradient>";
++    public static String commandTPSBarTextColorMedium = "<gradient:#ffff55:#ffaa00><text></gradient>";
++    public static String commandTPSBarTextColorLow = "<gradient:#ff5555:#aa0000><text></gradient>";
++    public static int commandTPSBarTickInterval = 20;
++    private static void commandSettings() {
++        commandTPSBarTitle = getString("settings.command.tpsbar.title", commandTPSBarTitle);
++        commandTPSBarProgressOverlay = BossBar.Overlay.valueOf(getString("settings.command.tpsbar.overlay", commandTPSBarProgressOverlay.name()));
++        commandTPSBarProgressFillMode = TPSBarTask.FillMode.valueOf(getString("settings.command.tpsbar.fill-mode", commandTPSBarProgressFillMode.name()));
++        commandTPSBarProgressColorGood = BossBar.Color.valueOf(getString("settings.command.tpsbar.progress-color.good", commandTPSBarProgressColorGood.name()));
++        commandTPSBarProgressColorMedium = BossBar.Color.valueOf(getString("settings.command.tpsbar.progress-color.medium", commandTPSBarProgressColorMedium.name()));
++        commandTPSBarProgressColorLow = BossBar.Color.valueOf(getString("settings.command.tpsbar.progress-color.low", commandTPSBarProgressColorLow.name()));
++        commandTPSBarTextColorGood = getString("settings.command.tpsbar.text-color.good", commandTPSBarTextColorGood);
++        commandTPSBarTextColorMedium = getString("settings.command.tpsbar.text-color.medium", commandTPSBarTextColorMedium);
++        commandTPSBarTextColorLow = getString("settings.command.tpsbar.text-color.low", commandTPSBarTextColorLow);
++        commandTPSBarTickInterval = getInt("settings.command.tpsbar.tick-interval", commandTPSBarTickInterval);
++    }
++
+     public static int barrelRows = 3;
+     public static boolean enderChestSixRows = false;
+     public static boolean enderChestPermissionRows = false;
+diff --git a/src/main/java/org/purpurmc/purpur/command/TPSBarCommand.java b/src/main/java/org/purpurmc/purpur/command/TPSBarCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d8f9b044107ff7c29a83eb5378aa9f5465ba1995
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/command/TPSBarCommand.java
+@@ -0,0 +1,44 @@
++package org.purpurmc.purpur.command;
++
++import com.mojang.brigadier.CommandDispatcher;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.NamedTextColor;
++import net.kyori.adventure.text.minimessage.MiniMessage;
++import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
++import net.minecraft.commands.CommandSourceStack;
++import net.minecraft.commands.Commands;
++import net.minecraft.commands.arguments.EntityArgument;
++import net.minecraft.server.level.ServerPlayer;
++import org.purpurmc.purpur.PurpurConfig;
++import org.purpurmc.purpur.task.TPSBarTask;
++
++import java.util.Collection;
++import java.util.Collections;
++
++public class TPSBarCommand {
++    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
++        dispatcher.register(Commands.literal("tpsbar")
++                .requires(listener -> listener.hasPermission(2, "bukkit.command.tpsbar"))
++                .executes(context -> execute(context.getSource(), Collections.singleton(context.getSource().getPlayerOrException())))
++                .then(Commands.argument("targets", EntityArgument.players())
++                        .requires(listener -> listener.hasPermission(2, "bukkit.command.tpsbar.other"))
++                        .executes((context) -> execute(context.getSource(), EntityArgument.getPlayers(context, "targets")))
++                )
++        );
++    }
++
++    private static int execute(CommandSourceStack sender, Collection<ServerPlayer> targets) {
++        for (ServerPlayer player : targets) {
++            boolean result = TPSBarTask.instance().togglePlayer(player.getBukkitEntity());
++            player.tpsBar(result);
++
++            Component output = MiniMessage.miniMessage().deserialize(PurpurConfig.tpsbarCommandOutput,
++                    Placeholder.component("onoff", Component.translatable(result ? "options.on" : "options.off")
++                            .color(result ? NamedTextColor.GREEN : NamedTextColor.RED)),
++                            Placeholder.parsed("target", player.getGameProfile().getName()));
++
++            sender.sendSuccess(output, false);
++        }
++        return targets.size();
++    }
++}
+diff --git a/src/main/java/org/purpurmc/purpur/task/BossBarTask.java b/src/main/java/org/purpurmc/purpur/task/BossBarTask.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d38b3c4a722396cc3b61a9a8ed7e39cea4ae65cb
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/task/BossBarTask.java
+@@ -0,0 +1,109 @@
++package org.purpurmc.purpur.task;
++
++import net.kyori.adventure.bossbar.BossBar;
++import net.minecraft.server.level.ServerPlayer;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.scheduler.MinecraftInternalPlugin;
++import org.bukkit.entity.Player;
++import org.bukkit.scheduler.BukkitRunnable;
++
++import java.util.HashMap;
++import java.util.HashSet;
++import java.util.Iterator;
++import java.util.Map;
++import java.util.UUID;
++
++public abstract class BossBarTask extends BukkitRunnable {
++    private final Map<UUID, BossBar> bossbars = new HashMap<>();
++    private boolean started;
++
++    abstract BossBar createBossBar();
++
++    abstract void updateBossBar(BossBar bossbar, Player player);
++
++    @Override
++    public void run() {
++        Iterator<Map.Entry<UUID, BossBar>> iter = bossbars.entrySet().iterator();
++        while (iter.hasNext()) {
++            Map.Entry<UUID, BossBar> entry = iter.next();
++            Player player = Bukkit.getPlayer(entry.getKey());
++            if (player == null) {
++                iter.remove();
++                continue;
++            }
++            updateBossBar(entry.getValue(), player);
++        }
++    }
++
++    @Override
++    public void cancel() {
++        super.cancel();
++        new HashSet<>(this.bossbars.keySet()).forEach(uuid -> {
++            Player player = Bukkit.getPlayer(uuid);
++            if (player != null) {
++                removePlayer(player);
++            }
++        });
++        this.bossbars.clear();
++    }
++
++    public boolean removePlayer(Player player) {
++        BossBar bossbar = this.bossbars.remove(player.getUniqueId());
++        if (bossbar != null) {
++            player.hideBossBar(bossbar);
++            return true;
++        }
++        return false;
++    }
++
++    public void addPlayer(Player player) {
++        removePlayer(player);
++        BossBar bossbar = createBossBar();
++        this.bossbars.put(player.getUniqueId(), bossbar);
++        this.updateBossBar(bossbar, player);
++        player.showBossBar(bossbar);
++    }
++
++    public boolean hasPlayer(UUID uuid) {
++        return this.bossbars.containsKey(uuid);
++    }
++
++    public boolean togglePlayer(Player player) {
++        if (removePlayer(player)) {
++            return false;
++        }
++        addPlayer(player);
++        return true;
++    }
++
++    public void start() {
++        stop();
++        this.runTaskTimerAsynchronously(new MinecraftInternalPlugin(), 1, 1);
++        started = true;
++    }
++
++    public void stop() {
++        if (started) {
++            cancel();
++        }
++    }
++
++    public static void startAll() {
++        TPSBarTask.instance().start();
++    }
++
++    public static void stopAll() {
++        TPSBarTask.instance().stop();
++    }
++
++    public static void addToAll(ServerPlayer player) {
++        Player bukkit = player.getBukkitEntity();
++        if (player.tpsBar()) {
++            TPSBarTask.instance().addPlayer(bukkit);
++        }
++    }
++
++    public static void removeFromAll(Player player) {
++        TPSBarTask.instance().removePlayer(player);
++    }
++}
+diff --git a/src/main/java/org/purpurmc/purpur/task/TPSBarTask.java b/src/main/java/org/purpurmc/purpur/task/TPSBarTask.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8769993e7ca59da309087051a3cd38fc562c15d1
+--- /dev/null
++++ b/src/main/java/org/purpurmc/purpur/task/TPSBarTask.java
+@@ -0,0 +1,142 @@
++package org.purpurmc.purpur.task;
++
++import net.kyori.adventure.bossbar.BossBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.minimessage.MiniMessage;
++import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
++import org.purpurmc.purpur.PurpurConfig;
++import org.bukkit.Bukkit;
++import org.bukkit.entity.Player;
++
++public class TPSBarTask extends BossBarTask {
++    private static TPSBarTask instance;
++    private double tps = 20.0D;
++    private double mspt = 0.0D;
++    private int tick = 0;
++
++    public static TPSBarTask instance() {
++        if (instance == null) {
++            instance = new TPSBarTask();
++        }
++        return instance;
++    }
++
++    @Override
++    BossBar createBossBar() {
++        return BossBar.bossBar(Component.text(""), 0.0F, instance().getBossBarColor(), PurpurConfig.commandTPSBarProgressOverlay);
++    }
++
++    @Override
++    void updateBossBar(BossBar bossbar, Player player) {
++        bossbar.progress(getBossBarProgress());
++        bossbar.color(getBossBarColor());
++        bossbar.name(MiniMessage.miniMessage().deserialize(PurpurConfig.commandTPSBarTitle,
++                Placeholder.component("tps", getTPSColor()),
++                Placeholder.component("mspt", getMSPTColor()),
++                Placeholder.component("ping", getPingColor(player.getPing()))
++        ));
++    }
++
++    @Override
++    public void run() {
++        if (++tick < PurpurConfig.commandTPSBarTickInterval) {
++            return;
++        }
++        tick = 0;
++
++        this.tps = Math.max(Math.min(Bukkit.getTPS()[0], 20.0D), 0.0D);
++        this.mspt = Bukkit.getAverageTickTime();
++
++        super.run();
++    }
++
++    private float getBossBarProgress() {
++        if (PurpurConfig.commandTPSBarProgressFillMode == FillMode.MSPT) {
++            return Math.max(Math.min((float) mspt / 50.0F, 1.0F), 0.0F);
++        } else {
++            return Math.max(Math.min((float) tps / 20.0F, 1.0F), 0.0F);
++        }
++    }
++
++    private BossBar.Color getBossBarColor() {
++        if (isGood(PurpurConfig.commandTPSBarProgressFillMode)) {
++            return PurpurConfig.commandTPSBarProgressColorGood;
++        } else if (isMedium(PurpurConfig.commandTPSBarProgressFillMode)) {
++            return PurpurConfig.commandTPSBarProgressColorMedium;
++        } else {
++            return PurpurConfig.commandTPSBarProgressColorLow;
++        }
++    }
++
++    private boolean isGood(FillMode mode) {
++        return isGood(mode, 0);
++    }
++
++    private boolean isGood(FillMode mode, int ping) {
++        if (mode == FillMode.MSPT) {
++            return mspt < 40;
++        } else if (mode == FillMode.TPS) {
++            return tps >= 19;
++        } else if (mode == FillMode.PING) {
++            return ping < 100;
++        } else {
++            return false;
++        }
++    }
++
++    private boolean isMedium(FillMode mode) {
++        return isMedium(mode, 0);
++    }
++
++    private boolean isMedium(FillMode mode, int ping) {
++        if (mode == FillMode.MSPT) {
++            return mspt < 50;
++        } else if (mode == FillMode.TPS) {
++            return tps >= 15;
++        } else if (mode == FillMode.PING) {
++            return ping < 200;
++        } else {
++            return false;
++        }
++    }
++
++    private Component getTPSColor() {
++        String color;
++        if (isGood(FillMode.TPS)) {
++            color = PurpurConfig.commandTPSBarTextColorGood;
++        } else if (isMedium(FillMode.TPS)) {
++            color = PurpurConfig.commandTPSBarTextColorMedium;
++        } else {
++            color = PurpurConfig.commandTPSBarTextColorLow;
++        }
++        return MiniMessage.miniMessage().deserialize(color, Placeholder.parsed("text", String.format("%.2f", tps)));
++    }
++
++    private Component getMSPTColor() {
++        String color;
++        if (isGood(FillMode.MSPT)) {
++            color = PurpurConfig.commandTPSBarTextColorGood;
++        } else if (isMedium(FillMode.MSPT)) {
++            color = PurpurConfig.commandTPSBarTextColorMedium;
++        } else {
++            color = PurpurConfig.commandTPSBarTextColorLow;
++        }
++        return MiniMessage.miniMessage().deserialize(color, Placeholder.parsed("text", String.format("%.2f", mspt)));
++    }
++
++    private Component getPingColor(int ping) {
++        String color;
++        if (isGood(FillMode.PING, ping)) {
++            color = PurpurConfig.commandTPSBarTextColorGood;
++        } else if (isMedium(FillMode.PING, ping)) {
++            color = PurpurConfig.commandTPSBarTextColorMedium;
++        } else {
++            color = PurpurConfig.commandTPSBarTextColorLow;
++        }
++        return MiniMessage.miniMessage().deserialize(color, Placeholder.parsed("text", String.format("%s", ping)));
++    }
++
++    public enum FillMode {
++        TPS, MSPT, PING
++    }
++}

patches/unapplied/server/0119-Striders-give-saddle-back.patch

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Sun, 13 Dec 2020 20:40:57 -0500
+Subject: [PATCH] Striders give saddle back
+
+
+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 93dca4758ed995373fe1585930f225604a4153fa..4c077c94b654f54465ece2aa45c5ead0a417ad0d 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Strider.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java
+@@ -486,6 +486,19 @@ public class Strider extends Animal implements ItemSteerable, Saddleable {
+     public InteractionResult mobInteract(Player player, InteractionHand hand) {
+         boolean flag = this.isFood(player.getItemInHand(hand));
+ 
++        // Purpur start
++        if (level().purpurConfig.striderGiveSaddleBack && 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;
++        }
++        // Purpur end
++
+         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 57cb484499525278fe2664ccba83503e9344a874..a0607bcc0da66718928c0ca6e0e02a5a4a56eaf4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1715,6 +1715,7 @@ public class PurpurWorldConfig {
+     public boolean striderControllable = true;
+     public double striderMaxHealth = 20.0D;
+     public int striderBreedingTicks = 6000;
++    public boolean striderGiveSaddleBack = false;
+     private void striderSettings() {
+         striderRidable = getBoolean("mobs.strider.ridable", striderRidable);
+         striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater);
+@@ -1726,6 +1727,7 @@ public class PurpurWorldConfig {
+         }
+         striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth);
+         striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks);
++        striderGiveSaddleBack = getBoolean("mobs.strider.give-saddle-back", striderGiveSaddleBack);
+     }
+ 
+     public boolean tadpoleRidable = false;

patches/unapplied/server/0120-PlayerBookTooLargeEvent.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Wed, 23 Dec 2020 00:43:59 -0600
+Subject: [PATCH] PlayerBookTooLargeEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 8126b1a67e62077c8a78f13deee767236665d7fa..6c5b0d1d8fe7fae29dc1ed449e0412c9f449acf9 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1279,10 +1279,12 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+             int maxBookPageSize = io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.pageMax;
+             double multiplier = Math.max(0.3D, Math.min(1D, io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.totalMultiplier));
+             long byteAllowed = maxBookPageSize;
++            ItemStack itemstack = this.player.getInventory().getItem(packet.getSlot()); // Purpur
+             for (String testString : pageList) {
+                 int byteLength = testString.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
+                 if (byteLength > 256 * 4) {
+                     ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send a book with with a page too large!");
++                    org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent event = new org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent(player.getBukkitEntity(), itemstack.asBukkitCopy()); if (event.shouldKickPlayer()) // Purpur
+                     server.scheduleOnMain(() -> this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause
+                     return;
+                 }
+@@ -1306,6 +1308,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+             if (byteTotal > byteAllowed) {
+                 ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send too large of a book. Book Size: " + byteTotal + " - Allowed:  "+ byteAllowed + " - Pages: " + pageList.size());
++                org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent event = new org.purpurmc.purpur.event.player.PlayerBookTooLargeEvent(player.getBukkitEntity(), itemstack.asBukkitCopy()); if (event.shouldKickPlayer()) // Purpur
+                 server.scheduleOnMain(() -> this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause
+                 return;
+             }

patches/unapplied/server/0121-Full-netherite-armor-grants-fire-resistance.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Thu, 24 Dec 2020 11:00:15 -0600
+Subject: [PATCH] Full netherite armor grants fire resistance
+
+
+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 fa2a0cc24bbe31abd49ce0f3f41bab2aa5d9c81f..04e816f01db7d2de7ffa9bbaaa72daadaab34831 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -366,6 +366,16 @@ public abstract class Player extends LivingEntity {
+             this.addEffect(new MobEffectInstance(MobEffects.WATER_BREATHING, 200, 0, false, false, true), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.TURTLE_HELMET); // CraftBukkit
+         }
+ 
++        // Purpur start
++        if (this.level().purpurConfig.playerNetheriteFireResistanceDuration > 0 && this.level().getGameTime() % 20 == 0) {
++            if (itemstack.is(Items.NETHERITE_HELMET)
++                    && this.getItemBySlot(EquipmentSlot.CHEST).is(Items.NETHERITE_CHESTPLATE)
++                    && this.getItemBySlot(EquipmentSlot.LEGS).is(Items.NETHERITE_LEGGINGS)
++                    && this.getItemBySlot(EquipmentSlot.FEET).is(Items.NETHERITE_BOOTS)) {
++                this.addEffect(new MobEffectInstance(MobEffects.FIRE_RESISTANCE, this.level().purpurConfig.playerNetheriteFireResistanceDuration, this.level().purpurConfig.playerNetheriteFireResistanceAmplifier, this.level().purpurConfig.playerNetheriteFireResistanceAmbient, this.level().purpurConfig.playerNetheriteFireResistanceShowParticles, this.level().purpurConfig.playerNetheriteFireResistanceShowIcon), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.NETHERITE_ARMOR);
++            }
++        }
++        // Purpur end
+     }
+ 
+     protected ItemCooldowns createItemCooldowns() {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a0607bcc0da66718928c0ca6e0e02a5a4a56eaf4..2606c631d93c8e7b99b0ac1fffffa6b0ce388679 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -295,6 +295,19 @@ public class PurpurWorldConfig {
+         villageSiegeSpawning = getBoolean("gameplay-mechanics.mob-spawning.village-sieges", predicate);
+     }
+ 
++    public int playerNetheriteFireResistanceDuration = 0;
++    public int playerNetheriteFireResistanceAmplifier = 0;
++    public boolean playerNetheriteFireResistanceAmbient = false;
++    public boolean playerNetheriteFireResistanceShowParticles = false;
++    public boolean playerNetheriteFireResistanceShowIcon = true;
++    private void playerNetheriteFireResistance() {
++        playerNetheriteFireResistanceDuration = getInt("gameplay-mechanics.player.netherite-fire-resistance.duration", playerNetheriteFireResistanceDuration);
++        playerNetheriteFireResistanceAmplifier = getInt("gameplay-mechanics.player.netherite-fire-resistance.amplifier", playerNetheriteFireResistanceAmplifier);
++        playerNetheriteFireResistanceAmbient = getBoolean("gameplay-mechanics.player.netherite-fire-resistance.ambient", playerNetheriteFireResistanceAmbient);
++        playerNetheriteFireResistanceShowParticles = getBoolean("gameplay-mechanics.player.netherite-fire-resistance.show-particles", playerNetheriteFireResistanceShowParticles);
++        playerNetheriteFireResistanceShowIcon = getBoolean("gameplay-mechanics.player.netherite-fire-resistance.show-icon", playerNetheriteFireResistanceShowIcon);
++    }
++
+     public boolean idleTimeoutKick = true;
+     public boolean idleTimeoutTickNearbyEntities = true;
+     public boolean idleTimeoutCountAsSleeping = false;

patches/unapplied/server/0122-Fix-rotating-UP-DOWN-CW-and-CCW.patch

@@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Wed, 6 Jan 2021 02:19:29 -0600
+Subject: [PATCH] Fix rotating UP/DOWN CW and CCW
+
+
+diff --git a/src/main/java/net/minecraft/core/Direction.java b/src/main/java/net/minecraft/core/Direction.java
+index d0a8092bf57a29ab7c00ec0ddf52a9fdb2a33267..defe5951938ce3a7b7f83017d4af36bb49ff5be0 100644
+--- a/src/main/java/net/minecraft/core/Direction.java
++++ b/src/main/java/net/minecraft/core/Direction.java
+@@ -238,6 +238,12 @@ public enum Direction implements StringRepresentable {
+             case EAST:
+                 var10000 = SOUTH;
+                 break;
++        // Purpur start
++        case UP:
++            return UP;
++        case DOWN:
++            return DOWN;
++        // Purpur end
+             default:
+                 throw new IllegalStateException("Unable to get Y-rotated facing of " + this);
+         }
+@@ -350,6 +356,12 @@ public enum Direction implements StringRepresentable {
+             case EAST:
+                 var10000 = NORTH;
+                 break;
++        // Purpur start
++        case UP:
++            return UP;
++        case DOWN:
++            return DOWN;
++        // Purpur end
+             default:
+                 throw new IllegalStateException("Unable to get CCW facing of " + this);
+         }

patches/unapplied/server/0123-Add-mobGriefing-bypass-to-everything-affected.patch

@@ -0,0 +1,679 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 5 Jan 2021 22:21:56 -0500
+Subject: [PATCH] Add mobGriefing bypass to everything affected
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 5b6b650e9fc477176d3229c28141d61ad50a2cda..47d1c9cd74454cb0ff2b3e0bcad40a3208129c7a 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1772,7 +1772,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             boolean flag = false;
+ 
+             if (this.dead && adversary instanceof WitherBoss) { // Paper
+-                if (this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++                if (this.level().purpurConfig.witherBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                     BlockPos blockposition = this.blockPosition();
+                     BlockState iblockdata = Blocks.WITHER_ROSE.defaultBlockState();
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 50747e73ab0a37073e431db82d79b1ebc024d347..6ae71386cdc0d30defd9a86b97f5e619d2dbf5fe 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -703,7 +703,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
+     public void aiStep() {
+         super.aiStep();
+         this.level().getProfiler().push("looting");
+-        if (!this.level().isClientSide && this.canPickUpLoot() && this.isAlive() && !this.dead && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++        if (!this.level().isClientSide && this.canPickUpLoot() && this.isAlive() && !this.dead && (this.level().purpurConfig.entitiesPickUpLootBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) {
+             Vec3i baseblockposition = this.getPickupReach();
+             List<ItemEntity> list = this.level().getEntitiesOfClass(ItemEntity.class, this.getBoundingBox().inflate((double) baseblockposition.getX(), (double) baseblockposition.getY(), (double) baseblockposition.getZ()));
+             Iterator iterator = list.iterator();
+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 66a568e6803b91040f3933d4598c52fa518badab..a1acc479c9d6a838e3180da3ac8a3a02d22db5c1 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
+@@ -47,7 +47,7 @@ public class HarvestFarmland extends Behavior<Villager> {
+     }
+ 
+     protected boolean checkExtraStartConditions(ServerLevel world, Villager entity) {
+-        if (!world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++        if (!world.purpurConfig.villagerBypassMobGriefing && !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+             return false;
+         } else if (entity.getVillagerData().getProfession() != VillagerProfession.FARMER && !(world.purpurConfig.villagerClericsFarmWarts && entity.getVillagerData().getProfession() == VillagerProfession.CLERIC)) { // Purpur
+             return false;
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
+index a85885ee51df585fa11ae9f8fcd67ff2a71c5a18..d81509e08e70ec5b2f837c9dc66b1254c86854e4 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
+@@ -32,7 +32,7 @@ public class BreakDoorGoal extends DoorInteractGoal {
+ 
+     @Override
+     public boolean canUse() {
+-        return !super.canUse() ? false : (!this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) ? false : this.isValidDifficulty(this.mob.level().getDifficulty()) && !this.isOpen());
++        return !super.canUse() ? false : ((!this.mob.level().purpurConfig.zombieBypassMobGriefing && !this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) ? false : this.isValidDifficulty(this.mob.level().getDifficulty()) && !this.isOpen()); // Purpur
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
+index 93bbda61f0eb2dd52573602b1f9cc7b031d1fc5a..63f9e5e2490e5b2fec6f2395077e21e601804ca5 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
+@@ -74,7 +74,7 @@ public class EatBlockGoal extends Goal {
+ 
+             final BlockState blockState = this.level.getBlockState(blockposition); // Paper - fix wrong block state
+             if (EatBlockGoal.IS_TALL_GRASS.test(blockState)) { // Paper - fix wrong block state
+-                if (CraftEventFactory.callEntityChangeBlockEvent(this.mob, blockposition, blockState.getFluidState().createLegacyBlock(), !this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit // Paper - fix wrong block state
++                if (CraftEventFactory.callEntityChangeBlockEvent(this.mob, blockposition, blockState.getFluidState().createLegacyBlock(), !this.level.purpurConfig.sheepBypassMobGriefing && !this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit // Paper - fix wrong block state // Purpur
+                     this.level.destroyBlock(blockposition, false);
+                 }
+ 
+@@ -83,7 +83,7 @@ public class EatBlockGoal extends Goal {
+                 BlockPos blockposition1 = blockposition.below();
+ 
+                 if (this.level.getBlockState(blockposition1).is(Blocks.GRASS_BLOCK)) {
+-                    if (CraftEventFactory.callEntityChangeBlockEvent(this.mob, blockposition1, Blocks.DIRT.defaultBlockState(), !this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit // Paper - Fix wrong block state
++                    if (CraftEventFactory.callEntityChangeBlockEvent(this.mob, blockposition1, Blocks.DIRT.defaultBlockState(), !this.level.purpurConfig.sheepBypassMobGriefing && !this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit // Paper - Fix wrong block state // Purpur
+                         this.level.levelEvent(2001, blockposition1, Block.getId(Blocks.GRASS_BLOCK.defaultBlockState()));
+                         this.level.setBlock(blockposition1, Blocks.DIRT.defaultBlockState(), 2);
+                     }
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
+index 509317a26c79f453335df1c19dc4c9ec570046af..8e4d673e4f2d7f50ea5ed13794da08b1d20e6665 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
+@@ -40,7 +40,7 @@ public class RemoveBlockGoal extends MoveToBlockGoal {
+ 
+     @Override
+     public boolean canUse() {
+-        if (!this.removerMob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++        if (!this.removerMob.level().purpurConfig.zombieBypassMobGriefing && !this.removerMob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+             return false;
+         } else if (this.nextStartTick > 0) {
+             --this.nextStartTick;
+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 2cf00af66b73e1891fadcabcf83307873cbed710..2a6f6753ce9b7ab899256edc181a92c19021822b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -1377,7 +1377,7 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+         }
+ 
+         protected void onReachedTarget() {
+-            if (Fox.this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            if (Fox.this.level().purpurConfig.foxBypassMobGriefing || Fox.this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                 BlockState iblockdata = Fox.this.level().getBlockState(this.blockPos);
+ 
+                 if (iblockdata.is(Blocks.SWEET_BERRY_BUSH)) {
+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 787391763cac2ae6ed9c178c44616b992849e819..0187af6c3380c1880ae1e3b8982b1543ae9da4a5 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java
+@@ -633,7 +633,7 @@ public class Rabbit extends Animal implements VariantHolder<Rabbit.Variant> {
+         @Override
+         public boolean canUse() {
+             if (this.nextStartTick <= 0) {
+-                if (!this.rabbit.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++                if (!this.rabbit.level().purpurConfig.rabbitBypassMobGriefing && !this.rabbit.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                     return false;
+                 }
+ 
+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 d3da7487f911ff791dca5f7b546dccda751fe44c..84e0a41620fd52af0cd22dc92fd13ee4efd206fb 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
++++ b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java
+@@ -127,7 +127,7 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM
+                 this.hurt(this.damageSources().melting, 1.0F); // CraftBukkit - DamageSource.BURN -> CraftEventFactory.MELTING
+             }
+ 
+-            if (!this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            if (!this.level().purpurConfig.snowGolemBypassMobGriefing && !this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                 return;
+             }
+ 
+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 3898653acb6127c88a94b5e7111a9cfecb2d136e..8f71c3b94ed17fd72e6bacce7d0a8e3943c37c36 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
+@@ -612,7 +612,7 @@ public class EnderDragon extends Mob implements Enemy {
+                     BlockState iblockdata = this.level().getBlockState(blockposition);
+ 
+                     if (!iblockdata.isAir() && !iblockdata.is(BlockTags.DRAGON_TRANSPARENT)) {
+-                        if (this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && !iblockdata.is(BlockTags.DRAGON_IMMUNE)) {
++                        if ((this.level().purpurConfig.enderDragonBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) && !iblockdata.is(BlockTags.DRAGON_IMMUNE)) { // Purpur
+                             // CraftBukkit start - Add blocks to list rather than destroying them
+                             // flag1 = this.level().removeBlock(blockposition, false) || flag1;
+                             flag1 = true;
+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 8796b779ac0550e32c7313b1280278de48070baf..97be7061d3cccac7b64f4b1a234ccbd83e2b7407 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
+@@ -492,7 +492,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+ 
+             if (this.destroyBlocksTick > 0) {
+                 --this.destroyBlocksTick;
+-                if (this.destroyBlocksTick == 0 && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++                if (this.destroyBlocksTick == 0 && (this.level().purpurConfig.witherBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // Purpur
+                     i = Mth.floor(this.getY());
+                     j = Mth.floor(this.getX());
+                     int i1 = Mth.floor(this.getZ());
+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 f49cbb9fcd13afc10aa76ac80128162a902ae345..65a6073a976ce0924ce3a9c7a34253b7e5a9fcec 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -542,7 +542,15 @@ 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);
++            // Purpur start
++            if (this.enderman.getCarriedBlock() == null) {
++                return false;
++            }
++            if (!this.enderman.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && !this.enderman.level().purpurConfig.endermanBypassMobGriefing) {
++                return false;
++            }
++            return this.enderman.getRandom().nextInt(reducedTickDelay(2000)) == 0;
++            // Purpur end
+         }
+ 
+         @Override
+@@ -588,7 +596,15 @@ 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);
++            // Purpur start
++            if (this.enderman.getCarriedBlock() != null) {
++                return false;
++            }
++            if (!this.enderman.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && !this.enderman.level().purpurConfig.endermanBypassMobGriefing) {
++                return false;
++            }
++            return this.enderman.getRandom().nextInt(reducedTickDelay(20)) == 0;
++            // Purpur end
+         }
+ 
+         @Override
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Evoker.java b/src/main/java/net/minecraft/world/entity/monster/Evoker.java
+index f71a70a72ba0bb01c26291ad9dbdd3b01bbf6ee7..ea2a2c56f94d03b73a5e3a06f91aee7fcb0867f4 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Evoker.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Evoker.java
+@@ -341,7 +341,7 @@ public class Evoker extends SpellcasterIllager {
+                 return false;
+             } else if (Evoker.this.tickCount < this.nextAttackTickCount) {
+                 return false;
+-            } else if (!Evoker.this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            } else if (!Evoker.this.level().purpurConfig.evokerBypassMobGriefing && !Evoker.this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                 return false;
+             } else {
+                 List<Sheep> list = Evoker.this.level().getNearbyEntities(Sheep.class, this.wololoTargeting, Evoker.this, Evoker.this.getBoundingBox().inflate(16.0D, 4.0D, 16.0D));
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+index 92b14a6056dfbf07852fc0ee0e3eaf7b4c1657a4..ab13d20dda5a8af471fd459950e7c3e2215e59db 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+@@ -193,7 +193,7 @@ public class Ravager extends Raider {
+                 this.getAttribute(Attributes.MOVEMENT_SPEED).setBaseValue(Mth.lerp(0.1D, d1, d0));
+             }
+ 
+-            if (this.horizontalCollision && this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++            if (this.horizontalCollision && (this.level().purpurConfig.ravagerBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // Purpur
+                 boolean flag = false;
+                 AABB axisalignedbb = this.getBoundingBox().inflate(0.2D);
+                 Iterator iterator = BlockPos.betweenClosed(Mth.floor(axisalignedbb.minX), Mth.floor(axisalignedbb.minY), Mth.floor(axisalignedbb.minZ), Mth.floor(axisalignedbb.maxX), Mth.floor(axisalignedbb.maxY), Mth.floor(axisalignedbb.maxZ)).iterator();
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Silverfish.java b/src/main/java/net/minecraft/world/entity/monster/Silverfish.java
+index 43b330e263ebe20b76629c350bf7773220f6583e..8f813469ece9f57b19335a155e97d73ed8ce1478 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Silverfish.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Silverfish.java
+@@ -208,7 +208,7 @@ public class Silverfish extends Monster {
+                                     continue;
+                                 }
+                                 // CraftBukkit end
+-                                if (world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
++                                if (world.purpurConfig.silverfishBypassMobGriefing || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) { // Purpur
+                                     world.destroyBlock(blockposition1, true, this.silverfish);
+                                 } else {
+                                     world.setBlock(blockposition1, ((InfestedBlock) block).hostStateByInfested(world.getBlockState(blockposition1)), 3);
+@@ -246,7 +246,7 @@ public class Silverfish extends Monster {
+             } else {
+                 RandomSource randomsource = this.mob.getRandom();
+ 
+-                if (this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && randomsource.nextInt(reducedTickDelay(10)) == 0) {
++                if ((this.mob.level().purpurConfig.silverfishBypassMobGriefing || this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) && randomsource.nextInt(reducedTickDelay(10)) == 0) { // Purpur
+                     this.selectedDirection = Direction.getRandom(randomsource);
+                     BlockPos blockposition = BlockPos.containing(this.mob.getX(), this.mob.getY() + 0.5D, this.mob.getZ()).relative(this.selectedDirection);
+                     BlockState iblockdata = this.mob.level().getBlockState(blockposition);
+diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
+index e45c061931c5ca03e204b78e60010a906d3ec945..e2e9545a583deb1e2bbdcb76e459d8bd481d5d77 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
+@@ -429,7 +429,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento
+ 
+     @Override
+     public boolean wantsToPickUp(ItemStack stack) {
+-        return this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) && this.canPickUpLoot() && PiglinAi.wantsToPickup(this, stack);
++        return (this.level().purpurConfig.piglinBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) && this.canPickUpLoot() && PiglinAi.wantsToPickup(this, stack);
+     }
+ 
+     protected boolean canReplaceCurrentItem(ItemStack stack) {
+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 251e6bc87eb02ec4372062ef22b21249ac5164ff..6b60597a0e837054b0d1891c1e6e5e7cd3af9539 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/LargeFireball.java
+@@ -16,20 +16,20 @@ public class LargeFireball extends Fireball {
+ 
+     public LargeFireball(EntityType<? extends LargeFireball> type, Level world) {
+         super(type, world);
+-        isIncendiary = this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // CraftBukkit
++        isIncendiary = this.level().purpurConfig.fireballsBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // CraftBukkit // Purpur
+     }
+ 
+     public LargeFireball(Level world, LivingEntity owner, double velocityX, double velocityY, double velocityZ, int explosionPower) {
+         super(EntityType.FIREBALL, owner, velocityX, velocityY, velocityZ, world);
+         this.explosionPower = explosionPower;
+-        isIncendiary = this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // CraftBukkit
++        isIncendiary = this.level().purpurConfig.fireballsBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // CraftBukkit // Purpur
+     }
+ 
+     @Override
+     protected void onHit(HitResult hitResult) {
+         super.onHit(hitResult);
+         if (!this.level().isClientSide) {
+-            boolean flag = this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
++            boolean flag = this.level().purpurConfig.fireballsBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // Purpur
+ 
+             // CraftBukkit start - fire ExplosionPrimeEvent
+             ExplosionPrimeEvent event = new ExplosionPrimeEvent((org.bukkit.entity.Explosive) this.getBukkitEntity());
+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 cd0629581bae5f805842157af36c2d838e01bee3..b0a559dfefac693bda8692a30fbaa5ac8062ef27 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -326,6 +326,6 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+     public boolean mayInteract(Level world, BlockPos pos) {
+         Entity entity = this.getOwner();
+ 
+-        return entity instanceof Player ? entity.mayInteract(world, pos) : entity == null || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
++        return entity instanceof Player ? entity.mayInteract(world, pos) : entity == null || world.purpurConfig.projectilesBypassMobGriefing || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+     }
+ }
+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 04c2ea1ff44af72ae48e2d6b7b912b1c14285038..7839d856b3f924f0c87b298d9a1e3b15ab0693d6 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/SmallFireball.java
+@@ -24,7 +24,7 @@ public class SmallFireball extends Fireball {
+         super(EntityType.SMALL_FIREBALL, owner, velocityX, velocityY, velocityZ, world);
+         // CraftBukkit start
+         if (this.getOwner() != null && this.getOwner() instanceof Mob) {
+-            isIncendiary = this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
++            isIncendiary = this.level().purpurConfig.fireballsBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING); // Purpur
+         }
+         // CraftBukkit end
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raider.java b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+index 57fdcdaf54fd1c92a6e51a3a81789029096e5abe..822dd4265ce02252afadbc652064450b7dfd7e0d 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raider.java
++++ b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+@@ -319,7 +319,7 @@ public abstract class Raider extends PatrollingMonster {
+ 
+         @Override
+         public boolean canUse() {
+-            if (!this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) || !this.mob.canPickUpLoot()) return false; // Paper - respect game and entity rules for picking up items
++            if ((!this.mob.level().purpurConfig.pillagerBypassMobGriefing && !this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) || !this.mob.canPickUpLoot()) return false; // Paper - respect game and entity rules for picking up items // Purpur
+             Raid raid = this.mob.getCurrentRaid();
+ 
+             if (this.mob.hasActiveRaid() && !this.mob.getCurrentRaid().isOver() && this.mob.canBeLeader() && !ItemStack.matches(this.mob.getItemBySlot(EquipmentSlot.HEAD), Raid.getLeaderBannerInstance())) {
+diff --git a/src/main/java/net/minecraft/world/level/block/CropBlock.java b/src/main/java/net/minecraft/world/level/block/CropBlock.java
+index decb8caa67bc5f4525e4d92fedf465a17171fceb..5ba5a510b30917235e135ccda1b7c98cb7dd93ec 100644
+--- a/src/main/java/net/minecraft/world/level/block/CropBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/CropBlock.java
+@@ -168,7 +168,7 @@ public class CropBlock extends BushBlock implements BonemealableBlock {
+     @Override
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+-        if (entity instanceof Ravager && CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { // CraftBukkit
++        if (entity instanceof Ravager && CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), (!world.purpurConfig.ravagerBypassMobGriefing && !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)))) { // CraftBukkit // Purpur
+             world.destroyBlock(pos, true, entity);
+         }
+ 
+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 7efae60a9a9269703a1fa7cd280b5b96557ec73e..e7b5f54d2fc53878e9466ccca972df21f10a7d67 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -101,7 +101,7 @@ public class FarmBlock extends Block {
+     @Override
+     public void fallOn(Level world, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+         super.fallOn(world, state, pos, entity, fallDistance); // CraftBukkit - moved here as game rules / events shouldn't affect fall damage.
+-        if (!world.isClientSide && world.random.nextFloat() < fallDistance - 0.5F && entity instanceof LivingEntity && (entity instanceof Player || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) && entity.getBbWidth() * entity.getBbWidth() * entity.getBbHeight() > 0.512F) {
++        if (!world.isClientSide && world.random.nextFloat() < fallDistance - 0.5F && entity instanceof LivingEntity && (entity instanceof Player || world.purpurConfig.farmlandBypassMobGriefing || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) && entity.getBbWidth() * entity.getBbWidth() * entity.getBbHeight() > 0.512F) { // Purpur
+             // CraftBukkit start - Interact soil
+             org.bukkit.event.Cancellable cancellable;
+             if (entity instanceof Player) {
+diff --git a/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java b/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java
+index 7e04ecba2a14be0f0d47c917368abd2a2bd64a05..5c944e39e611201c6ae4dad14511a54c451204f6 100644
+--- a/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java
+@@ -72,7 +72,7 @@ public class PowderSnowBlock extends Block implements BucketPickup {
+         if (!world.isClientSide) {
+             // CraftBukkit start
+             if (entity.isOnFire() && entity.mayInteract(world, pos)) {
+-                if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), !(world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) || entity instanceof Player))) {
++                if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), !((world.purpurConfig.powderSnowBypassMobGriefing || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) || entity instanceof Player))) {
+                     return;
+                 }
+                 // CraftBukkit end
+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 e53294e9c4bb3e832acbdc82bebc0df94523c7e4..86360fad47e4cda64b02ce4c8c0227649ed69a5d 100644
+--- a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+@@ -211,7 +211,7 @@ public class TurtleEggBlock extends Block {
+         }
+         if (entity instanceof Player) return true;
+ 
+-        return world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
++        return world.purpurConfig.turtleEggsBypassMobGriefing || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+         // Purpur end
+     }
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 2606c631d93c8e7b99b0ac1fffffa6b0ce388679..ce4855a70ad684c33420bf84c701fb46ad46e021 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -115,8 +115,11 @@ public class PurpurWorldConfig {
+     public boolean boatsDoFallDamage = false;
+     public boolean disableDropsOnCrammingDeath = false;
+     public boolean entitiesCanUsePortals = true;
++    public boolean entitiesPickUpLootBypassMobGriefing = false;
++    public boolean fireballsBypassMobGriefing = false;
+     public boolean milkCuresBadOmen = true;
+     public boolean persistentDroppableEntityDisplayNames = true;
++    public boolean projectilesBypassMobGriefing = false;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+@@ -128,8 +131,11 @@ public class PurpurWorldConfig {
+         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);
++        entitiesPickUpLootBypassMobGriefing = getBoolean("gameplay-mechanics.entities-pick-up-loot-bypass-mob-griefing", entitiesPickUpLootBypassMobGriefing);
++        fireballsBypassMobGriefing = getBoolean("gameplay-mechanics.fireballs-bypass-mob-griefing", fireballsBypassMobGriefing);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+         persistentDroppableEntityDisplayNames = getBoolean("gameplay-mechanics.persistent-droppable-entity-display-names", persistentDroppableEntityDisplayNames);
++        projectilesBypassMobGriefing = getBoolean("gameplay-mechanics.projectiles-bypass-mob-griefing", projectilesBypassMobGriefing);
+         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);
+@@ -448,9 +454,11 @@ public class PurpurWorldConfig {
+         dispenserPlaceAnvils = getBoolean("blocks.dispenser.place-anvils", dispenserPlaceAnvils);
+     }
+ 
++    public boolean farmlandBypassMobGriefing = false;
+     public boolean farmlandGetsMoistFromBelow = false;
+     public boolean farmlandAlpha = false;
+     private void farmlandSettings() {
++        farmlandBypassMobGriefing = getBoolean("blocks.farmland.bypass-mob-griefing", farmlandBypassMobGriefing);
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+         farmlandAlpha = getBoolean("blocks.farmland.use-alpha-farmland", farmlandAlpha);
+     }
+@@ -475,6 +483,11 @@ public class PurpurWorldConfig {
+         lavaSpeedNotNether = getInt("blocks.lava.speed.not-nether", lavaSpeedNotNether);
+     }
+ 
++    public boolean powderSnowBypassMobGriefing = false;
++    private void powderSnowSettings() {
++        powderSnowBypassMobGriefing = getBoolean("blocks.powder_snow.bypass-mob-griefing", powderSnowBypassMobGriefing);
++    }
++
+     public boolean respawnAnchorExplode = true;
+     public double respawnAnchorExplosionPower = 5.0D;
+     public boolean respawnAnchorExplosionFire = true;
+@@ -504,10 +517,12 @@ public class PurpurWorldConfig {
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;
++    public boolean turtleEggsBypassMobGriefing = false;
+     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);
++        turtleEggsBypassMobGriefing = getBoolean("blocks.turtle_egg.bypass-mob-griefing", turtleEggsBypassMobGriefing);
+     }
+ 
+     public int waterInfiniteRequiredSources = 2;
+@@ -741,6 +756,7 @@ public class PurpurWorldConfig {
+     public double creeperMaxHealth = 20.0D;
+     public double creeperChargedChance = 0.0D;
+     public boolean creeperAllowGriefing = true;
++    public boolean creeperBypassMobGriefing = false;
+     private void creeperSettings() {
+         creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
+         creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
+@@ -753,6 +769,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);
++        creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing);
+     }
+ 
+     public boolean dolphinRidable = false;
+@@ -847,6 +864,7 @@ public class PurpurWorldConfig {
+     public double enderDragonMaxY = 320D;
+     public double enderDragonMaxHealth = 200.0D;
+     public boolean enderDragonAlwaysDropsFullExp = false;
++    public boolean enderDragonBypassMobGriefing = false;
+     private void enderDragonSettings() {
+         enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable);
+         enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater);
+@@ -863,6 +881,7 @@ public class PurpurWorldConfig {
+         }
+         enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth);
+         enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp);
++        enderDragonBypassMobGriefing = getBoolean("mobs.ender_dragon.bypass-mob-griefing", enderDragonBypassMobGriefing);
+     }
+ 
+     public boolean endermanRidable = false;
+@@ -871,6 +890,7 @@ public class PurpurWorldConfig {
+     public double endermanMaxHealth = 40.0D;
+     public boolean endermanAllowGriefing = true;
+     public boolean endermanDespawnEvenWithBlock = false;
++    public boolean endermanBypassMobGriefing = false;
+     private void endermanSettings() {
+         endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
+         endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
+@@ -883,6 +903,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);
++        endermanBypassMobGriefing = getBoolean("mobs.enderman.bypass-mob-griefing", endermanBypassMobGriefing);
+     }
+ 
+     public boolean endermiteRidable = false;
+@@ -905,6 +926,7 @@ public class PurpurWorldConfig {
+     public boolean evokerRidableInWater = true;
+     public boolean evokerControllable = true;
+     public double evokerMaxHealth = 24.0D;
++    public boolean evokerBypassMobGriefing = false;
+     private void evokerSettings() {
+         evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable);
+         evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater);
+@@ -915,6 +937,7 @@ public class PurpurWorldConfig {
+             set("mobs.evoker.attributes.max_health", oldValue);
+         }
+         evokerMaxHealth = getDouble("mobs.evoker.attributes.max_health", evokerMaxHealth);
++        evokerBypassMobGriefing = getBoolean("mobs.evoker.bypass-mob-griefing", evokerBypassMobGriefing);
+     }
+ 
+     public boolean foxRidable = false;
+@@ -923,6 +946,7 @@ public class PurpurWorldConfig {
+     public double foxMaxHealth = 10.0D;
+     public boolean foxTypeChangesWithTulips = false;
+     public int foxBreedingTicks = 6000;
++    public boolean foxBypassMobGriefing = false;
+     private void foxSettings() {
+         foxRidable = getBoolean("mobs.fox.ridable", foxRidable);
+         foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater);
+@@ -935,6 +959,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);
++        foxBypassMobGriefing = getBoolean("mobs.fox.bypass-mob-griefing", foxBypassMobGriefing);
+     }
+ 
+     public boolean frogRidable = false;
+@@ -1382,6 +1407,7 @@ public class PurpurWorldConfig {
+     public boolean piglinRidableInWater = true;
+     public boolean piglinControllable = true;
+     public double piglinMaxHealth = 16.0D;
++    public boolean piglinBypassMobGriefing = false;
+     private void piglinSettings() {
+         piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable);
+         piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater);
+@@ -1392,6 +1418,7 @@ public class PurpurWorldConfig {
+             set("mobs.piglin.attributes.max_health", oldValue);
+         }
+         piglinMaxHealth = getDouble("mobs.piglin.attributes.max_health", piglinMaxHealth);
++        piglinBypassMobGriefing = getBoolean("mobs.piglin.bypass-mob-griefing", piglinBypassMobGriefing);
+     }
+ 
+     public boolean piglinBruteRidable = false;
+@@ -1414,6 +1441,7 @@ public class PurpurWorldConfig {
+     public boolean pillagerRidableInWater = true;
+     public boolean pillagerControllable = true;
+     public double pillagerMaxHealth = 24.0D;
++    public boolean pillagerBypassMobGriefing = false;
+     private void pillagerSettings() {
+         pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable);
+         pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater);
+@@ -1424,6 +1452,7 @@ public class PurpurWorldConfig {
+             set("mobs.pillager.attributes.max_health", oldValue);
+         }
+         pillagerMaxHealth = getDouble("mobs.pillager.attributes.max_health", pillagerMaxHealth);
++        pillagerBypassMobGriefing = getBoolean("mobs.pillager.bypass-mob-griefing", pillagerBypassMobGriefing);
+     }
+ 
+     public boolean polarBearRidable = false;
+@@ -1470,6 +1499,7 @@ public class PurpurWorldConfig {
+     public double rabbitNaturalToast = 0.0D;
+     public double rabbitNaturalKiller = 0.0D;
+     public int rabbitBreedingTicks = 6000;
++    public boolean rabbitBypassMobGriefing = false;
+     private void rabbitSettings() {
+         rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable);
+         rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater);
+@@ -1483,12 +1513,14 @@ public class PurpurWorldConfig {
+         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);
++        rabbitBypassMobGriefing = getBoolean("mobs.rabbit.bypass-mob-griefing", rabbitBypassMobGriefing);
+     }
+ 
+     public boolean ravagerRidable = false;
+     public boolean ravagerRidableInWater = false;
+     public boolean ravagerControllable = true;
+     public double ravagerMaxHealth = 100.0D;
++    public boolean ravagerBypassMobGriefing = false;
+     private void ravagerSettings() {
+         ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable);
+         ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater);
+@@ -1499,6 +1531,7 @@ public class PurpurWorldConfig {
+             set("mobs.ravager.attributes.max_health", oldValue);
+         }
+         ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth);
++        ravagerBypassMobGriefing = getBoolean("mobs.ravager.bypass-mob-griefing", ravagerBypassMobGriefing);
+     }
+ 
+     public boolean salmonRidable = false;
+@@ -1520,6 +1553,7 @@ public class PurpurWorldConfig {
+     public boolean sheepControllable = true;
+     public double sheepMaxHealth = 8.0D;
+     public int sheepBreedingTicks = 6000;
++    public boolean sheepBypassMobGriefing = false;
+     private void sheepSettings() {
+         sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable);
+         sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater);
+@@ -1531,6 +1565,7 @@ public class PurpurWorldConfig {
+         }
+         sheepMaxHealth = getDouble("mobs.sheep.attributes.max_health", sheepMaxHealth);
+         sheepBreedingTicks = getInt("mobs.sheep.breeding-delay-ticks", sheepBreedingTicks);
++        sheepBypassMobGriefing = getBoolean("mobs.sheep.bypass-mob-griefing", sheepBypassMobGriefing);
+     }
+ 
+     public boolean shulkerRidable = false;
+@@ -1553,6 +1588,7 @@ public class PurpurWorldConfig {
+     public boolean silverfishRidableInWater = true;
+     public boolean silverfishControllable = true;
+     public double silverfishMaxHealth = 8.0D;
++    public boolean silverfishBypassMobGriefing = false;
+     private void silverfishSettings() {
+         silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable);
+         silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater);
+@@ -1563,6 +1599,7 @@ public class PurpurWorldConfig {
+             set("mobs.silverfish.attributes.max_health", oldValue);
+         }
+         silverfishMaxHealth = getDouble("mobs.silverfish.attributes.max_health", silverfishMaxHealth);
++        silverfishBypassMobGriefing = getBoolean("mobs.silverfish.bypass-mob-griefing", silverfishBypassMobGriefing);
+     }
+ 
+     public boolean skeletonRidable = false;
+@@ -1639,6 +1676,7 @@ public class PurpurWorldConfig {
+     public int snowGolemSnowBallMax = 20;
+     public float snowGolemSnowBallModifier = 10.0F;
+     public double snowGolemAttackDistance = 1.25D;
++    public boolean snowGolemBypassMobGriefing = false;
+     private void snowGolemSettings() {
+         snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable);
+         snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater);
+@@ -1656,6 +1694,7 @@ public class PurpurWorldConfig {
+         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);
++        snowGolemBypassMobGriefing = getBoolean("mobs.snow_golem.bypass-mob-griefing", snowGolemBypassMobGriefing);
+     }
+ 
+     public boolean snifferRidable = false;
+@@ -1842,6 +1881,7 @@ public class PurpurWorldConfig {
+     public int villagerBreedingTicks = 6000;
+     public boolean villagerClericsFarmWarts = false;
+     public boolean villagerClericFarmersThrowWarts = true;
++    public boolean villagerBypassMobGriefing = false;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -1858,6 +1898,7 @@ public class PurpurWorldConfig {
+         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);
++        villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -1930,6 +1971,7 @@ public class PurpurWorldConfig {
+     public double witherMaxHealth = 300.0D;
+     public float witherHealthRegenAmount = 1.0f;
+     public int witherHealthRegenDelay = 20;
++    public boolean witherBypassMobGriefing = false;
+     private void witherSettings() {
+         witherRidable = getBoolean("mobs.wither.ridable", witherRidable);
+         witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater);
+@@ -1947,6 +1989,7 @@ public class PurpurWorldConfig {
+         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);
++        witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing);
+     }
+ 
+     public boolean witherSkeletonRidable = false;
+@@ -2018,6 +2061,7 @@ public class PurpurWorldConfig {
+     public double zombieJockeyChance = 0.05D;
+     public boolean zombieJockeyTryExistingChickens = true;
+     public boolean zombieAggressiveTowardsVillagerWhenLagging = true;
++    public boolean zombieBypassMobGriefing = false;
+     private void zombieSettings() {
+         zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable);
+         zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater);
+@@ -2033,6 +2077,7 @@ public class PurpurWorldConfig {
+         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);
++        zombieBypassMobGriefing = getBoolean("mobs.zombie.bypass-mob-griefing", zombieBypassMobGriefing);
+     }
+ 
+     public boolean zombieHorseRidableInWater = false;

patches/unapplied/server/0124-Config-to-allow-Note-Block-sounds-when-blocked.patch

@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Fri, 8 Jan 2021 16:07:32 -0500
+Subject: [PATCH] Config to allow Note Block sounds when blocked
+
+Allows for Note Blocks to ignore whether or not there's air above them to play.
+
+Normally, the sounds will only play when the block directly above is air.
+With this patch enabled, players can place any block above the Note Block and it will still work.
+
+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 e46d84750bdd7c940f400efda226e12a3fdc3848..6343cd0c33cafb30225cfae17ea1cf15859073b1 100644
+--- a/src/main/java/net/minecraft/world/level/block/NoteBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+@@ -87,7 +87,7 @@ public class NoteBlock extends Block {
+     }
+ 
+     private void playNote(@Nullable Entity entity, BlockState state, Level world, BlockPos pos) {
+-        if (((NoteBlockInstrument) state.getValue(NoteBlock.INSTRUMENT)).worksAboveNoteBlock() || world.getBlockState(pos.above()).isAir()) {
++        if (world.purpurConfig.noteBlockIgnoreAbove || ((NoteBlockInstrument) state.getValue(NoteBlock.INSTRUMENT)).worksAboveNoteBlock() || world.getBlockState(pos.above()).isAir()) { // Purpur
+             // CraftBukkit start
+             // org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, pos, state.getValue(NoteBlock.INSTRUMENT), state.getValue(NoteBlock.NOTE));
+             // if (event.isCancelled()) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ce4855a70ad684c33420bf84c701fb46ad46e021..028b6aa20c2d83d8a4eb7dabccc4f2451723000e 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -118,6 +118,7 @@ public class PurpurWorldConfig {
+     public boolean entitiesPickUpLootBypassMobGriefing = false;
+     public boolean fireballsBypassMobGriefing = false;
+     public boolean milkCuresBadOmen = true;
++    public boolean noteBlockIgnoreAbove = false;
+     public boolean persistentDroppableEntityDisplayNames = true;
+     public boolean projectilesBypassMobGriefing = false;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+@@ -134,6 +135,7 @@ public class PurpurWorldConfig {
+         entitiesPickUpLootBypassMobGriefing = getBoolean("gameplay-mechanics.entities-pick-up-loot-bypass-mob-griefing", entitiesPickUpLootBypassMobGriefing);
+         fireballsBypassMobGriefing = getBoolean("gameplay-mechanics.fireballs-bypass-mob-griefing", fireballsBypassMobGriefing);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
++        noteBlockIgnoreAbove = getBoolean("gameplay-mechanics.note-block-ignore-above", noteBlockIgnoreAbove);
+         persistentDroppableEntityDisplayNames = getBoolean("gameplay-mechanics.persistent-droppable-entity-display-names", persistentDroppableEntityDisplayNames);
+         projectilesBypassMobGriefing = getBoolean("gameplay-mechanics.projectiles-bypass-mob-griefing", projectilesBypassMobGriefing);
+         tridentLoyaltyVoidReturnHeight = getDouble("gameplay-mechanics.trident-loyalty-void-return-height", tridentLoyaltyVoidReturnHeight);

patches/unapplied/server/0125-Add-EntityTeleportHinderedEvent.patch

@@ -0,0 +1,125 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 9 Jan 2021 15:27:46 +0100
+Subject: [PATCH] Add EntityTeleportHinderedEvent
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+diff --git a/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java b/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
+index 41d7cff39fc37955877668337689b4b26cd8c7cf..f80f6da484f4144e743079e5104bf503419074b2 100644
+--- a/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
+@@ -46,6 +46,14 @@ public class EndPortalBlock extends BaseEntityBlock {
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (world instanceof ServerLevel && entity.canChangeDimensions() && Shapes.joinIsNotEmpty(Shapes.create(entity.getBoundingBox().move((double) (-pos.getX()), (double) (-pos.getY()), (double) (-pos.getZ()))), state.getShape(world, pos), BooleanOp.AND)) {
++            // Purpur start
++            if (entity.isPassenger() || entity.isVehicle()) {
++                if (new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), entity.isPassenger() ? org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_PASSENGER : org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, PlayerTeleportEvent.TeleportCause.END_PORTAL).callEvent()) {
++                    this.entityInside(state, world, pos, entity);
++                }
++                return;
++            }
++            // Purpur end
+             ResourceKey<Level> resourcekey = world.getTypeKey() == LevelStem.END ? Level.OVERWORLD : Level.END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
+             ServerLevel worldserver = ((ServerLevel) world).getServer().getLevel(resourcekey);
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java b/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
+index a6ab0d0defc05e56a91084c49897059670a1324b..2c085c4a154cb0f8a1d38453f43474a764398784 100644
+--- a/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
+@@ -84,6 +84,14 @@ public class NetherPortalBlock extends Block {
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (entity.canChangeDimensions()) {
++            // Purpur start
++            if (entity.isPassenger() || entity.isVehicle()) {
++                if (new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), entity.isPassenger() ? org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_PASSENGER : org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.NETHER_PORTAL).callEvent()) {
++                    this.entityInside(state, world, pos, entity);
++                }
++                return;
++            }
++            // Purpur end
+             // CraftBukkit start - Entity in portal
+             EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), pos.getX(), pos.getY(), pos.getZ()));
+             world.getCraftServer().getPluginManager().callEvent(event);
+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 9717b37aef9f487502e696c209ae209ab3b8f000..7291e4056b8e46ab59b71818388ac55fbb12993f 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
+@@ -178,6 +178,14 @@ 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
++            // Purpur start
++            if (world.purpurConfig.imposeTeleportRestrictionsOnGateways && (entity.isVehicle() || entity.isPassenger())) {
++                if (new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), entity.isPassenger() ? org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_PASSENGER : org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, PlayerTeleportEvent.TeleportCause.END_GATEWAY).callEvent()) {
++                    teleportEntity(world, pos, state, entity, blockEntity);
++                }
++                return;
++            }
++            // Purpur end
+             ServerLevel worldserver = (ServerLevel) world;
+ 
+             blockEntity.teleportCooldown = 100;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 912d9e4b3168cf89bd263ba63e049a791beefc90..283836981f5ed94dfc8999c3c5450213a1f2cfc1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -601,6 +601,10 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         // Paper end
+ 
+         if ((!ignorePassengers && this.entity.isVehicle()) || this.entity.isRemoved()) { // Paper - Teleport passenger API
++            // Purpur start
++            if (!entity.isRemoved() && new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, cause).callEvent())
++                return teleport(location, cause);
++            // Purpur end
+             return false;
+         }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index c6ede1fac5c68f2912a9c401765bd10b09afe7f9..5965b4e91e63a3d3b64e5193399ae3b6d774120b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1355,6 +1355,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+ 
+         if (entity.isVehicle() && !ignorePassengers) { // Paper - Teleport API
++            // Purpur start
++            if (new org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent(entity.getBukkitEntity(), org.purpurmc.purpur.event.entity.EntityTeleportHinderedEvent.Reason.IS_VEHICLE, cause).callEvent())
++                return teleport(location, cause);
++            // Purpur end
+             return false;
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 028b6aa20c2d83d8a4eb7dabccc4f2451723000e..f047edb4f52efaaa89463af0c4741b404459f6c4 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -117,6 +117,7 @@ public class PurpurWorldConfig {
+     public boolean entitiesCanUsePortals = true;
+     public boolean entitiesPickUpLootBypassMobGriefing = false;
+     public boolean fireballsBypassMobGriefing = false;
++    public boolean imposeTeleportRestrictionsOnGateways = false;
+     public boolean milkCuresBadOmen = true;
+     public boolean noteBlockIgnoreAbove = false;
+     public boolean persistentDroppableEntityDisplayNames = true;
+@@ -134,6 +135,7 @@ public class PurpurWorldConfig {
+         entitiesCanUsePortals = getBoolean("gameplay-mechanics.entities-can-use-portals", entitiesCanUsePortals);
+         entitiesPickUpLootBypassMobGriefing = getBoolean("gameplay-mechanics.entities-pick-up-loot-bypass-mob-griefing", entitiesPickUpLootBypassMobGriefing);
+         fireballsBypassMobGriefing = getBoolean("gameplay-mechanics.fireballs-bypass-mob-griefing", fireballsBypassMobGriefing);
++        imposeTeleportRestrictionsOnGateways = getBoolean("gameplay-mechanics.impose-teleport-restrictions-on-gateways", imposeTeleportRestrictionsOnGateways);
+         milkCuresBadOmen = getBoolean("gameplay-mechanics.milk-cures-bad-omen", milkCuresBadOmen);
+         noteBlockIgnoreAbove = getBoolean("gameplay-mechanics.note-block-ignore-above", noteBlockIgnoreAbove);
+         persistentDroppableEntityDisplayNames = getBoolean("gameplay-mechanics.persistent-droppable-entity-display-names", persistentDroppableEntityDisplayNames);

patches/unapplied/server/0126-Farmland-trampling-changes.patch

@@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 9 Jan 2021 16:06:40 +0100
+Subject: [PATCH] Farmland trampling changes
+
+This lets us choose if farmland trampling is fully disabled or only
+players may trample farmland.
+
+This lets us choose if entities can stop trampling if they fall a
+distance equal to their feather falling level, plus the extra block
+necessary to trample in the first place. Feather Falling 1 requires
+you to fall over 3+ blocks to trample. FF 2 requires 4+, etc.
+
+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 e7b5f54d2fc53878e9466ccca972df21f10a7d67..56e66fcd840d0d3681ba671d1ffc51b232631461 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -116,12 +116,20 @@ public class FarmBlock extends Block {
+             }
+ 
+             // Purpur start
++            if (world.purpurConfig.farmlandTramplingDisabled) return;
++            if (world.purpurConfig.farmlandTramplingOnlyPlayers && !(entity instanceof Player)) return;
+             if (world.purpurConfig.farmlandAlpha) {
+                 Block block = world.getBlockState(pos.below()).getBlock();
+                 if (block instanceof FenceBlock || block instanceof WallBlock) {
+                     return;
+                 }
+             }
++            if (world.purpurConfig.farmlandTramplingFeatherFalling) {
++                Iterator<net.minecraft.world.item.ItemStack> armor = entity.getArmorSlots().iterator();
++                if (armor.hasNext() && net.minecraft.world.item.enchantment.EnchantmentHelper.getItemEnchantmentLevel(net.minecraft.world.item.enchantment.Enchantments.FALL_PROTECTION, armor.next()) >= (int) entity.fallDistance) {
++                    return;
++                }
++            }
+             // Purpur end
+             if (!CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.DIRT.defaultBlockState())) {
+                 return;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f047edb4f52efaaa89463af0c4741b404459f6c4..afd1db5d51690191ad3836dfe8de305b1c1a29f0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -461,10 +461,16 @@ public class PurpurWorldConfig {
+     public boolean farmlandBypassMobGriefing = false;
+     public boolean farmlandGetsMoistFromBelow = false;
+     public boolean farmlandAlpha = false;
++    public boolean farmlandTramplingDisabled = false;
++    public boolean farmlandTramplingOnlyPlayers = false;
++    public boolean farmlandTramplingFeatherFalling = false;
+     private void farmlandSettings() {
+         farmlandBypassMobGriefing = getBoolean("blocks.farmland.bypass-mob-griefing", farmlandBypassMobGriefing);
+         farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
+         farmlandAlpha = getBoolean("blocks.farmland.use-alpha-farmland", farmlandAlpha);
++        farmlandTramplingDisabled = getBoolean("blocks.farmland.disable-trampling", farmlandTramplingDisabled);
++        farmlandTramplingOnlyPlayers = getBoolean("blocks.farmland.only-players-trample", farmlandTramplingOnlyPlayers);
++        farmlandTramplingFeatherFalling = getBoolean("blocks.farmland.feather-fall-distance-affects-trampling", farmlandTramplingFeatherFalling);
+     }
+ 
+     public boolean furnaceUseLavaFromUnderneath = false;

patches/unapplied/server/0127-Movement-options-for-armor-stands.patch

@@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 9 Jan 2021 22:22:59 +0100
+Subject: [PATCH] Movement options for armor stands
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 105b093cd0353a45197615e9fcdf06e72a0aad00..e45f4570ef8334f319dcee39e2f343b91da62fce 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1876,7 +1876,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         return this.isInWater() || flag;
+     }
+ 
+-    void updateInWaterStateAndDoWaterCurrentPushing() {
++    public void updateInWaterStateAndDoWaterCurrentPushing() { // Purpur - package-private -> public
+         Entity entity = this.getVehicle();
+ 
+         if (entity instanceof Boat) {
+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 76222084727c269d376d0df5702204c0bdf59d81..b48a3d318a14889c68a1de5c1997b1090aab4029 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -99,10 +99,12 @@ public class ArmorStand extends LivingEntity {
+     private boolean noTickPoseDirty = false;
+     private boolean noTickEquipmentDirty = false;
+     // Paper end
++    public boolean canMovementTick = true; // Purpur
+ 
+     public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
+         super(type, world);
+         if (world != null) this.canTick = world.paperConfig().entities.armorStands.tick; // Paper - armour stand ticking
++        if (world != null) this.canMovementTick = world.purpurConfig.armorstandMovement; // Purpur
+         this.handItems = NonNullList.withSize(2, ItemStack.EMPTY);
+         this.armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
+         this.headPose = ArmorStand.DEFAULT_HEAD_POSE;
+@@ -1017,4 +1019,18 @@ public class ArmorStand extends LivingEntity {
+     }
+     // Paper end
+     // Paper end
++
++    // Purpur start
++    @Override
++    public void updateInWaterStateAndDoWaterCurrentPushing() {
++        if (this.level().purpurConfig.armorstandWaterMovement &&
++                (this.level().purpurConfig.armorstandWaterFence || !(level().getBlockState(blockPosition().below()).getBlock() instanceof net.minecraft.world.level.block.FenceBlock)))
++            super.updateInWaterStateAndDoWaterCurrentPushing();
++    }
++
++    @Override
++    public void aiStep() {
++        if (this.canMovementTick && this.canMove) super.aiStep();
++    }
++    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index afd1db5d51690191ad3836dfe8de305b1c1a29f0..14e708b579fc8cbb648fc01d96439a05a6abe239 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -99,10 +99,16 @@ public class PurpurWorldConfig {
+     public float armorstandStepHeight = 0.0F;
+     public boolean armorstandSetNameVisible = true;
+     public boolean armorstandFixNametags = false;
++    public boolean armorstandMovement = true;
++    public boolean armorstandWaterMovement = true;
++    public boolean armorstandWaterFence = true;
+     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);
++        armorstandMovement = getBoolean("gameplay-mechanics.armorstand.can-movement-tick", armorstandMovement);
++        armorstandWaterMovement = getBoolean("gameplay-mechanics.armorstand.can-move-in-water", armorstandWaterMovement);
++        armorstandWaterFence = getBoolean("gameplay-mechanics.armorstand.can-move-in-water-over-fence", armorstandWaterFence);
+     }
+ 
+     public boolean arrowMovementResetsDespawnCounter = true;

patches/unapplied/server/0128-Fix-stuck-in-portals.patch

@@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Thu, 14 Jan 2021 16:48:10 -0600
+Subject: [PATCH] Fix stuck in portals
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index de7c199c0df87a1c1a0157328fa52351f74a0d3d..540c7b650deefa4a1a0e4f86650d9f3c56091566 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1272,6 +1272,7 @@ public class ServerPlayer extends Player {
+                 playerlist.sendPlayerPermissionLevel(this);
+                 worldserver1.removePlayerImmediately(this, Entity.RemovalReason.CHANGED_DIMENSION);
+                 this.unsetRemoved();
++                this.portalPos = io.papermc.paper.util.MCUtil.toBlockPosition(exit); // Purpur
+ 
+                 // CraftBukkit end
+                 this.setServerLevel(worldserver);
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index e45f4570ef8334f319dcee39e2f343b91da62fce..36e9b635f81f2799cd210075bced9e976a90a351 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3060,12 +3060,15 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         return Vec3.directionFromRotation(this.getRotationVector());
+     }
+ 
++    public BlockPos portalPos = BlockPos.ZERO; // Purpur
+     public void handleInsidePortal(BlockPos pos) {
+         if (this.isOnPortalCooldown()) {
++            if (!(level().purpurConfig.playerFixStuckPortal && this instanceof Player && !pos.equals(portalPos))) // Purpur
+             this.setPortalCooldown();
+         } else if (level().purpurConfig.entitiesCanUsePortals || this instanceof ServerPlayer) { // Purpur
+             if (!this.level().isClientSide && !pos.equals(this.portalEntrancePos)) {
+                 this.portalEntrancePos = pos.immutable();
++                portalPos = BlockPos.ZERO; // Purpur
+             }
+ 
+             this.isInsidePortal = true;
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 14e708b579fc8cbb648fc01d96439a05a6abe239..c72af60345ac9704118ff9d19295d1a663a1e985 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -335,6 +335,7 @@ public class PurpurWorldConfig {
+     public int playerDeathExpDropMax = 100;
+     public boolean teleportIfOutsideBorder = false;
+     public boolean totemOfUndyingWorksInInventory = false;
++    public boolean playerFixStuckPortal = false;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -352,6 +353,7 @@ public class PurpurWorldConfig {
+         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);
++        playerFixStuckPortal = getBoolean("gameplay-mechanics.player.fix-stuck-in-portal", playerFixStuckPortal);
+     }
+ 
+     private static boolean projectileDespawnRateSettingsMigrated = false;

patches/unapplied/server/0130-Config-to-always-tame-in-Creative.patch

@@ -0,0 +1,80 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 9 Feb 2021 21:23:37 -0500
+Subject: [PATCH] Config to always tame in Creative
+
+Adds a configuration option that ensures a player in Creative always tames a tameable entity.
+This essentially allows Creative mode players to tame animals on their first try.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/RunAroundLikeCrazyGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/RunAroundLikeCrazyGoal.java
+index 7fc5b5d624b61a3de9c71e975b51d20c5800be00..8fb070b1ae11d34b2fa420ded58097d421263cab 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/RunAroundLikeCrazyGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/RunAroundLikeCrazyGoal.java
+@@ -66,7 +66,7 @@ public class RunAroundLikeCrazyGoal extends Goal {
+                 int i = this.horse.getTemper();
+                 int j = this.horse.getMaxTemper();
+ 
+-                if (j > 0 && this.horse.getRandom().nextInt(j) < i && !CraftEventFactory.callEntityTameEvent(this.horse, ((CraftHumanEntity) this.horse.getBukkitEntity().getPassenger()).getHandle()).isCancelled()) { // CraftBukkit - fire EntityTameEvent
++                if ((this.horse.level().purpurConfig.alwaysTameInCreative && ((Player) entity).getAbilities().instabuild) || (j > 0 && this.horse.getRandom().nextInt(j) < i && !CraftEventFactory.callEntityTameEvent(this.horse, ((CraftHumanEntity) this.horse.getBukkitEntity().getPassenger()).getHandle()).isCancelled())) { // CraftBukkit - fire EntityTameEvent // Purpur
+                     this.horse.tameWithName((Player) entity);
+                     return;
+                 }
+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 1554e4a0e068e06ec121adf56421f8332132f062..7f1763b820a0c5dc69bdf6cdf14a97a283ba5916 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -470,7 +470,7 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
+                 }
+             } else if (this.isFood(itemstack)) {
+                 this.usePlayerItem(player, hand, itemstack);
+-                if (this.random.nextInt(3) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit
++                if ((this.level().purpurConfig.alwaysTameInCreative && player.getAbilities().instabuild) || (this.random.nextInt(3) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled())) { // CraftBukkit // Purpur
+                     this.tame(player);
+                     this.setOrderedToSit(true);
+                     this.level().broadcastEntityEvent(this, (byte) 7);
+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 583cbd4e891647d974b3ca4fc51d4aae6d2acb88..4c64feca8d78b907406cc409bd6beef4b3bd35f3 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Parrot.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Parrot.java
+@@ -334,7 +334,7 @@ public class Parrot extends ShoulderRidingEntity implements VariantHolder<Parrot
+             }
+ 
+             if (!this.level().isClientSide) {
+-                if (this.random.nextInt(10) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) { // CraftBukkit
++                if ((this.level().purpurConfig.alwaysTameInCreative && player.getAbilities().instabuild) || (this.random.nextInt(10) == 0 && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTameEvent(this, player).isCancelled())) { // CraftBukkit // Purpur
+                     this.tame(player);
+                     this.level().broadcastEntityEvent(this, (byte) 7);
+                 } else {
+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 f3c3db958c359b3b032bd54c7732f16fce108ec3..c967302542eeac0bad33c3b53b7d5b2aea7defbb 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -530,7 +530,7 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+             }
+ 
+             // CraftBukkit - added event call and isCancelled check.
+-            if (this.random.nextInt(3) == 0 && !CraftEventFactory.callEntityTameEvent(this, player).isCancelled()) {
++            if ((this.level().purpurConfig.alwaysTameInCreative && player.getAbilities().instabuild) || (this.random.nextInt(3) == 0 && !CraftEventFactory.callEntityTameEvent(this, player).isCancelled())) { // Purpur
+                 this.tame(player);
+                 this.navigation.stop();
+                 this.setTarget((LivingEntity) null);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index d077e5c5bc108d7ad37caf8339be449fe27960a1..9f136f87117de89eac06da9e79fb844b20fe5967 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -117,6 +117,7 @@ public class PurpurWorldConfig {
+     }
+ 
+     public boolean useBetterMending = false;
++    public boolean alwaysTameInCreative = false;
+     public boolean boatEjectPlayersOnLand = false;
+     public boolean boatsDoFallDamage = false;
+     public boolean disableDropsOnCrammingDeath = false;
+@@ -135,6 +136,7 @@ public class PurpurWorldConfig {
+     public int animalBreedingCooldownSeconds = 0;
+     private void miscGameplayMechanicsSettings() {
+         useBetterMending = getBoolean("gameplay-mechanics.use-better-mending", useBetterMending);
++        alwaysTameInCreative = getBoolean("gameplay-mechanics.always-tame-in-creative", alwaysTameInCreative);
+         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);

patches/unapplied/server/0131-End-crystal-explosion-options.patch

@@ -0,0 +1,102 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Sat, 13 Feb 2021 09:28:56 -0500
+Subject: [PATCH] End crystal explosion options
+
+
+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 ef0098e46bda8abc456f2bb5929d874c6aeb8698..564d17bc460e2a04947ff9676fbf4c8b1569659c 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
+@@ -48,6 +48,22 @@ public class EndCrystal extends Entity {
+         this.setPos(x, y, z);
+     }
+ 
++    public boolean shouldExplode() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplode : level().purpurConfig.baselessEndCrystalExplode;
++    }
++
++    public float getExplosionPower() {
++        return (float) (showsBottom() ? level().purpurConfig.basedEndCrystalExplosionPower : level().purpurConfig.baselessEndCrystalExplosionPower);
++    }
++
++    public boolean hasExplosionFire() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplosionFire : level().purpurConfig.baselessEndCrystalExplosionFire;
++    }
++
++    public Level.ExplosionInteraction getExplosionEffect() {
++        return showsBottom() ? level().purpurConfig.basedEndCrystalExplosionEffect : level().purpurConfig.baselessEndCrystalExplosionEffect;
++    }
++
+     @Override
+     protected Entity.MovementEmission getMovementEmission() {
+         return Entity.MovementEmission.NONE;
+@@ -173,16 +189,18 @@ public class EndCrystal extends Entity {
+                 // CraftBukkit end
+                 this.remove(Entity.RemovalReason.KILLED);
+                 if (!source.is(DamageTypeTags.IS_EXPLOSION)) {
++                    if (shouldExplode()) {// Purpur
+                     DamageSource damagesource1 = source.getEntity() != null ? this.damageSources().explosion(this, source.getEntity()) : null;
+ 
+                     // CraftBukkit start
+-                    ExplosionPrimeEvent event = CraftEventFactory.callExplosionPrimeEvent(this, 6.0F, false);
++                    ExplosionPrimeEvent event = CraftEventFactory.callExplosionPrimeEvent(this, getExplosionPower(), hasExplosionFire()); // Purpur
+                     if (event.isCancelled()) {
+                         this.unsetRemoved();
+                         return false;
+                     }
+-                    this.level().explode(this, damagesource1, (ExplosionDamageCalculator) null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), Level.ExplosionInteraction.BLOCK);
++                    this.level().explode(this, damagesource1, (ExplosionDamageCalculator) null, this.getX(), this.getY(), this.getZ(), event.getRadius(), event.getFire(), getExplosionEffect()); // Purpur
+                     // CraftBukkit end
++                    } else this.unsetRemoved(); // Purpur
+                 }
+ 
+                 this.onDestroyedBy(source);
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 9f136f87117de89eac06da9e79fb844b20fe5967..b16a62ea9e57d4114fc9f0c5c9fce0c14983cea0 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -468,6 +468,43 @@ public class PurpurWorldConfig {
+         dispenserPlaceAnvils = getBoolean("blocks.dispenser.place-anvils", dispenserPlaceAnvils);
+     }
+ 
++    public boolean baselessEndCrystalExplode = true;
++    public double baselessEndCrystalExplosionPower = 6.0D;
++    public boolean baselessEndCrystalExplosionFire = false;
++    public net.minecraft.world.level.Level.ExplosionInteraction baselessEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++    public boolean basedEndCrystalExplode = true;
++    public double basedEndCrystalExplosionPower = 6.0D;
++    public boolean basedEndCrystalExplosionFire = false;
++    public net.minecraft.world.level.Level.ExplosionInteraction basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++    private void endCrystalSettings() {
++        if (PurpurConfig.version < 31) {
++            if ("DESTROY".equals(getString("blocks.end-crystal.baseless.explosion-effect", baselessEndCrystalExplosionEffect.name()))) {
++                set("blocks.end-crystal.baseless.explosion-effect", "BLOCK");
++            }
++            if ("DESTROY".equals(getString("blocks.end-crystal.base.explosion-effect", basedEndCrystalExplosionEffect.name()))) {
++                set("blocks.end-crystal.base.explosion-effect", "BLOCK");
++            }
++        }
++        baselessEndCrystalExplode = getBoolean("blocks.end-crystal.baseless.explode", baselessEndCrystalExplode);
++        baselessEndCrystalExplosionPower = getDouble("blocks.end-crystal.baseless.explosion-power", baselessEndCrystalExplosionPower);
++        baselessEndCrystalExplosionFire = getBoolean("blocks.end-crystal.baseless.explosion-fire", baselessEndCrystalExplosionFire);
++        try {
++            baselessEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.valueOf(getString("blocks.end-crystal.baseless.explosion-effect", baselessEndCrystalExplosionEffect.name()));
++        } catch (IllegalArgumentException e) {
++            log(Level.SEVERE, "Unknown value for `blocks.end-crystal.baseless.explosion-effect`! Using default of `BLOCK`");
++            baselessEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++        }
++        basedEndCrystalExplode = getBoolean("blocks.end-crystal.base.explode", basedEndCrystalExplode);
++        basedEndCrystalExplosionPower = getDouble("blocks.end-crystal.base.explosion-power", basedEndCrystalExplosionPower);
++        basedEndCrystalExplosionFire = getBoolean("blocks.end-crystal.base.explosion-fire", basedEndCrystalExplosionFire);
++        try {
++            basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.valueOf(getString("blocks.end-crystal.base.explosion-effect", basedEndCrystalExplosionEffect.name()));
++        } catch (IllegalArgumentException e) {
++            log(Level.SEVERE, "Unknown value for `blocks.end-crystal.base.explosion-effect`! Using default of `BLOCK`");
++            basedEndCrystalExplosionEffect = net.minecraft.world.level.Level.ExplosionInteraction.BLOCK;
++        }
++    }
++
+     public boolean farmlandBypassMobGriefing = false;
+     public boolean farmlandGetsMoistFromBelow = false;
+     public boolean farmlandAlpha = false;

patches/unapplied/server/0132-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Sat, 20 Feb 2021 14:47:08 -0800
+Subject: [PATCH] Configs for if Wither/Ender Dragon can ride vehicles
+
+
+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 9986dbe52ad38fcc0f642401a932428afc39c9f6..a907930813b0a3176354b4b307576d9ff3b0c5ca 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
+@@ -1196,6 +1196,7 @@ public class EnderDragon extends Mob implements Enemy {
+ 
+     @Override
+     protected boolean canRide(Entity entity) {
++        if (this.level().purpurConfig.enderDragonCanRideVehicles) return this.boardingCooldown <= 0; // Purpur
+         return false;
+     }
+ 
+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 76f88b96e4965e61a620d8e8809411a0711bf02e..8d882e6ef4e199258866f30f5548a6feae4582da 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
+@@ -738,6 +738,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+ 
+     @Override
+     protected boolean canRide(Entity entity) {
++        if (this.level().purpurConfig.witherCanRideVehicles) return this.boardingCooldown <= 0; // Purpur
+         return false;
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b16a62ea9e57d4114fc9f0c5c9fce0c14983cea0..fd2865f5be6bffd8fcbbac35151e9dde2149ab8d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -951,6 +951,7 @@ public class PurpurWorldConfig {
+     public boolean enderDragonAlwaysDropsFullExp = false;
+     public boolean enderDragonBypassMobGriefing = false;
+     public boolean enderDragonTakeDamageFromWater = false;
++    public boolean enderDragonCanRideVehicles = false;
+     private void enderDragonSettings() {
+         enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable);
+         enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater);
+@@ -969,6 +970,7 @@ public class PurpurWorldConfig {
+         enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp);
+         enderDragonBypassMobGriefing = getBoolean("mobs.ender_dragon.bypass-mob-griefing", enderDragonBypassMobGriefing);
+         enderDragonTakeDamageFromWater = getBoolean("mobs.ender_dragon.takes-damage-from-water", enderDragonTakeDamageFromWater);
++        enderDragonCanRideVehicles = getBoolean("mobs.ender_dragon.can-ride-vehicles", enderDragonCanRideVehicles);
+     }
+ 
+     public boolean endermanRidable = false;
+@@ -2160,6 +2162,7 @@ public class PurpurWorldConfig {
+     public int witherHealthRegenDelay = 20;
+     public boolean witherBypassMobGriefing = false;
+     public boolean witherTakeDamageFromWater = false;
++    public boolean witherCanRideVehicles = false;
+     private void witherSettings() {
+         witherRidable = getBoolean("mobs.wither.ridable", witherRidable);
+         witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater);
+@@ -2179,6 +2182,7 @@ public class PurpurWorldConfig {
+         witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay);
+         witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing);
+         witherTakeDamageFromWater = getBoolean("mobs.wither.takes-damage-from-water", witherTakeDamageFromWater);
++        witherCanRideVehicles = getBoolean("mobs.wither.can-ride-vehicles", witherCanRideVehicles);
+     }
+ 
+     public boolean witherSkeletonRidable = false;

patches/unapplied/server/0133-Dont-run-with-scissors.patch

@@ -0,0 +1,134 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: JustDoom <justdoomdev@gmail.com>
+Date: Fri, 5 Mar 2021 14:23:16 -0500
+Subject: [PATCH] Dont run with scissors!
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 6c5b0d1d8fe7fae29dc1ed449e0412c9f449acf9..7ac39b9f7a0afabe4a6fde954a85f0d4f53a01df 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1741,6 +1741,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                                     this.player.resetFallDistance();
+                                 }
+ 
++                                // Purpur Start
++                                if (this.player.level().purpurConfig.dontRunWithScissors && this.player.isSprinting() && !(this.player.level().purpurConfig.ignoreScissorsInWater && this.player.isInWater()) && !(this.player.level().purpurConfig.ignoreScissorsInLava && this.player.isInLava()) && (isScissor(this.player.getItemInHand(InteractionHand.MAIN_HAND)) || isScissor(this.player.getItemInHand(InteractionHand.OFF_HAND))) && (int) (Math.random() * 10) == 0) {
++                                    this.player.hurt(this.player.damageSources().scissors(), (float) this.player.level().purpurConfig.scissorsRunningDamage);
++                                    if (!org.purpurmc.purpur.PurpurConfig.dontRunWithScissors.isBlank()) this.player.sendActionBarMessage(org.purpurmc.purpur.PurpurConfig.dontRunWithScissors);
++                                }
++                                // Purpur End
++
+                                 this.player.checkMovementStatistics(this.player.getX() - d3, this.player.getY() - d4, this.player.getZ() - d5);
+                                 this.lastGoodX = this.player.getX();
+                                 this.lastGoodY = this.player.getY();
+@@ -1785,6 +1792,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+         }
+     }
+     // Paper end - optimise out extra getCubes
++
++    // Purpur start
++    public boolean isScissor(ItemStack stack) {
++        return stack.is(Items.SHEARS) && (stack.getTag() == null || stack.getTag().getInt("CustomModelData") == 0);
++    }
++    // Purpur end
++
+     private boolean isPlayerCollidingWithAnythingNew(LevelReader world, AABB box, double newX, double newY, double newZ) {
+         AABB axisalignedbb1 = this.player.getBoundingBox().move(newX - this.player.getX(), newY - this.player.getY(), newZ - this.player.getZ());
+         Iterable<VoxelShape> iterable = world.getCollisions(this.player, axisalignedbb1.deflate(9.999999747378752E-6D));
+diff --git a/src/main/java/net/minecraft/world/damagesource/CombatTracker.java b/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
+index c12d7bacf2c54f268b1bc5e46250a083ca041415..c6f8ae130b75fbb0ad41f9a5917e934e33fd3043 100644
+--- a/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
++++ b/src/main/java/net/minecraft/world/damagesource/CombatTracker.java
+@@ -99,6 +99,11 @@ public class CombatTracker {
+                 Component component = ComponentUtils.wrapInSquareBrackets(Component.translatable(string + ".link")).withStyle(INTENTIONAL_GAME_DESIGN_STYLE);
+                 return Component.translatable(string + ".message", this.mob.getDisplayName(), component);
+             } else {
++                // Purpur start
++                if (damageSource.isScissors) {
++                    return damageSource.getLocalizedDeathMessage(org.purpurmc.purpur.PurpurConfig.deathMsgRunWithScissors, this.mob);
++                }
++                // Purpur end
+                 return damageSource.getLocalizedDeathMessage(this.mob);
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/damagesource/DamageSource.java b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+index 14fcfd7c1d3a62833978e163f4e0d6f9b2203042..33210bc66dcc5fdf03fbf438ce8734b31c4e7975 100644
+--- a/src/main/java/net/minecraft/world/damagesource/DamageSource.java
++++ b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
+@@ -54,6 +54,8 @@ public class DamageSource {
+     // CraftBukkit end
+     public @Nullable org.bukkit.block.BlockState explodedBlockState; // Paper - add exploded state
+ 
++    public boolean isScissors; // Purpur
++
+     public String toString() {
+         return "DamageSource (" + this.type().msgId() + ")";
+     }
+diff --git a/src/main/java/net/minecraft/world/damagesource/DamageSources.java b/src/main/java/net/minecraft/world/damagesource/DamageSources.java
+index 4604f8b38460e9113e966889a679d4547f24aff6..813916852774d6482791989252ecb67b945a8f84 100644
+--- a/src/main/java/net/minecraft/world/damagesource/DamageSources.java
++++ b/src/main/java/net/minecraft/world/damagesource/DamageSources.java
+@@ -267,4 +267,11 @@ public class DamageSources {
+     public DamageSource genericKill() {
+         return this.genericKill;
+     }
++    // Purpur start
++    public DamageSource scissors() {
++        DamageSource source = new DamageSource(this.damageTypes.getHolderOrThrow(DamageTypes.MAGIC));
++        source.isScissors = true;
++        return source;
++    }
++    // Purpur end
+ }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index 61e3bce901bdbf111ffc06521b0e6d5369fce051..ea9d99990b718beaef4bee3ff75340656f3c76c5 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -183,6 +183,7 @@ public class PurpurConfig {
+     public static String demoCommandOutput = "<green>%s has been shown the demo screen";
+     public static String pingCommandOutput = "<green>%s's ping is %sms";
+     public static String tpsbarCommandOutput = "<green>Tpsbar toggled <onoff> for <target>";
++    public static String dontRunWithScissors = "<red><italic>Don't run with scissors!";
+     private static void messages() {
+         cannotRideMob = getString("settings.messages.cannot-ride-mob", cannotRideMob);
+         afkBroadcastAway = getString("settings.messages.afk-broadcast-away", afkBroadcastAway);
+@@ -194,6 +195,12 @@ public class PurpurConfig {
+         demoCommandOutput = getString("settings.messages.demo-command-output", demoCommandOutput);
+         pingCommandOutput = getString("settings.messages.ping-command-output", pingCommandOutput);
+         tpsbarCommandOutput = getString("settings.messages.tpsbar-command-output", tpsbarCommandOutput);
++        dontRunWithScissors = getString("settings.messages.dont-run-with-scissors", dontRunWithScissors);
++    }
++
++    public static String deathMsgRunWithScissors = "<player> slipped and fell on their shears";
++    private static void deathMessages() {
++        deathMsgRunWithScissors = getString("settings.messages.death-message.run-with-scissors", deathMsgRunWithScissors);
+     }
+ 
+     public static String serverModName = "Purpur";
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index fd2865f5be6bffd8fcbbac35151e9dde2149ab8d..dec3823baee9264ea5257993d9b30df337e2d9bd 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -197,6 +197,10 @@ public class PurpurWorldConfig {
+     public List<Item> itemImmuneToExplosion = new ArrayList<>();
+     public List<Item> itemImmuneToFire = new ArrayList<>();
+     public List<Item> itemImmuneToLightning = new ArrayList<>();
++    public boolean dontRunWithScissors = false;
++    public boolean ignoreScissorsInWater = false;
++    public boolean ignoreScissorsInLava = false;
++    public double scissorsRunningDamage = 1D;
+     private void itemSettings() {
+         itemImmuneToCactus.clear();
+         getList("gameplay-mechanics.item.immune.cactus", new ArrayList<>()).forEach(key -> {
+@@ -234,6 +238,10 @@ public class PurpurWorldConfig {
+             Item item = BuiltInRegistries.ITEM.get(new ResourceLocation(key.toString()));
+             if (item != Items.AIR) itemImmuneToLightning.add(item);
+         });
++        dontRunWithScissors = getBoolean("gameplay-mechanics.item.shears.damage-if-sprinting", dontRunWithScissors);
++        ignoreScissorsInWater = getBoolean("gameplay-mechanics.item.shears.ignore-in-water", ignoreScissorsInWater);
++        ignoreScissorsInLava = getBoolean("gameplay-mechanics.item.shears.ignore-in-lava", ignoreScissorsInLava);
++        scissorsRunningDamage = getDouble("gameplay-mechanics.item.shears.sprinting-damage", scissorsRunningDamage);
+     }
+ 
+     public double minecartMaxSpeed = 0.4D;

patches/unapplied/server/0134-One-Punch-Man.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Fourmisain <8464472+Fourmisain@users.noreply.github.com>
+Date: Fri, 5 Mar 2021 17:42:35 -0500
+Subject: [PATCH] One Punch Man!
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 97dfdf4f5730d9f7c162f127bab38833cf757b4d..5ae73f8f86b0f55890b961cdbb8a31ff0ffc6209 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -2297,6 +2297,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                 }
+             }
+ 
++           // Purpur start
++           if (damagesource.getEntity() instanceof net.minecraft.world.entity.player.Player player && damagesource.getEntity().level().purpurConfig.creativeOnePunch) {
++               if (player.isCreative()) {
++                   double attackDamage = 0;
++                   for (AttributeModifier modifier : player.getMainHandItem().getAttributeModifiers(EquipmentSlot.MAINHAND).get(Attributes.ATTACK_DAMAGE)) {
++                       attackDamage += modifier.getAmount();
++                   }
++                   if (attackDamage == 0) {
++                       this.setHealth(0);
++                   }
++               }
++           }
++           // Purpur end
++
+             if (f > 0 || !human) {
+                 if (human) {
+                     // PAIL: Be sure to drag all this code from the EntityHuman subclass each update.
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index dec3823baee9264ea5257993d9b30df337e2d9bd..c0a6940d923a85c923502c07df11cceba093cc95 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -346,6 +346,7 @@ public class PurpurWorldConfig {
+     public boolean teleportIfOutsideBorder = false;
+     public boolean totemOfUndyingWorksInInventory = false;
+     public boolean playerFixStuckPortal = false;
++    public boolean creativeOnePunch = false;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -364,6 +365,7 @@ public class PurpurWorldConfig {
+         teleportIfOutsideBorder = getBoolean("gameplay-mechanics.player.teleport-if-outside-border", teleportIfOutsideBorder);
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+         playerFixStuckPortal = getBoolean("gameplay-mechanics.player.fix-stuck-in-portal", playerFixStuckPortal);
++        creativeOnePunch = getBoolean("gameplay-mechanics.player.one-punch-in-creative", creativeOnePunch);
+     }
+ 
+     private static boolean projectileDespawnRateSettingsMigrated = false;

patches/unapplied/server/0135-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch

@@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Sun, 7 Mar 2021 19:08:16 -0500
+Subject: [PATCH] Configurable Ender Pearl cooldown, damage, and Endermite RNG
+
+- Survival and Creative Cooldown speed
+- Damage dealt on pearl usage
+- Endermite spawn chance
+
+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 e8114d89a3129e56c0329410a49ded63cc77cb4c..5c12355ed8b9eb1367173dd956975db279e2fb73 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+@@ -68,7 +68,7 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+                     Bukkit.getPluginManager().callEvent(teleEvent);
+ 
+                     if (!teleEvent.isCancelled() && entityplayer.connection.isAcceptingMessages()) {
+-                        if (this.random.nextFloat() < 0.05F && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) {
++                        if (this.random.nextFloat() < this.level().purpurConfig.enderPearlEndermiteChance && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) { // Purpur
+                             Endermite entityendermite = (Endermite) EntityType.ENDERMITE.create(this.level());
+ 
+                             if (entityendermite != null) {
+@@ -84,7 +84,7 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+                         entityplayer.connection.teleport(teleEvent.getTo());
+                         entity.resetFallDistance();
+                         CraftEventFactory.entityDamage = this;
+-                        entity.hurt(this.damageSources().fall(), 5.0F);
++                        entity.hurt(this.damageSources().fall(), this.level().purpurConfig.enderPearlDamage); // Purpur
+                         CraftEventFactory.entityDamage = null;
+                     }
+                     // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/world/item/EnderpearlItem.java b/src/main/java/net/minecraft/world/item/EnderpearlItem.java
+index 749ab72edc0d2e9c6f1161415ab8d59d3d6ca976..897c202c0905040072a06fdfa2032a7f9461b088 100644
+--- a/src/main/java/net/minecraft/world/item/EnderpearlItem.java
++++ b/src/main/java/net/minecraft/world/item/EnderpearlItem.java
+@@ -36,7 +36,7 @@ public class EnderpearlItem extends Item {
+ 
+                 world.playSound((Player) null, user.getX(), user.getY(), user.getZ(), SoundEvents.ENDER_PEARL_THROW, SoundSource.NEUTRAL, 0.5F, 0.4F / (net.minecraft.world.entity.Entity.SHARED_RANDOM.nextFloat() * 0.4F + 0.8F));
+                 user.awardStat(Stats.ITEM_USED.get(this));
+-                user.getCooldowns().addCooldown(this, 20);
++                user.getCooldowns().addCooldown(this, user.getAbilities().instabuild ? world.purpurConfig.enderPearlCooldownCreative : world.purpurConfig.enderPearlCooldown); // Purpur
+             } else {
+                 // Paper end
+                 if (user instanceof net.minecraft.server.level.ServerPlayer) {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index c0a6940d923a85c923502c07df11cceba093cc95..02f332f2d1497668fbdf2e430d757f8699dc3a9a 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -201,6 +201,10 @@ public class PurpurWorldConfig {
+     public boolean ignoreScissorsInWater = false;
+     public boolean ignoreScissorsInLava = false;
+     public double scissorsRunningDamage = 1D;
++    public float enderPearlDamage = 5.0F;
++    public int enderPearlCooldown = 20;
++    public int enderPearlCooldownCreative = 20;
++    public float enderPearlEndermiteChance = 0.05F;
+     private void itemSettings() {
+         itemImmuneToCactus.clear();
+         getList("gameplay-mechanics.item.immune.cactus", new ArrayList<>()).forEach(key -> {
+@@ -242,6 +246,10 @@ public class PurpurWorldConfig {
+         ignoreScissorsInWater = getBoolean("gameplay-mechanics.item.shears.ignore-in-water", ignoreScissorsInWater);
+         ignoreScissorsInLava = getBoolean("gameplay-mechanics.item.shears.ignore-in-lava", ignoreScissorsInLava);
+         scissorsRunningDamage = getDouble("gameplay-mechanics.item.shears.sprinting-damage", scissorsRunningDamage);
++        enderPearlDamage = (float) getDouble("gameplay-mechanics.item.ender-pearl.damage", enderPearlDamage);
++        enderPearlCooldown = getInt("gameplay-mechanics.item.ender-pearl.cooldown", enderPearlCooldown);
++        enderPearlCooldownCreative = getInt("gameplay-mechanics.item.ender-pearl.creative-cooldown", enderPearlCooldownCreative);
++        enderPearlEndermiteChance = (float) getDouble("gameplay-mechanics.item.ender-pearl.endermite-spawn-chance", enderPearlEndermiteChance);
+     }
+ 
+     public double minecartMaxSpeed = 0.4D;

patches/unapplied/server/0136-Config-to-ignore-nearby-mobs-when-sleeping.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Mon, 8 Mar 2021 16:46:54 -0500
+Subject: [PATCH] Config to ignore nearby mobs when sleeping
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 08532053face8fcba4a808830d618d2e5f0da8ee..fe1591b8ae12eaffdd44b23c4c55f580512f293e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1430,7 +1430,7 @@ public class ServerPlayer extends Player {
+                             return entitymonster.isPreventingPlayerRest(this);
+                         });
+ 
+-                        if (!list.isEmpty()) {
++                        if (!this.level().purpurConfig.playerSleepNearMonsters && !list.isEmpty()) { // Purpur
+                             return Either.left(Player.BedSleepingProblem.NOT_SAFE);
+                         }
+                     }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 02f332f2d1497668fbdf2e430d757f8699dc3a9a..7db005d02e762163c403a8358281afc2fa4f2df1 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -355,6 +355,7 @@ public class PurpurWorldConfig {
+     public boolean totemOfUndyingWorksInInventory = false;
+     public boolean playerFixStuckPortal = false;
+     public boolean creativeOnePunch = false;
++    public boolean playerSleepNearMonsters = false;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -374,6 +375,7 @@ public class PurpurWorldConfig {
+         totemOfUndyingWorksInInventory = getBoolean("gameplay-mechanics.player.totem-of-undying-works-in-inventory", totemOfUndyingWorksInInventory);
+         playerFixStuckPortal = getBoolean("gameplay-mechanics.player.fix-stuck-in-portal", playerFixStuckPortal);
+         creativeOnePunch = getBoolean("gameplay-mechanics.player.one-punch-in-creative", creativeOnePunch);
++        playerSleepNearMonsters = getBoolean("gameplay-mechanics.player.sleep-ignore-nearby-mobs", playerSleepNearMonsters);
+     }
+ 
+     private static boolean projectileDespawnRateSettingsMigrated = false;

patches/unapplied/server/0137-Add-back-player-spawned-endermite-API.patch

@@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 9 Mar 2021 16:10:39 -0500
+Subject: [PATCH] Add back player spawned endermite API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Endermite.java b/src/main/java/net/minecraft/world/entity/monster/Endermite.java
+index cb0a2d522176a2d1d9785f95d205d4d924912a32..0cbf5a32611848e15e83eb0fc6f16c68337753c5 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Endermite.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Endermite.java
+@@ -31,6 +31,7 @@ import net.minecraft.world.level.block.state.BlockState;
+ public class Endermite extends Monster {
+     private static final int MAX_LIFE = 2400;
+     public int life;
++    private boolean isPlayerSpawned; // Purpur
+ 
+     public Endermite(EntityType<? extends Endermite> type, Level world) {
+         super(type, world);
+@@ -64,6 +65,14 @@ public class Endermite extends Monster {
+         return this.level().purpurConfig.endermiteTakeDamageFromWater;
+     }
+ 
++    public boolean isPlayerSpawned() {
++        return this.isPlayerSpawned;
++    }
++
++    public void setPlayerSpawned(boolean playerSpawned) {
++        this.isPlayerSpawned = playerSpawned;
++    }
++
+     @Override
+     protected void registerGoals() {
+         this.goalSelector.addGoal(1, new FloatGoal(this));
+@@ -116,12 +125,14 @@ public class Endermite extends Monster {
+     public void readAdditionalSaveData(CompoundTag nbt) {
+         super.readAdditionalSaveData(nbt);
+         this.life = nbt.getInt("Lifetime");
++        this.isPlayerSpawned = nbt.getBoolean("PlayerSpawned"); // Purpur
+     }
+ 
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         super.addAdditionalSaveData(nbt);
+         nbt.putInt("Lifetime", this.life);
++        nbt.putBoolean("PlayerSpawned", this.isPlayerSpawned); // Purpur
+     }
+ 
+     @Override
+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 5c12355ed8b9eb1367173dd956975db279e2fb73..d7359c675707eade00f9b737fd67ef8d066e813f 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownEnderpearl.java
+@@ -72,6 +72,7 @@ public class ThrownEnderpearl extends ThrowableItemProjectile {
+                             Endermite entityendermite = (Endermite) EntityType.ENDERMITE.create(this.level());
+ 
+                             if (entityendermite != null) {
++                                entityendermite.setPlayerSpawned(true); // Purpur
+                                 entityendermite.moveTo(entity.getX(), entity.getY(), entity.getZ(), entity.getYRot(), entity.getXRot());
+                                 this.level().addFreshEntity(entityendermite, CreatureSpawnEvent.SpawnReason.ENDER_PEARL);
+                             }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEndermite.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEndermite.java
+index d657fd2c507a5b215aeab0a5f3e9c2ee892a27c8..985e9ec21c60a1f47973bd5fc53b96a6f9b7d04a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEndermite.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEndermite.java
+@@ -21,12 +21,12 @@ public class CraftEndermite extends CraftMonster implements Endermite {
+ 
+     @Override
+     public boolean isPlayerSpawned() {
+-        return false;
++        return getHandle().isPlayerSpawned(); // Purpur
+     }
+ 
+     @Override
+     public void setPlayerSpawned(boolean playerSpawned) {
+-        // Nop
++        getHandle().setPlayerSpawned(playerSpawned); // Purpur
+     }
+     // Paper start
+     @Override

patches/unapplied/server/0138-Config-Enderman-aggressiveness-towards-Endermites.patch

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 9 Mar 2021 16:10:39 -0500
+Subject: [PATCH] Config Enderman aggressiveness towards Endermites
+
+
+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 d4d4ad5dfa776a39eabb840ed5b49acb8d37f587..ea596b7344f1849a8c6a8d536881c9a8b9cadb86 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -132,7 +132,7 @@ public class EnderMan extends Monster implements NeutralMob {
+         this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur
+         this.targetSelector.addGoal(1, new EnderMan.EndermanLookForPlayerGoal(this, this::isAngryAt));
+         this.targetSelector.addGoal(2, new HurtByTargetGoal(this, new Class[0]));
+-        this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Endermite.class, true, false));
++        this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Endermite.class, 10, true, false, (entityliving) -> entityliving.level().purpurConfig.endermanAggroEndermites && entityliving instanceof Endermite endermite && (!entityliving.level().purpurConfig.endermanAggroEndermitesOnlyIfPlayerSpawned || endermite.isPlayerSpawned()))); // Purpur
+         this.targetSelector.addGoal(4, new ResetUniversalAngerTargetGoal<>(this, false));
+     }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 7db005d02e762163c403a8358281afc2fa4f2df1..a10a43afa33a025e89474786810db45241c145c5 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1001,6 +1001,8 @@ public class PurpurWorldConfig {
+     public boolean endermanDespawnEvenWithBlock = false;
+     public boolean endermanBypassMobGriefing = false;
+     public boolean endermanTakeDamageFromWater = true;
++    public boolean endermanAggroEndermites = true;
++    public boolean endermanAggroEndermitesOnlyIfPlayerSpawned = false;
+     private void endermanSettings() {
+         endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
+         endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
+@@ -1010,11 +1012,17 @@ public class PurpurWorldConfig {
+             set("mobs.enderman.attributes.max-health", null);
+             set("mobs.enderman.attributes.max_health", oldValue);
+         }
++        if (PurpurConfig.version < 15) {
++            // remove old option
++            set("mobs.enderman.aggressive-towards-spawned-endermites", null);
++        }
+         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);
+         endermanBypassMobGriefing = getBoolean("mobs.enderman.bypass-mob-griefing", endermanBypassMobGriefing);
+         endermanTakeDamageFromWater = getBoolean("mobs.enderman.takes-damage-from-water", endermanTakeDamageFromWater);
++        endermanAggroEndermites = getBoolean("mobs.enderman.aggressive-towards-endermites", endermanAggroEndermites);
++        endermanAggroEndermitesOnlyIfPlayerSpawned = getBoolean("mobs.enderman.aggressive-towards-endermites-only-spawned-by-player-thrown-ender-pearls", endermanAggroEndermitesOnlyIfPlayerSpawned);
+     }
+ 
+     public boolean endermiteRidable = false;

patches/unapplied/server/0139-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch

@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 9 Mar 2021 16:16:01 -0500
+Subject: [PATCH] Config to ignore Dragon Head wearers and stare aggro
+
+Prevents Enderman from becoming aggresive towards players that are wearing a Dragon Head.
+Adds functionality to a useless item!
+
+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 ea596b7344f1849a8c6a8d536881c9a8b9cadb86..f4bf81ebcc792c8e04fa700e84b13b3b688dbdac 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -269,7 +269,7 @@ public class EnderMan extends Monster implements NeutralMob {
+         // Paper end
+         ItemStack itemstack = (ItemStack) player.getInventory().armor.get(3);
+ 
+-        if (itemstack.is(Blocks.CARVED_PUMPKIN.asItem())) {
++        if (this.level().purpurConfig.endermanDisableStareAggro || itemstack.is(Blocks.CARVED_PUMPKIN.asItem()) || (this.level().purpurConfig.endermanIgnorePlayerDragonHead && itemstack.is(net.minecraft.world.item.Items.DRAGON_HEAD))) { // Purpur
+             return false;
+         } else {
+             Vec3 vec3d = player.getViewVector(1.0F).normalize();
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index a10a43afa33a025e89474786810db45241c145c5..27581d6a560398e4e18425cfccd80e1dd9ec4dde 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1003,6 +1003,8 @@ public class PurpurWorldConfig {
+     public boolean endermanTakeDamageFromWater = true;
+     public boolean endermanAggroEndermites = true;
+     public boolean endermanAggroEndermitesOnlyIfPlayerSpawned = false;
++    public boolean endermanIgnorePlayerDragonHead = false;
++    public boolean endermanDisableStareAggro = false;
+     private void endermanSettings() {
+         endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable);
+         endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater);
+@@ -1023,6 +1025,8 @@ public class PurpurWorldConfig {
+         endermanTakeDamageFromWater = getBoolean("mobs.enderman.takes-damage-from-water", endermanTakeDamageFromWater);
+         endermanAggroEndermites = getBoolean("mobs.enderman.aggressive-towards-endermites", endermanAggroEndermites);
+         endermanAggroEndermitesOnlyIfPlayerSpawned = getBoolean("mobs.enderman.aggressive-towards-endermites-only-spawned-by-player-thrown-ender-pearls", endermanAggroEndermitesOnlyIfPlayerSpawned);
++        endermanIgnorePlayerDragonHead = getBoolean("mobs.enderman.ignore-players-wearing-dragon-head", endermanIgnorePlayerDragonHead);
++        endermanDisableStareAggro = getBoolean("mobs.enderman.disable-player-stare-aggression", endermanDisableStareAggro);
+     }
+ 
+     public boolean endermiteRidable = false;

patches/unapplied/server/0140-Tick-fluids-config.patch

@@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 15 Mar 2021 03:52:17 -0500
+Subject: [PATCH] Tick fluids config
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+index bbabe4ad8afcc3a2069f6e9d4a9adcb643266894..55419bd653f7f5391fa13cd15a0b00fbff5e9c39 100644
+--- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+@@ -105,7 +105,7 @@ public class LiquidBlock extends Block implements BucketPickup {
+ 
+     @Override
+     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+-        if (this.shouldSpreadLiquid(world, pos, state)) {
++        if (world.purpurConfig.tickFluids && this.shouldSpreadLiquid(world, pos, state)) { // Purpur
+             world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
+         }
+ 
+@@ -133,7 +133,7 @@ public class LiquidBlock extends Block implements BucketPickup {
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+-        if (state.getFluidState().isSource() || neighborState.getFluidState().isSource()) {
++        if (world.getMinecraftWorld().purpurConfig.tickFluids && state.getFluidState().isSource() || neighborState.getFluidState().isSource()) { // Purpur
+             world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
+         }
+ 
+@@ -142,7 +142,7 @@ public class LiquidBlock extends Block implements BucketPickup {
+ 
+     @Override
+     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
+-        if (this.shouldSpreadLiquid(world, pos, state)) {
++        if (world.purpurConfig.tickFluids && this.shouldSpreadLiquid(world, pos, state)) { // Purpur
+             world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 27581d6a560398e4e18425cfccd80e1dd9ec4dde..ea25998e4855b6e900ed96e1d814231da97ea325 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -129,6 +129,7 @@ public class PurpurWorldConfig {
+     public boolean noteBlockIgnoreAbove = false;
+     public boolean persistentDroppableEntityDisplayNames = true;
+     public boolean projectilesBypassMobGriefing = false;
++    public boolean tickFluids = true;
+     public double tridentLoyaltyVoidReturnHeight = 0.0D;
+     public double voidDamageHeight = -64.0D;
+     public double voidDamageDealt = 4.0D;
+@@ -148,6 +149,7 @@ public class PurpurWorldConfig {
+         noteBlockIgnoreAbove = getBoolean("gameplay-mechanics.note-block-ignore-above", noteBlockIgnoreAbove);
+         persistentDroppableEntityDisplayNames = getBoolean("gameplay-mechanics.persistent-droppable-entity-display-names", persistentDroppableEntityDisplayNames);
+         projectilesBypassMobGriefing = getBoolean("gameplay-mechanics.projectiles-bypass-mob-griefing", projectilesBypassMobGriefing);
++        tickFluids = getBoolean("gameplay-mechanics.tick-fluids", tickFluids);
+         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);

patches/unapplied/server/0141-Config-to-disable-Llama-caravans.patch

@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Wed, 17 Mar 2021 10:12:53 -0400
+Subject: [PATCH] Config to disable Llama caravans
+
+Disables the mechanic where llamas follow leashed llamas.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/LlamaFollowCaravanGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/LlamaFollowCaravanGoal.java
+index 849f0c7c6d13df00d90211a48d8b56ab156812b8..3fc9528201fb96d6a0f905afe0b6a82ec88a7235 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/LlamaFollowCaravanGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/LlamaFollowCaravanGoal.java
+@@ -22,7 +22,7 @@ public class LlamaFollowCaravanGoal extends Goal {
+ 
+     @Override
+     public boolean canUse() {
+-        if (!this.llama.shouldJoinCaravan) return false; // Purpur
++        if (!this.llama.level().purpurConfig.llamaJoinCaravans || !this.llama.shouldJoinCaravan) return false; // Purpur
+         if (!this.llama.isLeashed() && !this.llama.inCaravan()) {
+             List<Entity> list = this.llama.level().getEntities(this.llama, this.llama.getBoundingBox().inflate(9.0D, 4.0D, 9.0D), (entity) -> {
+                 EntityType<?> entityType = entity.getType();
+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 b7450d182ecf10ef17ac9eb3fce04e4334013c91..fac46dd905f9a634cff393494f6ff0404eb17fb7 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
+@@ -539,7 +539,7 @@ public class Llama extends AbstractChestedHorse implements VariantHolder<Llama.V
+     }
+ 
+     public void joinCaravan(Llama llama) {
+-        if (!shouldJoinCaravan || !new org.purpurmc.purpur.event.entity.LlamaJoinCaravanEvent((org.bukkit.entity.Llama) getBukkitEntity(), (org.bukkit.entity.Llama) llama.getBukkitEntity()).callEvent()) return; // Purpur
++        if (!this.level().purpurConfig.llamaJoinCaravans || !shouldJoinCaravan || !new org.purpurmc.purpur.event.entity.LlamaJoinCaravanEvent((org.bukkit.entity.Llama) getBukkitEntity(), (org.bukkit.entity.Llama) llama.getBukkitEntity()).callEvent()) return; // Purpur
+         this.caravanHead = llama;
+         this.caravanHead.caravanTail = this;
+     }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index ea25998e4855b6e900ed96e1d814231da97ea325..eed4919f50c081fc98ec448b99ee34083f72aa26 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1335,6 +1335,7 @@ public class PurpurWorldConfig {
+     public double llamaMovementSpeedMax = 0.175D;
+     public int llamaBreedingTicks = 6000;
+     public boolean llamaTakeDamageFromWater = false;
++    public boolean llamaJoinCaravans = true;
+     private void llamaSettings() {
+         llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable);
+         llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater);
+@@ -1354,6 +1355,7 @@ public class PurpurWorldConfig {
+         llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax);
+         llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks);
+         llamaTakeDamageFromWater = getBoolean("mobs.llama.takes-damage-from-water", llamaTakeDamageFromWater);
++        llamaJoinCaravans = getBoolean("mobs.llama.join-caravans", llamaJoinCaravans);
+     }
+ 
+     public boolean magmaCubeRidable = false;

patches/unapplied/server/0142-Config-to-make-Creepers-explode-on-death.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Encode42 <me@encode42.dev>
+Date: Tue, 16 Mar 2021 19:50:58 -0400
+Subject: [PATCH] Config to make Creepers explode on death
+
+Creepers exploded after being killed in the alpha days. This brings that back.
+
+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 e8191f0df3420d5a531cf226547a177732ff65ea..fd3b1e92a626402112bbd371a0ac1264a2c19c32 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -63,6 +63,7 @@ public class Creeper extends Monster implements PowerableMob {
+     private int spacebarCharge = 0;
+     private int prevSpacebarCharge = 0;
+     private int powerToggleDelay = 0;
++    private boolean exploding = false;
+     // Purpur end
+ 
+     public Creeper(EntityType<? extends Creeper> type, Level world) {
+@@ -268,6 +269,14 @@ public class Creeper extends Monster implements PowerableMob {
+         return this.level().purpurConfig.creeperTakeDamageFromWater;
+     }
+ 
++    @Override
++    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(DamageSource damagesource) {
++        if (!exploding && this.level().purpurConfig.creeperExplodeWhenKilled && damagesource.getEntity() instanceof net.minecraft.server.level.ServerPlayer) {
++            this.explodeCreeper();
++        }
++        return super.dropAllDeathLoot(damagesource);
++    }
++
+     @Override
+     protected SoundEvent getHurtSound(DamageSource source) {
+         return SoundEvents.CREEPER_HURT;
+@@ -359,6 +368,7 @@ public class Creeper extends Monster implements PowerableMob {
+     }
+ 
+     public void explodeCreeper() {
++        this.exploding = true; // Purpur
+         if (!this.level().isClientSide) {
+             float f = this.isPowered() ? 2.0F : 1.0F;
+ 
+@@ -377,7 +387,7 @@ public class Creeper extends Monster implements PowerableMob {
+             }
+             // CraftBukkit end
+         }
+-
++        this.exploding = false; // Purpur
+     }
+ 
+     private void spawnLingeringCloud() {
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index eed4919f50c081fc98ec448b99ee34083f72aa26..f477176dd6ba0b093fe81f11acfe98ddb25723cd 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -855,6 +855,7 @@ public class PurpurWorldConfig {
+     public boolean creeperAllowGriefing = true;
+     public boolean creeperBypassMobGriefing = false;
+     public boolean creeperTakeDamageFromWater = false;
++    public boolean creeperExplodeWhenKilled = false;
+     private void creeperSettings() {
+         creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable);
+         creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater);
+@@ -869,6 +870,7 @@ public class PurpurWorldConfig {
+         creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing);
+         creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing);
+         creeperTakeDamageFromWater = getBoolean("mobs.creeper.takes-damage-from-water", creeperTakeDamageFromWater);
++        creeperExplodeWhenKilled = getBoolean("mobs.creeper.explode-when-killed", creeperExplodeWhenKilled);
+     }
+ 
+     public boolean dolphinRidable = false;

patches/unapplied/server/0143-Configurable-ravager-griefable-blocks-list.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Wed, 17 Mar 2021 14:54:43 -0500
+Subject: [PATCH] Configurable ravager griefable blocks list
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+index d56e80014621dbd7e445f2f753807bd2b751310d..1de85b0a3aafb725452197de245e884cacdb4e3b 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
+@@ -208,7 +208,7 @@ public class Ravager extends Raider {
+                     BlockState iblockdata = this.level().getBlockState(blockposition);
+                     Block block = iblockdata.getBlock();
+ 
+-                    if (block instanceof LeavesBlock) {
++                    if (this.level().purpurConfig.ravagerGriefableBlocks.contains(block)) { // Purpur
+                         // CraftBukkit start
+                         if (!CraftEventFactory.callEntityChangeBlockEvent(this, blockposition, iblockdata.getFluidState().createLegacyBlock())) { // Paper - fix wrong block state
+                             continue;
+diff --git a/src/main/java/net/minecraft/world/level/block/CropBlock.java b/src/main/java/net/minecraft/world/level/block/CropBlock.java
+index 5ba5a510b30917235e135ccda1b7c98cb7dd93ec..373fda589014c71c07170ec6707d5ff66d46ddd5 100644
+--- a/src/main/java/net/minecraft/world/level/block/CropBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/CropBlock.java
+@@ -168,7 +168,7 @@ public class CropBlock extends BushBlock implements BonemealableBlock {
+     @Override
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+-        if (entity instanceof Ravager && CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), (!world.purpurConfig.ravagerBypassMobGriefing && !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)))) { // CraftBukkit // Purpur
++        if (entity instanceof Ravager && world.purpurConfig.ravagerGriefableBlocks.contains(world.getBlockState(pos).getBlock()) && CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.AIR.defaultBlockState(), (!world.purpurConfig.ravagerBypassMobGriefing && !world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)))) { // CraftBukkit // Purpur
+             world.destroyBlock(pos, true, entity);
+         }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index f477176dd6ba0b093fe81f11acfe98ddb25723cd..b946f607cd1689e6eae4759e100500c4db5c647f 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -1707,6 +1707,7 @@ public class PurpurWorldConfig {
+     public double ravagerMaxHealth = 100.0D;
+     public boolean ravagerBypassMobGriefing = false;
+     public boolean ravagerTakeDamageFromWater = false;
++    public List<Block> ravagerGriefableBlocks = new ArrayList<>();
+     private void ravagerSettings() {
+         ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable);
+         ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater);
+@@ -1719,6 +1720,23 @@ public class PurpurWorldConfig {
+         ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth);
+         ravagerBypassMobGriefing = getBoolean("mobs.ravager.bypass-mob-griefing", ravagerBypassMobGriefing);
+         ravagerTakeDamageFromWater = getBoolean("mobs.ravager.takes-damage-from-water", ravagerTakeDamageFromWater);
++        getList("mobs.ravager.griefable-blocks", new ArrayList<String>(){{
++            add("minecraft:oak_leaves");
++            add("minecraft:spruce_leaves");
++            add("minecraft:birch_leaves");
++            add("minecraft:jungle_leaves");
++            add("minecraft:acacia_leaves");
++            add("minecraft:dark_oak_leaves");
++            add("minecraft:beetroots");
++            add("minecraft:carrots");
++            add("minecraft:potatoes");
++            add("minecraft:wheat");
++        }}).forEach(key -> {
++            Block block = BuiltInRegistries.BLOCK.get(new ResourceLocation(key.toString()));
++            if (!block.defaultBlockState().isAir()) {
++                ravagerGriefableBlocks.add(block);
++            }
++        });
+     }
+ 
+     public boolean salmonRidable = false;

patches/unapplied/server/0144-Sneak-to-bulk-process-composter.patch

@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 7 May 2023 22:26:59 -0700
+Subject: [PATCH] Sneak to bulk process composter
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 618ab9a2903f6d4139acd4aaa2e6db0a26e88ba9..26f78343b5ecaafc3252654848c21a5405379c0e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -578,7 +578,7 @@ public class ServerPlayerGameMode {
+             boolean flag1 = player.isSecondaryUseActive() && flag;
+             ItemStack itemstack1 = stack.copy();
+ 
+-            if (!flag1) {
++            if (!flag1 || (player.level().purpurConfig.composterBulkProcess && iblockdata.is(Blocks.COMPOSTER))) { // Purpur
+                 enuminteractionresult = iblockdata.use(world, player, hand, hitResult);
+ 
+                 if (enuminteractionresult.consumesAction()) {
+diff --git a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+index 10d3912ef043eefdf89105332e29b0d2bf4a5539..596b77306f690a2298835f0f0fea1abee2a7c85d 100644
+--- a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+@@ -229,20 +229,28 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         ItemStack itemstack = player.getItemInHand(hand);
+ 
+         if (i < 8 && ComposterBlock.COMPOSTABLES.containsKey(itemstack.getItem())) {
+-            if (i < 7 && !world.isClientSide) {
+-                BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, itemstack);
+-                // Paper start - handle cancelled events
+-                if (iblockdata1 == null) {
+-                    return InteractionResult.PASS;
+-                }
+-                // Paper end
++            // Purpur start
++            BlockState newState = process(i, state, world, itemstack, pos, player);
++            if (newState == null) {
++                return InteractionResult.PASS;
++            }
+ 
+-                world.levelEvent(1500, pos, state != iblockdata1 ? 1 : 0);
+-                player.awardStat(Stats.ITEM_USED.get(itemstack.getItem()));
+-                if (!player.getAbilities().instabuild) {
+-                    itemstack.shrink(1);
+-                }
++            if (world.purpurConfig.composterBulkProcess && player.isShiftKeyDown() && newState != state) {
++                BlockState oldState;
++                int oldCount, newCount, oldLevel, newLevel;
++                do {
++                    oldState = newState;
++                    oldCount = itemstack.getCount();
++                    oldLevel = oldState.getValue(ComposterBlock.LEVEL);
++                    newState = process(oldLevel, oldState, world, itemstack, pos, player);
++                    if (newState == null) {
++                        return InteractionResult.PASS;
++                    }
++                    newCount = itemstack.getCount();
++                    newLevel = newState.getValue(ComposterBlock.LEVEL);
++                } while (newCount > 0 && (newCount != oldCount || newLevel != oldLevel || newState != oldState));
+             }
++            // Purpur end
+ 
+             return InteractionResult.sidedSuccess(world.isClientSide);
+         } else if (i == 8) {
+@@ -253,6 +261,26 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         }
+     }
+ 
++    private static BlockState process(int level, BlockState state, Level world, ItemStack itemstack, BlockPos pos, Player player) {
++        if (level < 7 && !world.isClientSide) {
++            BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, itemstack);
++            // Paper start - handle cancelled events
++            if (iblockdata1 == null) {
++                return iblockdata1;
++            }
++            // Paper end
++
++            world.levelEvent(1500, pos, state != iblockdata1 ? 1 : 0);
++            player.awardStat(Stats.ITEM_USED.get(itemstack.getItem()));
++            if (!player.getAbilities().instabuild) {
++                itemstack.shrink(1);
++            }
++            return iblockdata1;
++        }
++        return state;
++    }
++    // Purpur end
++
+     public static BlockState insertItem(Entity user, BlockState state, ServerLevel world, ItemStack stack, BlockPos pos) {
+         int i = (Integer) state.getValue(ComposterBlock.LEVEL);
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index b946f607cd1689e6eae4759e100500c4db5c647f..57f5792a06e55c7d7e9f0bf20c89c5d4337abd8d 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -483,6 +483,11 @@ public class PurpurWorldConfig {
+         chestOpenWithBlockOnTop = getBoolean("blocks.chest.open-with-solid-block-on-top", chestOpenWithBlockOnTop);
+     }
+ 
++    public boolean composterBulkProcess = false;
++    private void composterSettings() {
++        composterBulkProcess = getBoolean("blocks.composter.sneak-to-bulk-process", composterBulkProcess);
++    }
++
+     public boolean dispenserApplyCursedArmor = true;
+     public boolean dispenserPlaceAnvils = false;
+     private void dispenserSettings() {

patches/unapplied/server/0145-Config-for-skipping-night.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Thu, 18 Mar 2021 06:22:40 -0400
+Subject: [PATCH] Config for skipping night
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 0e8452f6a8300992f397fb15db763304d72fe3b9..49c412f46854ee877de1721b08629e8a3cd319f9 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -805,7 +805,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         int i = this.getGameRules().getInt(GameRules.RULE_PLAYERS_SLEEPING_PERCENTAGE);
+         long j;
+ 
+-        if (this.sleepStatus.areEnoughSleeping(i) && this.sleepStatus.areEnoughDeepSleeping(i, this.players)) {
++        if (this.purpurConfig.playersSkipNight && this.sleepStatus.areEnoughSleeping(i) && this.sleepStatus.areEnoughDeepSleeping(i, this.players)) {
+             // CraftBukkit start
+             j = this.levelData.getDayTime() + 24000L;
+             TimeSkipEvent event = new TimeSkipEvent(this.getWorld(), TimeSkipEvent.SkipReason.NIGHT_SKIP, (j - j % 24000L) - this.getDayTime());
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 57f5792a06e55c7d7e9f0bf20c89c5d4337abd8d..c324b47449148a2b07b748cca456faa67c9358ba 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -358,6 +358,7 @@ public class PurpurWorldConfig {
+     public boolean playerFixStuckPortal = false;
+     public boolean creativeOnePunch = false;
+     public boolean playerSleepNearMonsters = false;
++    public boolean playersSkipNight = true;
+     private void playerSettings() {
+         if (PurpurConfig.version < 19) {
+             boolean oldVal = getBoolean("gameplay-mechanics.player.idle-timeout.mods-target", idleTimeoutTargetPlayer);
+@@ -378,6 +379,7 @@ public class PurpurWorldConfig {
+         playerFixStuckPortal = getBoolean("gameplay-mechanics.player.fix-stuck-in-portal", playerFixStuckPortal);
+         creativeOnePunch = getBoolean("gameplay-mechanics.player.one-punch-in-creative", creativeOnePunch);
+         playerSleepNearMonsters = getBoolean("gameplay-mechanics.player.sleep-ignore-nearby-mobs", playerSleepNearMonsters);
++        playersSkipNight = getBoolean("gameplay-mechanics.player.can-skip-night", playersSkipNight);
+     }
+ 
+     private static boolean projectileDespawnRateSettingsMigrated = false;

patches/unapplied/server/0146-Add-config-for-villager-trading.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Thu, 18 Mar 2021 07:23:27 -0400
+Subject: [PATCH] Add config for villager trading
+
+
+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 01a1732ca13300b60979d250ebf156ca68bb014f..444dbab9a1c95d1f8bc97e165e5302473a29c7e8 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -371,7 +371,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+                     return tryRide(player, hand, InteractionResult.sidedSuccess(this.level().isClientSide)); // Purpur
+                 } else {
+                     if (level().purpurConfig.villagerRidable && itemstack.isEmpty()) return tryRide(player, hand); // Purpur
+-                    if (!this.level().isClientSide && !this.offers.isEmpty()) {
++                    if (this.level().purpurConfig.villagerAllowTrading && !this.offers.isEmpty()) {
+                         this.startTrading(player);
+                     }
+ 
+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 5c6f1d3ffa2a2b6990d2406b14679e8286f60729..68d263a7647e395d981014f7cc761fe76fc74cb6 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
++++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -149,7 +149,7 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+                 return tryRide(player, hand, InteractionResult.sidedSuccess(this.level().isClientSide)); // Purpur
+             } else {
+                 if (level().purpurConfig.wanderingTraderRidable && itemstack.isEmpty()) return tryRide(player, hand); // Purpur
+-                if (!this.level().isClientSide) {
++                if (this.level().purpurConfig.wanderingTraderAllowTrading) {
+                     this.setTradingPlayer(player);
+                     this.openTradingScreen(player, this.getDisplayName(), 1);
+                 }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index c324b47449148a2b07b748cca456faa67c9358ba..37ee42c46d469e11dc48eb292442beaac3e74445 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -2127,6 +2127,7 @@ public class PurpurWorldConfig {
+     public boolean villagerClericFarmersThrowWarts = true;
+     public boolean villagerBypassMobGriefing = false;
+     public boolean villagerTakeDamageFromWater = false;
++    public boolean villagerAllowTrading = true;
+     private void villagerSettings() {
+         villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable);
+         villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater);
+@@ -2145,6 +2146,7 @@ public class PurpurWorldConfig {
+         villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts);
+         villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing);
+         villagerTakeDamageFromWater = getBoolean("mobs.villager.takes-damage-from-water", villagerTakeDamageFromWater);
++        villagerAllowTrading = getBoolean("mobs.villager.allow-trading", villagerAllowTrading);
+     }
+ 
+     public boolean vindicatorRidable = false;
+@@ -2174,6 +2176,7 @@ public class PurpurWorldConfig {
+     public boolean wanderingTraderFollowEmeraldBlock = false;
+     public boolean wanderingTraderCanBeLeashed = false;
+     public boolean wanderingTraderTakeDamageFromWater = false;
++    public boolean wanderingTraderAllowTrading = true;
+     private void wanderingTraderSettings() {
+         wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable);
+         wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater);
+@@ -2187,6 +2190,7 @@ public class PurpurWorldConfig {
+         wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock);
+         wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed);
+         wanderingTraderTakeDamageFromWater = getBoolean("mobs.wandering_trader.takes-damage-from-water", wanderingTraderTakeDamageFromWater);
++        wanderingTraderAllowTrading = getBoolean("mobs.wandering_trader.allow-trading", wanderingTraderAllowTrading);
+     }
+ 
+     public boolean wardenRidable = false;

patches/unapplied/server/0147-Allow-infinity-on-crossbows.patch

@@ -0,0 +1,98 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Thu, 18 Mar 2021 12:25:29 -0400
+Subject: [PATCH] Allow infinity on crossbows
+
+
+diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+index eede02c3f125d230af537bb67bebed9b88f7d1b4..1ae5e17b95d994d69b060fc06c0a807c40a90f17 100644
+--- a/src/main/java/net/minecraft/world/item/CrossbowItem.java
++++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+@@ -114,7 +114,7 @@ public class CrossbowItem extends ProjectileWeaponItem implements Vanishable {
+         // Paper end
+         int i = EnchantmentHelper.getItemEnchantmentLevel(Enchantments.MULTISHOT, crossbow);
+         int j = i == 0 ? 1 : 3;
+-        boolean flag = !consume || shooter instanceof Player && ((Player) shooter).getAbilities().instabuild; // Paper - add consume
++        boolean flag = !consume || shooter instanceof Player && ((Player) shooter).getAbilities().instabuild || (org.purpurmc.purpur.PurpurConfig.allowCrossbowInfinity && EnchantmentHelper.getItemEnchantmentLevel(Enchantments.INFINITY_ARROWS, crossbow) > 0); // Paper - add consume // Purpur
+         ItemStack itemstack1 = shooter.getProjectile(crossbow);
+         ItemStack itemstack2 = itemstack1.copy();
+ 
+@@ -300,7 +300,7 @@ public class CrossbowItem extends ProjectileWeaponItem implements Vanishable {
+ 
+         for (int i = 0; i < list.size(); ++i) {
+             ItemStack itemstack1 = (ItemStack) list.get(i);
+-            boolean flag = entity instanceof Player && ((Player) entity).getAbilities().instabuild;
++            boolean flag = entity instanceof Player && ((Player) entity).getAbilities().instabuild || (org.purpurmc.purpur.PurpurConfig.allowCrossbowInfinity && EnchantmentHelper.getItemEnchantmentLevel(Enchantments.INFINITY_ARROWS, stack) > 0); // Purpur
+ 
+             if (!itemstack1.isEmpty()) {
+                 if (i == 0) {
+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 2c4ce164ab3011f372ff1719c8d4a3331d8db55f..27512787b37381a5236b1b473e9ce3f06df8e2d0 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
++++ b/src/main/java/net/minecraft/world/item/enchantment/ArrowInfiniteEnchantment.java
+@@ -7,6 +7,14 @@ public class ArrowInfiniteEnchantment extends Enchantment {
+         super(weight, EnchantmentCategory.BOW, slotTypes);
+     }
+ 
++    // Purpur start
++    @Override
++    public boolean canEnchant(net.minecraft.world.item.ItemStack stack) {
++        // we have to cheat the system because this class is loaded before purpur's config is loaded
++        return (org.purpurmc.purpur.PurpurConfig.allowCrossbowInfinity ? EnchantmentCategory.BOW_AND_CROSSBOW : EnchantmentCategory.BOW).canEnchant(stack.getItem());
++    }
++    // Purpur end
++
+     @Override
+     public int getMinCost(int level) {
+         return 20;
+diff --git a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentCategory.java b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentCategory.java
+index 246516e67db0b8b197b287c067d5a0163d8bde22..859435f747ceef860cb4e9e825a7353ea3b90798 100644
+--- a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentCategory.java
++++ b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentCategory.java
+@@ -121,6 +121,14 @@ public enum EnchantmentCategory {
+         public boolean canEnchant(Item item) {
+             return item instanceof Vanishable || Block.byItem(item) instanceof Vanishable || BREAKABLE.canEnchant(item);
+         }
++    // Purpur start
++    },
++    BOW_AND_CROSSBOW {
++        @Override
++        public boolean canEnchant(Item item) {
++            return item instanceof BowItem || item instanceof CrossbowItem;
++        }
++    // Purpur end
+     };
+ 
+     public abstract boolean canEnchant(Item item);
+diff --git a/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java b/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java
+index 3d0ce0803e1da8a2681a3cb41096ac942ece54a1..bcd075a771c7f43c6d1549aeec2ccb20ee168b57 100644
+--- a/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java
++++ b/src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java
+@@ -59,6 +59,7 @@ public class CraftEnchantment extends Enchantment {
+             return EnchantmentTarget.CROSSBOW;
+         case VANISHABLE:
+             return EnchantmentTarget.VANISHABLE;
++        case BOW_AND_CROSSBOW: return EnchantmentTarget.BOW_AND_CROSSBOW; // Purpur
+         default:
+             return null;
+         }
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurConfig.java b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+index ea9d99990b718beaef4bee3ff75340656f3c76c5..55963ed03a2e552636035b498cf7441bd4c3ee59 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurConfig.java
+@@ -284,6 +284,7 @@ public class PurpurConfig {
+     }
+ 
+     public static boolean allowInfinityMending = false;
++    public static boolean allowCrossbowInfinity = false;
+     private static void enchantmentSettings() {
+         if (version < 5) {
+             boolean oldValue = getBoolean("settings.enchantment.allow-infinite-and-mending-together", false);
+@@ -291,6 +292,7 @@ public class PurpurConfig {
+             set("settings.enchantment.allow-infinite-and-mending-together", null);
+         }
+         allowInfinityMending = getBoolean("settings.enchantment.allow-infinity-and-mending-together", allowInfinityMending);
++        allowCrossbowInfinity = getBoolean("settings.enchantment.allow-infinity-on-crossbow", allowCrossbowInfinity);
+     }
+ 
+     public static boolean endermanShortHeight = false;

patches/unapplied/server/0148-Drowning-Settings.patch

@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ben Kerllenevich <ben@omega24.dev>
+Date: Sun, 21 Mar 2021 15:26:52 -0400
+Subject: [PATCH] Drowning Settings
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 36e9b635f81f2799cd210075bced9e976a90a351..dbd61da31192896ced9839cf8a3b123a6625ae60 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3305,7 +3305,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+ 
+     public int getMaxAirSupply() {
+-        return this.maxAirTicks; // CraftBukkit - SPIGOT-6907: re-implement LivingEntity#setMaximumAir()
++        return this.level == null? this.maxAirTicks : this.level().purpurConfig.drowningAirTicks; // CraftBukkit - SPIGOT-6907: re-implement LivingEntity#setMaximumAir() // Purpur
+     }
+ 
+     public int getAirSupply() {
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 9a4ac87ae3cc766ba4080cf5b4f3743d13bd6266..217a0082f7f260678253f31e381a432099555177 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -439,7 +439,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+                 if (flag1) {
+                     this.setAirSupply(this.decreaseAirSupply(this.getAirSupply()));
+-                    if (this.getAirSupply() == -20) {
++                    if (this.getAirSupply() == -this.level().purpurConfig.drowningDamageInterval) { // Purpur
+                         this.setAirSupply(0);
+                         Vec3 vec3d = this.getDeltaMovement();
+ 
+@@ -451,7 +451,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                             this.level().addParticle(ParticleTypes.BUBBLE, this.getX() + d2, this.getY() + d3, this.getZ() + d4, vec3d.x, vec3d.y, vec3d.z);
+                         }
+ 
+-                        this.hurt(this.damageSources().drown(), 2.0F);
++                        this.hurt(this.damageSources().drown(), (float) this.level().purpurConfig.damageFromDrowning); // Purpur
+                     }
+                 }
+ 
+diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+index 37ee42c46d469e11dc48eb292442beaac3e74445..f7e9f7ebb35dcbcbd8dce440824e4729e0239503 100644
+--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java
+@@ -164,6 +164,15 @@ public class PurpurWorldConfig {
+         nighttimeTicks = getInt("gameplay-mechanics.daylight-cycle-ticks.nighttime", nighttimeTicks);
+     }
+ 
++    public int drowningAirTicks = 300;
++    public int drowningDamageInterval = 20;
++    public double damageFromDrowning = 2.0F;
++    private void drowningSettings() {
++        drowningAirTicks = getInt("gameplay-mechanics.drowning.air-ticks", drowningAirTicks);
++        drowningDamageInterval = getInt("gameplay-mechanics.drowning.ticks-per-damage", drowningDamageInterval);
++        damageFromDrowning = getDouble("gameplay-mechanics.drowning.damage-from-drowning", damageFromDrowning);
++    }
++
+     public int elytraDamagePerSecond = 1;
+     public double elytraDamageMultiplyBySpeed = 0;
+     public boolean elytraIgnoreUnbreaking = false;