some work

patches/server/Add-Early-Warning-Feature-to-WatchDog.patch

@@ -69,7 +69,7 @@ diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/spigotmc/WatchdogThread.java
 +++ b/src/main/java/org/spigotmc/WatchdogThread.java
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
      private static WatchdogThread instance;
      private long timeoutTime;
      private boolean restart;
@@ -80,7 +80,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private volatile long lastTick;
      private volatile boolean stopping;
  
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
          super( "Paper Watchdog Thread" );
          this.timeoutTime = timeoutTime;
          this.restart = restart;
@@ -89,7 +89,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      private static long monotonicMillis()
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
          while ( !this.stopping )
          {
              //
@@ -110,7 +110,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  log.log( Level.SEVERE, "------------------------------" );
                  log.log( Level.SEVERE, "The server has stopped responding! This is (probably) not a Paper bug." ); // Paper
                  log.log( Level.SEVERE, "If you see a plugin in the Server thread dump below, then please report it to that author" );
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
                      }
                  }
                  // Paper end
@@ -122,7 +122,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                // Paper end - Different message for short timeout
                  log.log( Level.SEVERE, "------------------------------" );
                  log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
-                 io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler.dumpAllChunkLoadInfo(isLongTimeout); // Paper // Paper - rewrite chunk system
                  WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
                  log.log( Level.SEVERE, "------------------------------" );
                  //

patches/server/Add-PhantomPreSpawnEvent.patch

@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
 @@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         return (double) this.getEyeHeight();
+         return -0.125F;
      }
  
 +    // Paper start

patches/server/Add-openSign-method-to-HumanEntity.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
          }
      }
