6 more

patches/server/0042-Ender-dragon-always-drop-full-exp.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 24 Aug 2019 14:42:54 -0500
+Subject: [PATCH] Ender dragon always drop full exp
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index c98202092752a9015aaf95bd1471135b88e84425..682b532967a501e21df93c28c4ee4b59eed073a7 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
+@@ -633,7 +633,7 @@ public class EnderDragon extends Mob implements Enemy {
+         boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT);
+         short short0 = 500;
+ 
+-        if (this.dragonFight != null && !this.dragonFight.hasPreviouslyKilledDragon()) {
++        if (this.dragonFight != null && (level.purpurConfig.enderDragonAlwaysDropsFullExp || !this.dragonFight.hasPreviouslyKilledDragon())) {
+             short0 = 12000;
+         }
+ 
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index d04981114fa2bce174441558b4d1c7c43ae2ea34..33aedbee4508ced806c8b72b91a6d8b4a04a4b76 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -142,6 +142,11 @@ public class PurpurWorldConfig {
+         creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance);
+     }
+ 
++    public boolean enderDragonAlwaysDropsFullExp = false;
++    private void enderDragonSettings() {
++        enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp);
++    }
++
+     public boolean foxTypeChangesWithTulips = false;
+     private void foxSettings() {
+         foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips);

