Remove wall-time / unused skip tick protection (#11412)

Spigot still maintains some partial implementation of "tick skipping", a
practice in which the MinecraftServer.currentTick field is updated not
by an increment of one per actual tick, but instead set to
System.currentTimeMillis() / 50. This behaviour means that the tracked
tick may "skip" a tick value in case a previous tick took more than the
expected 50ms.

To compensate for this in important paths, spigot/craftbukkit
implements "wall-time". Instead of incrementing/decrementing ticks on
block entities/entities by one for each call to their tick() method,
they instead increment/decrement important values, like
an ItemEntity's age or pickupDelay, by the difference of
`currentTick - lastTick`, where `lastTick` is the value of
`currentTick` during the last tick() call.

These "fixes" however do not play nicely with minecraft's simulation
distance as entities/block entities implementing the above behaviour
would "catch up" their values when moving from a non-ticking chunk to a
ticking one as their `lastTick` value remains stuck on the last tick in
a ticking chunk and hence lead to a large "catch up" once ticked again.

Paper completely removes the "tick skipping" behaviour (See patch
"Further-improve-server-tick-loop"), making the above precautions
completely unnecessary, which also rids paper of the previous described
incompatibility with non-ticking chunks.

1 files changed, 61 insertions, 0 deletions

diff --git a/patches/server/0772-Fix-premature-player-kicks-on-shutdown.patch b/patches/server/0772-Fix-premature-player-kicks-on-shutdown.patch
new file mode 100644
index 0000000000..034840341e
--- /dev/null
+++ b/patches/server/0772-Fix-premature-player-kicks-on-shutdown.patch
@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <[email protected]>
+Date: Thu, 11 Apr 2024 16:37:44 +0100
+Subject: [PATCH] Fix premature player kicks on shutdown
+
+When the server is stopping, the default execution handler method will throw a
+RejectedExecutionException in order to prevent further execution, this causes
+us to lose the actual kick reason. To mitigate this, we'll use a seperate marked
+class in order to gracefully ignore these.
+
+diff --git a/src/main/java/io/papermc/paper/util/ServerStopRejectedExecutionException.java b/src/main/java/io/papermc/paper/util/ServerStopRejectedExecutionException.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2c5cd77103c5a33d4349ab6b9ee2d8378bb60eb4
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/util/ServerStopRejectedExecutionException.java
+@@ -0,0 +1,20 @@
++package io.papermc.paper.util;
++
++import java.util.concurrent.RejectedExecutionException;
++
++public class ServerStopRejectedExecutionException extends RejectedExecutionException {
++    public ServerStopRejectedExecutionException() {
++    }
++
++    public ServerStopRejectedExecutionException(final String message) {
++        super(message);
++    }
++
++    public ServerStopRejectedExecutionException(final String message, final Throwable cause) {
++        super(message, cause);
++    }
++
++    public ServerStopRejectedExecutionException(final Throwable cause) {
++        super(cause);
++    }
++}
+diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
+index 4d9f1fc884050993287adfa4578a87da710623fb..a8dfe7a4b3d01bf75587be078f471d1ef1d7a667 100644
+--- a/src/main/java/net/minecraft/network/Connection.java
++++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -285,6 +285,7 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+                         Connection.genericsFtw(packet, packetlistener);
+                     } catch (RunningOnDifferentThreadException cancelledpackethandleexception) {
+                         ;
++                    } catch (io.papermc.paper.util.ServerStopRejectedExecutionException ignored) { // Paper - do not prematurely disconnect players on stop
+                     } catch (RejectedExecutionException rejectedexecutionexception) {
+                         this.disconnect((Component) Component.translatable("multiplayer.disconnect.server_shutdown"));
+                     } catch (ClassCastException classcastexception) {
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index bef05e09c654794405832ad75c3471f63399dfee..2cc22a9a5483c62cdf64870f5ce62b33018bef06 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -2091,7 +2091,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     @Override
+     public void executeIfPossible(Runnable runnable) {
+         if (this.isStopped()) {
+-            throw new RejectedExecutionException("Server already shutting down");
++            throw new io.papermc.paper.util.ServerStopRejectedExecutionException("Server already shutting down"); // Paper - do not prematurely disconnect players on stop
+         } else {
+             super.executeIfPossible(runnable);
+         }