-
+ 
 +    // Paper start - move open sign method to HumanEntity
 +    @Override
 +    public void openSign(final org.bukkit.block.Sign sign, final org.bukkit.block.sign.Side side) {

patches/server/Adventure.patch

@@ -2239,10 +2239,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public ChatDecorator getChatDecorator() {
 -        return ChatDecorator.PLAIN;
--    }
--
--    public boolean logIPs() {
--        return true;
 +        // Paper start - moved to ChatPreviewProcessor
 +        return ChatDecorator.create((sender, commandSourceStack, message) -> {
 +            final io.papermc.paper.adventure.ChatDecorationProcessor processor = new io.papermc.paper.adventure.ChatDecorationProcessor(this, sender, commandSourceStack, message);
@@ -2251,7 +2247,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end
      }
  
-     public static record ReloadableResources(CloseableResourceManager resourceManager, ReloadableServerResources managers) implements AutoCloseable {
+     public boolean logIPs() {
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java

patches/server/Block-Enderpearl-Travel-Exploit.patch

@@ -20,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-
+ 
          public void onTickingEnd(Entity entity) {
              ServerLevel.this.entityTickList.remove(entity);
 +            // Paper start - Reset pearls when they stop being ticked
@@ -30,7 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +            // Paper end
          }
-
+ 
          public void onTrackingStart(Entity entity) {
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -42,5 +42,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.cachedOwner = null;
 +            if (this instanceof ThrownEnderpearl && this.level() != null && this.level().paperConfig().fixes.disableUnloadedChunkEnderpearlExploit) { this.ownerUUID = null; } // Paper - Don't store shooter name for pearls to block enderpearl travel exploit
          }
-
+ 
          this.leftOwner = nbt.getBoolean("LeftOwner");

patches/server/Break-up-and-make-tab-spam-limits-configurable.patch

@@ -25,23 +25,23 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListener
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
-     private long keepAliveChallenge;
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     private int ackBlockChangesUpTo = -1;
      // CraftBukkit start - multithreaded fields
      private final AtomicInteger chatSpamTickCount = new AtomicInteger();
 +    private final java.util.concurrent.atomic.AtomicInteger tabSpamLimiter = new java.util.concurrent.atomic.AtomicInteger(); // Paper - configurable tab spam limits
      // CraftBukkit end
      private int dropSpamTickCount;
      private double firstGoodX;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
-         this.server.getProfiler().pop();
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         this.keepConnectionAlive();
          // CraftBukkit start
          for (int spam; (spam = this.chatSpamTickCount.get()) > 0 && !this.chatSpamTickCount.compareAndSet(spam, spam - 1); ) ;
 +        if (tabSpamLimiter.get() > 0) tabSpamLimiter.getAndDecrement(); // Paper - split to seperate variable
          /* Use thread-safe field access instead
          if (this.chatSpamTickCount > 0) {
              --this.chatSpamTickCount;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
      public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
          // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // Paper - run this async
          // CraftBukkit start

patches/server/Call-PaperServerListPingEvent-for-legacy-pings.patch

@@ -90,61 +90,66 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
 +++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
 @@ -0,0 +0,0 @@ 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
+                 SocketAddress socketaddress = channelhandlercontext.channel().remoteAddress();
+                 int i = bytebuf.readableBytes();
+                 String s = null; // Paper
+-                org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.getMaxPlayers()); // CraftBukkit
++                // org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.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(Locale.ROOT, "%s\u00a7%d\u00a7%d", event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()); // CraftBukkit
+                 if (i == 0) {
+                     LegacyQueryHandler.LOGGER.debug("Ping: (<1.3.x) from {}", socketaddress);
+-                    s = LegacyQueryHandler.createVersion0Response(this.server, event); // CraftBukkit
++
 +                    // Paper start - Call PaperServerListPingEvent and use results
-+                    event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(minecraftserver, inetsocketaddress, 39, null);
++                    event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(net.minecraft.server.MinecraftServer.getServer(), (java.net.InetSocketAddress) socketaddress, 39, null);
 +                    if (event == null) {
 +                        channelhandlercontext.close();
-+                        break;
++                        bytebuf.release();
++                        flag = false;
++                        return;
 +                    }
 +                    s = String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", com.destroystokyo.paper.network.PaperLegacyStatusClient.getUnformattedMotd(event), event.getNumPlayers(), event.getMaxPlayers());
-                     this.sendFlushAndClose(channelhandlercontext, this.createReply(s));
 +                    // Paper end
-                     break;
-                 case 1:
+                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
+                 } else {
                      if (bytebuf.readUnsignedByte() != 1) {
 @@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+                         LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}", socketaddress);
                      }
  
-                     LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}:{}", inetsocketaddress.getAddress(), inetsocketaddress.getPort());
--                    s = String.format(Locale.ROOT, "\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 = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(minecraftserver, inetsocketaddress, 127, null); // Paper
-+                    if (event == null) {
-+                        channelhandlercontext.close();
-+                        break;
+-                    if (s == null) s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit // Paper
++                    if (s == null) {
++                        // Paper start - Call PaperServerListPingEvent and use results
++                        event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(net.minecraft.server.MinecraftServer.getServer(), (java.net.InetSocketAddress) socketaddress, 127, null); // Paper
++                        if (event == null) {
++                            channelhandlercontext.close();
++                            bytebuf.release();
++                            flag = false;
++                            return;
++                        }
++                        s = String.format(Locale.ROOT, "\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", new Object[] { event.getProtocolVersion(), this.server.getServerVersion(), event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()}); // CraftBukkit
++                        // Paper end
 +                    }
-+                    s = String.format(Locale.ROOT, "\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:
+                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
+                 }
+ 
 @@ -0,0 +0,0 @@ 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);
+-            Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
++        java.net.InetSocketAddress virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(host, port);
 +        com.destroystokyo.paper.event.server.PaperServerListPingEvent event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(
-+                server, (InetSocketAddress) ctx.channel().remoteAddress(), protocolVersion, virtualHost);
++                server, (java.net.InetSocketAddress) ctx.channel().remoteAddress(), protocolVersion, virtualHost);
 +        if (event == null) {
 +            ctx.close();
-+            return;
++            return null;
 +        }
 +
 +        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", event.getProtocolVersion(), event.getVersion(),
 +            com.destroystokyo.paper.network.PaperLegacyStatusClient.getMotd(event), event.getNumPlayers(), event.getMaxPlayers());
-         this.sendFlushAndClose(ctx, this.createReply(response));
+         return response;
      }
  

patches/server/Configurable-sprint-interruption-on-attack.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/entity/player/Player.java
 @@ -0,0 +0,0 @@ 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
@@ -20,5 +20,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            }
 +                            // Paper end
                          }
-
+ 
                          if (flag3) {

patches/server/Enderman.teleportRandomly.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class CraftEnderman extends CraftMonster implements Enderman {
          super(server, entity);
      }
-
+ 
 +    @Override public boolean teleportRandomly() { return getHandle().teleport(); } // Paper
      @Override
      public MaterialData getCarriedMaterial() {

patches/server/EndermanAttackPlayerEvent.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
          this.readPersistentAngerSaveData(this.level(), nbt);
      }
-
+ 
 -    boolean isLookingAtMe(Player player) {
 +    // Paper start - EndermanAttackPlayerEvent
 +    private boolean isLookingAtMe(Player player) {
@@ -26,5 +26,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private boolean isLookingAtMe_check(Player player) {
 +        // Paper end
          ItemStack itemstack = (ItemStack) player.getInventory().armor.get(3);
-
+ 
          if (itemstack.is(Blocks.CARVED_PUMPKIN.asItem())) {

patches/server/EndermanEscapeEvent.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
          this.setTarget(target, 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();
@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
          if (this.level().isDay() && this.tickCount >= this.targetChangeTime + 600) {
              float f = this.getLightLevelDependentMagicValue();
-
+ 
 -            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);
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
              } else {
                  flag1 = flag && this.hurtWithCleanWater(source, (ThrownPotion) source.getDirectEntity(), amount);
-
+ 
 +                if (this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.INDIRECT)) { // Paper start
                  for (int i = 0; i < 64; ++i) {
                      if (this.teleport()) {
@@ -44,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      }
                  }
 +                } // Paper end
-
+ 
                  return flag1;
              }
 @@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
@@ -55,4 +55,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        if (this.target.distanceToSqr((Entity) this.enderman) < 16.0D && this.enderman.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.STARE)) { // Paper
                              this.enderman.teleport();
                          }
-
+ 

patches/server/Expand-World.spawnParticle-API-and-add-Builder.patch

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
      }
-
+ 
      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);
@@ -25,20 +25,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor 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) {
 -        if (data != null) {

patches/server/Fix-exploit-that-allowed-colored-signs-to-be-created.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
 @@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
              Style chatmodifier = signtext.getMessage(i, entityhuman.isTextFilteringEnabled()).getStyle();
-
+ 
              if (entityhuman.isTextFilteringEnabled()) {
 -                signtext = signtext.setMessage(i, Component.literal(filteredtext.filteredOrEmpty()).setStyle(chatmodifier));
 +                signtext = signtext.setMessage(i, Component.literal(net.minecraft.SharedConstants.filterText(filteredtext.filteredOrEmpty())).setStyle(chatmodifier)); // Paper - filter sign text to chat only
@@ -19,4 +19,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                signtext = signtext.setMessage(i, Component.literal(net.minecraft.SharedConstants.filterText(filteredtext.raw())).setStyle(chatmodifier), Component.literal(net.minecraft.SharedConstants.filterText(filteredtext.filteredOrEmpty())).setStyle(chatmodifier)); // Paper - filter sign text to chat only
              }
          }
-
+ 

patches/server/InventoryCloseEvent-Reason-API.patch

@@ -86,7 +86,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import org.bukkit.event.inventory.InventoryCreativeEvent;
  import org.bukkit.event.inventory.InventoryType.SlotType;
  import org.bukkit.event.inventory.SmithItemEvent;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
  
      @Override
      public void handleContainerClose(ServerboundContainerClosePacket packet) {
@@ -115,7 +115,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            entityplayer.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper
          }
  
-         PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : PaperAdventure.asAdventure(entityplayer.getDisplayName()))); // Paper - Adventure
+         PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(entityplayer.getDisplayName()))); // Paper - Adventure
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java

patches/server/Make-legacy-ping-handler-more-reliable.patch

@@ -32,13 +32,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
 +++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
 @@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
+ 
      private static final Logger LOGGER = LogUtils.getLogger();
-     public static final int FAKE_PROTOCOL_VERSION = 127;
-     private final ServerConnectionListener serverConnectionListener;
+     private final ServerInfo server;
 +    private ByteBuf buf; // Paper
  
-     public LegacyQueryHandler(ServerConnectionListener networkIo) {
-         this.serverConnectionListener = networkIo;
+     public LegacyQueryHandler(ServerInfo server) {
+         this.server = server;
 @@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
      public void channelRead(ChannelHandlerContext channelhandlercontext, Object object) {
          ByteBuf bytebuf = (ByteBuf) object;
@@ -57,26 +57,46 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          boolean flag = true;
  
 @@ -0,0 +0,0 @@ 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;
+                 SocketAddress socketaddress = channelhandlercontext.channel().remoteAddress();
+                 int i = bytebuf.readableBytes();
+-                String s;
++                String s = null; // Paper
+                 org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.getMaxPlayers()); // CraftBukkit
+ 
+                 if (i == 0) {
 @@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-                     } finally {
-                         bytebuf1.release();
                      }
-+                */ // Paper end - Replace with improved version below
-             }
  
-             bytebuf.release();
+                     if (bytebuf.isReadable()) {
+-                        if (!LegacyQueryHandler.readCustomPayloadPacket(bytebuf)) {
+-                            return;
++                        // Paper start - Replace with improved version below
++                        if (bytebuf.readUnsignedByte() != 250) {
++                            s = this.readLegacy1_6(channelhandlercontext, bytebuf);
++                            if (s == null) {
++                                return;
++                            }
+                         }
+-
+-                        LegacyQueryHandler.LOGGER.debug("Ping: (1.6) from {}", socketaddress);
++                        // if (!LegacyQueryHandler.readCustomPayloadPacket(bytebuf)) {
++                        //     return;
++                        // }
++                        //
++                        // LegacyQueryHandler.LOGGER.debug("Ping: (1.6) from {}", socketaddress);
++                        // Paper end
+                     } else {
+                         LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}", socketaddress);
+                     }
+ 
+-                    s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit
++                    if (s == null) s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit // Paper
+                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
+                 }
+ 
 @@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
- 
+         }
      }
  
 +    // Paper start
@@ -86,12 +106,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            return null;
 +        }
 +