patches/server/0043-Signs-editable-on-right-click.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 24 May 2019 02:39:25 -0500
+Subject: [PATCH] Signs editable on right click
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/SignBlock.java b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+index 1844ea93f8cea420f01937f85ed17c0ec1bb8bf0..9e80ba8970cad91ea22ac701f76e1413551a591f 100644
+--- a/src/main/java/net/minecraft/world/level/block/SignBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+@@ -14,6 +14,7 @@ import net.minecraft.world.item.DyeItem;
+ import net.minecraft.world.item.Item;
+ import net.minecraft.world.item.ItemStack;
+ import net.minecraft.world.item.Items;
++import net.minecraft.world.item.SignItem;
+ import net.minecraft.world.level.BlockGetter;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.LevelAccessor;
+@@ -108,6 +109,17 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
+                         }
+                     }
+ 
++                    // Purpur start - right click to open sign editor
++                    if (world.purpurConfig.signRightClickEdit && itemStack.getItem() instanceof SignItem &&
++                        !player.isCrouching() && player.getAbilities().mayBuild &&
++                        player.getBukkitEntity().hasPermission("purpur.sign.edit")) {
++                        signBlockEntity.setEditable(true);
++                        signBlockEntity.setAllowedPlayerEditor(player.getUUID());
++                        player.openTextEdit(signBlockEntity);
++                        return InteractionResult.SUCCESS;
++                    }
++                    // Purpur end
++
+                     return signBlockEntity.executeClickCommands((ServerPlayer)player) ? InteractionResult.SUCCESS : InteractionResult.PASS;
+                 } else {
+                     return InteractionResult.PASS;
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index 33aedbee4508ced806c8b72b91a6d8b4a04a4b76..26f5a224c7441a96ba4d4bd86eff4cdb100c28e6 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -109,6 +109,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
++    public boolean signRightClickEdit = false;
++    private void signSettings() {
++        signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
++    }
++
+     public boolean turtleEggsBreakFromExpOrbs = true;
+     public boolean turtleEggsBreakFromItems = true;
+     public boolean turtleEggsBreakFromMinecarts = true;

patches/server/0044-Signs-allow-color-codes.patch

@@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 6 Jun 2019 17:40:30 -0500
+Subject: [PATCH] Signs allow color codes
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 02965cc9ca344cd9673ed3361f7c28b829a2d97b..869bfb88d3d93a9601d97a1b03ead5969bbfd283 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1425,6 +1425,7 @@ public class ServerPlayer extends Player {
+ 
+     @Override
+     public void openTextEdit(SignBlockEntity sign) {
++        if (level.purpurConfig.signAllowColors) this.connection.send(sign.getTranslatedUpdatePacket(textFilteringEnabled)); // Purpur
+         sign.setAllowedPlayerEditor(this.getUUID());
+         this.connection.send(new ClientboundBlockUpdatePacket(this.level, sign.getBlockPos()));
+         this.connection.send(new ClientboundOpenSignEditorPacket(sign.getBlockPos()));
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 7255ce0b4d3e424b05542abcc35300a30e39687e..6680877abd9f0a6a66c6916dfaa899444fa6b52b 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2999,9 +2999,21 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+                 }
+                 // Paper end
+                 if (this.player.isTextFilteringEnabled()) {
+-                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(currentLine.getFiltered())));
++                    String filtered = currentLine.getFiltered();
++                    if (worldserver.purpurConfig.signAllowColors) {
++                        if (player.hasPermission("purpur.sign.color")) filtered = filtered.replaceAll("(?i)&([0-9a-fr])", "\u00a7$1");
++                        if (player.hasPermission("purpur.sign.style")) filtered = filtered.replaceAll("(?i)&([l-or])", "\u00a7$1");
++                        if (player.hasPermission("purpur.sign.magic")) filtered = filtered.replaceAll("(?i)&([kr])", "\u00a7$1");
++                    }
++                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(filtered)));
+                 } else {
+-                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(currentLine.getRaw())));
++                    String raw = currentLine.getRaw();
++                    if (worldserver.purpurConfig.signAllowColors) {
++                        if (player.hasPermission("purpur.sign.color")) raw = raw.replaceAll("(?i)&([0-9a-fr])", "\u00a7$1");
++                        if (player.hasPermission("purpur.sign.style")) raw = raw.replaceAll("(?i)&([l-or])", "\u00a7$1");
++                        if (player.hasPermission("purpur.sign.magic")) raw = raw.replaceAll("(?i)&([kr])", "\u00a7$1");
++                    }
++                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(raw)));
+                 }
+             }
+             SignChangeEvent event = new SignChangeEvent((org.bukkit.craftbukkit.block.CraftBlock) player.getWorld().getBlockAt(x, y, z), this.cserver.getPlayer(this.player), lines);
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+index 9b5d11ece006d7aa893360a84ba652c666517ac1..3373c21f90eb08e2bfbb71bc348d085aad77de77 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+@@ -4,6 +4,8 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException;
+ import java.util.UUID;
+ import java.util.function.Function;
+ import javax.annotation.Nullable;
++
++import io.papermc.paper.adventure.PaperAdventure;
+ import net.minecraft.commands.CommandSource;
+ import net.minecraft.commands.CommandSourceStack;
+ import net.minecraft.core.BlockPos;
+@@ -180,6 +182,18 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
+         return filtered ? this.filteredMessages : this.messages;
+     }
+ 
++    // Purpur start
++    public ClientboundBlockEntityDataPacket getTranslatedUpdatePacket(boolean filtered) {
++        CompoundTag nbt = save(new CompoundTag());
++        for (int i = 0; i < 4; ++i) {
++            String line = PaperAdventure.LEGACY_AMPERSAND.serialize(PaperAdventure.asAdventure(getMessages(filtered)[i]));
++            nbt.putString("Text" + (i + 1), net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().serialize(net.kyori.adventure.text.Component.text(line)));
++        }
++        nbt.putString("PurpurEditor", "true");
++        return new ClientboundBlockEntityDataPacket(worldPosition, 9, nbt);
++    }
++    // Purpur end
++
+     @Nullable
+     @Override
+     public ClientboundBlockEntityDataPacket getUpdatePacket() {
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index 26f5a224c7441a96ba4d4bd86eff4cdb100c28e6..3a9efffb7579665e7360bfcaf4ba390aca3201cb 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -109,8 +109,10 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
++    public boolean signAllowColors = false;
+     public boolean signRightClickEdit = false;
+     private void signSettings() {
++        signAllowColors = getBoolean("blocks.sign.allow-colors", signAllowColors);
+         signRightClickEdit = getBoolean("blocks.sign.right-click-edit", signRightClickEdit);
+     }
+ 

patches/server/0045-Allow-soil-to-moisten-from-water-directly-under-it.patch

@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Fri, 21 Jun 2019 14:37:10 -0500
+Subject: [PATCH] Allow soil to moisten from water directly under it
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FarmBlock.java b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+index aa1ba8b74ab70b6cede99e4853ac0203f388ab06..97e5cb4fd9f97c0bfa9d66c0ceac84e134f1053f 100644
+--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
+@@ -139,19 +139,14 @@ public class FarmBlock extends Block {
+     }
+ 
+     private static boolean isNearWater(LevelReader world, BlockPos pos) {
+-        Iterator iterator = BlockPos.betweenClosed(pos.offset(-4, 0, -4), pos.offset(4, 1, 4)).iterator();
+-
+-        BlockPos blockposition1;
+-
+-        do {
+-            if (!iterator.hasNext()) {
+-                return false;
++        // Purpur start
++        for (BlockPos position : BlockPos.betweenClosed(pos.offset(-4, 0, -4), pos.offset(4, 1, 4))) {
++            if (world.getFluidState(position).is(FluidTags.WATER)) {
++                return true;
+             }
+-
+-            blockposition1 = (BlockPos) iterator.next();
+-        } while (!world.getFluidState(blockposition1).is((Tag) FluidTags.WATER));
+-
+-        return true;
++        }
++        return ((ServerLevel) world).purpurConfig.farmlandGetsMoistFromBelow && world.getFluidState(pos.relative(Direction.DOWN)).is(FluidTags.WATER);
++        // Purpur end
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index 3a9efffb7579665e7360bfcaf4ba390aca3201cb..42cf3dc7185408964e226c1fa41e4587c785e045 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -109,6 +109,11 @@ public class PurpurWorldConfig {
+         });
+     }
+ 
++    public boolean farmlandGetsMoistFromBelow = false;
++    private void farmlandSettings() {
++        farmlandGetsMoistFromBelow = getBoolean("blocks.farmland.gets-moist-from-below", farmlandGetsMoistFromBelow);
++    }
++
+     public boolean signAllowColors = false;
+     public boolean signRightClickEdit = false;
+     private void signSettings() {

patches/server/0046-Minecart-settings-and-WASD-controls.patch

@@ -0,0 +1,255 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sat, 29 Jun 2019 02:32:40 -0500
+Subject: [PATCH] Minecart settings and WASD controls
+
+
+diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
+index 22ea0da3836b61bb018ae974d2b8c7546b9528d6..dea8abfd8443702e138823bd536aaac2c3395d6f 100644
+--- a/src/main/java/net/minecraft/core/BlockPos.java
++++ b/src/main/java/net/minecraft/core/BlockPos.java
+@@ -41,6 +41,12 @@ public class BlockPos extends Vec3i {
+     private static final int X_OFFSET = 38;
+     // Paper end
+ 
++    // Purpur start
++    public BlockPos(net.minecraft.world.entity.Entity entity) {
++        super(entity.getX(), entity.getY(), entity.getZ());
++    }
++    // Purpur end
++
+     public BlockPos(int x, int y, int z) {
+         super(x, y, z);
+     }
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 869bfb88d3d93a9601d97a1b03ead5969bbfd283..a8f1aa81ec02deb75efef820508ec4be79545be8 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -952,6 +952,7 @@ public class ServerPlayer extends Player {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else {
++            if (source == DamageSource.FALL && getRootVehicle() instanceof net.minecraft.world.entity.vehicle.AbstractMinecart && level.purpurConfig.minecartControllable && !level.purpurConfig.minecartControllableFallDamage) return false; // Purpur
+             boolean flag = this.server.isDedicatedServer() && this.isPvpAllowed() && "fall".equals(source.msgId);
+ 
+             if (!flag && isSpawnInvulnerable() && source != DamageSource.OUT_OF_WORLD) { // Purpur
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+index 309bafd257d4932cfd69c2c212b32306938cd234..1e3077a22d9d3d26356b865001dcce81c9c1d7e5 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -110,11 +110,13 @@ public abstract class AbstractMinecart extends Entity {
+     private double flyingY = 0.949999988079071D; // Paper - restore vanilla precision
+     private double flyingZ = 0.949999988079071D; // Paper - restore vanilla precision
+     public double maxSpeed = 0.4D;
++    public double storedMaxSpeed; // Purpur
+     // CraftBukkit end
+ 
+     protected AbstractMinecart(EntityType<?> type, Level world) {
+         super(type, world);
+         this.blocksBuilding = true;
++        if (world != null) maxSpeed = storedMaxSpeed = world.purpurConfig.minecartMaxSpeed; // Purpur
+     }
+ 
+     protected AbstractMinecart(EntityType<?> type, Level world, double x, double y, double z) {
+@@ -327,6 +329,12 @@ public abstract class AbstractMinecart extends Entity {
+ 
+     @Override
+     public void tick() {
++        // Purpur start
++        if (storedMaxSpeed != level.purpurConfig.minecartMaxSpeed) {
++            maxSpeed = storedMaxSpeed = level.purpurConfig.minecartMaxSpeed;
++        }
++        // Purpur end
++
+         // CraftBukkit start
+         double prevX = this.getX();
+         double prevY = this.getY();
+@@ -490,16 +498,62 @@ public abstract class AbstractMinecart extends Entity {
+ 
+     public void activateMinecart(int x, int y, int z, boolean powered) {}
+ 
++    // Purpur start
++    private Double lastSpeed;
++
++    public double getControllableSpeed() {
++        BlockPos pos = new BlockPos(this);
++        Block block = level.getBlockState(pos).getBlock();
++        if (!block.material.isSolid()) {
++            block = level.getBlockState(pos.relative(Direction.DOWN)).getBlock();
++        }
++        Double speed = level.purpurConfig.minecartControllableBlockSpeeds.get(block);
++        if (!block.material.isSolid()) {
++            speed = lastSpeed;
++        } else if (speed == null) {
++            speed = level.purpurConfig.minecartControllableBaseSpeed;
++        }
++        return lastSpeed = speed;
++    }
++    // Purpur end
++
+     protected void comeOffTrack() {
+         double d0 = this.getMaxSpeed();
+         Vec3 vec3d = this.getDeltaMovement();
+ 
+         this.setDeltaMovement(Mth.clamp(vec3d.x, -d0, d0), vec3d.y, Mth.clamp(vec3d.z, -d0, d0));
++
++        // Purpur start
++        if (level.purpurConfig.minecartControllable && !isInWater() && !isInLava() && !passengers.isEmpty()) {
++            Entity passenger = passengers.get(0);
++            if (passenger instanceof Player) {
++                Player player = (Player) passenger;
++                if (player.jumping && this.onGround) {
++                    setDeltaMovement(new Vec3(getDeltaMovement().x, level.purpurConfig.minecartControllableHopBoost, getDeltaMovement().z));
++                }
++                if (player.zza != 0.0F) {
++                    Vector velocity = player.getBukkitEntity().getEyeLocation().getDirection().normalize().multiply(getControllableSpeed());
++                    if (player.zza < 0.0) {
++                        velocity.multiply(-0.5);
++                    }
++                    setDeltaMovement(new Vec3(velocity.getX(), getDeltaMovement().y, velocity.getZ()));
++                }
++                this.setYRot(passenger.getYRot() - 90);
++                maxUpStep = level.purpurConfig.minecartControllableStepHeight;
++            } else {
++                maxUpStep = 0.0F;
++            }
++        } else {
++            maxUpStep = 0.0F;
++        }
++        // Purpur end
++
+         if (this.onGround) {
+             // CraftBukkit start - replace magic numbers with our variables
+             this.setDeltaMovement(new Vec3(this.getDeltaMovement().x * this.derailedX, this.getDeltaMovement().y * this.derailedY, this.getDeltaMovement().z * this.derailedZ));
+             // CraftBukkit end
+         }
++        else if (level.purpurConfig.minecartControllable) setDeltaMovement(new Vec3(getDeltaMovement().x * derailedX, getDeltaMovement().y, getDeltaMovement().z * derailedZ)); // Purpur
+ 
+         this.move(MoverType.SELF, this.getDeltaMovement());
+         if (!this.onGround) {
+diff --git a/src/main/java/net/minecraft/world/item/MinecartItem.java b/src/main/java/net/minecraft/world/item/MinecartItem.java
+index 9ea3837acc315e5c57f28c63c356efd633f1e6cf..e8b76b67f972c2f44e7611434246a822d549a129 100644
+--- a/src/main/java/net/minecraft/world/item/MinecartItem.java
++++ b/src/main/java/net/minecraft/world/item/MinecartItem.java
+@@ -123,8 +123,9 @@ public class MinecartItem extends Item {
+         BlockState iblockdata = world.getBlockState(blockposition);
+ 
+         if (!iblockdata.is((Tag) BlockTags.RAILS)) {
+-            return InteractionResult.FAIL;
+-        } else {
++            if (!world.purpurConfig.minecartPlaceAnywhere) return InteractionResult.FAIL;
++            if (iblockdata.getMaterial().isSolid()) blockposition = blockposition.relative(context.getClickedFace());
++        } // else { // Purpur - place minecarts anywhere
+             ItemStack itemstack = context.getItemInHand();
+ 
+             if (!world.isClientSide) {
+@@ -152,6 +153,6 @@ public class MinecartItem extends Item {
+ 
+             itemstack.shrink(1);
+             return InteractionResult.sidedSuccess(world.isClientSide);
+-        }
++        // } // Purpur - place minecarts anywhere
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 933448659367b5f0b323bd91992fc9b59314b8a1..572e5f32a3c5aaffcec31da0cff9151efea252ac 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
++++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -70,7 +70,7 @@ import net.minecraft.world.phys.shapes.VoxelShape;
+ public abstract class BlockBehaviour {
+ 
+     protected static final Direction[] UPDATE_SHAPE_ORDER = new Direction[]{Direction.WEST, Direction.EAST, Direction.NORTH, Direction.SOUTH, Direction.DOWN, Direction.UP};
+-    protected final Material material;
++    public final Material material; // Purpur - protected -> public
+     protected final boolean hasCollision;
+     protected final float explosionResistance;
+     protected final boolean isRandomlyTicking;
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index 42cf3dc7185408964e226c1fa41e4587c785e045..c63e46ae34a937a3ba5d1dc19afca256e306a224 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -4,10 +4,15 @@ import net.minecraft.core.Registry;
+ import net.minecraft.resources.ResourceLocation;
+ import net.minecraft.world.item.Item;
+ import net.minecraft.world.item.Items;
++import net.minecraft.world.level.block.Block;
++import net.minecraft.world.level.block.Blocks;
+ import org.bukkit.configuration.ConfigurationSection;
+ 
+ import java.util.ArrayList;
++import java.util.HashMap;
+ import java.util.List;
++import java.util.Map;
++
+ import static net.pl3x.purpur.PurpurConfig.log;
+ 
+ public class PurpurWorldConfig {
+@@ -68,6 +73,68 @@ public class PurpurWorldConfig {
+         armorstandStepHeight = (float) getDouble("gameplay-mechanics.armorstand.step-height", armorstandStepHeight);
+     }
+ 
++    public double minecartMaxSpeed = 0.4D;
++    public boolean minecartPlaceAnywhere = false;
++    public boolean minecartControllable = false;
++    public float minecartControllableStepHeight = 1.0F;
++    public double minecartControllableHopBoost = 0.5D;
++    public boolean minecartControllableFallDamage = true;
++    public double minecartControllableBaseSpeed = 0.1D;
++    public Map<Block, Double> minecartControllableBlockSpeeds = new HashMap<>();
++    private void minecartSettings() {
++        if (PurpurConfig.version < 12) {
++            boolean oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.place-anywhere", minecartPlaceAnywhere);
++            set("gameplay-mechanics.controllable-minecarts.place-anywhere", null);
++            set("gameplay-mechanics.minecart.place-anywhere", oldBool);
++            oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.enabled", minecartControllable);
++            set("gameplay-mechanics.controllable-minecarts.enabled", null);
++            set("gameplay-mechanics.minecart.controllable.enabled", oldBool);
++            double oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.step-height", minecartControllableStepHeight);
++            set("gameplay-mechanics.controllable-minecarts.step-height", null);
++            set("gameplay-mechanics.minecart.controllable.step-height", oldDouble);
++            oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.hop-boost", minecartControllableHopBoost);
++            set("gameplay-mechanics.controllable-minecarts.hop-boost", null);
++            set("gameplay-mechanics.minecart.controllable.hop-boost", oldDouble);
++            oldBool = getBoolean("gameplay-mechanics.controllable-minecarts.fall-damage", minecartControllableFallDamage);
++            set("gameplay-mechanics.controllable-minecarts.fall-damage", null);
++            set("gameplay-mechanics.minecart.controllable.fall-damage", oldBool);
++            oldDouble = getDouble("gameplay-mechanics.controllable-minecarts.base-speed", minecartControllableBaseSpeed);
++            set("gameplay-mechanics.controllable-minecarts.base-speed", null);
++            set("gameplay-mechanics.minecart.controllable.base-speed", oldDouble);
++            ConfigurationSection section = getConfigurationSection("gameplay-mechanics.controllable-minecarts.block-speed");
++            if (section != null) {
++                for (String key : section.getKeys(false)) {
++                    if ("grass-block".equals(key)) key = "grass_block"; // oopsie
++                    oldDouble = section.getDouble(key, minecartControllableBaseSpeed);
++                    set("gameplay-mechanics.controllable-minecarts.block-speed." + key, null);
++                    set("gameplay-mechanics.minecart.controllable.block-speed." + key, oldDouble);
++                }
++                set("gameplay-mechanics.controllable-minecarts.block-speed", null);
++            }
++            set("gameplay-mechanics.controllable-minecarts", null);
++        }
++
++        minecartMaxSpeed = getDouble("gameplay-mechanics.minecart.max-speed", minecartMaxSpeed);
++        minecartPlaceAnywhere = getBoolean("gameplay-mechanics.minecart.place-anywhere", minecartPlaceAnywhere);
++        minecartControllable = getBoolean("gameplay-mechanics.minecart.controllable.enabled", minecartControllable);
++        minecartControllableStepHeight = (float) getDouble("gameplay-mechanics.minecart.controllable.step-height", minecartControllableStepHeight);
++        minecartControllableHopBoost = getDouble("gameplay-mechanics.minecart.controllable.hop-boost", minecartControllableHopBoost);
++        minecartControllableFallDamage = getBoolean("gameplay-mechanics.minecart.controllable.fall-damage", minecartControllableFallDamage);
++        minecartControllableBaseSpeed = getDouble("gameplay-mechanics.minecart.controllable.base-speed", minecartControllableBaseSpeed);
++        ConfigurationSection section = getConfigurationSection("gameplay-mechanics.minecart.controllable.block-speed");
++        if (section != null) {
++            for (String key : section.getKeys(false)) {
++                Block block = Registry.BLOCK.get(new ResourceLocation(key));
++                if (block != Blocks.AIR) {
++                    minecartControllableBlockSpeeds.put(block, section.getDouble(key, minecartControllableBaseSpeed));
++                }
++            }
++        } else {
++            set("gameplay-mechanics.minecart.controllable.block-speed.grass_block", 0.3D);
++            set("gameplay-mechanics.minecart.controllable.block-speed.stone", 0.5D);
++        }
++    }
++
+     public boolean idleTimeoutKick = true;
+     public boolean idleTimeoutTickNearbyEntities = true;
+     public boolean idleTimeoutCountAsSleeping = false;

patches/server/0047-Disable-loot-drops-on-death-by-cramming.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Wed, 3 Jul 2019 23:58:31 -0500
+Subject: [PATCH] Disable loot drops on death by cramming
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 3c40cec55a1195f81ce453eaebe9487e140297ae..3cf3a6ba7bec27ce2ae9b294b0676fdc6c9e38b6 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1700,8 +1700,10 @@ public abstract class LivingEntity extends Entity {
+ 
+         this.dropEquipment(); // CraftBukkit - from below
+         if (this.shouldDropLoot() && this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
++            if (!(source == DamageSource.CRAMMING && level.purpurConfig.disableDropsOnCrammingDeath)) { // Purpur
+             this.dropFromLootTable(source, flag);
+             this.dropCustomDeathLoot(source, i, flag);
++            } // Purpur
+         }
+         // CraftBukkit start - Call death event
+         org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, this.drops); // Paper
+diff --git a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+index c63e46ae34a937a3ba5d1dc19afca256e306a224..ecca777f038f90f5f731777dde2e6cfd39af9bb7 100644
+--- a/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
++++ b/src/main/java/net/pl3x/purpur/PurpurWorldConfig.java
+@@ -146,6 +146,11 @@ public class PurpurWorldConfig {
+         idleTimeoutUpdateTabList = getBoolean("gameplay-mechanics.player.idle-timeout.update-tab-list", idleTimeoutUpdateTabList);
+     }
+ 
++    public boolean disableDropsOnCrammingDeath = false;
++    private void miscGameplayMechanicsSettings() {
++        disableDropsOnCrammingDeath = getBoolean("gameplay-mechanics.disable-drops-on-cramming-death", disableDropsOnCrammingDeath);
++    }
++
+     public int playerSpawnInvulnerableTicks = 60;
+     public boolean playerInvulnerableWhileAcceptingResourcePack = false;
+     private void playerInvulnerabilities() {