more patches (#5808)

2021-06-12 12:30:37 -07:00 · 2021-06-12 12:30:37 -07:00 · 716a3139b7
commit 716a3139b7
parent d7e184d055
73 changed files with 515 additions and 605 deletions
--- a/patches/server/0125-Provide-E-TE-Chunk-count-stat-methods.patch
+++ b/patches/server/0125-Provide-E-TE-Chunk-count-stat-methods.patch
@ -6,19 +6,6 @@ Subject: [PATCH] Provide E/TE/Chunk count stat methods
 Provides counts without the ineffeciency of using .getEntities().size()
 which creates copy of the collections.

-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 8323ddb363f49d266dd95f11241a30a9a27250aa..2cd34f326f374e3ad46a4eea8c84be326cd489a0 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -173,7 +173,7 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
-     public static final BlockPos END_SPAWN_POINT = new BlockPos(100, 50, 0);
-     private static final Logger LOGGER = LogManager.getLogger();
-     private static final int EMPTY_TIME_NO_TICK = 300;
-    final List<ServerPlayer> players;
-+    final List<ServerPlayer> players; public final int getPlayerListSize() { return this.players.size(); } // Paper
-     public final ServerChunkCache chunkSource; // Paper - public
-     private final MinecraftServer server;
-     public final PrimaryLevelData serverLevelData; // CraftBukkit - type
 diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
 index 52d80086deff664fcfd8952b7cabbfa1f48ad131..a86b5272c0ac4dd64f796f7fd025c7a34a5d2f8d 100644
 --- a/src/main/java/net/minecraft/world/level/Level.java
@ -33,7 +20,7 @@ index 52d80086deff664fcfd8952b7cabbfa1f48ad131..a86b5272c0ac4dd64f796f7fd025c7a3
     private boolean tickingBlockEntities;
     public final Thread thread;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 5133febf4b3a83b2870fee2f9e45b1d12894df54..e11a1a21bff1fc5e730d6c63c5b0c623b3b2e037 100644
+index 5133febf4b3a83b2870fee2f9e45b1d12894df54..10b046ed843acac205608fa2fa3ffd4e4a277b5c 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
@@ -270,6 +270,57 @@ public class CraftWorld implements World {
@ -87,7 +74,7 @@ index 5133febf4b3a83b2870fee2f9e45b1d12894df54..e11a1a21bff1fc5e730d6c63c5b0c623
 +
 +    @Override
 +    public int getPlayerCount() {
-+        return world.getPlayerListSize();
+        return world.players().size();
 +    }
 +    // Paper end
 +
--- a/patches/server/0185-getPlayerUniqueId-API.patch
+++ b/patches/server/0185-getPlayerUniqueId-API.patch
@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 22 Mar 2018 01:40:24 -0400
+Subject: [PATCH] getPlayerUniqueId API
+
+Gets the unique ID of the player currently known as the specified player name
+In Offline Mode, will return an Offline UUID
+
+This is a more performant way to obtain a UUID for a name than loading an OfflinePlayer
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index cb09b6170a74984628f2c3dbacad2ddc9fe56faf..df94ac3f5319cd990f5592d57d2e319c84f51524 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1517,6 +1517,25 @@ public final class CraftServer implements Server {
+         return recipients.size();
+     }
+ 
+    // Paper start
+    @Nullable
+    public UUID getPlayerUniqueId(String name) {
+        Player player = Bukkit.getPlayerExact(name);
+        if (player != null) {
+            return player.getUniqueId();
+        }
+        GameProfile profile;
+        // Only fetch an online UUID in online mode
+        if (com.destroystokyo.paper.PaperConfig.isProxyOnlineMode()) {
+            profile = console.getProfileCache().get( name );
+        } else {
+            // Make an OfflinePlayer using an offline mode UUID since the name has no profile
+            profile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)), name);
+        }
+        return profile != null ? profile.getId() : null;
+    }
+    // Paper end
+
+     @Override
+     @Deprecated
+     public OfflinePlayer getOfflinePlayer(String name) {
--- a/patches/server/0186-Make-player-data-saving-configurable.patch
+++ b/patches/server/0186-Make-player-data-saving-configurable.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Mon, 26 Mar 2018 18:30:53 +0300
+Subject: [PATCH] Make player data saving configurable
+
+Upstream has added a patch which negates the need for this patch,
+however, we should still migrate our configuration back upstream,
+to prevent unexpected situations
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+index 52954fc3bf932cfc9d5ce63e3d3cace351305790..05a5abb951abe37f30a719cb75376d2d43c0d252 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+@@ -279,4 +279,13 @@ public class PaperConfig {
+     private static void authenticationServersDownKickMessage() {
+         authenticationServersDownKickMessage = Strings.emptyToNull(getString("messages.kick.authentication-servers-down", authenticationServersDownKickMessage));
+     }
+
+    private static void savePlayerData() {
+        Object val = config.get("settings.save-player-data");
+        if (val instanceof Boolean) {
+            SpigotConfig.disablePlayerDataSaving = !(Boolean) val;
+            SpigotConfig.config.set("players.disable-saving", SpigotConfig.disableAdvancementSaving);
+            SpigotConfig.save();
+        }
+    }
+ }
--- a/patches/server/0187-Make-legacy-ping-handler-more-reliable.patch
+++ b/patches/server/0187-Make-legacy-ping-handler-more-reliable.patch
@ -0,0 +1,168 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Wed, 11 Oct 2017 18:22:50 +0200
+Subject: [PATCH] Make legacy ping handler more reliable
+
+The Minecraft server often fails to respond to old ("legacy") pings
+from old Minecraft versions using the protocol used before the switch
+to Netty in Minecraft 1.7.
+
+Due to packet fragmentation[1], we might not have all needed bytes
+available when the LegacyPingHandler is called. In this case, it will
+run into an error, remove the handler and continue using the modern
+protocol.
+
+This is unlikely to happen for the first two revisions of the legacy
+ping protocol (used in Minecraft 1.5.x and older) since the request
+consists of only one or two bytes, but happens frequently for the
+last/third revision introduced in Minecraft 1.6.
+
+It has much larger, variable packet sizes due to the inclusion of
+the virtual host (the hostname/port used to connect to the server).
+
+The solution[2] is simple: If we find more than two matching bytes,
+we buffer the remaining bytes until we have enough to fully read and
+respond to the request.
+
+[1]: https://netty.io/wiki/user-guide-for-4.x.html#wiki-h3-11
+[2]: https://netty.io/wiki/user-guide-for-4.x.html#wiki-h4-13
+
+diff --git a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+index a2b0237a27379d05e8ca15cb033ee3fd2a5bb29b..6a759cfd0c2df4daaf126d12d20ac8d701e41f9d 100644
+--- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+@@ -16,6 +16,7 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+     private static final Logger LOGGER = LogManager.getLogger();
+     public static final int FAKE_PROTOCOL_VERSION = 127;
+     private final ServerConnectionListener serverConnectionListener;
+    private ByteBuf buf; // Paper
+ 
+     public LegacyQueryHandler(ServerConnectionListener networkIo) {
+         this.serverConnectionListener = networkIo;
+@@ -24,6 +25,16 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+     public void channelRead(ChannelHandlerContext channelhandlercontext, Object object) {
+         ByteBuf bytebuf = (ByteBuf) object;
+ 
+        // Paper start - Make legacy ping handler more reliable
+        if (this.buf != null) {
+            try {
+                readLegacy1_6(channelhandlercontext, bytebuf);
+            } finally {
+                bytebuf.release();
+            }
+            return;
+        }
+        // Paper end
+         bytebuf.markReaderIndex();
+         boolean flag = true;
+ 
+@@ -54,6 +65,10 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+                     this.sendFlushAndClose(channelhandlercontext, this.createReply(s));
+                     break;
+                 default:
+                // Paper start - Replace with improved version below
+                if (bytebuf.readUnsignedByte() != 0x01 || bytebuf.readUnsignedByte() != 0xFA) return;
+                readLegacy1_6(channelhandlercontext, bytebuf);
+                /*
+                     boolean flag1 = bytebuf.readUnsignedByte() == 1;
+ 
+                     flag1 &= bytebuf.readUnsignedByte() == 250;
+@@ -77,6 +92,7 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+                     } finally {
+                         bytebuf1.release();
+                     }
+                */ // Paper end - Replace with improved version below
+             }
+ 
+             bytebuf.release();
+@@ -94,6 +110,90 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+ 
+     }
+ 
+    // Paper start
+    private static String readLegacyString(ByteBuf buf) {
+        int size = buf.readShort() * Character.BYTES;
+        if (!buf.isReadable(size)) {
+            return null;
+        }
+
+        String result = buf.toString(buf.readerIndex(), size, StandardCharsets.UTF_16BE);
+        buf.skipBytes(size); // toString doesn't increase readerIndex automatically
+        return result;
+    }
+
+    private void readLegacy1_6(ChannelHandlerContext ctx, ByteBuf part) {
+        ByteBuf buf = this.buf;
+
+        if (buf == null) {
+            this.buf = buf = ctx.alloc().buffer();
+            buf.markReaderIndex();
+        } else {
+            buf.resetReaderIndex();
+        }
+
+        buf.writeBytes(part);
+
+        if (!buf.isReadable(Short.BYTES + Short.BYTES + Byte.BYTES + Short.BYTES + Integer.BYTES)) {
+            return;
+        }
+
+        String s = readLegacyString(buf);
+        if (s == null) {
+            return;
+        }
+
+        if (!s.equals("MC|PingHost")) {
+            removeHandler(ctx);
+            return;
+        }
+
+        if (!buf.isReadable(Short.BYTES) || !buf.isReadable(buf.readShort())) {
+            return;
+        }
+
+        MinecraftServer server = this.serverConnectionListener.getServer();
+        int protocolVersion = buf.readByte();
+        String host = readLegacyString(buf);
+        if (host == null) {
+            removeHandler(ctx);
+            return;
+        }
+        int port = buf.readInt();
+
+        if (buf.isReadable()) {
+            removeHandler(ctx);
+            return;
+        }
+
+        buf.release();
+        this.buf = null;
+
+        LOGGER.debug("Ping: (1.6) from {}", ctx.channel().remoteAddress());
+
+        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d",
+                Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
+        this.sendFlushAndClose(ctx, this.createReply(response));
+    }
+
+    private void removeHandler(ChannelHandlerContext ctx) {
+        ByteBuf buf = this.buf;
+        this.buf = null;
+
+        buf.resetReaderIndex();
+        ctx.pipeline().remove(this);
+        ctx.fireChannelRead(buf);
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) {
+        if (this.buf != null) {
+            this.buf.release();
+            this.buf = null;
+        }
+    }
+    // Paper end
+
+     private void sendFlushAndClose(ChannelHandlerContext ctx, ByteBuf buf) {
+         ctx.pipeline().firstContext().writeAndFlush(buf).addListener(ChannelFutureListener.CLOSE);
+     }
--- a/patches/server/0188-Call-PaperServerListPingEvent-for-legacy-pings.patch
+++ b/patches/server/0188-Call-PaperServerListPingEvent-for-legacy-pings.patch
@ -0,0 +1,154 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Wed, 11 Oct 2017 19:30:51 +0200
+Subject: [PATCH] Call PaperServerListPingEvent for legacy pings
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java b/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..74c012fd40491f1d870fbc1aa8c318a2197eb106
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java
+@@ -0,0 +1,73 @@
+package com.destroystokyo.paper.network;
+
+import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
+import net.minecraft.server.MinecraftServer;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.ChatColor;
+
+import java.net.InetSocketAddress;
+
+import javax.annotation.Nullable;
+
+public final class PaperLegacyStatusClient implements StatusClient {
+
+    private final InetSocketAddress address;
+    private final int protocolVersion;
+    @Nullable private final InetSocketAddress virtualHost;
+
+    private PaperLegacyStatusClient(InetSocketAddress address, int protocolVersion, @Nullable InetSocketAddress virtualHost) {
+        this.address = address;
+        this.protocolVersion = protocolVersion;
+        this.virtualHost = virtualHost;
+    }
+
+    @Override
+    public InetSocketAddress getAddress() {
+        return this.address;
+    }
+
+    @Override
+    public int getProtocolVersion() {
+        return this.protocolVersion;
+    }
+
+    @Nullable
+    @Override
+    public InetSocketAddress getVirtualHost() {
+        return this.virtualHost;
+    }
+
+    @Override
+    public boolean isLegacy() {
+        return true;
+    }
+
+    public static PaperServerListPingEvent processRequest(MinecraftServer server,
+            InetSocketAddress address, int protocolVersion, @Nullable InetSocketAddress virtualHost) {
+
+        PaperServerListPingEvent event =  new PaperServerListPingEventImpl(server,
+                new PaperLegacyStatusClient(address, protocolVersion, virtualHost), Byte.MAX_VALUE, null);
+        server.server.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return null;
+        }
+
+        return event;
+    }
+
+    public static String getMotd(PaperServerListPingEvent event) {
+        return getFirstLine(event.getMotd());
+    }
+
+    public static String getUnformattedMotd(PaperServerListPingEvent event) {
+        // Strip color codes and all other occurrences of the color char (because it's used as delimiter)
+        return getFirstLine(StringUtils.remove(ChatColor.stripColor(event.getMotd()), ChatColor.COLOR_CHAR));
+    }
+
+    private static String getFirstLine(String s) {
+        int pos = s.indexOf('\n');
+        return pos >= 0 ? s.substring(0, pos) : s;
+    }
+
+}
+diff --git a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+index 6a759cfd0c2df4daaf126d12d20ac8d701e41f9d..3962e82d4e4c5f792a37e825891e6960e737452d 100644
+--- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server.network;
+ 
+import com.destroystokyo.paper.network.PaperLegacyStatusClient;
+
+ import io.netty.buffer.ByteBuf;
+ import io.netty.buffer.Unpooled;
+ import io.netty.channel.ChannelFutureListener;
+@@ -47,12 +49,19 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+             MinecraftServer minecraftserver = this.serverConnectionListener.getServer();
+             int i = bytebuf.readableBytes();
+             String s;
+-            org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(minecraftserver.server, inetsocketaddress.getAddress(), minecraftserver.getMotd(), minecraftserver.getPlayerCount(), minecraftserver.getMaxPlayers()); // CraftBukkit
+            //org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(minecraftserver.server, inetsocketaddress.getAddress(), minecraftserver.getMotd(), minecraftserver.getPlayerCount(), minecraftserver.getMaxPlayers()); // CraftBukkit // Paper
+            com.destroystokyo.paper.event.server.PaperServerListPingEvent event; // Paper
+ 
+             switch (i) {
+                 case 0:
+                     LegacyQueryHandler.LOGGER.debug("Ping: (<1.3.x) from {}:{}", inetsocketaddress.getAddress(), inetsocketaddress.getPort());
+-                    s = String.format("%s\u00a7%d\u00a7%d", event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()); // CraftBukkit
+                // Paper start - Call PaperServerListPingEvent and use results
+                event = PaperLegacyStatusClient.processRequest(minecraftserver, inetsocketaddress, 39, null);
+                if (event == null) {
+                    channelhandlercontext.close();
+                    break;
+                }
+                s = String.format("%s\u00a7%d\u00a7%d", PaperLegacyStatusClient.getUnformattedMotd(event), event.getNumPlayers(), event.getMaxPlayers());
+                     this.sendFlushAndClose(channelhandlercontext, this.createReply(s));
+                     break;
+                 case 1:
+@@ -61,7 +70,14 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+                     }
+ 
+                     LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}:{}", inetsocketaddress.getAddress(), inetsocketaddress.getPort());
+-                    s = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", 127, minecraftserver.getServerVersion(), event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()); // CraftBukkit
+                // Paper start - Call PaperServerListPingEvent and use results
+                event = PaperLegacyStatusClient.processRequest(minecraftserver, inetsocketaddress, 127, null); // Paper
+                if (event == null) {
+                    channelhandlercontext.close();
+                    break;
+                }
+                s = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", new Object[] { event.getProtocolVersion(), minecraftserver.getServerVersion(), event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()}); // CraftBukkit
+                // Paper end
+                     this.sendFlushAndClose(channelhandlercontext, this.createReply(s));
+                     break;
+                 default:
+@@ -171,8 +187,16 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+ 
+         LOGGER.debug("Ping: (1.6) from {}", ctx.channel().remoteAddress());
+ 
+-        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d",
+-                Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
+        InetSocketAddress virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(host, port);
+        com.destroystokyo.paper.event.server.PaperServerListPingEvent event = PaperLegacyStatusClient.processRequest(
+                server, (InetSocketAddress) ctx.channel().remoteAddress(), protocolVersion, virtualHost);
+        if (event == null) {
+            ctx.close();
+            return;
+        }
+
+        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", event.getProtocolVersion(), event.getVersion(),
+            PaperLegacyStatusClient.getMotd(event), event.getNumPlayers(), event.getMaxPlayers());
+         this.sendFlushAndClose(ctx, this.createReply(response));
+     }
+ 
--- a/patches/server/0189-Flag-to-disable-the-channel-limit.patch
+++ b/patches/server/0189-Flag-to-disable-the-channel-limit.patch
@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sat, 31 Mar 2018 17:04:26 +0100
+Subject: [PATCH] Flag to disable the channel limit
+
+In some enviroments, the channel limit set by spigot can cause issues,
+e.g. servers which allow and support the usage of mod packs.
+
+provide an optional flag to disable this check, at your own risk.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 8bf0c74ee32e8cb7c0f48bc964552811ad6ee468..8df1894df3583840412ccc7ccdc4b23db6dd6265 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -148,6 +148,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     // Paper start
+     private org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus;
+     private String resourcePackHash;
+    private static final boolean DISABLE_CHANNEL_LIMIT = System.getProperty("paper.disableChannelLimit") != null; // Paper - add a flag to disable the channel limit
+     // Paper end
+ 
+     public CraftPlayer(CraftServer server, ServerPlayer entity) {
+@@ -1589,7 +1590,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     public void addChannel(String channel) {
+-        Preconditions.checkState(this.channels.size() < 128, "Cannot register channel '%s'. Too many channels registered!", channel);
+        Preconditions.checkState(DISABLE_CHANNEL_LIMIT || this.channels.size() < 128, "Cannot register channel '%s'. Too many channels registered!", channel); // Paper - flag to disable channel limit
+         channel = StandardMessenger.validateAndCorrectChannel(channel);
+         if (this.channels.add(channel)) {
+             server.getPluginManager().callEvent(new PlayerRegisterChannelEvent(this, channel));
--- a/patches/server/0190-Add-method-to-open-already-placed-sign.patch
+++ b/patches/server/0190-Add-method-to-open-already-placed-sign.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Sun, 1 Apr 2018 02:29:37 +0300
+Subject: [PATCH] Add method to open already placed sign
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index 6c404878e58f68c9ac86a1771c23e528f3817e32..7f7322b5174a7580675b0607b0f282f7bf75a3e2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -604,6 +604,17 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         }
+     }
+ 
+    // Paper start - Add method to open already placed sign
+    @Override
+    public void openSign(org.bukkit.block.Sign sign) {
+        org.apache.commons.lang.Validate.isTrue(sign.getWorld().equals(this.getWorld()), "Sign must be in the same world as player is in");
+        org.bukkit.craftbukkit.block.CraftSign craftSign = (org.bukkit.craftbukkit.block.CraftSign) sign;
+        net.minecraft.world.level.block.entity.SignBlockEntity teSign = craftSign.getTileEntity();
+        // Make sign editable temporarily, will be set back to false in PlayerConnection later
+        teSign.isEditable = true;
+        this.getHandle().openTextEdit(teSign);
+    }
+    // Paper end
+     @Override
+     public boolean dropItem(boolean dropAll) {
+         return this.getHandle().drop(dropAll);
--- a/patches/server/0191-Configurable-sprint-interruption-on-attack.patch
+++ b/patches/server/0191-Configurable-sprint-interruption-on-attack.patch
@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Sat, 14 Apr 2018 20:20:46 +0200
+Subject: [PATCH] Configurable sprint interruption on attack
+
+If the sprint interruption is disabled players continue sprinting when they attack entities.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index da4a110809eee691c1d5b072de335d75e1516eae..9225372cb9ef51a8cfbd4cee543c250aa2ac9c49 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -352,4 +352,9 @@ public class PaperWorldConfig {
+     private void squidMaxSpawnHeight() {
+         squidMaxSpawnHeight = getDouble("squid-spawn-height.maximum", 0.0D);
+     }
+
+    public boolean disableSprintInterruptionOnAttack;
+    private void disableSprintInterruptionOnAttack() {
+        disableSprintInterruptionOnAttack = getBoolean("game-mechanics.disable-sprint-interruption-on-attack", false);
+    }
+ }
+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 3c0aca2b90521da83cf494d9fff953a17a57701d..a3f719d9dc63af9decc54a789f04595bb2d55710 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1240,7 +1240,11 @@ public abstract class Player extends LivingEntity {
+                             }
+ 
+                             this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
+-                            this.setSprinting(false);
+                            // Paper start - Configuration option to disable automatic sprint interruption
+                            if (!level.paperConfig.disableSprintInterruptionOnAttack) {
+                                this.setSprinting(false);
+                            }
+                            // Paper end
+                         }
+ 
+                         if (flag3) {
--- a/patches/server/0192-Fix-exploit-that-allowed-colored-signs-to-be-created.patch
+++ b/patches/server/0192-Fix-exploit-that-allowed-colored-signs-to-be-created.patch
@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: 0x22 <0x22@futureclient.net>
+Date: Thu, 26 Apr 2018 04:41:11 -0400
+Subject: [PATCH] Fix exploit that allowed colored signs to be created
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 205e4ef25f49edc11a408c302d9ba68a59c68a5a..35a00a622ff0c3582e08dbbefb1d34a84e590a81 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2787,9 +2787,9 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+ 
+             for (int i = 0; i < list.size(); ++i) {
+                 if (this.player.isTextFilteringEnabled()) {
+-                    lines.add(net.kyori.adventure.text.Component.text(list.get(i).getFiltered()));
+                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(list.get(i).getFiltered())));
+                 } else {
+-                    lines.add(net.kyori.adventure.text.Component.text(list.get(i).getRaw()));
+                    lines.add(net.kyori.adventure.text.Component.text(SharedConstants.filterText(list.get(i).getRaw())));
+                 }
+             }
+             SignChangeEvent event = new SignChangeEvent((org.bukkit.craftbukkit.block.CraftBlock) player.getWorld().getBlockAt(x, y, z), this.cserver.getPlayer(this.player), lines);
--- a/patches/server/0193-EndermanEscapeEvent.patch
+++ b/patches/server/0193-EndermanEscapeEvent.patch
@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 30 Apr 2018 13:15:55 -0400
+Subject: [PATCH] EndermanEscapeEvent
+
+Fires an event anytime an enderman intends to teleport away from the player
+
+You may cancel this, enabling ranged attacks to damage the enderman for example.
+
+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 a18765fe0be5a83ee2da3638aa5107e9345f19b6..29e53aebd1dc22d5dd2753cc7acbea425cb0054e 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -109,6 +109,12 @@ public class EnderMan extends Monster implements NeutralMob {
+         this.setGoalTarget(target, org.bukkit.event.entity.EntityTargetEvent.TargetReason.UNKNOWN, true);
+     }
+ 
+    // Paper start
+    private boolean tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason reason) {
+        return new com.destroystokyo.paper.event.entity.EndermanEscapeEvent((org.bukkit.craftbukkit.entity.CraftEnderman) this.getBukkitEntity(), reason).callEvent();
+    }
+    // Paper end
+
+     @Override
+     public boolean setGoalTarget(LivingEntity entityliving, org.bukkit.event.entity.EntityTargetEvent.TargetReason reason, boolean fireEvent) {
+         if (!super.setGoalTarget(entityliving, reason, fireEvent)) {
+@@ -262,7 +268,7 @@ public class EnderMan extends Monster implements NeutralMob {
+         if (this.level.isDay() && this.tickCount >= this.targetChangeTime + 600) {
+             float f = this.getBrightness();
+ 
+-            if (f > 0.5F && this.level.canSeeSky(this.blockPosition()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F) {
+            if (f > 0.5F && this.level.canSeeSky(this.blockPosition()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.RUNAWAY)) { // Paper
+                 this.setTarget((LivingEntity) null);
+                 this.teleport();
+             }
+@@ -360,17 +366,19 @@ public class EnderMan extends Monster implements NeutralMob {
+         if (this.isInvulnerableTo(source)) {
+             return false;
+         } else if (source instanceof IndirectEntityDamageSource) {
+            if (this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.INDIRECT)) { // Paper start
+             for (int i = 0; i < 64; ++i) {
+                 if (this.teleport()) {
+                     return true;
+                 }
+             }
+            } // Paper end
+ 
+             return false;
+         } else {
+             boolean flag = super.hurt(source, amount);
+ 
+-            if (!this.level.isClientSide() && !(source.getEntity() instanceof LivingEntity) && this.random.nextInt(10) != 0) {
+            if (!this.level.isClientSide() && !(source.getEntity() instanceof LivingEntity) && this.random.nextInt(10) != 0 && this.tryEscape(source == DamageSource.DROWN ? com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.DROWN : com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.INDIRECT)) { // Paper - use to be critical hits as else, but mojang removed critical hits in 1.16.2 due to MC-185684
+                 this.teleport();
+             }
+ 
+@@ -516,7 +524,7 @@ public class EnderMan extends Monster implements NeutralMob {
+ 
+     private static class EndermanLookForPlayerGoal extends NearestAttackableTargetGoal<Player> {
+ 
+-        private final EnderMan enderman;
+        private final EnderMan enderman; public final EnderMan getEnderman() { return this.enderman; } // Paper - OBFHELPER
+         private Player pendingTarget;
+         private int aggroTime;
+         private int teleportTime;
+@@ -579,7 +587,7 @@ public class EnderMan extends Monster implements NeutralMob {
+             } else {
+                 if (this.target != null && !this.enderman.isPassenger()) {
+                     if (this.enderman.isLookingAtMe((Player) this.target)) {
+-                        if (this.target.distanceToSqr((Entity) this.enderman) < 16.0D) {
+                        if (this.target.distanceToSqr((Entity) this.enderman) < 16.0D && this.getEnderman().tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.STARE)) { // Paper
+                             this.enderman.teleport();
+                         }
+ 
--- a/patches/server/0194-Enderman.teleportRandomly.patch
+++ b/patches/server/0194-Enderman.teleportRandomly.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 30 Apr 2018 13:29:44 -0400
+Subject: [PATCH] Enderman.teleportRandomly()
+
+Ability to trigger the vanilla "teleport randomly" mechanic of an enderman.
+
+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 29e53aebd1dc22d5dd2753cc7acbea425cb0054e..dedab212105f55ebce31f2309e34d8c3136c193f 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -277,7 +277,7 @@ public class EnderMan extends Monster implements NeutralMob {
+         super.customServerAiStep();
+     }
+ 
+-    protected boolean teleport() {
+    public boolean teleport() { // Paper - protected->public
+         if (!this.level.isClientSide() && this.isAlive()) {
+             double d0 = this.getX() + (this.random.nextDouble() - 0.5D) * 64.0D;
+             double d1 = this.getY() + (double) (this.random.nextInt(64) - 32);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
+index b72d7ade10075a13a617a370e2b8021326c9478d..ae669a970aa1f17ed786640de8a481364543c58e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
+@@ -16,6 +16,7 @@ public class CraftEnderman extends CraftMonster implements Enderman {
+         super(server, entity);
+     }
+ 
+    @Override public boolean teleportRandomly() { return getHandle().teleport(); } // Paper
+     @Override
+     public MaterialData getCarriedMaterial() {
+         BlockState blockData = this.getHandle().getCarriedBlock();
--- a/patches/server/0195-Block-Enderpearl-Travel-Exploit.patch
+++ b/patches/server/0195-Block-Enderpearl-Travel-Exploit.patch
@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 30 Apr 2018 17:15:26 -0400
+Subject: [PATCH] Block Enderpearl Travel Exploit
+
+Players are able to use alt accounts and enderpearls to travel
+long distances utilizing the pearls in unloaded chunks and loading
+the chunk later when convenient.
+
+This disables that by not saving the thrower when the chunk is unloaded.
+
+This is mainly useful for survival servers that do not allow freeform teleporting.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 9225372cb9ef51a8cfbd4cee543c250aa2ac9c49..a0a846a2e60bdc17537bd697137f65321c1a61d8 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -357,4 +357,10 @@ public class PaperWorldConfig {
+     private void disableSprintInterruptionOnAttack() {
+         disableSprintInterruptionOnAttack = getBoolean("game-mechanics.disable-sprint-interruption-on-attack", false);
+     }
+
+    public boolean disableEnderpearlExploit = true;
+    private void disableEnderpearlExploit() {
+        disableEnderpearlExploit = getBoolean("game-mechanics.disable-unloaded-chunk-enderpearl-exploit", disableEnderpearlExploit);
+        log("Disable Unloaded Chunk Enderpearl Exploit: " + (disableEnderpearlExploit ? "enabled" : "disabled"));
+    }
+ }
+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 c72ec22beff6aa1f7932fa44dc7d591ceeec1158..c25cb17ef1a7c56e10ce3ccb5665c9dce3e6efa6 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -88,6 +88,7 @@ public abstract class Projectile extends Entity {
+     protected void readAdditionalSaveData(CompoundTag nbt) {
+         if (nbt.hasUUID("Owner")) {
+             this.ownerUUID = nbt.getUUID("Owner");
+            if (this instanceof ThrownEnderpearl && this.level != null && this.level.paperConfig.disableEnderpearlExploit) { this.ownerUUID = null; } // Paper - Don't store shooter name for pearls to block enderpearl travel exploit
+         }
+ 
+         this.leftOwner = nbt.getBoolean("LeftOwner");
--- a/patches/server/0196-Expand-World.spawnParticle-API-and-add-Builder.patch
+++ b/patches/server/0196-Expand-World.spawnParticle-API-and-add-Builder.patch
@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 15 Aug 2017 22:29:12 -0400
+Subject: [PATCH] Expand World.spawnParticle API and add Builder
+
+Adds ability to control who receives it and who is the source/sender (vanish API)
+the standard API is to send the packet to everyone in the world, which is ineffecient.
+Adds an option to control the force mode of the particle.
+
+This adds a new Builder API which is much friendlier to use.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 8323ddb363f49d266dd95f11241a30a9a27250aa..cf074ef0cb01bc2cbd8c529e7233ceb9443f764d 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1287,12 +1287,17 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
+     }
+ 
+     public <T extends ParticleOptions> int sendParticles(ServerPlayer sender, T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, boolean force) {
+        // Paper start - Particle API Expansion
+        return sendParticles(players, sender, t0, d0, d1, d2, i, d3, d4, d5, d6, force);
+    }
+    public <T extends ParticleOptions> int sendParticles(List<ServerPlayer> receivers, ServerPlayer sender, T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, boolean force) {
+        // Paper end
+         ClientboundLevelParticlesPacket packetplayoutworldparticles = new ClientboundLevelParticlesPacket(t0, force, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
+         // CraftBukkit end
+         int j = 0;
+ 
+-        for (int k = 0; k < this.players.size(); ++k) {
+-            ServerPlayer entityplayer = (ServerPlayer) this.players.get(k);
+        for (Player entityhuman : receivers) { // Paper - Particle API Expansion
+            ServerPlayer entityplayer = (ServerPlayer) entityhuman; // Paper - Particle API Expansion
+             if (sender != null && !entityplayer.getBukkitEntity().canSee(sender.getBukkitEntity())) continue; // CraftBukkit
+ 
+             if (this.sendParticles(entityplayer, force, d0, d1, d2, packetplayoutworldparticles)) { // CraftBukkit
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index bc80e0062ef679e7cb147bd1a6da52bf95da52b8..ab59b0e9dc827e7ebe0c4dea633680908dcb5874 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -2355,11 +2355,17 @@ public class CraftWorld implements World {
+ 
+     @Override
+     public <T> void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) {
+        // Paper start - Particle API Expansion
+        spawnParticle(particle, null, null, x, y, z, count, offsetX, offsetY, offsetZ, extra, data, force);
+    }
+    public <T> void spawnParticle(Particle particle, List<Player> receivers, Player sender, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) {
+        // Paper end
+         if (data != null && !particle.getDataType().isInstance(data)) {
+             throw new IllegalArgumentException("data should be " + particle.getDataType() + " got " + data.getClass());
+         }
+         this.getHandle().sendParticles(
+-                null, // Sender
+                receivers == null ? getHandle().players() : receivers.stream().map(player -> ((CraftPlayer) player).getHandle()).collect(java.util.stream.Collectors.toList()), // Paper -  Particle API Expansion
+                sender != null ? ((CraftPlayer) sender).getHandle() : null, // Sender // Paper - Particle API Expansion
+                 CraftParticle.toNMS(particle, data), // Particle
+                 x, y, z, // Position
+                 count,  // Count
--- a/patches/server/0197-Prevent-Frosted-Ice-from-loading-holding-chunks.patch
+++ b/patches/server/0197-Prevent-Frosted-Ice-from-loading-holding-chunks.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 10 Mar 2018 16:33:15 -0500
+Subject: [PATCH] Prevent Frosted Ice from loading/holding chunks
+
+1.17: Shouldn't be needed as blocks no longer tick without at least 1 radius chunk loaded.
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java b/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
+index 54eb7ba0265bb155dd1c753661242fa9d299ff80..5b5d606a794c885267b6f5e2bbfe9b0a318ad767 100644
+--- a/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
+@@ -38,7 +38,8 @@ public class FrostedIceBlock extends IceBlock {
+ 
+             for(Direction direction : Direction.values()) {
+                 mutableBlockPos.setWithOffset(pos, direction);
+-                BlockState blockState = world.getBlockState(mutableBlockPos);
+                BlockState blockState = world.getTypeIfLoaded(mutableBlockPos); // Paper
+                if (blockState == null) { continue; } // Paper
+                 if (blockState.is(this) && !this.slightlyMelt(blockState, world, mutableBlockPos)) {
+                     world.getBlockTicks().scheduleTick(mutableBlockPos, this, Mth.nextInt(random, world.paperConfig.frostedIceDelayMin, world.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
+                 }
+@@ -75,7 +76,10 @@ public class FrostedIceBlock extends IceBlock {
+ 
+         for(Direction direction : Direction.values()) {
+             mutableBlockPos.setWithOffset(pos, direction);
+-            if (world.getBlockState(mutableBlockPos).is(this)) {
+            // Paper start
+            BlockState blockState = world.getTypeIfLoaded(mutableBlockPos);
+            if (blockState != null && blockState.is(this)) {
+                // Paper end
+                 ++i;
+                 if (i >= maxNeighbors) {
+                     return false;
--- a/patches/server/0198-EndermanAttackPlayerEvent.patch
+++ b/patches/server/0198-EndermanAttackPlayerEvent.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 1 May 2018 20:18:54 -0400
+Subject: [PATCH] EndermanAttackPlayerEvent
+
+Allow control over whether or not an enderman aggros a player.
+
+This allows you to override/extend the pumpkin/stare logic.
+
+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 dedab212105f55ebce31f2309e34d8c3136c193f..abd1130529dd74780054e26bac89cf757ba9cdc1 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -220,7 +220,15 @@ public class EnderMan extends Monster implements NeutralMob {
+         this.readPersistentAngerSaveData(this.level, nbt);
+     }
+ 
+-    boolean isLookingAtMe(Player player) {
+    // Paper start - EndermanAttackPlayerEvent
+    private boolean isLookingAtMe(Player player) {
+        boolean shouldAttack = isLookingAtMe_check(player);
+        com.destroystokyo.paper.event.entity.EndermanAttackPlayerEvent event = new com.destroystokyo.paper.event.entity.EndermanAttackPlayerEvent((org.bukkit.entity.Enderman) getBukkitEntity(), (org.bukkit.entity.Player) player.getBukkitEntity());
+        event.setCancelled(!shouldAttack);
+        return event.callEvent();
+    }
+    private boolean isLookingAtMe_check(Player player) {
+        // Paper end
+         ItemStack itemstack = (ItemStack) player.getInventory().armor.get(3);
+ 
+         if (itemstack.is(Blocks.CARVED_PUMPKIN.asItem())) {
--- a/patches/server/0199-WitchConsumePotionEvent.patch
+++ b/patches/server/0199-WitchConsumePotionEvent.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 16 May 2018 20:35:16 -0400
+Subject: [PATCH] WitchConsumePotionEvent
+
+Fires when a witch consumes the potion in their hand
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+index 0c04665c6e2f5624e21e269d706fea842d54cefd..ecb3843ff3b4f0034f6aaa16cfc09cbd046d9008 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+@@ -124,7 +124,11 @@ public class Witch extends Raider implements RangedAttackMob {
+ 
+                     this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
+                     if (itemstack.is(Items.POTION)) {
+-                        List<MobEffectInstance> list = PotionUtils.getMobEffects(itemstack);
+                        // Paper start
+                        com.destroystokyo.paper.event.entity.WitchConsumePotionEvent event = new com.destroystokyo.paper.event.entity.WitchConsumePotionEvent((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack));
+
+                        List<MobEffectInstance> list = event.callEvent() ? PotionUtils.getMobEffects(org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getPotion())) : null;
+                        // Paper end
+ 
+                         if (list != null) {
+                             Iterator iterator = list.iterator();
--- a/patches/server/0200-WitchThrowPotionEvent.patch
+++ b/patches/server/0200-WitchThrowPotionEvent.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 16 May 2018 20:44:58 -0400
+Subject: [PATCH] WitchThrowPotionEvent
+
+Fired when a witch throws a potion at a player
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+index ecb3843ff3b4f0034f6aaa16cfc09cbd046d9008..e2762c6c37975eb2da59d408998a5c0368c146d1 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+@@ -236,9 +236,16 @@ public class Witch extends Raider implements RangedAttackMob {
+                 potionregistry = Potions.WEAKNESS;
+             }
+ 
+            // Paper start
+            ItemStack potion = PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), potionregistry);
+            com.destroystokyo.paper.event.entity.WitchThrowPotionEvent event = new com.destroystokyo.paper.event.entity.WitchThrowPotionEvent((org.bukkit.entity.Witch) this.getBukkitEntity(), (org.bukkit.entity.LivingEntity) target.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
+            if (!event.callEvent()) {
+                return;
+            }
+            potion = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getPotion());
+             ThrownPotion entitypotion = new ThrownPotion(this.level, this);
+-
+-            entitypotion.setItem(PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), potionregistry));
+            entitypotion.setItem(potion);
+            // Paper end
+             entitypotion.setXRot(entitypotion.getXRot() - -20.0F);
+             entitypotion.shoot(d0, d1 + d3 * 0.2D, d2, 0.75F, 8.0F);
+             if (!this.isSilent()) {
--- a/patches/server/0201-Allow-spawning-Item-entities-with-World.spawnEntity.patch
+++ b/patches/server/0201-Allow-spawning-Item-entities-with-World.spawnEntity.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 4 Jun 2018 20:39:20 -0400
+Subject: [PATCH] Allow spawning Item entities with World.spawnEntity
+
+This API has more capabilities than .dropItem with the Consumer function
+
+Item can be set inside of the Consumer pre spawn function.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index ab59b0e9dc827e7ebe0c4dea633680908dcb5874..058346b89c07d44a5425a61abedcfc440cb9ee21 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1505,6 +1505,10 @@ public class CraftWorld implements World {
+         if (Boat.class.isAssignableFrom(clazz)) {
+             entity = new net.minecraft.world.entity.vehicle.Boat(this.world, x, y, z);
+             entity.moveTo(x, y, z, yaw, pitch);
+            // Paper start
+        } else if (org.bukkit.entity.Item.class.isAssignableFrom(clazz)) {
+            entity = new ItemEntity(world, x, y, z, new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Item.byBlock(net.minecraft.world.level.block.Blocks.DIRT)));
+            // Paper end
+         } else if (FallingBlock.class.isAssignableFrom(clazz)) {
+             entity = new FallingBlockEntity(this.world, x, y, z, this.world.getBlockState(new BlockPos(x, y, z)));
+         } else if (Projectile.class.isAssignableFrom(clazz)) {
--- a/patches/server/0202-WitchReadyPotionEvent.patch
+++ b/patches/server/0202-WitchReadyPotionEvent.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 5 Jun 2018 22:47:26 -0400
+Subject: [PATCH] WitchReadyPotionEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+index e2762c6c37975eb2da59d408998a5c0368c146d1..5e2e8cb5eba4ba36065f07abed954b2aad022321 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+@@ -157,7 +157,11 @@ public class Witch extends Raider implements RangedAttackMob {
+                 }
+ 
+                 if (potionregistry != null) {
+-                    this.setItemSlot(EquipmentSlot.MAINHAND, PotionUtils.setPotion(new ItemStack(Items.POTION), potionregistry));
+                    // Paper start
+                    ItemStack potion = PotionUtils.setPotion(new ItemStack(Items.POTION), potionregistry);
+                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
+                    this.setItemSlot(EquipmentSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
+                    // Paper end
+                     this.usingTime = this.getMainHandItem().getUseDuration();
+                     this.setUsingItem(true);
+                     if (!this.isSilent()) {
--- a/patches/server/0203-ItemStack-getMaxItemUseDuration.patch
+++ b/patches/server/0203-ItemStack-getMaxItemUseDuration.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 5 Jun 2018 23:00:29 -0400
+Subject: [PATCH] ItemStack#getMaxItemUseDuration
+
+Allows you to determine how long it takes to use a usable/consumable item
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index 51c1f62af5c25fe620f1d8a9cb03473e849db68d..3fbfe4f77c4b82d96ed022498b2d9175d548e247 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -173,6 +173,13 @@ public final class CraftItemStack extends ItemStack {
+         return (this.handle == null) ? Material.AIR.getMaxStackSize() : this.handle.getItem().getMaxStackSize();
+     }
+ 
+    // Paper start
+    @Override
+    public int getMaxItemUseDuration() {
+        return handle == null ? 0 : handle.getUseDuration();
+    }
+    // Paper end
+
+     @Override
+     public void addUnsafeEnchantment(Enchantment ench, int level) {
+         Validate.notNull(ench, "Cannot add null enchantment");
--- a/patches/server/0204-Implement-EntityTeleportEndGatewayEvent.patch
+++ b/patches/server/0204-Implement-EntityTeleportEndGatewayEvent.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sat, 9 Jun 2018 14:08:39 +0200
+Subject: [PATCH] Implement EntityTeleportEndGatewayEvent
+
+
+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 2bf65c8da827c6bdbfb74a9d8ee5754584c40c53..f9cd4c28db815205e548ac59515cd80989741bab 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
+@@ -225,9 +225,20 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+ 
+                 }
+                 // CraftBukkit end
+                // Paper start - EntityTeleportEndGatewayEvent - replicated from above
+                org.bukkit.craftbukkit.entity.CraftEntity bukkitEntity = entity.getBukkitEntity();
+                org.bukkit.Location location = new Location(world.getWorld(), (double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.5D, (double) blockposition1.getZ() + 0.5D);
+                location.setPitch(bukkitEntity.getLocation().getPitch());
+                location.setYaw(bukkitEntity.getLocation().getYaw());
+
+                com.destroystokyo.paper.event.entity.EntityTeleportEndGatewayEvent event = new com.destroystokyo.paper.event.entity.EntityTeleportEndGatewayEvent(bukkitEntity, bukkitEntity.getLocation(), location, new org.bukkit.craftbukkit.block.CraftEndGateway(MCUtil.toLocation(world, blockEntity.getBlockPos()).getBlock()));
+                if (!event.callEvent()) {
+                    return;
+                }
+                // Paper end
+ 
+                 entity1.setPortalCooldown();
+-                entity1.teleportToWithTicket((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY(), (double) blockposition1.getZ() + 0.5D);
+                entity1.teleportToWithTicket(event.getTo().getX(), event.getTo().getY(), event.getTo().getZ()); // Paper
+             }
+ 
+             TheEndGatewayBlockEntity.triggerCooldown(world, pos, state, blockEntity);
--- a/patches/server/0205-Unset-Ignited-flag-on-cancel-of-Explosion-Event.patch
+++ b/patches/server/0205-Unset-Ignited-flag-on-cancel-of-Explosion-Event.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 10 Jun 2018 01:18:49 -0400
+Subject: [PATCH] Unset Ignited flag on cancel of Explosion Event
+
+Otherwise the creeper infinite explodes
+
+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 ddc48d37f962b6743f3f356745c9ebe6a06f79f1..3bbf6c9bfbb79fd4242cf66d7ace1d8f87404636 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -272,6 +272,7 @@ public class Creeper extends Monster implements PowerableMob {
+                 this.spawnLingeringCloud();
+             } else {
+                 this.swell = 0;
+                this.entityData.set(DATA_IS_IGNITED, Boolean.valueOf(false)); // Paper
+             }
+             // CraftBukkit end
+         }
--- a/patches/server/0206-Fix-CraftEntity-hashCode.patch
+++ b/patches/server/0206-Fix-CraftEntity-hashCode.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 10 Jun 2018 20:20:15 -0400
+Subject: [PATCH] Fix CraftEntity hashCode
+
+hashCodes are not allowed to change, however bukkit used a value
+that does change, the entityId.
+
+When an entity is teleported dimensions, the entity reference is
+replaced with a new one with a new entity ID.
+
+For hashCode, we can simply use the UUID's hashCode to keep
+the hashCode from changing.
+
+equals() is ok to use getEntityId() because equals() should only
+be true if both the left and right are the same reference.
+
+Since entity ids can not duplicate during runtime, this
+check is essentially the same as this.getHandle() == other.getHandle()
+
+However, replaced it too to make it clearer of intent.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 1fd891b53c54153c28d636b2679b4a083510ba3c..0bc816407157264bf3e736da678535d08b4d85f2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -782,14 +782,15 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+             return false;
+         }
+         final CraftEntity other = (CraftEntity) obj;
+-        return (this.getEntityId() == other.getEntityId());
+        return (this.getHandle() == other.getHandle()); // Paper - while logically the same, this is clearer
+     }
+ 
+    // Paper - Fix hashCode. entity ID's are not static.
+    // A CraftEntity can change reference to a new entity with a new ID, and hash codes should never change
+     @Override
+     public int hashCode() {
+-        int hash = 7;
+-        hash = 29 * hash + this.getEntityId();
+-        return hash;
+        return getUniqueId().hashCode();
+        // Paper end
+     }
+ 
+     @Override
--- a/patches/server/0207-Configurable-Alternative-LootPool-Luck-Formula.patch
+++ b/patches/server/0207-Configurable-Alternative-LootPool-Luck-Formula.patch
@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 15 Jun 2018 00:30:32 -0400
+Subject: [PATCH] Configurable Alternative LootPool Luck Formula
+
+Rewrites the Vanilla luck application formula so that luck can be
+applied to items that do not have any quality defined.
+
+See: https://luckformula.emc.gs for data and details
+-----------
+
+The rough summary is:
+My goal was that in a pool, when luck was applied, the pool
+rebalances so the percentages for bigger items is
+lowered and smaller items is boosted.
+
+Do this by boosting and then reducing the weight value,
+so that larger numbers are penalized more than smaller numbers.
+resulting in a larger reduction of entries for more common
+items than the reduction on small weights,
+giving smaller weights more of a chance
+
+-----------
+
+This work kind of obsoletes quality, but quality would be useful
+for 2 items with same weight that you want luck to impact
+in varying directions.
+
+Fishing still falls into that as the weights are closer, so luck
+will invalidate junk more.
+
+This change will result in some major changes to fishing formulas.
+
+-----------
+
+I would love to see this change in Vanilla, so Mojang please pull :)
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+index 05a5abb951abe37f30a719cb75376d2d43c0d252..77a03abd59db4a43f6f2d59d4c7ef176e782f205 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+@@ -288,4 +288,12 @@ public class PaperConfig {
+             SpigotConfig.save();
+         }
+     }
+
+    public static boolean useAlternativeLuckFormula = false;
+    private static void useAlternativeLuckFormula() {
+        useAlternativeLuckFormula = getBoolean("settings.use-alternative-luck-formula", false);
+        if (useAlternativeLuckFormula) {
+            Bukkit.getLogger().log(Level.INFO, "Using Aikar's Alternative Luck Formula to apply Luck attribute to all loot pool calculations. See https://luckformula.emc.gs");
+        }
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java b/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
+index 710a66e9aafe8bd622f9f37789c281aba98d030e..558f43580d976d7bde32779e47e24c9ad388892d 100644
+--- a/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
+++ b/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
+@@ -113,9 +113,35 @@ public abstract class LootPoolSingletonContainer extends LootPoolEntryContainer
+     protected abstract class EntryBase implements LootPoolEntry {
+         @Override
+         public int getWeight(float luck) {
+-            return Math.max(Mth.floor((float)LootPoolSingletonContainer.this.weight + (float)LootPoolSingletonContainer.this.quality * luck), 0);
+            // Paper start - Offer an alternative loot formula to refactor how luck bonus applies
+            // SEE: https://luckformula.emc.gs for details and data
+            if (LootPoolSingletonContainer.this.lastLuck != null && LootPoolSingletonContainer.this.lastLuck == luck) {
+                return lastWeight;
+            }
+            // This is vanilla
+            float qualityModifer = (float) LootPoolSingletonContainer.this.quality * luck;
+            double baseWeight = (LootPoolSingletonContainer.this.weight + qualityModifer);
+            if (com.destroystokyo.paper.PaperConfig.useAlternativeLuckFormula) {
+                // Random boost to avoid losing precision in the final int cast on return
+                final int weightBoost = 100;
+                baseWeight *= weightBoost;
+                // If we have vanilla 1, bump that down to 0 so nothing is is impacted
+                // vanilla 3 = 300, 200 basis = impact 2%
+                // =($B2*(($B2-100)/100/100))
+                double impacted = baseWeight * ((baseWeight - weightBoost) / weightBoost / 100);
+                // =($B$7/100)
+                float luckModifier = Math.min(100, luck * 10) / 100;
+                // =B2 - (C2 *($B$7/100))
+                baseWeight = Math.ceil(baseWeight - (impacted * luckModifier));
+            }
+            LootPoolSingletonContainer.this.lastLuck = luck;
+            LootPoolSingletonContainer.this.lastWeight = (int) Math.max(Math.floor(baseWeight), 0);
+            return lastWeight;
+         }
+     }
+    private Float lastLuck = null;
+    private int lastWeight = 0;
+    // Paper end
+ 
+     @FunctionalInterface
+     protected interface EntryConstructor {
--- a/patches/server/0208-Print-Error-details-when-failing-to-save-player-data.patch
+++ b/patches/server/0208-Print-Error-details-when-failing-to-save-player-data.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 15 Jun 2018 20:37:03 -0400
+Subject: [PATCH] Print Error details when failing to save player data
+
+
+diff --git a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+index 7b367e273c2a6869f8d8929c24ee45efdf6d4b1e..6727468946ea5f60bd80549f827a7c2b9a42b98b 100644
+--- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+@@ -43,7 +43,7 @@ public class PlayerDataStorage {
+ 
+             Util.safeReplaceFile(file1, file, file2);
+         } catch (Exception exception) {
+-            PlayerDataStorage.LOGGER.warn("Failed to save player data for {}", player.getName().getString());
+            PlayerDataStorage.LOGGER.warn("Failed to save player data for {}", player.getScoreboardName(), exception); // Paper
+         }
+ 
+     }
--- a/patches/server/0209-Make-shield-blocking-delay-configurable.patch
+++ b/patches/server/0209-Make-shield-blocking-delay-configurable.patch
@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 16 Jun 2018 01:18:16 -0500
+Subject: [PATCH] Make shield blocking delay configurable
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index a0a846a2e60bdc17537bd697137f65321c1a61d8..e1110274a9f6b8f7007537732ec8eff7e72040ee 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -363,4 +363,9 @@ public class PaperWorldConfig {
+         disableEnderpearlExploit = getBoolean("game-mechanics.disable-unloaded-chunk-enderpearl-exploit", disableEnderpearlExploit);
+         log("Disable Unloaded Chunk Enderpearl Exploit: " + (disableEnderpearlExploit ? "enabled" : "disabled"));
+     }
+
+    public int shieldBlockingDelay = 5;
+    private void shieldBlockingDelay() {
+        shieldBlockingDelay = getInt("game-mechanics.shield-blocking-delay", 5);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 28de49c8b5771491b168bba26e6033669c48e3c9..a3af689df12852ac47bd658f28c9f5b9991d3301 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3665,12 +3665,24 @@ public abstract class LivingEntity extends Entity {
+         if (this.isUsingItem() && !this.useItem.isEmpty()) {
+             Item item = this.useItem.getItem();
+ 
+-            return item.getUseAnimation(this.useItem) != UseAnim.BLOCK ? false : item.getUseDuration(this.useItem) - this.useItemRemaining >= 5;
+            return item.getUseAnimation(this.useItem) != UseAnim.BLOCK ? false : item.getUseDuration(this.useItem) - this.useItemRemaining >= getShieldBlockingDelay(); // Paper - shieldBlockingDelay
+         } else {
+             return false;
+         }
+     }
+ 
+    // Paper start
+    public int shieldBlockingDelay = level.paperConfig.shieldBlockingDelay;
+
+    public int getShieldBlockingDelay() {
+        return shieldBlockingDelay;
+    }
+
+    public void setShieldBlockingDelay(int shieldBlockingDelay) {
+        this.shieldBlockingDelay = shieldBlockingDelay;
+    }
+    // Paper end
+
+     public boolean isSuppressingSlidingDownLadder() {
+         return this.isShiftKeyDown();
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 4e9565def5a28a7391f8f541d066c2981d0bbc92..dea64f96139fbf4e1ff860b75f2005169a55c395 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -707,5 +707,15 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     public void setArrowsStuck(int arrows) {
+         getHandle().setArrowCount(arrows);
+     }
+
+    @Override
+    public int getShieldBlockingDelay() {
+        return getHandle().getShieldBlockingDelay();
+    }
+
+    @Override
+    public void setShieldBlockingDelay(int delay) {
+        getHandle().setShieldBlockingDelay(delay);
+    }
+     // Paper end
+ }
--- a/patches/server/0210-Improve-EntityShootBowEvent.patch
+++ b/patches/server/0210-Improve-EntityShootBowEvent.patch
@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 15 Jun 2013 19:51:17 -0400
+Subject: [PATCH] Improve EntityShootBowEvent
+
+Adds missing call to Illagers and also adds Arrow ItemStack to skeltons
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+index d7bca8fa71e325ba1967537d4102ccb207c4d717..3d8f3e22223e4effeaf52cb18c14c60276d4689c 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+++ b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+@@ -196,7 +196,7 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
+ 
+         entityarrow.shoot(d0, d1 + d3 * 0.20000000298023224D, d2, 1.6F, (float) (14 - this.level.getDifficulty().getId() * 4));
+         // CraftBukkit start
+-        org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), null, entityarrow, net.minecraft.world.InteractionHand.MAIN_HAND, 0.8F, true);
+        org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), entityarrow.getPickupItem(), entityarrow, net.minecraft.world.InteractionHand.MAIN_HAND, 0.8F, true); // Paper
+         if (event.isCancelled()) {
+             event.getProjectile().remove();
+             return;
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
+index ff38ad2ac16ff49a290976e392175e96fa986925..c9fa01b910de7ecb494d3000afebea9a2bd1276a 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
+@@ -196,8 +196,18 @@ public class Illusioner extends SpellcasterIllager implements RangedAttackMob {
+         double d3 = Math.sqrt(d0 * d0 + d2 * d2);
+ 
+         entityarrow.shoot(d0, d1 + d3 * 0.20000000298023224D, d2, 1.6F, (float) (14 - this.level.getDifficulty().getId() * 4));
+        // Paper start
+        org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), entityarrow.getPickupItem(), entityarrow, target.getUsedItemHand(), 0.8F, true);
+        if (event.isCancelled()) {
+            event.getProjectile().remove();
+            return;
+        }
+
+        if (event.getProjectile() == entityarrow.getBukkitEntity()) {
+            this.level.addFreshEntity(entityarrow);
+        }
+         this.playSound(SoundEvents.SKELETON_SHOOT, 1.0F, 1.0F / (this.getRandom().nextFloat() * 0.4F + 0.8F));
+-        this.level.addFreshEntity(entityarrow);
+        // Paper end
+     }
+ 
+     @Override
+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 71f0de893fe0243cc226fd36685f2a3fba02575f..988986d549dae93cfcb8147126c84f263efe3452 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -586,7 +586,7 @@ public abstract class AbstractArrow extends Projectile {
+         }
+     }
+ 
+-    protected abstract ItemStack getPickupItem();
+    public abstract ItemStack getPickupItem(); // Paper - protected -> public
+ 
+     @Override
+     protected Entity.MovementEmission getMovementEmission() {
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Arrow.java b/src/main/java/net/minecraft/world/entity/projectile/Arrow.java
+index 1b71df52df1e1d408d2cdf5bef5fbea95fdced80..c0a3bfde24ef5e4b9c1bb1c0b8fbffdde3604513 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Arrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Arrow.java
+@@ -244,7 +244,7 @@ public class Arrow extends AbstractArrow {
+     }
+ 
+     @Override
+-    protected ItemStack getPickupItem() {
+    public ItemStack getPickupItem() { // Paper - protected -> public
+         if (this.effects.isEmpty() && this.potion == Potions.EMPTY) {
+             return new ItemStack(Items.ARROW);
+         } else {
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/SpectralArrow.java b/src/main/java/net/minecraft/world/entity/projectile/SpectralArrow.java
+index 4f62f72d125504602d4b0278119247d36d58b3c9..f6081e0fdf71d6b2b80c94f2ffd3395c08fb84a7 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/SpectralArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/SpectralArrow.java
+@@ -36,7 +36,7 @@ public class SpectralArrow extends AbstractArrow {
+     }
+ 
+     @Override
+-    protected ItemStack getPickupItem() {
+    public ItemStack getPickupItem() { // Paper - protected -> public
+         return new ItemStack(Items.SPECTRAL_ARROW);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+index 04c6c3bf372186182b91a03e11dba0495357393d..227cb0834a075cbe2db136bf6dc9820d2a04c458 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+@@ -98,7 +98,7 @@ public class ThrownTrident extends AbstractArrow {
+     }
+ 
+     @Override
+-    protected ItemStack getPickupItem() {
+    public ItemStack getPickupItem() { // Paper - protected -> public
+         return this.tridentItem.copy();
+     }
+ 
--- a/patches/server/0211-PlayerReadyArrowEvent.patch
+++ b/patches/server/0211-PlayerReadyArrowEvent.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 18 Jun 2018 01:12:53 -0400
+Subject: [PATCH] PlayerReadyArrowEvent
+
+Called when a player is firing a bow and the server is choosing an arrow to use.
+Plugins can skip selection of certain arrows and control which is used.
+
+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 a3f719d9dc63af9decc54a789f04595bb2d55710..a4bb172ed720869578575562738521e99a53acca 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -2186,6 +2186,17 @@ public abstract class Player extends LivingEntity {
+         return ImmutableList.of(Pose.STANDING, Pose.CROUCHING, Pose.SWIMMING);
+     }
+ 
+    // Paper start
+    protected boolean tryReadyArrow(ItemStack bow, ItemStack itemstack) {
+        return !(this instanceof ServerPlayer) ||
+                new com.destroystokyo.paper.event.player.PlayerReadyArrowEvent(
+                    ((ServerPlayer) this).getBukkitEntity(),
+                    org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(bow),
+                    org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack)
+                ).callEvent();
+        // Paper end
+    }
+
+     @Override
+     public ItemStack getProjectile(ItemStack stack) {
+         if (!(stack.getItem() instanceof ProjectileWeaponItem)) {
+@@ -2202,7 +2213,7 @@ public abstract class Player extends LivingEntity {
+                 for (int i = 0; i < this.inventory.getContainerSize(); ++i) {
+                     ItemStack itemstack2 = this.inventory.getItem(i);
+ 
+-                    if (predicate.test(itemstack2)) {
+                    if (predicate.test(itemstack2) && tryReadyArrow(stack, itemstack2)) { // Paper
+                         return itemstack2;
+                     }
+                 }
--- a/patches/server/0212-Implement-EntityKnockbackByEntityEvent.patch
+++ b/patches/server/0212-Implement-EntityKnockbackByEntityEvent.patch
@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Mon, 18 Jun 2018 15:46:23 +0200
+Subject: [PATCH] Implement EntityKnockbackByEntityEvent
+
+This event is called when an entity receives knockback by another entity.
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index a3af689df12852ac47bd658f28c9f5b9991d3301..acf6f04fa229fb0850217ff3d50bf3b8c16cafdf 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1437,7 +1437,7 @@ public abstract class LivingEntity extends Entity {
+                     }
+ 
+                     this.hurtDir = (float) (Mth.atan2(d1, d0) * 57.2957763671875D - (double) this.getYRot());
+-                    this.knockback(0.4000000059604645D, d0, d1);
+                    this.knockback(0.4000000059604645D, d0, d1, entity1);
+                 } else {
+                     this.hurtDir = (float) ((int) (Math.random() * 2.0D) * 180);
+                 }
+@@ -1485,7 +1485,7 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     protected void blockedByShield(LivingEntity target) {
+-        target.knockback(0.5D, target.getX() - this.getX(), target.getZ() - this.getZ());
+        target.knockback(0.5D, target.getX() - this.getX(), target.getZ() - this.getZ(), this);
+     }
+ 
+     private boolean checkTotemDeathProtection(DamageSource source) {
+@@ -1733,6 +1733,11 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     public void knockback(double strength, double x, double z) {
+        // Paper start - add knockbacking entity parameter
+        this.knockback(strength, x, z, null);
+    }
+    public void knockback(double strength, double x, double z, Entity knockingBackEntity) {
+        // Paper end - add knockbacking entity parameter
+         strength *= 1.0D - this.getAttributeValue(Attributes.KNOCKBACK_RESISTANCE);
+         if (strength > 0.0D) {
+             this.hasImpulse = true;
+@@ -1740,6 +1745,15 @@ public abstract class LivingEntity extends Entity {
+             Vec3 vec3d1 = (new Vec3(x, 0.0D, z)).normalize().scale(strength);
+ 
+             this.setDeltaMovement(vec3d.x / 2.0D - vec3d1.x, this.onGround ? Math.min(0.4D, vec3d.y / 2.0D + strength) : vec3d.y, vec3d.z / 2.0D - vec3d1.z);
+            // Paper start - call EntityKnockbackByEntityEvent
+            Vec3 currentMovement = this.getDeltaMovement();
+            org.bukkit.util.Vector delta = new org.bukkit.util.Vector(currentMovement.x - vec3d.x, currentMovement.y - vec3d.y, currentMovement.z - vec3d.z);
+            // Restore old velocity to be able to access it in the event
+            this.setDeltaMovement(vec3d);
+            if (knockingBackEntity == null || new com.destroystokyo.paper.event.entity.EntityKnockbackByEntityEvent((org.bukkit.entity.LivingEntity) getBukkitEntity(), knockingBackEntity.getBukkitEntity(), (float) strength, delta).callEvent()) {
+                this.setDeltaMovement(vec3d.x + delta.getX(), vec3d.y + delta.getY(), vec3d.z + delta.getZ());
+            }
+            // Paper end
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 2ed756c73b0cfddb559126d85316f37c3f958c0c..8451baff82cb7ec7615ab50a409724897ccf4d95 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1532,7 +1532,7 @@ public abstract class Mob extends LivingEntity {
+ 
+         if (flag) {
+             if (f1 > 0.0F && target instanceof LivingEntity) {
+-                ((LivingEntity) target).knockback((double) (f1 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
+                ((LivingEntity) target).knockback((double) (f1 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this); // Paper
+                 this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
+             }
+ 
+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 a4bb172ed720869578575562738521e99a53acca..0d6e024208182d5779be3d84cff193ce904ad541 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1234,7 +1234,7 @@ public abstract class Player extends LivingEntity {
+                     if (flag5) {
+                         if (i > 0) {
+                             if (target instanceof LivingEntity) {
+-                                ((LivingEntity) target).knockback((double) ((float) i * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
+                                ((LivingEntity) target).knockback((double) ((float) i * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this); // Paper
+                             } else {
+                                 target.push((double) (-Mth.sin(this.getYRot() * 0.017453292F) * (float) i * 0.5F), 0.1D, (double) (Mth.cos(this.getYRot() * 0.017453292F) * (float) i * 0.5F));
+                             }
+@@ -1258,7 +1258,7 @@ public abstract class Player extends LivingEntity {
+                                 if (entityliving != this && entityliving != target && !this.isAlliedTo(entityliving) && (!(entityliving instanceof ArmorStand) || !((ArmorStand) entityliving).isMarker()) && this.distanceToSqr((Entity) entityliving) < 9.0D) {
+                                     // CraftBukkit start - Only apply knockback if the damage hits
+                                     if (entityliving.hurt(DamageSource.playerAttack(this).sweep(), f4)) {
+-                                    entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
+                                    entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this); // Paper
+                                     }
+                                     // CraftBukkit end
+                                 }
--- a/patches/server/0213-Expand-Explosions-API.patch
+++ b/patches/server/0213-Expand-Explosions-API.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 20 Jun 2018 23:17:24 -0400
+Subject: [PATCH] Expand Explosions API
+
+Add Entity as a Source capability, and add more API choices, and on Location.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 058346b89c07d44a5425a61abedcfc440cb9ee21..df6b4f65dd84621b8477b42a504f9e62c633a6b5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -889,6 +889,12 @@ public class CraftWorld implements World {
+     public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks, Entity source) {
+         return !this.world.explode(source == null ? null : ((CraftEntity) source).getHandle(), x, y, z, power, setFire, breakBlocks ? Explosion.BlockInteraction.BREAK : Explosion.BlockInteraction.NONE).wasCanceled;
+     }
+    // Paper start
+    @Override
+    public boolean createExplosion(Entity source, Location loc, float power, boolean setFire, boolean breakBlocks) {
+        return !world.explode(source != null ? ((org.bukkit.craftbukkit.entity.CraftEntity) source).getHandle() : null, loc.getX(), loc.getY(), loc.getZ(), power, setFire, breakBlocks ? Explosion.BlockInteraction.BREAK : Explosion.BlockInteraction.NONE).wasCanceled;
+    }
+    // Paper end
+ 
+     @Override
+     public boolean createExplosion(Location loc, float power) {
--- a/patches/server/0214-LivingEntity-Hand-Raised-Item-Use-API.patch
+++ b/patches/server/0214-LivingEntity-Hand-Raised-Item-Use-API.patch
@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 29 Jun 2018 00:21:28 -0400
+Subject: [PATCH] LivingEntity Hand Raised/Item Use API
+
+How long an entity has raised hands to charge an attack or use an item
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index dea64f96139fbf4e1ff860b75f2005169a55c395..5194da5a141718390a317d75b31205f951cec7a2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -717,5 +717,30 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     public void setShieldBlockingDelay(int delay) {
+         getHandle().setShieldBlockingDelay(delay);
+     }
+
+    @Override
+    public ItemStack getActiveItem() {
+        return getHandle().getUseItem().asBukkitMirror();
+    }
+
+    @Override
+    public int getItemUseRemainingTime() {
+        return getHandle().getUseItemRemainingTicks();
+    }
+
+    @Override
+    public int getHandRaisedTime() {
+        return getHandle().getTicksUsingItem();
+    }
+
+    @Override
+    public boolean isHandRaised() {
+        return getHandle().isUsingItem();
+    }
+
+    @Override
+    public org.bukkit.inventory.EquipmentSlot getHandRaised() {
+        return getHandle().getUsedItemHand() == net.minecraft.world.InteractionHand.MAIN_HAND ? org.bukkit.inventory.EquipmentSlot.HAND : org.bukkit.inventory.EquipmentSlot.OFF_HAND;
+    }
+     // Paper end
+ }
--- a/patches/server/0215-RangedEntity-API.patch
+++ b/patches/server/0215-RangedEntity-API.patch
@ -0,0 +1,164 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 26 Jun 2018 22:00:49 -0400
+Subject: [PATCH] RangedEntity API
+
+Allows you to determine if an entity is capable of ranged attacks,
+and to perform an attack.
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/CraftRangedEntity.java b/src/main/java/com/destroystokyo/paper/entity/CraftRangedEntity.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e75e1d0d833c96af139fd955b2585ec24281b294
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/entity/CraftRangedEntity.java
+@@ -0,0 +1,19 @@
+package com.destroystokyo.paper.entity;
+
+import net.minecraft.world.entity.monster.RangedAttackMob;
+import org.bukkit.craftbukkit.entity.CraftLivingEntity;
+import org.bukkit.entity.LivingEntity;
+
+public interface CraftRangedEntity<T extends RangedAttackMob> extends RangedEntity {
+    T getHandle();
+
+    @Override
+    default void rangedAttack(LivingEntity target, float charge) {
+        getHandle().rangedAttack(((CraftLivingEntity) target).getHandle(), charge);
+    }
+
+    @Override
+    default void setChargingAttack(boolean raiseHands) {
+        getHandle().setChargingAttack(raiseHands);
+    }
+}
+diff --git a/src/main/java/net/minecraft/world/entity/monster/RangedAttackMob.java b/src/main/java/net/minecraft/world/entity/monster/RangedAttackMob.java
+index 6c3162606ccf799e99d591da33fd649847db54b8..7ff5d0410ac281da20a031e748e8c15f3156d809 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/RangedAttackMob.java
+++ b/src/main/java/net/minecraft/world/entity/monster/RangedAttackMob.java
+@@ -3,5 +3,8 @@ package net.minecraft.world.entity.monster;
+ import net.minecraft.world.entity.LivingEntity;
+ 
+ public interface RangedAttackMob {
+-    void performRangedAttack(LivingEntity target, float pullProgress);
+    void performRangedAttack(LivingEntity target, float pullProgress); default void rangedAttack(LivingEntity entityliving, float f) { performRangedAttack(entityliving, f); } // Paper - OBFHELPER
+
+    // - see EntitySkeletonAbstract melee goal
+    void setAggressive(boolean flag); default void setChargingAttack(boolean charging) { setAggressive(charging); }; // Paper
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftDrowned.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftDrowned.java
+index 34cb8062168258bfd168826ceeb2fde669f6d1a8..03e2acd4829da449a471b0fa1a311e74aee114d3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftDrowned.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftDrowned.java
+@@ -4,7 +4,7 @@ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.entity.Drowned;
+ import org.bukkit.entity.EntityType;
+ 
+-public class CraftDrowned extends CraftZombie implements Drowned {
+public class CraftDrowned extends CraftZombie implements Drowned, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Drowned> { // Paper
+ 
+     public CraftDrowned(CraftServer server, net.minecraft.world.entity.monster.Drowned entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftIllusioner.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftIllusioner.java
+index 59b866e54e0d7e1dd8815ffa85275e36271113da..bbf7189a0fc9921e7a6007494f91229d9fba0846 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftIllusioner.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftIllusioner.java
+@@ -4,7 +4,7 @@ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Illusioner;
+ 
+-public class CraftIllusioner extends CraftSpellcaster implements Illusioner {
+public class CraftIllusioner extends CraftSpellcaster implements Illusioner, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Illusioner> { // Paper
+ 
+     public CraftIllusioner(CraftServer server, net.minecraft.world.entity.monster.Illusioner entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLlama.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLlama.java
+index bda998c9e621bd9bca6642bfa86befed08f4902b..6ad12711a82d7be42ba41c0428779f86536fd900 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLlama.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLlama.java
+@@ -9,7 +9,7 @@ import org.bukkit.entity.Llama;
+ import org.bukkit.entity.Llama.Color;
+ import org.bukkit.inventory.LlamaInventory;
+ 
+-public class CraftLlama extends CraftChestedHorse implements Llama {
+public class CraftLlama extends CraftChestedHorse implements Llama, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.animal.horse.Llama> { // Paper
+ 
+     public CraftLlama(CraftServer server, net.minecraft.world.entity.animal.horse.Llama entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPiglin.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPiglin.java
+index 27763d1eca832abda76c8b3c22595cbaf9b1fe45..aeda5fc001fe4ce55ee467240b275b6050a29f98 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPiglin.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPiglin.java
+@@ -13,7 +13,7 @@ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Piglin;
+ import org.bukkit.inventory.Inventory;
+ 
+-public class CraftPiglin extends CraftPiglinAbstract implements Piglin {
+public class CraftPiglin extends CraftPiglinAbstract implements Piglin, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.piglin.Piglin> { // Paper
+ 
+     public CraftPiglin(CraftServer server, net.minecraft.world.entity.monster.piglin.Piglin entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPillager.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPillager.java
+index 06786fba1fef36e8fc3d0f5650160123f728a6d1..beea227855f0b978e655efc298024120df8f4945 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPillager.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPillager.java
+@@ -6,7 +6,7 @@ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Pillager;
+ import org.bukkit.inventory.Inventory;
+ 
+-public class CraftPillager extends CraftIllager implements Pillager {
+public class CraftPillager extends CraftIllager implements Pillager, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Pillager> { // Paper
+ 
+     public CraftPillager(CraftServer server, net.minecraft.world.entity.monster.Pillager entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
+index 4cd3dfd3466f384aab06dacd388e8053b045b046..b2d3244cca4d9d108159f3537d8a9aace3f8e77f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
+@@ -6,7 +6,7 @@ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Skeleton;
+ import org.bukkit.entity.Skeleton.SkeletonType;
+ 
+-public class CraftSkeleton extends CraftMonster implements Skeleton {
+public class CraftSkeleton extends CraftMonster implements Skeleton, com.destroystokyo.paper.entity.CraftRangedEntity<AbstractSkeleton> { // Paper
+ 
+     public CraftSkeleton(CraftServer server, AbstractSkeleton entity) {
+         super(server, entity);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSnowman.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSnowman.java
+index 6a82d567d96a42bfea0e38afb4e8de13eb3ad5a2..659e2959c5330e4764ea1edc7f8de9f464f9ff52 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSnowman.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSnowman.java
+@@ -5,7 +5,7 @@ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Snowman;
+ 
+-public class CraftSnowman extends CraftGolem implements Snowman {
+public class CraftSnowman extends CraftGolem implements Snowman, com.destroystokyo.paper.entity.CraftRangedEntity<SnowGolem> { // Paper
+     public CraftSnowman(CraftServer server, SnowGolem entity) {
+         super(server, entity);
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
+index 60e00e539d214eb8854a53364c92c3cf55ca1062..d4eeb071dbbfca3ecea256228853bcb5c11f49ee 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
+@@ -4,7 +4,7 @@ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Witch;
+ 
+-public class CraftWitch extends CraftRaider implements Witch {
+public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Witch> { // Paper
+     public CraftWitch(CraftServer server, net.minecraft.world.entity.monster.Witch entity) {
+         super(server, entity);
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWither.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWither.java
+index 54a7defa85542765f3dd0d7ccb770dafd9c7d484..640b0860fbe3412da32d03187e6f355ba8f099ea 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWither.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWither.java
+@@ -7,7 +7,7 @@ import org.bukkit.craftbukkit.boss.CraftBossBar;
+ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Wither;
+ 
+-public class CraftWither extends CraftMonster implements Wither {
+public class CraftWither extends CraftMonster implements Wither, com.destroystokyo.paper.entity.CraftRangedEntity<WitherBoss> { // Paper
+ 
+     private BossBar bossBar;
+ 
--- a/patches/server/0216-Add-config-to-disable-ender-dragon-legacy-check.patch
+++ b/patches/server/0216-Add-config-to-disable-ender-dragon-legacy-check.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 22 Jun 2018 10:38:31 -0500
+Subject: [PATCH] Add config to disable ender dragon legacy check
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index e1110274a9f6b8f7007537732ec8eff7e72040ee..8f8a3ea51823a9cfba985efeb7e320ae42e0da8a 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -368,4 +368,9 @@ public class PaperWorldConfig {
+     private void shieldBlockingDelay() {
+         shieldBlockingDelay = getInt("game-mechanics.shield-blocking-delay", 5);
+     }
+
+    public boolean scanForLegacyEnderDragon = true;
+    private void scanForLegacyEnderDragon() {
+        scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+index 758af2c2d66073aeaee766adb672c465d2993eab..711be01abe9d47bdc9bfe8b09a2719d666b986fb 100644
+--- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+@@ -84,6 +84,10 @@ public class EndDragonFight {
+     private List<EndCrystal> respawnCrystals;
+ 
+     public EndDragonFight(ServerLevel world, long gatewaysSeed, CompoundTag nbt) {
+        // Paper start
+        this.needsStateScanning = world.paperConfig.scanForLegacyEnderDragon;
+        if (!this.needsStateScanning) this.dragonKilled = true;
+        // Paper end
+         this.level = world;
+         if (nbt.contains("NeedsStateScanning")) {
+             this.needsStateScanning = nbt.getBoolean("NeedsStateScanning");
--- a/patches/server/0217-Implement-World.getEntity-UUID-API.patch
+++ b/patches/server/0217-Implement-World.getEntity-UUID-API.patch
@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Tue, 3 Jul 2018 16:08:14 +0200
+Subject: [PATCH] Implement World.getEntity(UUID) API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index df6b4f65dd84621b8477b42a504f9e62c633a6b5..e7f5cd35869790baf616e6c65f49169aa5349e89 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1295,6 +1295,15 @@ public class CraftWorld implements World {
+         return list;
+     }
+ 
+    // Paper start - getEntity by UUID API
+    @Override
+    public Entity getEntity(UUID uuid) {
+        Validate.notNull(uuid, "UUID cannot be null");
+        net.minecraft.world.entity.Entity entity = world.getEntity(uuid);
+        return entity == null ? null : entity.getBukkitEntity();
+    }
+    // Paper end
+
+     @Override
+     public void save() {
+         org.spigotmc.AsyncCatcher.catchOp("world save"); // Spigot
--- a/patches/server/0218-InventoryCloseEvent-Reason-API.patch
+++ b/patches/server/0218-InventoryCloseEvent-Reason-API.patch
@ -0,0 +1,232 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 3 Jul 2018 21:56:23 -0400
+Subject: [PATCH] InventoryCloseEvent Reason API
+
+Allows you to determine why an inventory was closed, enabling plugin developers
+to "confirm" things based on if it was player triggered close or not.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index cf074ef0cb01bc2cbd8c529e7233ceb9443f764d..ca0907601c6262d27c3406cea806a40421bc4ace 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1055,7 +1055,7 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
+         for (BlockEntity tileentity : chunk.getBlockEntities().values()) {
+             if (tileentity instanceof net.minecraft.world.Container) {
+                 for (org.bukkit.entity.HumanEntity h : Lists.newArrayList(((net.minecraft.world.Container) tileentity).getViewers())) {
+-                    h.closeInventory();
+                    h.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); // Paper
+                 }
+             }
+         }
+@@ -1937,7 +1937,7 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
+             // Spigot Start
+             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder) {
+                 for (org.bukkit.entity.HumanEntity h : Lists.newArrayList(((org.bukkit.inventory.InventoryHolder) entity.getBukkitEntity()).getInventory().getViewers())) {
+-                    h.closeInventory();
+                    h.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); // Paper
+                 }
+             }
+             // Spigot End
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 7159a433e9a264d2151dddc84a74689d0bc7635b..171500918c8ee248689909ae97230eb18adc33e5 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -602,7 +602,7 @@ public class ServerPlayer extends Player {
+         }
+         // Paper end
+         if (!this.level.isClientSide && !this.containerMenu.stillValid(this)) {
+-            this.closeContainer();
+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper
+             this.containerMenu = this.inventoryMenu;
+         }
+ 
+@@ -754,7 +754,7 @@ public class ServerPlayer extends Player {
+ 
+         // SPIGOT-943 - only call if they have an inventory open
+         if (this.containerMenu != this.inventoryMenu) {
+-            this.closeContainer();
+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DEATH); // Paper
+         }
+ 
+         net.kyori.adventure.text.Component deathMessage = event.deathMessage() != null ? event.deathMessage() : net.kyori.adventure.text.Component.empty(); // Paper - Adventure
+@@ -1341,7 +1341,7 @@ public class ServerPlayer extends Player {
+             return OptionalInt.empty();
+         } else {
+             if (this.containerMenu != this.inventoryMenu) {
+-                this.closeContainer();
+                this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.OPEN_NEW); // Paper
+             }
+ 
+             this.nextContainerCounter();
+@@ -1401,7 +1401,7 @@ public class ServerPlayer extends Player {
+         }
+         // CraftBukkit end
+         if (this.containerMenu != this.inventoryMenu) {
+-            this.closeContainer();
+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.OPEN_NEW); // Paper
+         }
+ 
+         // this.nextContainerCounter(); // CraftBukkit - moved up
+@@ -1430,7 +1430,13 @@ public class ServerPlayer extends Player {
+ 
+     @Override
+     public void closeContainer() {
+-        CraftEventFactory.handleInventoryCloseEvent(this); // CraftBukkit
+        // Paper start
+        this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNKNOWN);
+    }
+    @Override
+    public void closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
+        CraftEventFactory.handleInventoryCloseEvent(this, reason); // CraftBukkit
+        // Paper end
+         this.connection.send(new ClientboundContainerClosePacket(this.containerMenu.containerId));
+         this.doCloseContainer();
+     }
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 35a00a622ff0c3582e08dbbefb1d34a84e590a81..ce88f701f296e67afc67d7e3882406e86147408e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -188,6 +188,7 @@ import org.bukkit.event.inventory.ClickType;
+ import org.bukkit.event.inventory.CraftItemEvent;
+ import org.bukkit.event.inventory.InventoryAction;
+ import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent; // Paper
+ import org.bukkit.event.inventory.InventoryCreativeEvent;
+ import org.bukkit.event.inventory.InventoryType.SlotType;
+ import org.bukkit.event.inventory.SmithItemEvent;
+@@ -2332,10 +2333,15 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+ 
+     @Override
+     public void handleContainerClose(ServerboundContainerClosePacket packet) {
+-        PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
+        // Paper start
+        handleContainerClose(packet, InventoryCloseEvent.Reason.PLAYER);
+    }
+    public void handleContainerClose(ServerboundContainerClosePacket packetplayinclosewindow, InventoryCloseEvent.Reason reason) {
+        // Paper end
+        PacketUtils.ensureRunningOnSameThread(packetplayinclosewindow, this, this.player.getLevel());
+ 
+         if (this.player.isImmobile()) return; // CraftBukkit
+-        CraftEventFactory.handleInventoryCloseEvent(this.player); // CraftBukkit
+        CraftEventFactory.handleInventoryCloseEvent(this.player, reason); // CraftBukkit // Paper
+ 
+         this.player.doCloseContainer();
+     }
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 429e6c7f9a5e5355e26deeae1e89ffea7439cd96..7c5a75fb34640bb4e7ef839412dbb30b0d0fc8e8 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -494,7 +494,7 @@ public abstract class PlayerList {
+         // CraftBukkit start - Quitting must be before we do final save of data, in case plugins need to modify it
+         // See SPIGOT-5799, SPIGOT-6145
+         if (entityplayer.containerMenu != entityplayer.inventoryMenu) {
+-            entityplayer.closeContainer();
+            entityplayer.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper
+         }
+ 
+         PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(this.cserver.getPlayer(entityplayer), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? entityplayer.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(entityplayer.getScoreboardName())));
+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 0d6e024208182d5779be3d84cff193ce904ad541..e0e33dd92b686939f622f0a7da0d5a971f43d0d6 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -264,7 +264,7 @@ public abstract class Player extends LivingEntity {
+         this.updateIsUnderwater();
+         super.tick();
+         if (!this.level.isClientSide && this.containerMenu != null && !this.containerMenu.stillValid(this)) {
+-            this.closeContainer();
+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper
+             this.containerMenu = this.inventoryMenu;
+         }
+ 
+@@ -487,6 +487,13 @@ public abstract class Player extends LivingEntity {
+ 
+     }
+ 
+    // Paper start - unused code, but to keep signatures aligned
+    public void closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
+        closeContainer();
+        this.containerMenu = this.inventoryMenu;
+    }
+    // Paper end
+
+     public void closeContainer() {
+         this.containerMenu = this.inventoryMenu;
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index 7f7322b5174a7580675b0607b0f282f7bf75a3e2..662a4cec1d292428f06ec5a1f862a1f8d8834c09 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -373,7 +373,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         if (((ServerPlayer) this.getHandle()).connection == null) return;
+         if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
+             // fire INVENTORY_CLOSE if one already open
+-            ((ServerPlayer) this.getHandle()).connection.handleContainerClose(new ServerboundContainerClosePacket(this.getHandle().containerMenu.containerId));
+            ((ServerPlayer) this.getHandle()).connection.handleContainerClose(new ServerboundContainerClosePacket(this.getHandle().containerMenu.containerId), org.bukkit.event.inventory.InventoryCloseEvent.Reason.OPEN_NEW); // Paper
+         }
+         ServerPlayer player = (ServerPlayer) this.getHandle();
+         AbstractContainerMenu container;
+@@ -443,8 +443,16 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+ 
+     @Override
+     public void closeInventory() {
+-        this.getHandle().closeContainer();
+        this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.PLUGIN);
+        getHandle().closeContainer();
+        // Paper start
+        getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.PLUGIN);
+     }
+    @Override
+    public void closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
+        getHandle().closeContainer(reason);
+    }
+    // Paper end
+ 
+     @Override
+     public boolean isBlocking() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 8df1894df3583840412ccc7ccdc4b23db6dd6265..f8155d7edb4e13c2ec5ed832231f02ee6eff3f35 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -908,7 +908,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+         // Close any foreign inventory
+         if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
+-            this.getHandle().closeContainer();
+            this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.TELEPORT); // Paper
+         }
+ 
+         // Check if the fromWorld and toWorld are the same.
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 56900b5810db623a49559ad218a5385c110bf479..375e9e45331d5be237c67f11af94c6998409418b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1154,7 +1154,7 @@ public class CraftEventFactory {
+ 
+     public static AbstractContainerMenu callInventoryOpenEvent(ServerPlayer player, AbstractContainerMenu container, boolean cancelled) {
+         if (player.containerMenu != player.inventoryMenu) { // fire INVENTORY_CLOSE if one already open
+-            player.connection.handleContainerClose(new ServerboundContainerClosePacket(player.containerMenu.containerId));
+            player.connection.handleContainerClose(new ServerboundContainerClosePacket(player.containerMenu.containerId), InventoryCloseEvent.Reason.OPEN_NEW); // Paper
+         }
+ 
+         CraftServer server = player.level.getCraftServer();
+@@ -1320,8 +1320,18 @@ public class CraftEventFactory {
+         return event;
+     }
+ 
+    // Paper start
+    /**
+     * Incase plugins hooked into this or Spigot adds a new inventory close event. Prefer to pass a reason
+     * @param human
+     */
+    @Deprecated
+     public static void handleInventoryCloseEvent(net.minecraft.world.entity.player.Player human) {
+-        InventoryCloseEvent event = new InventoryCloseEvent(human.containerMenu.getBukkitView());
+        handleInventoryCloseEvent(human, org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNKNOWN);
+    }
+    public static void handleInventoryCloseEvent(net.minecraft.world.entity.player.Player human, org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
+        // Paper end
+        InventoryCloseEvent event = new InventoryCloseEvent(human.containerMenu.getBukkitView(), reason); // Paper
+         human.level.getCraftServer().getPluginManager().callEvent(event);
+         human.containerMenu.transferTo(human.inventoryMenu, human.getBukkitEntity());
+     }