-+        String result = buf.toString(buf.readerIndex(), size, StandardCharsets.UTF_16BE);
++        String result = buf.toString(buf.readerIndex(), size, java.nio.charset.StandardCharsets.UTF_16BE);
 +        buf.skipBytes(size); // toString doesn't increase readerIndex automatically
 +        return result;
 +    }
 +
-+    private void readLegacy1_6(ChannelHandlerContext ctx, ByteBuf part) {
++    private String readLegacy1_6(ChannelHandlerContext ctx, ByteBuf part) {
 +        ByteBuf buf = this.buf;
 +
 +        if (buf == null) {
@@ -104,35 +124,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        buf.writeBytes(part);
 +
 +        if (!buf.isReadable(Short.BYTES + Short.BYTES + Byte.BYTES + Short.BYTES + Integer.BYTES)) {
-+            return;
++            return null;
 +        }
 +
 +        String s = readLegacyString(buf);
 +        if (s == null) {
-+            return;
++            return null;
 +        }
 +
 +        if (!s.equals("MC|PingHost")) {
 +            removeHandler(ctx);
-+            return;
++            return null;
 +        }
 +
 +        if (!buf.isReadable(Short.BYTES) || !buf.isReadable(buf.readShort())) {
-+            return;
++            return null;
 +        }
 +
-+        MinecraftServer server = this.serverConnectionListener.getServer();
++        net.minecraft.server.MinecraftServer server = net.minecraft.server.MinecraftServer.getServer();
 +        int protocolVersion = buf.readByte();
 +        String host = readLegacyString(buf);
 +        if (host == null) {
 +            removeHandler(ctx);
-+            return;
++            return null;
 +        }
 +        int port = buf.readInt();
 +
 +        if (buf.isReadable()) {
 +            removeHandler(ctx);
-+            return;
++            return null;
 +        }
 +
 +        buf.release();
@@ -141,8 +161,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        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));
++            Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
++        return response;
 +    }
 +
 +    private void removeHandler(ChannelHandlerContext ctx) {
@@ -163,6 +183,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
 +
-     private void sendFlushAndClose(ChannelHandlerContext ctx, ByteBuf buf) {
-         ctx.pipeline().firstContext().writeAndFlush(buf).addListener(ChannelFutureListener.CLOSE);
-     }
+     // CraftBukkit start
+     private static String createVersion0Response(ServerInfo serverinfo, org.bukkit.event.server.ServerListPingEvent event) {
+         return String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", event.getMotd(), event.getNumPlayers(), event.getMaxPlayers());

patches/server/Option-to-prevent-armor-stands-from-doing-entity-loo.patch

@@ -14,8 +14,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      protected void pushEntities() {
 +        if (!this.level().paperConfig().entities.armorStands.doCollisionEntityLookups) return; // Paper
          List<Entity> list = this.level().getEntities((Entity) this, this.getBoundingBox(), ArmorStand.RIDABLE_MINECARTS);
+         Iterator iterator = list.iterator();
  
-         for (int i = 0; i < list.size(); ++i) {
 diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/Level.java

patches/server/Prevent-Frosted-Ice-from-loading-holding-chunks.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
 @@ -0,0 +0,0 @@ public class FrostedIceBlock extends IceBlock {
-
+ 
              for(Direction direction : Direction.values()) {
                  mutableBlockPos.setWithOffset(pos, direction);
 -                BlockState blockState = world.getBlockState(mutableBlockPos);
@@ -20,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      world.scheduleTick(mutableBlockPos, this, Mth.nextInt(random, world.paperConfig().environment.frostedIce.delay.min, world.paperConfig().environment.frostedIce.delay.max)); // Paper - use configurable min/max delay
                  }
 @@ -0,0 +0,0 @@ public class FrostedIceBlock extends IceBlock {
-
+ 
          for(Direction direction : Direction.values()) {
              mutableBlockPos.setWithOffset(pos, direction);
 -            if (world.getBlockState(mutableBlockPos).is(this)) {

patches/server/Refresh-player-inventory-when-cancelling-PlayerInter.patch

@@ -19,7 +19,7 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListener
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
                              }
  
                              if (event.isCancelled()) {

patches/server/Slime-Pathfinder-Events.patch

@@ -8,19 +8,6 @@ diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/m
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Slime.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.ServerLevelAccessor;
- import net.minecraft.world.level.WorldGenLevel;
- import net.minecraft.world.level.levelgen.WorldgenRandom;
- import net.minecraft.world.phys.Vec3;
-+// Paper start
-+import com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent;
-+import com.destroystokyo.paper.event.entity.SlimeSwimEvent;
-+import com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent;
-+import com.destroystokyo.paper.event.entity.SlimeWanderEvent;
-+// Paper end
- // CraftBukkit start
- import java.util.ArrayList;
- import java.util.List;
 @@ -0,0 +0,0 @@ public class Slime extends Mob implements Enemy {
      @Override
      public void addAdditionalSaveData(CompoundTag nbt) {
@@ -46,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          @Override
          public boolean canUse() {
 -            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl;
-+            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new SlimeSwimEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
++            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeSwimEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
          }
  
          @Override
@@ -62,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (!this.slime.canAttack(entityliving)) {
 +                return false;
 +            }
-+            return this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
++            return this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
 +            // Paper end
          }
  
@@ -79,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (!this.slime.canAttack(entityliving)) {
 +                return false;
 +            }
-+            return --this.growTiredTimer > 0 && this.slime.canWander && new SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
++            return --this.growTiredTimer > 0 && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
 +            // Paper end
          }
  
@@ -112,7 +99,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.nextRandomizeTime = this.adjustedTickDelay(40 + this.slime.getRandom().nextInt(60));
                  this.chosenDegrees = (float) this.slime.getRandom().nextInt(360);
 +                // Paper start
-+                SlimeChangeDirectionEvent event = new SlimeChangeDirectionEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), this.chosenDegrees);
++                com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent event = new com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), this.chosenDegrees);
 +                if (!this.slime.canWander || !event.callEvent()) return;
 +                this.chosenDegrees = event.getNewYaw();
 +                // Paper end
@@ -124,7 +111,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          @Override
          public boolean canUse() {
 -            return !this.slime.isPassenger();
-+            return !this.slime.isPassenger() && this.slime.canWander && new SlimeWanderEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
++            return !this.slime.isPassenger() && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeWanderEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
          }
  
          @Override

patches/server/Use-AsyncAppender-to-keep-logging-IO-off-main-thread.patch

@@ -10,8 +10,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/build.gradle.kts
 @@ -0,0 +0,0 @@ dependencies {
      implementation("commons-lang:commons-lang:2.6")
-     runtimeOnly("org.xerial:sqlite-jdbc:3.42.0.0")
-     runtimeOnly("com.mysql:mysql-connector-j:8.0.33")
+     runtimeOnly("org.xerial:sqlite-jdbc:3.43.0.0")
+     runtimeOnly("com.mysql:mysql-connector-j:8.1.0")
 +    runtimeOnly("com.lmax:disruptor:3.4.4") // Paper
  
      runtimeOnly("org.apache.maven:maven-resolver-provider:3.8.5")

patches/server/Use-a-Queue-for-Queueing-Commands.patch

@@ -17,11 +17,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final java.util.Queue<ConsoleInput> serverCommandQueue = new java.util.concurrent.ConcurrentLinkedQueue<>(); // Paper - use a proper queuemmands
      @Nullable
      private QueryThreadGs4 queryThreadGs4;
-     // public final RemoteControlCommandListener rconConsoleSource; // CraftBukkit - remove field
+     // private final RemoteControlCommandListener rconConsoleSource; // CraftBukkit - remove field
 @@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-             return;
-         }
-         // Paper end - rewrite chunk system
+     }
+ 
+     public void handleConsoleInput(String command, CommandSourceStack commandSource) {
 -        this.consoleInput.add(new ConsoleInput(command, commandSource));
 +        this.serverCommandQueue.add(new ConsoleInput(command, commandSource)); // Paper - use proper queue
      }

patches/server/WitchConsumePotionEvent.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
 @@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
-
+ 
                      this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
                      if (itemstack.is(Items.POTION)) {
 -                        List<MobEffectInstance> list = PotionUtils.getMobEffects(itemstack);
@@ -19,6 +19,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +                        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();

patches/server/WitchThrowPotionEvent.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ 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));