Move to configurate for paper.yml (#7609)

.editorconfig

@@ -10,3 +10,9 @@ indent_style=tab
 
 [*.bat]
 end_of_line=crlf
+
+[*.yml]
+indent_size=2
+
+[*.patch]
+trim_trailing_whitespace=false

patches/server/Add-API-for-quit-reason.patch

@@ -56,8 +56,8 @@ 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, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? entityplayer.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(entityplayer.getScoreboardName())));
+-        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() : net.kyori.adventure.text.Component.text(entityplayer.getScoreboardName())));
-+        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), 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())), entityplayer.quitReason); // Paper - quit reason
++        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() : net.kyori.adventure.text.Component.text(entityplayer.getScoreboardName())), entityplayer.quitReason); // Paper - quit reason
          if (entityplayer.didPlayerJoinEvent) this.cserver.getPluginManager().callEvent(playerQuitEvent); // Paper - if we disconnected before join ever fired, don't fire quit
          entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
  

patches/server/Add-Alternate-Current-redstone-implementation.patch

@@ -1920,39 +1920,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return LevelHelper.setWireState(level, pos, state, added);
 +    }
 +}
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     }
- 
-     public enum RedstoneImplementation {
--        VANILLA, EIGENCRAFT
-+        VANILLA, EIGENCRAFT, ALTERNATE_CURRENT
-     }
-     public RedstoneImplementation redstoneImplementation = RedstoneImplementation.VANILLA;
-     private void redstoneImplementation() {
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-         switch (implementation) {
-             default:
--                logError("Invalid redstone-implementation config " + implementation + " - must be one of: vanilla, eigencraft");
-+                logError("Invalid redstone-implementation config " + implementation + " - must be one of: vanilla, eigencraft, alternate-current");
-             case "vanilla":
-                 redstoneImplementation = RedstoneImplementation.VANILLA;
-                 log("Using the Vanilla redstone implementation.");
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-                 redstoneImplementation = RedstoneImplementation.EIGENCRAFT;
-                 log("Using Eigencraft's redstone implementation by theosib.");
-                 break;
-+            case "alternate-current":
-+                redstoneImplementation = RedstoneImplementation.ALTERNATE_CURRENT;
-+                log("Using Alternate Current's redstone implementation by Space Walker.");
-+                break;
-         }
-     }
- 
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -2213,7 +2180,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!oldState.is(state.getBlock()) && !world.isClientSide) {
 -            this.updateSurroundingRedstone(world, pos, state, null); // Paper - Optimize redstone
 +            // Paper start - optimize redstone - replace call to updatePowerStrength
-+            if (world.paperConfig.redstoneImplementation == com.destroystokyo.paper.PaperWorldConfig.RedstoneImplementation.ALTERNATE_CURRENT) {
++            if (world.paperConfig().misc.redstoneImplementation == io.papermc.paper.configuration.WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
 +                world.getWireHandler().onWireAdded(pos); // Alternate Current
 +            } else {
 +                this.updateSurroundingRedstone(world, pos, state, null); // vanilla/Eigencraft
@@ -2228,7 +2195,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -                this.updateSurroundingRedstone(world, pos, state, null); // Paper - Optimize redstone
 +                // Paper start - optimize redstone - replace call to updatePowerStrength
-+                if (world.paperConfig.redstoneImplementation == com.destroystokyo.paper.PaperWorldConfig.RedstoneImplementation.ALTERNATE_CURRENT) {
++                if (world.paperConfig().misc.redstoneImplementation == io.papermc.paper.configuration.WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
 +                    world.getWireHandler().onWireRemoved(pos, state); // Alternate Current
 +                } else {
 +                    this.updateSurroundingRedstone(world, pos, state, null); // vanilla/Eigencraft
@@ -2243,7 +2210,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!world.isClientSide) {
 +            // Paper start - optimize redstone (Alternate Current)
 +            // Alternate Current handles breaking of redstone wires in the WireHandler.
-+            if (world.paperConfig.redstoneImplementation == com.destroystokyo.paper.PaperWorldConfig.RedstoneImplementation.ALTERNATE_CURRENT) {
++            if (world.paperConfig().misc.redstoneImplementation == io.papermc.paper.configuration.WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
 +                world.getWireHandler().onWireUpdated(pos);
 +            } else
 +            // Paper end

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

@@ -8,33 +8,6 @@ thread dumps at an interval until the point of crash.
 
 This will help diagnose what was going on in that time before the crash.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ import org.bukkit.configuration.file.YamlConfiguration;
- import co.aikar.timings.Timings;
- import co.aikar.timings.TimingsManager;
- import org.spigotmc.SpigotConfig;
-+import org.spigotmc.WatchdogThread;
- 
- public class PaperConfig {
- 
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-     }
- 
-+    public static int watchdogPrintEarlyWarningEvery = 5000;
-+    public static int watchdogPrintEarlyWarningDelay = 10000;
-+    private static void watchdogEarlyWarning() {
-+        watchdogPrintEarlyWarningEvery = getInt("settings.watchdog.early-warning-every", 5000);
-+        watchdogPrintEarlyWarningDelay = getInt("settings.watchdog.early-warning-delay", 10000);
-+        WatchdogThread.doStart(SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash );
-+    }
-+
-     public static int tabSpamIncrement = 1;
-     public static int tabSpamLimit = 500;
-     private static void tabSpamLimiters() {
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -47,6 +20,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              Arrays.fill( recentTps, 20 );
              long start = System.nanoTime(), curTime, tickSection = start; // Paper - Further improve server tick loop
              lastTick = start - TICK_TIME; // Paper
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         // Paper start
+         paperConfigurations.initializeGlobalConfiguration();
+         paperConfigurations.initializeWorldDefaultsConfiguration();
++        org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash);
+         io.papermc.paper.configuration.PaperConfigurations.registerCommands(this);
+         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // load version history now
+         // Paper end
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -76,7 +61,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          SpigotConfig.restartMessage = SpigotConfig.transform( SpigotConfig.getString( "messages.restart", "Server is restarting" ) );
          SpigotConfig.commands.put( "restart", new RestartCommand( "restart" ) );
 -        WatchdogThread.doStart( timeoutTime, restartOnCrash );
-+        //WatchdogThread.doStart( timeoutTime, restartOnCrash ); // Paper - moved to PaperConfig
++        // WatchdogThread.doStart( timeoutTime, restartOnCrash ); // Paper - moved to after paper config initialization
      }
  
      public static boolean bungee;
@@ -84,14 +69,6 @@ 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 @@ import java.lang.management.MonitorInfo;
- import java.lang.management.ThreadInfo;
- import java.util.logging.Level;
- import java.util.logging.Logger;
-+import com.destroystokyo.paper.PaperConfig;
- import net.minecraft.server.MinecraftServer;
- import org.bukkit.Bukkit;
- 
 @@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
      private static WatchdogThread instance;
      private long timeoutTime;
@@ -107,8 +84,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super( "Paper Watchdog Thread" );
          this.timeoutTime = timeoutTime;
          this.restart = restart;
-+        earlyWarningEvery = Math.min(PaperConfig.watchdogPrintEarlyWarningEvery, timeoutTime); // Paper
++        earlyWarningEvery = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningEvery, timeoutTime); // Paper
-+        earlyWarningDelay = Math.min(PaperConfig.watchdogPrintEarlyWarningDelay, timeoutTime); // Paper
++        earlyWarningDelay = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningDelay, timeoutTime); // Paper
      }
  
      private static long monotonicMillis()

patches/server/Add-LivingEntity-getTargetEntity.patch

@@ -52,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return result;
 +    }
 +
-     public int shieldBlockingDelay = level.paperConfig.shieldBlockingDelay;
+     public int shieldBlockingDelay = level.paperConfig().misc.shieldBlockingDelay;
  
      public int getShieldBlockingDelay() {
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java

patches/server/Add-PlayerKickEvent-causes.patch

@@ -64,8 +64,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.clientIsFloating && !this.player.isSleeping() && !this.player.isPassenger()) {
              if (++this.aboveGroundTickCount > 80) {
                  ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating too long!", this.player.getName().getString());
--                this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickPlayerMessage); // Paper - use configurable kick message
+-                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer); // Paper - use configurable kick message
-+                this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickPlayerMessage, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_PLAYER); // Paper - use configurable kick message & kick event cause
++                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_PLAYER); // Paper - use configurable kick message & kick event cause
                  return;
              }
          } else {
@@ -73,8 +73,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (this.clientVehicleIsFloating && this.player.getRootVehicle().getControllingPassenger() == this.player) {
                  if (++this.aboveGroundVehicleTickCount > 80) {
                      ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating a vehicle too long!", this.player.getName().getString());
--                    this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickVehicleMessage); // Paper - use configurable kick message
+-                    this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingVehicle); // Paper - use configurable kick message
-+                    this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickVehicleMessage, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_VEHICLE); // Paper - use configurable kick message & kick event cause
++                    this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingVehicle, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_VEHICLE); // Paper - use configurable kick message & kick event cause
                      return;
                  }
              } else {
@@ -124,7 +124,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.processedDisconnect) {
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
          }
-         net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? this.player.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(this.player.getScoreboardName())); // Paper - Adventure
+         net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? this.player.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(this.player.getScoreboardName())); // Paper - Adventure
  
 -        PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), reason, leaveMessage); // Paper - Adventure
 +        PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), reason, leaveMessage, cause); // Paper - Adventure & kick event reason
@@ -143,7 +143,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
          // PlayerConnectionUtils.ensureMainThread(packetplayintabcomplete, this, this.player.getWorldServer()); // Paper - run this async
          // CraftBukkit start
-         if (this.chatSpamTickCount.addAndGet(com.destroystokyo.paper.PaperConfig.tabSpamIncrement) > com.destroystokyo.paper.PaperConfig.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
+         if (this.chatSpamTickCount.addAndGet(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamIncrement) > io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
 -            server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]))); // Paper
 +            server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM)); // Paper - kick event cause
              return;
@@ -275,7 +275,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
          // Paper start
          if (!org.bukkit.Bukkit.isPrimaryThread()) {
-             if (recipeSpamPackets.addAndGet(com.destroystokyo.paper.PaperConfig.autoRecipeIncrement) > com.destroystokyo.paper.PaperConfig.autoRecipeLimit) {
+             if (recipeSpamPackets.addAndGet(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.recipeSpamIncrement) > io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.recipeSpamLimit) {
 -                server.scheduleOnMain(() -> this.disconnect(net.minecraft.network.chat.Component.translatable("disconnect.spam", new Object[0]))); // Paper
 +                server.scheduleOnMain(() -> this.disconnect(net.minecraft.network.chat.Component.translatable("disconnect.spam", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM)); // Paper - kick event cause
                  return;

patches/server/Add-Unix-domain-socket-support.patch

@@ -41,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                DedicatedServer.LOGGER.error("**** INVALID CONFIGURATION!");
 +                DedicatedServer.LOGGER.error("You are trying to use a Unix domain socket but you're not on a supported OS.");
 +                return false;
-+            } else if (!com.destroystokyo.paper.PaperConfig.velocitySupport && !org.spigotmc.SpigotConfig.bungee) {
++            } else if (!io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled && !org.spigotmc.SpigotConfig.bungee) {
 +                DedicatedServer.LOGGER.error("**** INVALID CONFIGURATION!");
 +                DedicatedServer.LOGGER.error("Unix domain sockets require IPs to be forwarded from a proxy.");
 +                return false;

patches/server/Add-Velocity-IP-Forwarding-Support.patch

@@ -13,48 +13,6 @@ of messages, is packed into a binary format that is smaller than BungeeCord's
 forwarding, and is integrated into the Minecraft login process by using the 1.13
 login plugin message packet.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ import java.io.IOException;
- import java.lang.reflect.InvocationTargetException;
- import java.lang.reflect.Method;
- import java.lang.reflect.Modifier;
-+import java.nio.charset.StandardCharsets;
- import java.util.HashMap;
- import java.util.List;
- import java.util.Map;
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     }
- 
-     public static boolean isProxyOnlineMode() {
--        return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode);
-+        return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode) || (velocitySupport && velocityOnlineMode);
-     }
- 
-     public static int packetInSpamThreshold = 300;
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         tabSpamLimit = getInt("settings.spam-limiter.tab-spam-limit", tabSpamLimit);
-     }
- 
-+    public static boolean velocitySupport;
-+    public static boolean velocityOnlineMode;
-+    public static byte[] velocitySecretKey;
-+    private static void velocitySupport() {
-+        velocitySupport = getBoolean("settings.velocity-support.enabled", false);
-+        velocityOnlineMode = getBoolean("settings.velocity-support.online-mode", false);
-+        String secret = getString("settings.velocity-support.secret", "");
-+        if (velocitySupport && secret.isEmpty()) {
-+            fatal("Velocity support is enabled, but no secret key was specified. A secret key is required!");
-+        } else {
-+            velocitySecretKey = secret.getBytes(StandardCharsets.UTF_8);
-+        }
-+    }
-+
-     public static boolean asyncChunks = false;
-     private static void asyncChunks() {
-         ConfigurationSection section;
 diff --git a/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java b/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
@@ -63,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.proxy;
 +
-+import com.destroystokyo.paper.PaperConfig;
++import io.papermc.paper.configuration.GlobalConfiguration;
 +import com.google.common.net.InetAddresses;
 +import com.mojang.authlib.GameProfile;
 +import com.mojang.authlib.properties.Property;
@@ -90,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        try {
 +            final Mac mac = Mac.getInstance("HmacSHA256");
-+            mac.init(new SecretKeySpec(PaperConfig.velocitySecretKey, "HmacSHA256"));
++            mac.init(new SecretKeySpec(GlobalConfiguration.get().proxies.velocity.secret.getBytes(java.nio.charset.StandardCharsets.UTF_8), "HmacSHA256"));
 +            final byte[] mySignature = mac.doFinal(data);
 +            if (!MessageDigest.isEqual(signature, mySignature)) {
 +                return false;
@@ -131,14 +89,6 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListene
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ import org.bukkit.craftbukkit.util.Waitable;
- import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
- import org.bukkit.event.player.PlayerPreLoginEvent;
- // CraftBukkit end
-+import io.netty.buffer.Unpooled; // Paper
- 
- public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener {
- 
 @@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
      @Nullable
      private ProfilePublicKey playerProfilePublicKey;
@@ -152,9 +102,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.nonce));
              } else {
 +                // Paper start - Velocity support
-+                if (com.destroystokyo.paper.PaperConfig.velocitySupport) {
++                if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
 +                    this.velocityLoginMessageId = java.util.concurrent.ThreadLocalRandom.current().nextInt();
-+                    net.minecraft.network.protocol.login.ClientboundCustomQueryPacket packet1 = new net.minecraft.network.protocol.login.ClientboundCustomQueryPacket(this.velocityLoginMessageId, com.destroystokyo.paper.proxy.VelocityProxy.PLAYER_INFO_CHANNEL, new net.minecraft.network.FriendlyByteBuf(Unpooled.EMPTY_BUFFER));
++                    net.minecraft.network.protocol.login.ClientboundCustomQueryPacket packet1 = new net.minecraft.network.protocol.login.ClientboundCustomQueryPacket(this.velocityLoginMessageId, com.destroystokyo.paper.proxy.VelocityProxy.PLAYER_INFO_CHANNEL, new net.minecraft.network.FriendlyByteBuf(io.netty.buffer.Unpooled.EMPTY_BUFFER));
 +                    this.connection.send(packet1);
 +                    return;
 +                }
@@ -167,7 +117,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          public void fireEvents() throws Exception {
 +                            // Paper start - Velocity support
-+                            if (ServerLoginPacketListenerImpl.this.velocityLoginMessageId == -1 && com.destroystokyo.paper.PaperConfig.velocitySupport) {
++                            if (ServerLoginPacketListenerImpl.this.velocityLoginMessageId == -1 && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
 +                                disconnect("This server requires you to connect with Velocity.");
 +                                return;
 +                            }
@@ -180,7 +130,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public void handleCustomQueryPacket(ServerboundCustomQueryPacket packet) {
 +        // Paper start - Velocity support
-+        if (com.destroystokyo.paper.PaperConfig.velocitySupport && packet.getTransactionId() == this.velocityLoginMessageId) {
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled && packet.getTransactionId() == this.velocityLoginMessageId) {
 +            net.minecraft.network.FriendlyByteBuf buf = packet.getData();
 +            if (buf == null) {
 +                this.disconnect("This server requires you to connect with Velocity.");
@@ -225,7 +175,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public long getConnectionThrottle() {
          // Spigot Start - Automatically set connection throttle for bungee configurations
 -        if (org.spigotmc.SpigotConfig.bungee) {
-+        if (org.spigotmc.SpigotConfig.bungee || com.destroystokyo.paper.PaperConfig.velocitySupport) { // Paper - Velocity support
++        if (org.spigotmc.SpigotConfig.bungee || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) { // Paper - Velocity support
              return -1;
          } else {
              return this.configuration.getInt("settings.connection-throttle");

patches/server/Add-Wandering-Trader-spawn-rate-config-options.patch

@@ -10,30 +10,6 @@ Usages of the vanilla WanderingTraderSpawnDelay and WanderingTraderSpawnChance v
 in IWorldServerData are removed as they were only used in certain places, with hardcoded
 values used in other places.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-     }
- 
-+    public int wanderingTraderSpawnMinuteTicks = 1200;
-+    public int wanderingTraderSpawnDayTicks = 24000;
-+    public int wanderingTraderSpawnChanceFailureIncrement = 25;
-+    public int wanderingTraderSpawnChanceMin = 25;
-+    public int wanderingTraderSpawnChanceMax = 75;
-+    private void wanderingTraderSettings() {
-+        wanderingTraderSpawnMinuteTicks = getInt("wandering-trader.spawn-minute-length", wanderingTraderSpawnMinuteTicks);
-+        wanderingTraderSpawnDayTicks = getInt("wandering-trader.spawn-day-length", wanderingTraderSpawnDayTicks);
-+        wanderingTraderSpawnChanceFailureIncrement = getInt("wandering-trader.spawn-chance-failure-increment", wanderingTraderSpawnChanceFailureIncrement);
-+        wanderingTraderSpawnChanceMin = getInt("wandering-trader.spawn-chance-min", wanderingTraderSpawnChanceMin);
-+        wanderingTraderSpawnChanceMax = getInt("wandering-trader.spawn-chance-max", wanderingTraderSpawnChanceMax);
-+    }
-+
-     public short keepLoadedRange;
-     private void keepLoadedRange() {
-         keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
 diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
@@ -69,9 +45,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public int tick(ServerLevel world, boolean spawnMonsters, boolean spawnAnimals) {
 +        // Paper start
 +        if (this.tickDelay == Integer.MIN_VALUE) {
-+            this.tickDelay = world.paperConfig.wanderingTraderSpawnMinuteTicks;
++            this.tickDelay = world.paperConfig().entities.spawning.wanderingTrader.spawnMinuteLength;
-+            this.spawnDelay = world.paperConfig.wanderingTraderSpawnDayTicks;
++            this.spawnDelay = world.paperConfig().entities.spawning.wanderingTrader.spawnDayLength;
-+            this.spawnChance = world.paperConfig.wanderingTraderSpawnChanceMin;
++            this.spawnChance = world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMin;
 +        }
          if (!world.getGameRules().getBoolean(GameRules.RULE_DO_TRADER_SPAWNING)) {
              return 0;
@@ -83,14 +59,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            this.tickDelay = 1200;
 -            this.spawnDelay -= 1200;
 -            this.serverLevelData.setWanderingTraderSpawnDelay(this.spawnDelay);
-+            this.tickDelay = world.paperConfig.wanderingTraderSpawnMinuteTicks;
++            this.tickDelay = world.paperConfig().entities.spawning.wanderingTrader.spawnMinuteLength;
-+            this.spawnDelay = this.spawnDelay - world.paperConfig.wanderingTraderSpawnMinuteTicks;
++            this.spawnDelay = this.spawnDelay - world.paperConfig().entities.spawning.wanderingTrader.spawnMinuteLength;
 +            //this.serverLevelData.setWanderingTraderSpawnDelay(this.spawnDelay); // Paper - We don't need to save this value to disk if it gets set back to a hardcoded value anyways
              if (this.spawnDelay > 0) {
                  return 0;
              } else {
 -                this.spawnDelay = 24000;
-+                this.spawnDelay = world.paperConfig.wanderingTraderSpawnDayTicks;
++                this.spawnDelay = world.paperConfig().entities.spawning.wanderingTrader.spawnDayLength;
                  if (!world.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) {
                      return 0;
                  } else {
@@ -98,13 +74,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -                    this.spawnChance = Mth.clamp(this.spawnChance + 25, (int) 25, (int) 75);
 -                    this.serverLevelData.setWanderingTraderSpawnChance(this.spawnChance);
-+                    this.spawnChance = Mth.clamp(i + world.paperConfig.wanderingTraderSpawnChanceFailureIncrement, world.paperConfig.wanderingTraderSpawnChanceMin, world.paperConfig.wanderingTraderSpawnChanceMax);
++                    this.spawnChance = Mth.clamp(i + world.paperConfig().entities.spawning.wanderingTrader.spawnChanceFailureIncrement, world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMin, world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMax);
 +                    //this.serverLevelData.setWanderingTraderSpawnChance(this.spawnChance); // Paper - We don't need to save this value to disk if it gets set back to a hardcoded value anyways
                      if (this.random.nextInt(100) > i) {
                          return 0;
                      } else if (this.spawn(world)) {
 -                        this.spawnChance = 25;
-+                        this.spawnChance = world.paperConfig.wanderingTraderSpawnChanceMin;
++                        this.spawnChance = world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMin;
 +                        // Paper end
                          return 1;
                      } else {

patches/server/Add-ability-to-configure-frosted_ice-properties.patch

@@ -4,25 +4,6 @@ Date: Thu, 21 Apr 2016 23:51:55 -0700
 Subject: [PATCH] Add ability to configure frosted_ice properties
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void useVanillaScoreboardColoring() {
-         useVanillaScoreboardColoring = getBoolean("use-vanilla-world-scoreboard-name-coloring", false);
-     }
-+
-+    public boolean frostedIceEnabled = true;
-+    public int frostedIceDelayMin = 20;
-+    public int frostedIceDelayMax = 40;
-+    private void frostedIce() {
-+        this.frostedIceEnabled = this.getBoolean("frosted-ice.enabled", this.frostedIceEnabled);
-+        this.frostedIceDelayMin = this.getInt("frosted-ice.delay.min", this.frostedIceDelayMin);
-+        this.frostedIceDelayMax = this.getInt("frosted-ice.delay.max", this.frostedIceDelayMax);
-+        log("Frosted Ice: " + (this.frostedIceEnabled ? "enabled" : "disabled") + " / delay: min=" + this.frostedIceDelayMin + ", max=" + this.frostedIceDelayMax);
-+    }
- }
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
@@ -31,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-+        if (!world.paperConfig.frostedIceEnabled) return; // Paper - add ability to disable frosted ice
++        if (!world.paperConfig().environment.frostedIce.enabled) return; // Paper - add ability to disable frosted ice
          if ((random.nextInt(3) == 0 || this.fewerNeigboursThan(world, pos, 4)) && world.getMaxLocalRawBrightness(pos) > 11 - state.getValue(AGE) - state.getLightBlock(world, pos) && this.slightlyMelt(state, world, pos)) {
              BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos();
  
@@ -40,13 +21,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  BlockState blockState = world.getBlockState(mutableBlockPos);
                  if (blockState.is(this) && !this.slightlyMelt(blockState, world, mutableBlockPos)) {
 -                    world.scheduleTick(mutableBlockPos, this, Mth.nextInt(random, 20, 40));
-+                    world.scheduleTick(mutableBlockPos, this, Mth.nextInt(random, world.paperConfig.frostedIceDelayMin, world.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
++                    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
                  }
              }
  
          } else {
 -            world.scheduleTick(pos, this, Mth.nextInt(random, 20, 40));
-+            world.scheduleTick(pos, this, Mth.nextInt(random, world.paperConfig.frostedIceDelayMin, world.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
++            world.scheduleTick(pos, this, Mth.nextInt(random, world.paperConfig().environment.frostedIce.delay.min, world.paperConfig().environment.frostedIce.delay.max)); // Paper - use configurable min/max delay
          }
      }
  

patches/server/Add-config-for-mobs-immune-to-default-effects.patch

@@ -4,32 +4,6 @@ Date: Wed, 2 Dec 2020 21:03:02 -0800
 Subject: [PATCH] Add config for mobs immune to default effects
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         log("Hopper Ignore Container Entities inside Occluding Blocks: " + (hoppersIgnoreOccludingBlocks ? "enabled" : "disabled"));
-     }
- 
-+    public boolean undeadImmuneToCertainEffects = true;
-+    public boolean spidersImmuneToPoisonEffect = true;
-+    public boolean witherImmuneToWitherEffect = true;
-+    public boolean witherSkeletonImmuneToWitherEffect = true;
-+    private void mobEffectChanges() {
-+        undeadImmuneToCertainEffects = getBoolean("mob-effects.undead-immune-to-certain-effects", undeadImmuneToCertainEffects);
-+        log("Undead immune to harmful effects: " + undeadImmuneToCertainEffects);
-+        spidersImmuneToPoisonEffect = getBoolean("mob-effects.spiders-immune-to-poison-effect", spidersImmuneToPoisonEffect);
-+        log("Spiders immune to poison effect: " + spidersImmuneToPoisonEffect);
-+        witherImmuneToWitherEffect = getBoolean("mob-effects.immune-to-wither-effect.wither", witherImmuneToWitherEffect);
-+        log("Wither immune to wither effect: " + witherImmuneToWitherEffect);
-+        witherSkeletonImmuneToWitherEffect = getBoolean("mob-effects.immune-to-wither-effect.wither-skeleton", witherSkeletonImmuneToWitherEffect);
-+        log("Wither skeleton immune to wither effect: " + witherSkeletonImmuneToWitherEffect);
-+    }
-+
-     public boolean nerfNetherPortalPigmen = false;
-     private void nerfNetherPortalPigmen() {
-         nerfNetherPortalPigmen = getBoolean("game-mechanics.nerf-pigmen-from-nether-portals", nerfNetherPortalPigmen);
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
@@ -39,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              MobEffect mobeffectlist = effect.getEffect();
  
 -            if (mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) {
-+            if ((mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) && this.level.paperConfig.undeadImmuneToCertainEffects) { // Paper
++            if ((mobeffectlist == MobEffects.REGENERATION || mobeffectlist == MobEffects.POISON) && this.level.paperConfig().entities.mobEffects.undeadImmuneToCertainEffects) { // Paper
                  return false;
              }
          }
@@ -52,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.WITHER ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.WITHER && this.level.paperConfig.witherImmuneToWitherEffect ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.WITHER && this.level.paperConfig().entities.mobEffects.immuneToWitherEffect.wither ? false : super.canBeAffected(effect); // Paper
      }
  
      private class WitherDoNothingGoal extends Goal {
@@ -65,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.POISON ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.POISON && this.level.paperConfig.spidersImmuneToPoisonEffect ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.POISON && this.level.paperConfig().entities.mobEffects.spidersImmuneToPoisonEffect ? false : super.canBeAffected(effect); // Paper
      }
  
      public boolean isClimbing() {
@@ -78,6 +52,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canBeAffected(MobEffectInstance effect) {
 -        return effect.getEffect() == MobEffects.WITHER ? false : super.canBeAffected(effect);
-+        return effect.getEffect() == MobEffects.WITHER && this.level.paperConfig.witherSkeletonImmuneToWitherEffect ? false : super.canBeAffected(effect); // Paper
++        return effect.getEffect() == MobEffects.WITHER && this.level.paperConfig().entities.mobEffects.immuneToWitherEffect.witherSkeleton ? false : super.canBeAffected(effect); // Paper
      }
  }

patches/server/Add-config-option-for-logging-player-ip-addresses.patch

@@ -4,22 +4,6 @@ Date: Tue, 5 Oct 2021 20:04:21 +0200
 Subject: [PATCH] Add config option for logging player ip addresses
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-     }
- 
-+    public static boolean logPlayerIpAddresses = true;
-+    private static void playerIpAddresses() {
-+        logPlayerIpAddresses = getBoolean("settings.log-player-ip-addresses", logPlayerIpAddresses);
-+    }
-+
-     public static int maxJoinsPerTick;
-     private static void maxJoinsPerTick() {
-         maxJoinsPerTick = getInt("settings.max-joins-per-tick", 3);
 diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java
@@ -28,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          packet.handle(listener);
                      } catch (Exception exception) {
                          net.minecraft.network.Connection networkmanager = listener.getConnection();
-+                        String playerIP = com.destroystokyo.paper.PaperConfig.logPlayerIpAddresses ? String.valueOf(networkmanager.getRemoteAddress()) : "<ip address withheld>"; // Paper
++                        String playerIP = io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? String.valueOf(networkmanager.getRemoteAddress()) : "<ip address withheld>"; // Paper
                          if (networkmanager.getPlayer() != null) {
 -                            LOGGER.error("Error whilst processing packet {} for {}[{}]", packet, networkmanager.getPlayer().getScoreboardName(), networkmanager.getRemoteAddress(), exception);
 +                            LOGGER.error("Error whilst processing packet {} for {}[{}]", packet, networkmanager.getPlayer().getScoreboardName(), playerIP, exception); // Paper
@@ -47,7 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.buf = null;
  
 -        LOGGER.debug("Ping: (1.6) from {}", ctx.channel().remoteAddress());
-+        LOGGER.debug("Ping: (1.6) from {}", com.destroystokyo.paper.PaperConfig.logPlayerIpAddresses ? ctx.channel().remoteAddress() : "<ip address withheld>"); // Paper
++        LOGGER.debug("Ping: (1.6) from {}", io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? ctx.channel().remoteAddress() : "<ip address withheld>"); // Paper
  
          InetSocketAddress virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(host, port);
          com.destroystokyo.paper.event.server.PaperServerListPingEvent event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(
@@ -60,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                              }
  
 -                            ServerConnectionListener.LOGGER.warn("Failed to handle packet for {}", networkmanager.getRemoteAddress(), exception);
-+                            ServerConnectionListener.LOGGER.warn("Failed to handle packet for {}", com.destroystokyo.paper.PaperConfig.logPlayerIpAddresses ? String.valueOf(networkmanager.getRemoteAddress()) : "<ip address withheld>", exception); // Paper
++                            ServerConnectionListener.LOGGER.warn("Failed to handle packet for {}", io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? String.valueOf(networkmanager.getRemoteAddress()) : "<ip address withheld>", exception); // Paper
                              MutableComponent ichatmutablecomponent = Component.literal("Internal server error");
  
                              networkmanager.send(new ClientboundDisconnectPacket(ichatmutablecomponent), (future) -> {
@@ -74,7 +58,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public String getUserName() {
 -        return this.gameProfile != null ? this.gameProfile + " (" + this.connection.getRemoteAddress() + ")" : String.valueOf(this.connection.getRemoteAddress());
 +        // Paper start
-+        String ip = com.destroystokyo.paper.PaperConfig.logPlayerIpAddresses ? String.valueOf(this.connection.getRemoteAddress()) : "<ip address withheld>";
++        String ip = io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? String.valueOf(this.connection.getRemoteAddress()) : "<ip address withheld>";
 +        return this.gameProfile != null ? this.gameProfile + " (" + ip + ")" : String.valueOf(ip);
 +        // Paper end
      }
@@ -89,7 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          if (connection.getRemoteAddress() != null) {
 -            s1 = connection.getRemoteAddress().toString();
-+            s1 = com.destroystokyo.paper.PaperConfig.logPlayerIpAddresses ? connection.getRemoteAddress().toString() : "<ip address withheld>"; // Paper
++            s1 = io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? connection.getRemoteAddress().toString() : "<ip address withheld>"; // Paper
          } else {
              s1 = "local";
          }

patches/server/Add-config-option-for-worlds-affected-by-time-cmd.patch

@@ -4,20 +4,6 @@ Date: Sun, 2 Jan 2022 22:34:51 -0800
 Subject: [PATCH] Add config option for worlds affected by time cmd
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void sendFullPosForHardCollidingEntities() {
-         sendFullPosForHardCollidingEntities = getBoolean("settings.send-full-pos-for-hard-colliding-entities", true);
-     }
-+
-+    public static boolean timeCommandAffectsAllWorlds = false; // See https://hub.spigotmc.org/stash/projects/SPIGOT/repos/craftbukkit/commits/aeaeb359317e6ba25b7c45cf6d70ff945a3777cf
-+    private static void timeCommandAffectsAllWorlds() {
-+        timeCommandAffectsAllWorlds = getBoolean("settings.time-command-affects-all-worlds", timeCommandAffectsAllWorlds);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/commands/TimeCommand.java b/src/main/java/net/minecraft/server/commands/TimeCommand.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/commands/TimeCommand.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static int setTime(CommandSourceStack source, int time) {
 -        Iterator iterator = com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in
-+        Iterator iterator = com.destroystokyo.paper.PaperConfig.timeCommandAffectsAllWorlds ? source.getServer().getAllLevels().iterator() : com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in // Paper - add config option for spigot's change
++        Iterator iterator = io.papermc.paper.configuration.GlobalConfiguration.get().commands.timeCommandAffectsAllWorlds ? source.getServer().getAllLevels().iterator() : com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in // Paper - add config option for spigot's change
  
          while (iterator.hasNext()) {
              ServerLevel worldserver = (ServerLevel) iterator.next();
@@ -36,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static int addTime(CommandSourceStack source, int time) {
 -        Iterator iterator = com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in
-+        Iterator iterator = com.destroystokyo.paper.PaperConfig.timeCommandAffectsAllWorlds ? source.getServer().getAllLevels().iterator() : com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in // Paper - add config option for spigot's change
++        Iterator iterator = io.papermc.paper.configuration.GlobalConfiguration.get().commands.timeCommandAffectsAllWorlds ? source.getServer().getAllLevels().iterator() : com.google.common.collect.Iterators.singletonIterator(source.getLevel()); // CraftBukkit - SPIGOT-6496: Only set the time for the world the command originates in // Paper - add config option for spigot's change
  
          while (iterator.hasNext()) {
              ServerLevel worldserver = (ServerLevel) iterator.next();

patches/server/Add-config-to-disable-ender-dragon-legacy-check.patch

@@ -4,20 +4,6 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public EndDragonFight(ServerLevel world, long gatewaysSeed, CompoundTag nbt) {
 +        // Paper start
-+        this.needsStateScanning = world.paperConfig.scanForLegacyEnderDragon;
++        this.needsStateScanning = world.paperConfig().entities.spawning.scanForLegacyEnderDragon;
 +        if (!this.needsStateScanning) this.dragonKilled = true;
 +        // Paper end
          this.level = world;

patches/server/Add-configurable-despawn-distances-for-living-entiti.patch

@@ -4,66 +4,6 @@ Date: Tue, 1 Mar 2016 13:51:54 -0600
 Subject: [PATCH] Add configurable despawn distances for living entities
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ package com.destroystokyo.paper;
- import java.util.List;
- 
- import java.util.stream.Collectors;
-+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
-+import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
-+import net.minecraft.world.entity.MobCategory;
- import org.bukkit.Bukkit;
- import org.bukkit.configuration.file.YamlConfiguration;
- import org.spigotmc.SpigotWorldConfig;
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     public void removeOldValues() {
-         boolean needsSave = false;
- 
-+        if (PaperConfig.version < 24) {
-+            needsSave = true;
-+
-+            set("despawn-ranges.soft", null);
-+            set("despawn-ranges.hard", null);
-+        }
-+
-         if (needsSave) {
-             saveConfig();
-         }
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void nerfedMobsShouldJump() {
-         nerfedMobsShouldJump = getBoolean("spawner-nerfed-mobs-should-jump", false);
-     }
-+
-+    public final Reference2IntMap<MobCategory> softDespawnDistances = new Reference2IntOpenHashMap<>(MobCategory.values().length);
-+    public final Reference2IntMap<MobCategory> hardDespawnDistances = new Reference2IntOpenHashMap<>(MobCategory.values().length);
-+    private void despawnDistances() {
-+        if (PaperConfig.version < 24) {
-+            int softDistance = getInt("despawn-ranges.soft", 32, false); // 32^2 = 1024, Minecraft Default
-+            int hardDistance = getInt("despawn-ranges.hard", 128, false); // 128^2 = 16384, Minecraft Default
-+            for (MobCategory value : MobCategory.values()) {
-+                if (softDistance != 32) {
-+                    softDespawnDistances.put(value, softDistance);
-+                }
-+                if (hardDistance != 128) {
-+                    hardDespawnDistances.put(value, hardDistance);
-+                }
-+            }
-+        }
-+        for (MobCategory category : MobCategory.values()) {
-+            int softDistance = getInt("despawn-ranges." + category.getName() + ".soft", softDespawnDistances.getOrDefault(category, category.getNoDespawnDistance()));
-+            int hardDistance = getInt("despawn-ranges." + category.getName() + ".hard", hardDespawnDistances.getOrDefault(category, category.getDespawnDistance()));
-+            if (softDistance > hardDistance) {
-+                softDistance = hardDistance;
-+            }
-+            log("Mobs in " + category.getName() + " Despawn Ranges: Soft" + softDistance + " Hard: " + hardDistance);
-+            softDespawnDistances.put(category, softDistance);
-+            hardDespawnDistances.put(category, hardDistance);
-+        }
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
@@ -73,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (entityhuman != null) {
                  double d0 = entityhuman.distanceToSqr((Entity) this);
 -                int i = this.getType().getCategory().getDespawnDistance();
-+                int i = this.level.paperConfig.hardDespawnDistances.getInt(this.getType().getCategory()); // Paper - custom despawn distances
++                int i = this.level.paperConfig().entities.spawning.despawnRanges.get(this.getType().getCategory()).hard(); // Paper - custom despawn distances
                  int j = i * i;
  
                  if (d0 > (double) j && this.removeWhenFarAway(d0)) {
@@ -81,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
  
 -                int k = this.getType().getCategory().getNoDespawnDistance();
-+                int k = this.level.paperConfig.softDespawnDistances.getInt(this.getType().getCategory()); // Paper - custom despawn distances
++                int k = this.level.paperConfig().entities.spawning.despawnRanges.get(this.getType().getCategory()).soft(); // Paper - custom despawn distances
                  int l = k * k;
  
                  if (this.noActionTime > 600 && this.random.nextInt(800) == 0 && d0 > (double) l && this.removeWhenFarAway(d0)) {

patches/server/Add-configurable-height-for-slime-spawn.patch

@@ -4,27 +4,6 @@ Date: Mon, 2 Aug 2021 11:24:39 -0400
 Subject: [PATCH] Add configurable height for slime spawn
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
-     }
- 
-+    public double slimeMaxSpawnHeightInSwamp = 70;
-+    public double slimeMinSpawnHeightInSwamp = 50;
-+    public double slimeMaxSpawnHeightInSlimeChunks = 40;
-+    private void slimeSpawnHeight() {
-+        slimeMaxSpawnHeightInSwamp = getDouble("slime-spawn-height.swamp-biome.maximum", this.slimeMaxSpawnHeightInSwamp);
-+        slimeMinSpawnHeightInSwamp = getDouble("slime-spawn-height.swamp-biome.minimum", this.slimeMinSpawnHeightInSwamp);
-+        slimeMaxSpawnHeightInSlimeChunks = getDouble("slime-spawn-height.slime-chunk.maximum", this.slimeMaxSpawnHeightInSlimeChunks);
-+    }
-+
-+
-     public int portalSearchRadius;
-     public int portalCreateRadius;
-     public boolean portalSearchVanillaDimensionScaling;
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
@@ -35,8 +14,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (world.getDifficulty() != Difficulty.PEACEFUL) {
 -            if (world.getBiome(pos).is(BiomeTags.ALLOWS_SURFACE_SLIME_SPAWNS) && pos.getY() > 50 && pos.getY() < 70 && random.nextFloat() < 0.5F && random.nextFloat() < world.getMoonBrightness() && world.getMaxLocalRawBrightness(pos) <= random.nextInt(8)) {
 +            // Paper start - Replace rules for Height in Swamp Biome
-+            final double maxHeightSwamp = world.getMinecraftWorld().paperConfig.slimeMaxSpawnHeightInSwamp;
++            final double maxHeightSwamp = world.getMinecraftWorld().paperConfig().entities.spawning.slimeSpawnHeight.swampBiome.maximum;
-+            final double minHeightSwamp = world.getMinecraftWorld().paperConfig.slimeMinSpawnHeightInSwamp;
++            final double minHeightSwamp = world.getMinecraftWorld().paperConfig().entities.spawning.slimeSpawnHeight.swampBiome.minimum;
 +            if (world.getBiome(pos).is(net.minecraft.world.level.biome.Biomes.SWAMP) && pos.getY() > minHeightSwamp && pos.getY() < maxHeightSwamp && random.nextFloat() < 0.5F && random.nextFloat() < world.getMoonBrightness() && world.getMaxLocalRawBrightness(pos) <= random.nextInt(8)) {
 +                // Paper end
                  return checkMobSpawnRules(type, world, spawnReason, pos, random);
@@ -44,11 +23,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 @@ -0,0 +0,0 @@ public class Slime extends Mob implements Enemy {
              ChunkPos chunkcoordintpair = new ChunkPos(pos);
-             boolean flag = world.getMinecraftWorld().paperConfig.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
+             boolean flag = world.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
  
 -            if (random.nextInt(10) == 0 && flag && pos.getY() < 40) {
 +            // Paper start - Replace rules for Height in Slime Chunks
-+            final double maxHeightSlimeChunk = world.getMinecraftWorld().paperConfig.slimeMaxSpawnHeightInSlimeChunks;
++            final double maxHeightSlimeChunk = world.getMinecraftWorld().paperConfig().entities.spawning.slimeSpawnHeight.slimeChunk.maximum;
 +            if (random.nextInt(10) == 0 && flag && pos.getY() < maxHeightSlimeChunk) {
 +            // Paper end
                  return checkMobSpawnRules(type, world, spawnReason, pos, random);

patches/server/Add-configurable-portal-search-radius.patch

@@ -4,24 +4,6 @@ Date: Thu, 3 Mar 2016 02:46:17 -0600
 Subject: [PATCH] Add configurable portal search radius
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void allChunksAreSlimeChunks() {
-         allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
-     }
-+
-+    public int portalSearchRadius;
-+    public int portalCreateRadius;
-+    public boolean portalSearchVanillaDimensionScaling;
-+    private void portalSearchRadius() {
-+        portalSearchRadius = getInt("portal-search-radius", 128);
-+        portalCreateRadius = getInt("portal-create-radius", 16);
-+        portalSearchVanillaDimensionScaling = getBoolean("portal-search-vanilla-dimension-scaling", true);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -32,12 +14,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  // CraftBukkit start
 -                CraftPortalEvent event = this.callPortalEvent(this, destination, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, flag2 ? 16 : 128, 16);
 +                // Paper start
-+                int portalSearchRadius = destination.paperConfig.portalSearchRadius;
++                int portalSearchRadius = destination.paperConfig().environment.portalSearchRadius;
-+                if (level.paperConfig.portalSearchVanillaDimensionScaling && flag2) { // == THE_NETHER
++                if (level.paperConfig().environment.portalSearchVanillaDimensionScaling && flag2) { // == THE_NETHER
 +                    portalSearchRadius = (int) (portalSearchRadius / destination.dimensionType().coordinateScale());
 +                }
 +                // Paper end
-+                CraftPortalEvent event = this.callPortalEvent(this, destination, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, portalSearchRadius, destination.paperConfig.portalCreateRadius); // Paper start - configurable portal radius
++                CraftPortalEvent event = this.callPortalEvent(this, destination, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, portalSearchRadius, destination.paperConfig().environment.portalCreateRadius); // Paper start - configurable portal radius
                  if (event == null) {
                      return null;
                  }
@@ -50,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public Optional<BlockUtil.FoundRectangle> findPortalAround(BlockPos pos, boolean destIsNether, WorldBorder worldBorder) {
          // CraftBukkit start
 -        return this.findPortalAround(pos, worldBorder, destIsNether ? 16 : 128); // Search Radius
-+        return this.findPortalAround(pos, worldBorder, destIsNether ? level.paperConfig.portalCreateRadius : level.paperConfig.portalSearchRadius); // Search Radius // Paper - search Radius
++        return this.findPortalAround(pos, worldBorder, destIsNether ? level.paperConfig().environment.portalCreateRadius : level.paperConfig().environment.portalSearchRadius); // Search Radius // Paper - search Radius
      }
  
      public Optional<BlockUtil.FoundRectangle> findPortalAround(BlockPos blockposition, WorldBorder worldborder, int i) {

patches/server/Add-configuration-option-to-prevent-player-names-fro.patch

@@ -5,20 +5,6 @@ Subject: [PATCH] Add configuration option to prevent player names from being
  suggested
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         flyingKickPlayerMessage = getString("messages.kick.flying-player", flyingKickPlayerMessage);
-         flyingKickVehicleMessage = getString("messages.kick.flying-vehicle", flyingKickVehicleMessage);
-     }
-+
-+    public static boolean suggestPlayersWhenNullTabCompletions = true;
-+    private static void suggestPlayersWhenNull() {
-+        suggestPlayersWhenNullTabCompletions = getBoolean("settings.suggest-player-names-when-null-tab-completions", suggestPlayersWhenNullTabCompletions);
-+    }
- }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -30,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean suggestPlayerNamesWhenNullTabCompletions() {
-+        return com.destroystokyo.paper.PaperConfig.suggestPlayersWhenNullTabCompletions;
++        return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
 +    }
      // Paper end
  }

patches/server/Add-critical-damage-API.patch

@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                    boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity;
 +                    boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity; // Paper - Add critical damage API - conflict on change
  
-                     flag2 = flag2 && !level.paperConfig.disablePlayerCrits; // Paper
+                     flag2 = flag2 && !level.paperConfig().entities.behavior.disablePlayerCrits; // Paper
                      flag2 = flag2 && !this.isSprinting();
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
                      }

patches/server/Add-dropLeash-variable-to-EntityUnleashEvent.patch

@@ -75,7 +75,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class PathfinderMob extends Mob {
  
              if (this instanceof TamableAnimal && ((TamableAnimal) this).isInSittingPose()) {
-                 if (f > entity.level.paperConfig.maxLeashDistance) { // Paper
+                 if (f > entity.level.paperConfig().misc.maxLeashDistance) { // Paper
 -                    this.level.getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
 -                    this.dropLeash(true, true);
 +                    // Paper start - drop leash variable
@@ -89,7 +89,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class PathfinderMob extends Mob {
  
              this.onLeashDistance(f);
-             if (f > entity.level.paperConfig.maxLeashDistance) { // Paper
+             if (f > entity.level.paperConfig().misc.maxLeashDistance) { // Paper
 -                this.level.getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
 -                this.dropLeash(true, true);
 +                // Paper start - drop leash variable

patches/server/Add-entity-liquid-API.patch

@@ -4,18 +4,6 @@ Date: Thu, 2 Jul 2020 18:11:43 -0500
 Subject: [PATCH] Add entity liquid API
 
 
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-         return this.isInWater() || this.isInRain();
-     }
- 
--    @Deprecated public final boolean isInWaterOrRainOrBubble() { return isInWaterRainOrBubble(); } // Paper - OBFHELPER
-     public boolean isInWaterRainOrBubble() {
-         return this.isInWater() || this.isInRain() || this.isInBubbleColumn();
-     }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java

patches/server/Add-option-for-console-having-all-permissions.patch

@@ -4,20 +4,6 @@ Date: Sat, 16 May 2020 10:12:15 +0200
 Subject: [PATCH] Add option for console having all permissions
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         config.set("settings.unsupported-settings.allow-permanent-block-break-exploits-readme", "This setting controls if players should be able to break bedrock, end portals and other intended to be permanent blocks.");
-         allowBlockPermanentBreakingExploits = getBoolean("settings.unsupported-settings.allow-permanent-block-break-exploits", allowBlockPermanentBreakingExploits);
-     }
-+
-+    public static boolean consoleHasAllPermissions = false;
-+    private static void consoleHasAllPermissions() {
-+        consoleHasAllPermissions = getBoolean("settings.console-has-all-permissions", consoleHasAllPermissions);
-+    }
- }
 diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
@@ -29,12 +15,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean hasPermission(String name) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(name);
++        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(name);
 +    }
 +
 +    @Override
 +    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(perm);
++        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(perm);
 +    }
      // Paper end
  }
@@ -50,12 +36,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper start
 +    @Override
 +    public boolean hasPermission(String name) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(name);
++        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(name);
 +    }
 +
 +    @Override
 +    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(perm);
++        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(perm);
 +    }
 +    // Paper end
  }

patches/server/Add-option-to-allow-iron-golems-to-spawn-in-air.patch

@@ -4,22 +4,6 @@ Date: Sat, 13 Apr 2019 16:50:58 -0500
 Subject: [PATCH] Add option to allow iron golems to spawn in air
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true);
-     }
- 
-+    public boolean ironGolemsCanSpawnInAir = false;
-+    private void ironGolemsCanSpawnInAir() {
-+        ironGolemsCanSpawnInAir = getBoolean("iron-golems-can-spawn-in-air", ironGolemsCanSpawnInAir);
-+    }
-+
-     public boolean armorStandEntityLookups = true;
-     private void armorStandEntityLookups() {
-         armorStandEntityLookups = getBoolean("armor-stands-do-collision-entity-lookups", true);
 diff --git a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java b/src/main/java/net/minecraft/world/entity/animal/IronGolem.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          BlockState iblockdata = world.getBlockState(blockposition1);
  
 -        if (!iblockdata.entityCanStandOn(world, blockposition1, this)) {
-+        if (!iblockdata.entityCanStandOn(world, blockposition1, this) && !level.paperConfig.ironGolemsCanSpawnInAir) { // Paper
++        if (!iblockdata.entityCanStandOn(world, blockposition1, this) && !level.paperConfig().entities.spawning.ironGolemsCanSpawnInAir) { // Paper
              return false;
          } else {
              for (int i = 1; i < 3; ++i) {

patches/server/Add-option-to-disable-pillager-patrols.patch

@@ -4,21 +4,6 @@ Date: Wed, 9 Oct 2019 21:46:15 -0500
 Subject: [PATCH] Add option to disable pillager patrols
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableRelativeProjectileVelocity() {
-         disableRelativeProjectileVelocity = getBoolean("game-mechanics.disable-relative-projectile-velocity", false);
-     }
-+
-+    public boolean disablePillagerPatrols = false;
-+    private void pillagerSettings() {
-+        disablePillagerPatrols = getBoolean("game-mechanics.disable-pillager-patrols", disablePillagerPatrols);
-+    }
- }
- 
 diff --git a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
@@ -27,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public int tick(ServerLevel world, boolean spawnMonsters, boolean spawnAnimals) {
-+        if (world.paperConfig.disablePillagerPatrols) return 0; // Paper
++        if (world.paperConfig().entities.behavior.pillagerPatrols.disable) return 0; // Paper
          if (!spawnMonsters) {
              return 0;
          } else if (!world.getGameRules().getBoolean(GameRules.RULE_DO_PATROL_SPAWNING)) {

patches/server/Add-option-to-fix-items-merging-through-walls.patch

@@ -4,20 +4,6 @@ Date: Wed, 10 Mar 2021 10:06:45 -0800
 Subject: [PATCH] Add option to fix items merging through walls
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void mapItemFrameCursorLimit() {
-         mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit);
-     }
-+
-+    public boolean fixItemsMergingThroughWalls;
-+    private void fixItemsMergingThroughWalls() {
-+        fixItemsMergingThroughWalls = getBoolean("fix-items-merging-through-walls", fixItemsMergingThroughWalls);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (entityitem.isMergable()) {
 +                    // Paper Start - Fix items merging through walls
-+                        if (this.level.paperConfig.fixItemsMergingThroughWalls) {
++                        if (this.level.paperConfig().fixes.fixItemsMergingThroughWalls) {
 +                            net.minecraft.world.level.ClipContext rayTrace = new net.minecraft.world.level.ClipContext(this.position(), entityitem.position(),
 +                                net.minecraft.world.level.ClipContext.Block.COLLIDER, net.minecraft.world.level.ClipContext.Fluid.NONE, this);
 +                            net.minecraft.world.phys.BlockHitResult rayTraceResult = level.clip(rayTrace);

patches/server/Add-option-to-make-parrots-stay-on-shoulders-despite.patch

@@ -10,21 +10,6 @@ I suspect Mojang may switch to this behavior before full release.
 
 To be converted into a Paper-API event at some point in the future?
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         maxCollisionsPerEntity = getInt( "max-entity-collisions", this.spigotConfig.getInt("max-entity-collisions", this.maxCollisionsPerEntity, false) );
-         log( "Max Entity Collisions: " + maxCollisionsPerEntity );
-     }
-+
-+    public boolean parrotsHangOnBetter;
-+    private void parrotsHangOnBetter() {
-+        parrotsHangOnBetter = getBoolean("parrots-are-unaffected-by-player-movement", false);
-+        log("Parrots are unaffected by player movement: " + parrotsHangOnBetter);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -35,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.player.setShiftKeyDown(true);
 +
 +                // Paper start - Hang on!
-+                if (this.player.level.paperConfig.parrotsHangOnBetter) {
++                if (this.player.level.paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) {
 +                    this.player.removeEntitiesOnShoulder();
 +                }
 +                // Paper end
@@ -52,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.playShoulderEntityAmbientSound(this.getShoulderEntityRight());
          if (!this.level.isClientSide && (this.fallDistance > 0.5F || this.isInWater()) || this.abilities.flying || this.isSleeping() || this.isInPowderSnow) {
 -            this.removeEntitiesOnShoulder();
-+            if (!this.level.paperConfig.parrotsHangOnBetter) this.removeEntitiesOnShoulder(); // Paper - Hang on!
++            if (!this.level.paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) this.removeEntitiesOnShoulder(); // Paper - Hang on!
          }
  
      }

patches/server/Add-option-to-nerf-pigmen-from-nether-portals.patch

@@ -4,22 +4,6 @@ Date: Fri, 7 Feb 2020 14:36:56 -0600
 Subject: [PATCH] Add option to nerf pigmen from nether portals
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         log("Hopper Ignore Container Entities inside Occluding Blocks: " + (hoppersIgnoreOccludingBlocks ? "enabled" : "disabled"));
-     }
- 
-+    public boolean nerfNetherPortalPigmen = false;
-+    private void nerfNetherPortalPigmen() {
-+        nerfNetherPortalPigmen = getBoolean("game-mechanics.nerf-pigmen-from-nether-portals", nerfNetherPortalPigmen);
-+    }
-+
-     public int lightQueueSize = 20;
-     private void lightQueueSize() {
-         lightQueueSize = getInt("light-queue-size", lightQueueSize);
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -59,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (entity != null) {
                      entity.setPortalCooldown();
 +                    entity.fromNetherPortal = true; // Paper
-+                    if (world.paperConfig.nerfNetherPortalPigmen) ((net.minecraft.world.entity.Mob) entity).aware = false; // Paper
++                    if (world.paperConfig().entities.behavior.nerfPigmenFromNetherPortals) ((net.minecraft.world.entity.Mob) entity).aware = false; // Paper
                  }
              }
          }

patches/server/Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -5,20 +5,6 @@ Subject: [PATCH] Add option to prevent players from moving into unloaded
  chunks #1551
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         waterOverLavaFlowSpeed = getInt("water-over-lava-flow-speed", 5);
-         log("Water over lava flow speed: " + waterOverLavaFlowSpeed);
-     }
-+
-+    public boolean preventMovingIntoUnloadedChunks = false;
-+    private void preventMovingIntoUnloadedChunks() {
-+        preventMovingIntoUnloadedChunks = getBoolean("prevent-moving-into-unloaded-chunks", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -41,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  speed *= 2f; // TODO: Get the speed of the vehicle instead of the player
  
 +                // Paper start - Prevent moving into unloaded chunks
-+                if (player.level.paperConfig.preventMovingIntoUnloadedChunks && (
++                if (player.level.paperConfig().chunks.preventMovingIntoUnloadedChunks && (
 +                    !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position()))) ||
 +                        !worldserver.areChunksLoadedForMove(entity.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(entity.position())))
 +                    )) {
@@ -71,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                                  speed = this.player.getAbilities().walkingSpeed * 10f;
                              }
 +                            // Paper start - Prevent moving into unloaded chunks
-+                            if (player.level.paperConfig.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
++                            if (player.level.paperConfig().chunks.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
 +                                this.internalTeleport(this.player.getX(), this.player.getY(), this.player.getZ(), this.player.getYRot(), this.player.getXRot(), Collections.emptySet(), true);
 +                                return;
 +                            }

patches/server/Add-packet-limiter-config.patch

@@ -23,113 +23,6 @@ and an action can be defined: DROP or KICK
 
 If interval or rate are less-than 0, the limit is ignored
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         itemValidationBookAuthorLength = getInt("settings.item-validation.book.author", itemValidationBookAuthorLength);
-         itemValidationBookPageLength = getInt("settings.item-validation.book.page", itemValidationBookPageLength);
-     }
-+
-+    public static final class PacketLimit {
-+        public final double packetLimitInterval;
-+        public final double maxPacketRate;
-+        public final ViolateAction violateAction;
-+
-+        public PacketLimit(final double packetLimitInterval, final double maxPacketRate, final ViolateAction violateAction) {
-+            this.packetLimitInterval = packetLimitInterval;
-+            this.maxPacketRate = maxPacketRate;
-+            this.violateAction = violateAction;
-+        }
-+
-+        public static enum ViolateAction {
-+            KICK, DROP;
-+        }
-+    }
-+
-+    public static String kickMessage;
-+    public static PacketLimit allPacketsLimit;
-+    public static java.util.Map<Class<? extends net.minecraft.network.protocol.Packet<?>>, PacketLimit> packetSpecificLimits = new java.util.HashMap<>();
-+
-+    private static void packetLimiter() {
-+        packetSpecificLimits.clear();
-+        kickMessage = org.bukkit.ChatColor.translateAlternateColorCodes('&', getString("settings.packet-limiter.kick-message", "&cSent too many packets"));
-+        allPacketsLimit = new PacketLimit(
-+            getDouble("settings.packet-limiter.limits.all.interval", 7.0),
-+            getDouble("settings.packet-limiter.limits.all.max-packet-rate", 500.0),
-+            PacketLimit.ViolateAction.KICK
-+        );
-+        if (allPacketsLimit.maxPacketRate <= 0.0 || allPacketsLimit.packetLimitInterval <= 0.0) {
-+            allPacketsLimit = null;
-+        }
-+        final ConfigurationSection section = config.getConfigurationSection("settings.packet-limiter.limits");
-+
-+        // add default packets
-+
-+        // auto recipe limiting
-+        getDouble("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".interval", 4.0);
-+        getDouble("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".max-packet-rate", 5.0);
-+        getString("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".action", PacketLimit.ViolateAction.DROP.name());
-+
-+        final Map<String, String> mojangToSpigot = new HashMap<>();
-+        final Map<String, io.papermc.paper.util.ObfHelper.ClassMapping> maps = io.papermc.paper.util.ObfHelper.INSTANCE.mappingsByObfName();
-+        if (maps != null) {
-+            maps.forEach((spigotName, classMapping) ->
-+                mojangToSpigot.put(classMapping.mojangName(), classMapping.obfName()));
-+        }
-+
-+        for (final String packetClassName : section.getKeys(false)) {
-+            if (packetClassName.equals("all")) {
-+                continue;
-+            }
-+            Class<?> packetClazz = null;
-+
-+            for (final String subpackage : List.of("game", "handshake", "login", "status")) {
-+                final String fullName = "net.minecraft.network.protocol." + subpackage + "." + packetClassName;
-+                try {
-+                    packetClazz = Class.forName(fullName);
-+                    break;
-+                } catch (final ClassNotFoundException ex) {
-+                    try {
-+                        final String spigot = mojangToSpigot.get(fullName);
-+                        if (spigot != null) {
-+                            packetClazz = Class.forName(spigot);
-+                        }
-+                    } catch (final ClassNotFoundException ignore) {}
-+                }
-+            }
-+
-+            if (packetClazz == null || !net.minecraft.network.protocol.Packet.class.isAssignableFrom(packetClazz)) {
-+                MinecraftServer.LOGGER.warn("Packet '" + packetClassName + "' does not exist, cannot limit it! Please update paper.yml");
-+                continue;
-+            }
-+
-+            if (!(section.get(packetClassName.concat(".interval")) instanceof Number) || !(section.get(packetClassName.concat(".max-packet-rate")) instanceof Number)) {
-+                throw new RuntimeException("Packet limit setting " + packetClassName + " is missing interval or max-packet-rate!");
-+            }
-+
-+            final String actionString = section.getString(packetClassName.concat(".action"), "KICK");
-+            PacketLimit.ViolateAction action = PacketLimit.ViolateAction.KICK;
-+            for (PacketLimit.ViolateAction test : PacketLimit.ViolateAction.values()) {
-+                if (actionString.equalsIgnoreCase(test.name())) {
-+                    action = test;
-+                    break;
-+                }
-+            }
-+
-+            final double interval = section.getDouble(packetClassName.concat(".interval"));
-+            final double rate = section.getDouble(packetClassName.concat(".max-packet-rate"));
-+
-+            if (interval > 0.0 && rate > 0.0) {
-+                packetSpecificLimits.put((Class)packetClazz, new PacketLimit(interval, rate, action));
-+            }
-+        }
-+    }
- }
 diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/Connection.java
@@ -140,15 +33,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end - allow controlled flushing
 +    // Paper start - packet limiter
 +    protected final Object PACKET_LIMIT_LOCK = new Object();
-+    protected final io.papermc.paper.util.IntervalledCounter allPacketCounts = com.destroystokyo.paper.PaperConfig.allPacketsLimit != null ? new io.papermc.paper.util.IntervalledCounter(
++    protected final @Nullable io.papermc.paper.util.IntervalledCounter allPacketCounts = io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.isEnabled() ? new io.papermc.paper.util.IntervalledCounter(
-+            (long)(com.destroystokyo.paper.PaperConfig.allPacketsLimit.packetLimitInterval * 1.0e9)
++            (long)(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.interval() * 1.0e9)
 +    ) : null;
 +    protected final java.util.Map<Class<? extends net.minecraft.network.protocol.Packet<?>>, io.papermc.paper.util.IntervalledCounter> packetSpecificLimits = new java.util.HashMap<>();
 +
 +    private boolean stopReadingPackets;
 +    private void killForPacketSpam() {
-+        this.sendPacket(new ClientboundDisconnectPacket(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(com.destroystokyo.paper.PaperConfig.kickMessage, true)[0]), (future) -> {
++        this.sendPacket(new ClientboundDisconnectPacket(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.kickMessage, true)[0]), (future) -> {
-+            this.disconnect(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(com.destroystokyo.paper.PaperConfig.kickMessage, true)[0]);
++            this.disconnect(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.kickMessage, true)[0]);
 +        });
 +        this.setReadOnly();
 +        this.stopReadingPackets = true;
@@ -166,29 +59,29 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return;
 +            }
 +            if (this.allPacketCounts != null ||
-+                    com.destroystokyo.paper.PaperConfig.packetSpecificLimits.containsKey(packet.getClass())) {
++                io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.overrides.containsKey(packet.getClass())) {
 +                long time = System.nanoTime();
 +                synchronized (PACKET_LIMIT_LOCK) {
 +                    if (this.allPacketCounts != null) {
 +                        this.allPacketCounts.updateAndAdd(1, time);
-+                        if (this.allPacketCounts.getRate() >= com.destroystokyo.paper.PaperConfig.allPacketsLimit.maxPacketRate) {
++                        if (this.allPacketCounts.getRate() >= io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.maxPacketRate()) {
 +                            this.killForPacketSpam();
 +                            return;
 +                        }
 +                    }
 +
 +                    for (Class<?> check = packet.getClass(); check != Object.class; check = check.getSuperclass()) {
-+                        com.destroystokyo.paper.PaperConfig.PacketLimit packetSpecificLimit =
++                        io.papermc.paper.configuration.GlobalConfiguration.PacketLimiter.PacketLimit packetSpecificLimit =
-+                            com.destroystokyo.paper.PaperConfig.packetSpecificLimits.get(check);
++                            io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.overrides.get(check);
 +                        if (packetSpecificLimit == null) {
 +                            continue;
 +                        }
 +                        io.papermc.paper.util.IntervalledCounter counter = this.packetSpecificLimits.computeIfAbsent((Class)check, (clazz) -> {
-+                            return new io.papermc.paper.util.IntervalledCounter((long)(packetSpecificLimit.packetLimitInterval * 1.0e9));
++                            return new io.papermc.paper.util.IntervalledCounter((long)(packetSpecificLimit.interval() * 1.0e9));
 +                        });
 +                        counter.updateAndAdd(1, time);
-+                        if (counter.getRate() >= packetSpecificLimit.maxPacketRate) {
++                        if (counter.getRate() >= packetSpecificLimit.maxPacketRate()) {
-+                            switch (packetSpecificLimit.violateAction) {
++                            switch (packetSpecificLimit.action()) {
 +                                case DROP:
 +                                    return;
 +                                case KICK:

patches/server/Add-paper-mobcaps-and-paper-playermobcaps.patch

@@ -208,7 +208,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        final ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
 +        final ServerLevel level = serverPlayer.getLevel();
 +
-+        if (!level.paperConfig.perPlayerMobSpawns) {
++        if (!level.paperConfig().entities.spawning.perPlayerMobSpawns) {
 +            sender.sendMessage(Component.text("Use '/paper mobcaps' for worlds where per-player mob spawning is disabled.", NamedTextColor.RED));
 +            return;
 +        }

patches/server/Add-phantom-creative-and-insomniac-controls.patch

@@ -4,22 +4,6 @@ Date: Sat, 25 Apr 2020 15:13:41 -0500
 Subject: [PATCH] Add phantom creative and insomniac controls
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-         perPlayerMobSpawns = getBoolean("per-player-mob-spawns", true);
-     }
-+
-+    public boolean phantomIgnoreCreative = true;
-+    public boolean phantomOnlyAttackInsomniacs = true;
-+    private void phantomSettings() {
-+        phantomIgnoreCreative = getBoolean("phantoms-do-not-spawn-on-creative-players", phantomIgnoreCreative);
-+        phantomOnlyAttackInsomniacs = getBoolean("phantoms-only-attack-insomniacs", phantomOnlyAttackInsomniacs);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/EntitySelector.java b/src/main/java/net/minecraft/world/entity/EntitySelector.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/EntitySelector.java
@@ -40,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          Player entityhuman = (Player) iterator.next();
  
                          if (Phantom.this.canAttack(entityhuman, TargetingConditions.DEFAULT)) {
-+                            if (!level.paperConfig.phantomOnlyAttackInsomniacs || EntitySelector.isInsomniac.test(entityhuman)) // Paper
++                            if (!level.paperConfig().entities.behavior.phantomsOnlyAttackInsomniacs || EntitySelector.isInsomniac.test(entityhuman)) // Paper
                              Phantom.this.setTarget(entityhuman, org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER, true); // CraftBukkit - reason
                              return true;
                          }
@@ -53,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          Player entityhuman = (Player) iterator.next();
  
 -                        if (!entityhuman.isSpectator()) {
-+                        if (!entityhuman.isSpectator() && (!world.paperConfig.phantomIgnoreCreative || !entityhuman.isCreative())) { // Paper
++                        if (!entityhuman.isSpectator() && (!world.paperConfig().entities.behavior.phantomsDoNotSpawnOnCreativePlayers || !entityhuman.isCreative())) { // Paper
                              BlockPos blockposition = entityhuman.blockPosition();
  
                              if (!world.dimensionType().hasSkyLight() || blockposition.getY() >= world.getSeaLevel() && world.canSeeSky(blockposition)) {

patches/server/Add-ray-tracing-methods-to-LivingEntity.patch

@@ -52,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return level.clip(raytrace);
 +    }
 +
-     public int shieldBlockingDelay = level.paperConfig.shieldBlockingDelay;
+     public int shieldBlockingDelay = level.paperConfig().misc.shieldBlockingDelay;
  
      public int getShieldBlockingDelay() {
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java

patches/server/Add-setting-for-proxy-online-mode-status.patch

@@ -5,32 +5,6 @@ Subject: [PATCH] Add setting for proxy online mode status
 
 TODO: Add isProxyOnlineMode check to Metrics
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ import org.bukkit.configuration.InvalidConfigurationException;
- import org.bukkit.configuration.file.YamlConfiguration;
- import co.aikar.timings.Timings;
- import co.aikar.timings.TimingsManager;
-+import org.spigotmc.SpigotConfig;
- 
- public class PaperConfig {
- 
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void saveEmptyScoreboardTeams() {
-         saveEmptyScoreboardTeams = getBoolean("settings.save-empty-scoreboard-teams", false);
-     }
-+
-+    public static boolean bungeeOnlineMode = true;
-+    private static void bungeeOnlineMode() {
-+        bungeeOnlineMode = getBoolean("settings.bungee-online-mode", true);
-+    }
-+
-+    public static boolean isProxyOnlineMode() {
-+        return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
@@ -39,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
          };
  
-+        if (com.destroystokyo.paper.PaperConfig.isProxyOnlineMode()) // Paper - only run in online mode - 100 COL
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()) // Paper - only run in online mode - 100 COL
          repository.findProfilesByNames(new String[]{name}, Agent.MINECRAFT, profilelookupcallback);
          GameProfile gameprofile = (GameProfile) atomicreference.get();
  
@@ -48,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      private static boolean usesAuthentication() {
 -        return GameProfileCache.usesAuthentication;
-+        return com.destroystokyo.paper.PaperConfig.isProxyOnlineMode(); // Paper
++        return io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode(); // Paper
      }
  
      public void add(GameProfile profile) {
@@ -62,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -        if (server.usesAuthentication() || org.spigotmc.SpigotConfig.bungee) { // Spigot: bungee = online mode, for now.
 +        if (server.usesAuthentication()
-+                || (com.destroystokyo.paper.PaperConfig.isProxyOnlineMode())) { // Spigot: bungee = online mode, for now.  // Paper - Handle via setting
++                || (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode())) { // Spigot: bungee = online mode, for now.  // Paper - Handle via setting
              server.getProfileRepository().findProfilesByNames(astring, Agent.MINECRAFT, callback);
          } else {
              String[] astring1 = astring;
@@ -75,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              GameProfile profile = null;
              // Only fetch an online UUID in online mode
 -            if ( this.getOnlineMode() || org.spigotmc.SpigotConfig.bungee )
-+            if ( this.getOnlineMode() || com.destroystokyo.paper.PaperConfig.isProxyOnlineMode() ) // Paper - Handle via setting
++            if ( this.getOnlineMode() || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() ) // Paper - Handle via setting
              {
                  profile = this.console.getProfileCache().get(name).orElse(null);
              }

patches/server/Add-support-for-Proxy-Protocol.patch

@@ -16,20 +16,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end
      implementation("org.apache.logging.log4j:log4j-iostreams:2.17.1") // Paper
      implementation("org.apache.logging.log4j:log4j-slf4j18-impl:2.17.1") // Paper
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void useDimensionTypeForCustomSpawners() {
-         useDimensionTypeForCustomSpawners = getBoolean("settings.use-dimension-type-for-custom-spawners", false);
-     }
-+
-+    public static boolean useProxyProtocol;
-+    private static void useProxyProtocol() {
-+        useProxyProtocol = getBoolean("settings.proxy-protocol", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
@@ -39,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // Paper end
  
 +            // Paper start - indicate Proxy Protocol usage
-+            if (com.destroystokyo.paper.PaperConfig.useProxyProtocol) {
++            if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.proxyProtocol) {
 +                ServerConnectionListener.LOGGER.info("Paper: Using Proxy Protocol");
 +            }
 +            // Paper end
@@ -52,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      Object object = j > 0 ? new RateKickingConnection(j) : new Connection(PacketFlow.SERVERBOUND);
  
 +                    // Paper start - Add support for Proxy Protocol
-+                    if (com.destroystokyo.paper.PaperConfig.useProxyProtocol) {
++                    if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.proxyProtocol) {
 +                        channel.pipeline().addAfter("timeout", "haproxy-decoder", new io.netty.handler.codec.haproxy.HAProxyMessageDecoder());
 +                        channel.pipeline().addAfter("haproxy-decoder", "haproxy-handler", new ChannelInboundHandlerAdapter() {
 +                            @Override

patches/server/Add-support-for-hex-color-codes-in-console.patch

@@ -5,21 +5,6 @@ Subject: [PATCH] Add support for hex color codes in console
 
 Converts upstream's hex color code legacy format into actual hex color codes in the console.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     }
- 
-     public static boolean deobfuscateStacktraces = true;
-+    public static boolean useRgbForNamedTextColors = true;
-     private static void loggerSettings() {
-         deobfuscateStacktraces = getBoolean("settings.loggers.deobfuscate-stacktraces", deobfuscateStacktraces);
-+        useRgbForNamedTextColors = getBoolean("settings.loggers.use-rgb-for-named-text-colors", useRgbForNamedTextColors);
-     }
- 
-     public static boolean allowBlockPermanentBreakingExploits = false;
 diff --git a/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java b/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
@@ -59,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.console;
 +
-+import com.destroystokyo.paper.PaperConfig;
++import io.papermc.paper.configuration.GlobalConfiguration;
 +import io.papermc.paper.adventure.PaperAdventure;
 +import net.kyori.adventure.text.format.NamedTextColor;
 +import net.kyori.adventure.text.format.TextColor;
@@ -227,7 +212,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        Matcher matcher = NAMED_PATTERN.matcher(content);
 +        StringBuilder buffer = new StringBuilder();
-+        final String[] ansiCodes = PaperConfig.useRgbForNamedTextColors ? RGB_ANSI_CODES : ANSI_ANSI_CODES;
++        final String[] ansiCodes = GlobalConfiguration.get().logging.useRgbForNamedTextColors ? RGB_ANSI_CODES : ANSI_ANSI_CODES;
 +        while (matcher.find()) {
 +            int format = LOOKUP.indexOf(Character.toLowerCase(matcher.group().charAt(1)));
 +            if (format != -1) {

patches/server/Add-tick-times-API-and-mspt-command.patch

@@ -109,18 +109,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return text(DF.format(avg), avg >= 50 ? RED : avg >= 40 ? YELLOW : GREEN);
 +    }
 +}
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+diff --git a/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java b/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+--- a/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
++++ b/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
+@@ -0,0 +0,0 @@
+ package io.papermc.paper.configuration;
  
-         commands = new HashMap<String, Command>();
++import com.destroystokyo.paper.MSPTCommand;
-         commands.put("paper", new PaperCommand("paper"));
+ import com.destroystokyo.paper.Metrics;
-+        commands.put("mspt", new MSPTCommand("mspt"));
+ import com.destroystokyo.paper.PaperCommand;
+ import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray;
+@@ -0,0 +0,0 @@ public class PaperConfigurations extends Configurations<GlobalConfiguration, Wor
+     private static boolean metricsStarted = false;
+     static {
+         COMMANDS.put("paper", new PaperCommand("paper"));
++        COMMANDS.put("mspt", new MSPTCommand("mspt"));
+     }
  
-         version = getInt("config-version", 27);
+     public static void registerCommands(final MinecraftServer server) {
-         set("config-version", 27);
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java

patches/server/Add-toggle-for-always-placing-the-dragon-egg.patch

@@ -4,22 +4,6 @@ Date: Thu, 26 Nov 2020 11:47:24 +0000
 Subject: [PATCH] Add toggle for always placing the dragon egg
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         perPlayerMobSpawns = getBoolean("per-player-mob-spawns", true);
-     }
- 
-+    public boolean enderDragonsDeathAlwaysPlacesDragonEgg = false;
-+    private void enderDragonsDeathAlwaysPlacesDragonEgg() {
-+        enderDragonsDeathAlwaysPlacesDragonEgg = getBoolean("ender-dragons-death-always-places-dragon-egg", enderDragonsDeathAlwaysPlacesDragonEgg);
-+    }
-+
-     public boolean phantomIgnoreCreative = true;
-     public boolean phantomOnlyAttackInsomniacs = true;
-     private void phantomSettings() {
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.spawnExitPortal(true);
              this.spawnNewGateway();
 -            if (!this.previouslyKilled) {
-+            if (this.level.paperConfig.enderDragonsDeathAlwaysPlacesDragonEgg || !this.previouslyKilled) { // Paper - always place dragon egg
++            if (this.level.paperConfig().entities.behavior.enderDragonsDeathAlwaysPlacesDragonEgg || !this.previouslyKilled) { // Paper - always place dragon egg
                  this.level.setBlockAndUpdate(this.level.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, EndPodiumFeature.END_PODIUM_LOCATION), Blocks.DRAGON_EGG.defaultBlockState());
              }
  

patches/server/Add-version-history-to-version-command.patch

@@ -205,9 +205,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-             return false;
+         paperConfigurations.initializeGlobalConfiguration();
-         }
+         paperConfigurations.initializeWorldDefaultsConfiguration();
-         com.destroystokyo.paper.PaperConfig.registerCommands();
+         io.papermc.paper.configuration.PaperConfigurations.registerCommands(this);
 +        com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // load version history now
          // Paper end
  

patches/server/Add-zombie-targets-turtle-egg-config.patch

@@ -4,22 +4,6 @@ Date: Sun, 23 Aug 2020 15:47:34 +0200
 Subject: [PATCH] Add zombie targets turtle egg config
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-     }
- 
-+    public boolean zombiesTargetTurtleEggs = true;
-+    private void zombiesTargetTurtleEggs() {
-+        zombiesTargetTurtleEggs = getBoolean("zombies-target-turtle-eggs", zombiesTargetTurtleEggs);
-+    }
-+
-     public short keepLoadedRange;
-     private void keepLoadedRange() {
-         keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      protected void registerGoals() {
 -        this.goalSelector.addGoal(4, new Zombie.ZombieAttackTurtleEggGoal(this, 1.0D, 3));
-+        if (level.paperConfig.zombiesTargetTurtleEggs) this.goalSelector.addGoal(4, new Zombie.ZombieAttackTurtleEggGoal(this, 1.0D, 3)); // Paper
++        if (level.paperConfig().entities.behavior.zombiesTargetTurtleEggs) this.goalSelector.addGoal(4, new Zombie.ZombieAttackTurtleEggGoal(this, 1.0D, 3)); // Paper
          this.goalSelector.addGoal(8, new LookAtPlayerGoal(this, Player.class, 8.0F));
          this.goalSelector.addGoal(8, new RandomLookAroundGoal(this));
          this.addBehaviourGoals();

patches/server/Added-world-settings-for-mobs-picking-up-loot.patch

@@ -4,25 +4,6 @@ Date: Sat, 28 Nov 2020 18:43:52 -0800
 Subject: [PATCH] Added world settings for mobs picking up loot
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         phantomOnlyAttackInsomniacs = getBoolean("phantoms-only-attack-insomniacs", phantomOnlyAttackInsomniacs);
-     }
- 
-+    public boolean zombiesAlwaysCanPickUpLoot;
-+    public boolean skeletonsAlwaysCanPickUpLoot;
-+    private void setMobsAlwaysCanPickUpLoot() {
-+        zombiesAlwaysCanPickUpLoot = getBoolean("mobs-can-always-pick-up-loot.zombies", false);
-+        skeletonsAlwaysCanPickUpLoot = getBoolean("mobs-can-always-pick-up-loot.skeletons", false);
-+        log("Zombies can always pick up loot: " + zombiesAlwaysCanPickUpLoot + ". Skeletons can always pick up loot: " + skeletonsAlwaysCanPickUpLoot + ".");
-+    }
-+
-     public int expMergeMaxValue;
-     private void expMergeMaxValue() {
-         expMergeMaxValue = getInt("experience-merge-max-value", -1);
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
@@ -32,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.populateDefaultEquipmentEnchantments(randomsource, difficulty);
          this.reassessWeaponGoal();
 -        this.setCanPickUpLoot(randomsource.nextFloat() < 0.55F * difficulty.getSpecialMultiplier());
-+        this.setCanPickUpLoot(this.level.paperConfig.skeletonsAlwaysCanPickUpLoot || randomsource.nextFloat() < 0.55F * difficulty.getSpecialMultiplier()); // Paper
++        this.setCanPickUpLoot(this.level.paperConfig().entities.behavior.mobsCanAlwaysPickUpLoot.skeletons || randomsource.nextFloat() < 0.55F * difficulty.getSpecialMultiplier()); // Paper
          if (this.getItemBySlot(EquipmentSlot.HEAD).isEmpty()) {
              LocalDate localdate = LocalDate.now();
              int i = localdate.get(ChronoField.DAY_OF_MONTH);
@@ -45,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          float f = difficulty.getSpecialMultiplier();
  
 -        this.setCanPickUpLoot(randomsource.nextFloat() < 0.55F * f);
-+        this.setCanPickUpLoot(this.level.paperConfig.zombiesAlwaysCanPickUpLoot || randomsource.nextFloat() < 0.55F * f); // Paper
++        this.setCanPickUpLoot(this.level.paperConfig().entities.behavior.mobsCanAlwaysPickUpLoot.zombies || randomsource.nextFloat() < 0.55F * f); // Paper
          if (object == null) {
              object = new Zombie.ZombieGroupData(Zombie.getSpawnAsBabyOdds(randomsource), true);
          }

patches/server/Adventure.patch

@@ -6,24 +6,6 @@ Subject: [PATCH] Adventure
 Co-authored-by: zml <zml@stellardrift.ca>
 Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         config.addDefault(path, def);
-         return config.getString(path, config.getString(path));
-     }
-+
-+    public static boolean useDisplayNameInQuit = false;
-+    private static void useDisplayNameInQuit() {
-+        if (version < 21) {
-+            boolean oldValue = getBoolean("use-display-name-in-quit-message", useDisplayNameInQuit);
-+            set("settings.use-display-name-in-quit-message", oldValue);
-+        }
-+        useDisplayNameInQuit = getBoolean("settings.use-display-name-in-quit-message", useDisplayNameInQuit);
-+    }
- }
 diff --git a/src/main/java/io/papermc/paper/adventure/AdventureComponent.java b/src/main/java/io/papermc/paper/adventure/AdventureComponent.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
@@ -1473,7 +1455,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return;
          }
 -        String leaveMessage = ChatFormatting.YELLOW + this.player.getScoreboardName() + " left the game.";
-+        net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? this.player.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(this.player.getScoreboardName())); // Paper - Adventure
++        net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? this.player.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(this.player.getScoreboardName())); // Paper - Adventure
  
 -        PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), s, leaveMessage);
 +        PlayerKickEvent event = new PlayerKickEvent(this.player.getBukkitEntity(), reason, leaveMessage); // Paper - Adventure
@@ -1666,7 +1648,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), entityplayer.kickLeaveMessage != null ? entityplayer.kickLeaveMessage : "\u00A7e" + entityplayer.getScoreboardName() + " left the game");
-+        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), 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())));
++        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() : net.kyori.adventure.text.Component.text(entityplayer.getScoreboardName())));
          this.cserver.getPluginManager().callEvent(playerQuitEvent);
          entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
  
@@ -1958,9 +1940,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public String getMotd() {
          return this.console.getMotd();
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-             return null;
+         return this.spigot;
-         }
      }
+     // Spigot end
 +
 +    // Paper start
 +    private Iterable<? extends net.kyori.adventure.audience.Audience> adventure$audiences;
@@ -1971,7 +1953,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        return this.adventure$audiences;
 +    }
-     // Paper end
++    // Paper end
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/All-chunks-are-slime-spawn-chunks-toggle.patch

@@ -4,20 +4,6 @@ Date: Thu, 3 Mar 2016 01:19:22 -0600
 Subject: [PATCH] All chunks are slime spawn chunks toggle
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableChestCatDetection() {
-         disableChestCatDetection = getBoolean("game-mechanics.disable-chest-cat-detection", false);
-     }
-+
-+    public boolean allChunksAreSlimeChunks;
-+    private void allChunksAreSlimeChunks() {
-+        allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              ChunkPos chunkcoordintpair = new ChunkPos(pos);
 -            boolean flag = WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot
-+            boolean flag = world.getMinecraftWorld().paperConfig.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
++            boolean flag = world.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
  
              if (random.nextInt(10) == 0 && flag && pos.getY() < 40) {
                  return checkMobSpawnRules(type, world, spawnReason, pos, random);
@@ -40,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public boolean isSlimeChunk() {
          // 987234911L is deterimined in EntitySlime when seeing if a slime can spawn in a chunk
 -        return WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0;
-+        return this.worldServer.paperConfig.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
++        return this.worldServer.paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
      }
  
      @Override

patches/server/Allow-Reloading-of-Custom-Permissions.patch

@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    public void reloadPermissions() {
 +        pluginManager.clearPermissions();
-+        if (com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions();
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions();
 +        for (Plugin plugin : pluginManager.getPlugins()) {
 +            for (Permission perm : plugin.getDescription().getPermissions()) {
 +                try {
@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                }
 +            }
 +        }
-+        if (!com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions();
++        if (!io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions();
 +        DefaultPermissions.registerCorePermissions();
 +        CraftDefaultPermissions.registerCorePermissions();
 +    }

patches/server/Allow-disabling-armour-stand-ticking.patch

@@ -4,21 +4,6 @@ Date: Wed, 15 Aug 2018 01:26:09 -0700
 Subject: [PATCH] Allow disabling armour stand ticking
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void armorStandEntityLookups() {
-         armorStandEntityLookups = getBoolean("armor-stands-do-collision-entity-lookups", true);
-     }
-+
-+    public boolean armorStandTick = true;
-+    private void armorStandTick() {
-+        this.armorStandTick = this.getBoolean("armor-stands-tick", this.armorStandTick);
-+        log("ArmorStand ticking is " + (this.armorStandTick ? "enabled" : "disabled") + " by default");
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
@@ -36,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
          super(type, world);
-+        if (world != null) this.canTick = world.paperConfig.armorStandTick; // Paper - armour stand ticking
++        if (world != null) this.canTick = world.paperConfig().entities.armorStands.tick; // Paper - armour stand ticking
          this.handItems = NonNullList.withSize(2, ItemStack.EMPTY);
          this.armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
          this.headPose = ArmorStand.DEFAULT_HEAD_POSE;

patches/server/Allow-disabling-mob-spawner-spawn-egg-transformation.patch

@@ -4,22 +4,6 @@ Date: Fri, 9 Oct 2020 20:30:12 -0400
 Subject: [PATCH] Allow disabling mob spawner spawn egg transformation
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         fixCuringZombieVillagerDiscountExploit = getBoolean("game-mechanics.fix-curing-zombie-villager-discount-exploit", fixCuringZombieVillagerDiscountExploit);
-     }
- 
-+    public boolean disableMobSpawnerSpawnEggTransformation = false;
-+    private void disableMobSpawnerSpawnEggTransformation() {
-+        disableMobSpawnerSpawnEggTransformation = getBoolean("game-mechanics.disable-mob-spawner-spawn-egg-transformation", disableMobSpawnerSpawnEggTransformation);
-+    }
-+
-     public short keepLoadedRange;
-     private void keepLoadedRange() {
-         keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
 diff --git a/src/main/java/net/minecraft/world/item/SpawnEggItem.java b/src/main/java/net/minecraft/world/item/SpawnEggItem.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/SpawnEggItem.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              BlockState iblockdata = world.getBlockState(blockposition);
  
 -            if (iblockdata.is(Blocks.SPAWNER)) {
-+            if (!world.paperConfig.disableMobSpawnerSpawnEggTransformation && iblockdata.is(Blocks.SPAWNER)) { // Paper
++            if (!world.paperConfig().entities.spawning.disableMobSpawnerSpawnEggTransformation && iblockdata.is(Blocks.SPAWNER)) { // Paper
                  BlockEntity tileentity = world.getBlockEntity(blockposition);
  
                  if (tileentity instanceof SpawnerBlockEntity) {

patches/server/Allow-for-toggling-of-spawn-chunks.patch

@@ -4,21 +4,6 @@ Date: Thu, 3 Mar 2016 03:53:43 -0600
 Subject: [PATCH] Allow for toggling of spawn chunks
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             hardDespawnDistances.put(category, hardDistance);
-         }
-     }
-+
-+    public boolean keepSpawnInMemory;
-+    private void keepSpawnInMemory() {
-+        keepSpawnInMemory = getBoolean("keep-spawn-loaded", true);
-+        log("Keep spawn chunk loaded: " + keepSpawnInMemory);
-+    }
- }
 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
@@ -27,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          });
          // CraftBukkit end
          timings = new co.aikar.timings.WorldTimingsHandler(this); // Paper - code below can generate new world and access timings
-+        this.keepSpawnInMemory = this.paperConfig.keepSpawnInMemory; // Paper
++        this.keepSpawnInMemory = this.paperConfig().spawn.keepSpawnLoaded; // Paper
          this.entityLimiter = new org.spigotmc.TickLimiter(spigotConfig.entityMaxTickTime);
          this.tileLimiter = new org.spigotmc.TickLimiter(spigotConfig.tileMaxTickTime);
      }

patches/server/Allow-nerfed-mobs-to-jump-and-take-water-damage.patch

@@ -4,32 +4,6 @@ Date: Tue, 1 Mar 2016 13:24:16 -0600
 Subject: [PATCH] Allow nerfed mobs to jump and take water damage
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         fishingMaxTicks = getInt("fishing-time-range.MaximumTicks", 600);
-         log("Fishing time ranges are between " + fishingMinTicks +" and " + fishingMaxTicks + " ticks");
-     }
-+
-+    public boolean nerfedMobsShouldJump;
-+    private void nerfedMobsShouldJump() {
-+        nerfedMobsShouldJump = getBoolean("spawner-nerfed-mobs-should-jump", false);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-         return this.isInWater() || this.isInRain();
-     }
- 
-+    @Deprecated public final boolean isInWaterOrRainOrBubble() { return isInWaterRainOrBubble(); } // Paper - OBFHELPER
-     public boolean isInWaterRainOrBubble() {
-         return this.isInWater() || this.isInRain() || this.isInBubbleColumn();
-     }
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
@@ -69,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public FloatGoal(Mob mob) {
          this.mob = mob;
-+        if (mob.getCommandSenderWorld().paperConfig.nerfedMobsShouldJump) mob.goalFloat = this; // Paper
++        if (mob.getCommandSenderWorld().paperConfig().entities.behavior.spawnerNerfedMobsShouldJump) mob.goalFloat = this; // Paper
          this.setFlags(EnumSet.of(Goal.Flag.JUMP));
          mob.getNavigation().setCanFloat(true);
      }

patches/server/Allow-specifying-a-custom-authentication-servers-dow.patch

@@ -5,27 +5,6 @@ Subject: [PATCH] Allow specifying a custom "authentication servers down" kick
  message
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@
- package com.destroystokyo.paper;
- 
-+import com.google.common.base.Strings;
- import com.google.common.base.Throwables;
- 
- import java.io.File;
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void suggestPlayersWhenNull() {
-         suggestPlayersWhenNullTabCompletions = getBoolean("settings.suggest-player-names-when-null-tab-completions", suggestPlayersWhenNullTabCompletions);
-     }
-+
-+    public static String authenticationServersDownKickMessage = ""; // empty = use translatable message
-+    private static void authenticationServersDownKickMessage() {
-+        authenticationServersDownKickMessage = Strings.emptyToNull(getString("messages.kick.authentication-servers-down", authenticationServersDownKickMessage));
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
@@ -35,8 +14,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          ServerLoginPacketListenerImpl.this.state = ServerLoginPacketListenerImpl.State.READY_TO_ACCEPT;
                      } else {
 +                        // Paper start
-+                        if (com.destroystokyo.paper.PaperConfig.authenticationServersDownKickMessage != null) {
++                        if (!io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.authenticationServersDown.isEmpty()) {
-+                            ServerLoginPacketListenerImpl.this.disconnect(Component.literal(com.destroystokyo.paper.PaperConfig.authenticationServersDownKickMessage));
++                            ServerLoginPacketListenerImpl.this.disconnect(Component.literal(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.authenticationServersDown));
 +                        } else // Paper end
                          ServerLoginPacketListenerImpl.this.disconnect(Component.translatable("multiplayer.disconnect.authservers_down"));
                          ServerLoginPacketListenerImpl.LOGGER.error("Couldn't verify username because servers are unavailable");

patches/server/Allow-using-signs-inside-spawn-protection.patch

@@ -4,20 +4,6 @@ Date: Wed, 15 Apr 2020 01:54:02 +0200
 Subject: [PATCH] Allow using signs inside spawn protection
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             delayChunkUnloadsBy *= 20;
-         }
-     }
-+
-+    public boolean allowUsingSignsInsideSpawnProtection = false;
-+    private void allowUsingSignsInsideSpawnProtection() {
-+        allowUsingSignsInsideSpawnProtection = getBoolean("allow-using-signs-inside-spawn-protection", allowUsingSignsInsideSpawnProtection);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (blockposition.getY() < i) {
 -                    if (this.awaitingPositionFromClient == null && this.player.distanceToSqr((double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D) < 64.0D && worldserver.mayInteract(this.player, blockposition)) {
-+                    if (this.awaitingPositionFromClient == null && this.player.distanceToSqr((double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D) < 64.0D && (worldserver.mayInteract(this.player, blockposition)  || (worldserver.paperConfig.allowUsingSignsInsideSpawnProtection && worldserver.getBlockState(blockposition).getBlock() instanceof net.minecraft.world.level.block.SignBlock))) { // Paper - sign check
++                    if (this.awaitingPositionFromClient == null && this.player.distanceToSqr((double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D) < 64.0D && (worldserver.mayInteract(this.player, blockposition)  || (worldserver.paperConfig().spawn.allowUsingSignsInsideSpawnProtection && worldserver.getBlockState(blockposition).getBlock() instanceof net.minecraft.world.level.block.SignBlock))) { // Paper - sign check
                          this.player.stopUsingItem(); // CraftBukkit - SPIGOT-4706
                          InteractionResult enuminteractionresult = this.player.gameMode.useItemOn(this.player, worldserver, itemstack, enumhand, movingobjectpositionblock);
  

patches/server/Anti-Xray.patch

@@ -4,65 +4,6 @@ Date: Thu, 25 Nov 2021 13:27:51 +0100
 Subject: [PATCH] Anti-Xray
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@
- package com.destroystokyo.paper;
- 
-+import java.util.Arrays;
- import java.util.List;
- 
- import java.util.stream.Collectors;
- import it.unimi.dsi.fastutil.objects.Reference2IntMap;
- import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
- import net.minecraft.world.entity.MobCategory;
-+import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode;
- import org.bukkit.Bukkit;
- import org.bukkit.configuration.file.YamlConfiguration;
- import org.spigotmc.SpigotWorldConfig;
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void lightQueueSize() {
-         lightQueueSize = getInt("light-queue-size", lightQueueSize);
-     }
-+
-+    public boolean antiXray;
-+    public EngineMode engineMode;
-+    public int maxBlockHeight;
-+    public int updateRadius;
-+    public boolean lavaObscures;
-+    public boolean usePermission;
-+    public List<String> hiddenBlocks;
-+    public List<String> replacementBlocks;
-+    private void antiXray() {
-+        antiXray = getBoolean("anti-xray.enabled", false);
-+        engineMode = EngineMode.getById(getInt("anti-xray.engine-mode", EngineMode.HIDE.getId()));
-+        engineMode = engineMode == null ? EngineMode.HIDE : engineMode;
-+        maxBlockHeight = getInt("anti-xray.max-block-height", 64);
-+        updateRadius = getInt("anti-xray.update-radius", 2);
-+        lavaObscures = getBoolean("anti-xray.lava-obscures", false);
-+        usePermission = getBoolean("anti-xray.use-permission", false);
-+        hiddenBlocks = getList("anti-xray.hidden-blocks", Arrays.asList("copper_ore", "deepslate_copper_ore", "gold_ore", "deepslate_gold_ore", "iron_ore", "deepslate_iron_ore",
-+            "coal_ore", "deepslate_coal_ore", "lapis_ore", "deepslate_lapis_ore", "mossy_cobblestone", "obsidian", "chest", "diamond_ore", "deepslate_diamond_ore",
-+            "redstone_ore", "deepslate_redstone_ore", "clay", "emerald_ore", "deepslate_emerald_ore", "ender_chest"));
-+        replacementBlocks = getList("anti-xray.replacement-blocks", Arrays.asList("stone", "oak_planks", "deepslate"));
-+        if (PaperConfig.version < 19) {
-+            hiddenBlocks.remove("lit_redstone_ore");
-+            int index = replacementBlocks.indexOf("planks");
-+            if (index != -1) {
-+                replacementBlocks.set(index, "oak_planks");
-+            }
-+            set("anti-xray.hidden-blocks", hiddenBlocks);
-+            set("anti-xray.replacement-blocks", replacementBlocks);
-+        }
-+        log("Anti-Xray: " + (antiXray ? "enabled" : "disabled") + " / Engine Mode: " + engineMode.getDescription() + " / Up to " + ((maxBlockHeight >> 4) << 4) + " blocks / Update Radius: " + updateRadius);
-+        if (antiXray && usePermission) {
-+            Bukkit.getLogger().warning("You have enabled permission-based Anti-Xray checking - depending on your permission plugin, this may cause performance issues");
-+        }
-+    }
- }
- 
 diff --git a/src/main/java/com/destroystokyo/paper/antixray/BitStorageReader.java b/src/main/java/com/destroystokyo/paper/antixray/BitStorageReader.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
@@ -264,7 +205,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.antixray;
 +
-+import com.destroystokyo.paper.PaperWorldConfig;
++import io.papermc.paper.configuration.WorldConfiguration;
 +import net.minecraft.core.BlockPos;
 +import net.minecraft.core.Direction;
 +import net.minecraft.core.Registry;
@@ -284,11 +225,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.world.level.block.state.BlockState;
 +import net.minecraft.world.level.chunk.*;
 +import org.bukkit.Bukkit;
++import org.spongepowered.configurate.serialize.ScalarSerializer;
++import org.spongepowered.configurate.serialize.SerializationException;
 +
++import java.lang.reflect.Type;
 +import java.util.*;
 +import java.util.concurrent.Executor;
 +import java.util.concurrent.ThreadLocalRandom;
 +import java.util.function.IntSupplier;
++import java.util.function.Predicate;
 +
 +public final class ChunkPacketBlockControllerAntiXray extends ChunkPacketBlockController {
 +
@@ -317,7 +262,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    public ChunkPacketBlockControllerAntiXray(Level level, Executor executor) {
 +        this.executor = executor;
-+        PaperWorldConfig paperWorldConfig = level.paperConfig;
++        WorldConfiguration.AntiCheat.AntiXRay paperWorldConfig = level.paperConfig().anticheat.antiXray;
 +        engineMode = paperWorldConfig.engineMode;
 +        maxBlockHeight = paperWorldConfig.maxBlockHeight >> 4 << 4;
 +        updateRadius = paperWorldConfig.updateRadius;
@@ -901,6 +846,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        HIDE(1, "hide ores"),
 +        OBFUSCATE(2, "obfuscate");
 +
++        public static final ScalarSerializer<EngineMode> SERIALIZER = new Serializer();
++
 +        private final int id;
 +        private final String description;
 +
@@ -926,6 +873,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        public String getDescription() {
 +            return description;
 +        }
++
++        static class Serializer extends ScalarSerializer<EngineMode> {
++
++            Serializer() {
++                super(EngineMode.class);
++            }
++
++            @Override
++            public EngineMode deserialize(Type type, Object obj) throws SerializationException {
++                if (obj instanceof Integer num) {
++                    return Objects.requireNonNullElse(EngineMode.getById(num), HIDE);
++                }
++                throw new SerializationException(obj + " is not of a valid type (" + type + ") for this node");
++            }
++
++            @Override
++            protected Object serialize(EngineMode item, Predicate<Class<?>> typeSupported) {
++                return item.getId();
++            }
++        }
 +    }
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java
@@ -1049,6 +1016,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        chunkPacketBlockControllerAntiXray.obfuscate(this);
 +    }
 +}
+diff --git a/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java b/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
++++ b/src/main/java/io/papermc/paper/configuration/PaperConfigurations.java
+@@ -0,0 +0,0 @@ package io.papermc.paper.configuration;
+ 
+ import com.destroystokyo.paper.Metrics;
+ import com.destroystokyo.paper.PaperCommand;
++import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray;
+ import com.google.common.collect.Table;
+ import com.mojang.logging.LogUtils;
+ import io.leangen.geantyref.TypeToken;
+@@ -0,0 +0,0 @@ public class PaperConfigurations extends Configurations<GlobalConfiguration, Wor
+                     .register(DoubleOrDefault.SERIALIZER)
+                     .register(BooleanOrDefault.SERIALIZER)
+                     .register(Duration.SERIALIZER)
++                    .register(ChunkPacketBlockControllerAntiXray.EngineMode.SERIALIZER)
+                     .register(FallbackValueSerializer.create(spigotConfig, MinecraftServer::getServer))
+                     .register(new RegistryValueSerializer<>(new TypeToken<EntityType<?>>() {}, Registry.ENTITY_TYPE, true))
+                     .register(new RegistryValueSerializer<>(Item.class, Registry.ITEM, true))
 diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
@@ -1193,8 +1180,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PrimaryLevelData iworlddataserver, ResourceKey<Level> resourcekey, LevelStem worlddimension, ChunkProgressListener worldloadlistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
          // Holder holder = worlddimension.typeHolder(); // CraftBukkit - decompile error
          // Objects.requireNonNull(minecraftserver); // CraftBukkit - decompile error
--        super(iworlddataserver, resourcekey, worlddimension.typeHolder(), minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates(), gen, biomeProvider, env);
+-        super(iworlddataserver, resourcekey, worlddimension.typeHolder(), minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates(), gen, biomeProvider, env, spigotConfig -> minecraftserver.paperConfigurations.createWorldConfig(convertable_conversionsession.levelDirectory.path(), iworlddataserver.getLevelName(), spigotConfig)); // Paper
-+        super(iworlddataserver, resourcekey, worlddimension.typeHolder(), minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates(), gen, biomeProvider, env, executor); // Paper - Async-Anti-Xray - Pass executor
++        super(iworlddataserver, resourcekey, worlddimension.typeHolder(), minecraftserver::getProfiler, false, flag, i, minecraftserver.getMaxChainedNeighborUpdates(), gen, biomeProvider, env, spigotConfig -> minecraftserver.paperConfigurations.createWorldConfig(convertable_conversionsession.levelDirectory.path(), iworlddataserver.getLevelName(), spigotConfig), executor); // Paper - Async-Anti-Xray - Pass executor
          this.pvpMode = minecraftserver.isPvpAllowed();
          this.convertable = convertable_conversionsession;
          this.uuid = WorldUUID.getUUID(convertable_conversionsession.levelDirectory.path().toFile());
@@ -1225,27 +1212,28 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/Level.java
 +++ b/src/main/java/net/minecraft/world/level/Level.java
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     public final org.spigotmc.SpigotWorldConfig spigotConfig; // Spigot
+     }
+     // Paper end
  
-     public final com.destroystokyo.paper.PaperWorldConfig paperConfig; // Paper
 +    public final com.destroystokyo.paper.antixray.ChunkPacketBlockController chunkPacketBlockController; // Paper - Anti-Xray
- 
++
      public final co.aikar.timings.WorldTimingsHandler timings; // Paper
      public static BlockPos lastPhysicsProblem; // Spigot
+     private org.spigotmc.TickLimiter entityLimiter;
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
  
      public abstract ResourceKey<LevelStem> getTypeKey();
  
--    protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env) {
+-    protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator) { // Paper
-+    protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor
++    protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor
          this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot
-         this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), this.spigotConfig); // Paper
+         this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper
          this.generator = gen;
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-         this.keepSpawnInMemory = this.paperConfig.keepSpawnInMemory; // Paper
+         this.keepSpawnInMemory = this.paperConfig().spawn.keepSpawnLoaded; // Paper
          this.entityLimiter = new org.spigotmc.TickLimiter(spigotConfig.entityMaxTickTime);
          this.tileLimiter = new org.spigotmc.TickLimiter(spigotConfig.tileMaxTickTime);
-+        this.chunkPacketBlockController = this.paperConfig.antiXray ? new com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray(this, executor) : com.destroystokyo.paper.antixray.ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray
++        this.chunkPacketBlockController = this.paperConfig().anticheat.antiXray.enabled ? new com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray(this, executor) : com.destroystokyo.paper.antixray.ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray
      }
  
      // Paper start

patches/server/Asynchronous-chunk-IO-and-loading.patch

@@ -160,76 +160,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static Timing getTickList(ServerLevel worldserver, String timingsType) {
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@
- package com.destroystokyo.paper;
- 
-+import com.destroystokyo.paper.io.chunk.ChunkTaskManager;
- import com.google.common.base.Strings;
- import com.google.common.base.Throwables;
- 
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-         tabSpamLimit = getInt("settings.spam-limiter.tab-spam-limit", tabSpamLimit);
-     }
-+
-+    public static boolean asyncChunks = false;
-+    private static void asyncChunks() {
-+        ConfigurationSection section;
-+        if (version < 15) {
-+            section = config.createSection("settings.async-chunks");
-+            section.set("threads", -1);
-+        } else {
-+            section = config.getConfigurationSection("settings.async-chunks");
-+            if (section == null) {
-+                section = config.createSection("settings.async-chunks");
-+            }
-+        }
-+        // Clean up old configs
-+        if (section.contains("load-threads")) {
-+            if (!section.contains("threads")) {
-+                section.set("threads", section.get("load-threads"));
-+            }
-+            section.set("load-threads", null);
-+        }
-+        section.set("generation", null);
-+        section.set("enabled", null);
-+        section.set("thread-per-world-generation", null);
-+
-+        int threads = getInt("settings.async-chunks.threads", -1);
-+        int cpus = Runtime.getRuntime().availableProcessors() / 2;
-+        if (threads <= 0) {
-+            if (cpus <= 4) {
-+                threads = cpus <= 2 ? 1 : 2;
-+            } else {
-+                threads = (int) Math.min(Integer.getInteger("paper.maxChunkThreads", 4), cpus / 2);
-+            }
-+        }
-+        if (cpus == 1 && !Boolean.getBoolean("Paper.allowAsyncChunksSingleCore")) {
-+            asyncChunks = false;
-+        } else {
-+            asyncChunks = true;
-+        }
-+
-+        // Let Shared Host set some limits
-+        String sharedHostThreads = System.getenv("PAPER_ASYNC_CHUNKS_SHARED_HOST_THREADS");
-+        if (sharedHostThreads != null) {
-+            try {
-+                threads = Math.max(1, Math.min(threads, Integer.parseInt(sharedHostThreads)));
-+            } catch (NumberFormatException ignored) {}
-+        }
-+
-+        if (!asyncChunks) {
-+            log("Async Chunks: Disabled - Chunks will be managed synchronously, and will cause tremendous lag.");
-+        } else {
-+            ChunkTaskManager.initGlobalLoadThreads(threads);
-+            log("Async Chunks: Enabled - Chunks will be loaded much faster, without lag.");
-+        }
-+    }
- }
 diff --git a/src/main/java/com/destroystokyo/paper/io/IOUtil.java b/src/main/java/com/destroystokyo/paper/io/IOUtil.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
@@ -1793,6 +1723,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import com.destroystokyo.paper.io.IOUtil;
 +import com.destroystokyo.paper.io.PrioritizedTaskQueue;
 +import com.destroystokyo.paper.io.QueueExecutorThread;
++import io.papermc.paper.configuration.GlobalConfiguration;
 +import net.minecraft.nbt.CompoundTag;
 +import net.minecraft.server.MinecraftServer;
 +import net.minecraft.server.level.ChunkHolder;
@@ -1919,6 +1850,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +    }
 +
++    public static void processConfiguration(GlobalConfiguration.AsyncChunks config) {
++        int cpus = Runtime.getRuntime().availableProcessors() / 2;
++        if (config.threads <= 0) {
++            if (cpus <= 4) {
++                config.threads = cpus <= 2 ? 1 : 2;
++            } else {
++                config.threads = (int) Math.min(Integer.getInteger("paper.maxChunkThreads", 4), cpus / 2);
++            }
++        }
++        if (cpus == 1 && !Boolean.getBoolean("Paper.allowAsyncChunksSingleCore")) {
++            config.asyncChunks = false;
++        } else {
++            config.asyncChunks = true;
++        }
++
++        // Let Shared Host set some limits
++        String sharedHostThreads = System.getenv("PAPER_ASYNC_CHUNKS_SHARED_HOST_THREADS");
++        if (sharedHostThreads != null) {
++            try {
++                config.threads = Math.max(1, Math.min(config.threads, Integer.parseInt(sharedHostThreads)));
++            } catch (NumberFormatException ignored) {}
++        }
++
++        if (config.asyncChunks) {
++            ChunkTaskManager.initGlobalLoadThreads(config.threads);
++        }
++    }
++
 +    public static void initGlobalLoadThreads(int threads) {
 +        if (threads <= 0 || globalWorkers != null) {
 +            return;
@@ -3405,7 +3364,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper end
              return regionfile;
          } else {
-             if (this.regionCache.size() >= com.destroystokyo.paper.PaperConfig.regionFileCacheSize) { // Paper - configurable
+             if (this.regionCache.size() >= io.papermc.paper.configuration.GlobalConfiguration.get().misc.regionFileCacheSize) { // Paper - configurable
 @@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
              RegionFile regionfile1 = new RegionFile(path1, this.folder, this.sync);
  

patches/server/Basic-PlayerProfile-API.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.profile;
 +
-+import com.destroystokyo.paper.PaperConfig;
++import io.papermc.paper.configuration.GlobalConfiguration;
 +import com.google.common.base.Charsets;
 +import com.google.common.collect.Iterables;
 +import com.mojang.authlib.GameProfile;
@@ -190,7 +190,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean completeFromCache() {
-+        return completeFromCache(false, PaperConfig.isProxyOnlineMode());
++        return completeFromCache(false, GlobalConfiguration.get().proxies.isProxyOnlineMode());
 +    }
 +
 +    public boolean completeFromCache(boolean onlineMode) {
@@ -233,7 +233,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    public boolean complete(boolean textures) {
-+        return complete(textures, PaperConfig.isProxyOnlineMode());
++        return complete(textures, GlobalConfiguration.get().proxies.isProxyOnlineMode());
 +    }
 +    public boolean complete(boolean textures, boolean onlineMode) {
 +        MinecraftServer server = MinecraftServer.getServer();
@@ -593,8 +593,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
              File file = (File) optionset.valueOf("universe"); // CraftBukkit
--            Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file);
+-            Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
-+            Services services = Services.create(new com.destroystokyo.paper.profile.PaperAuthenticationService(Proxy.NO_PROXY), file); // Paper
++            Services services = Services.create(new com.destroystokyo.paper.profile.PaperAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
              // CraftBukkit start
              String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
              LevelStorageSource convertable = LevelStorageSource.createDefault(file.toPath());
@@ -644,7 +644,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
      public boolean suggestPlayerNamesWhenNullTabCompletions() {
-         return com.destroystokyo.paper.PaperConfig.suggestPlayersWhenNullTabCompletions;
+         return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
      }
 +
 +    @Override

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

@@ -11,21 +11,6 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ 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/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -35,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          public void onTickingEnd(Entity entity) {
              ServerLevel.this.entityTickList.remove(entity);
 +            // Paper start - Reset pearls when they stop being ticked
-+            if (paperConfig.disableEnderpearlExploit && entity instanceof net.minecraft.world.entity.projectile.ThrownEnderpearl pearl) {
++            if (paperConfig().fixes.disableUnloadedChunkEnderpearlExploit && entity instanceof net.minecraft.world.entity.projectile.ThrownEnderpearl pearl) {
 +                pearl.cachedOwner = null;
 +                pearl.ownerUUID = null;
 +            }
@@ -51,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      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
++            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/Book-Size-Limits.patch

@@ -5,24 +5,6 @@ Subject: [PATCH] Book Size Limits
 
 Puts some limits on the size of books.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-     }
- 
-+    public static int maxBookPageSize = 2560;
-+    public static double maxBookTotalSizeMultiplier = 0.98D;
-+    private static void maxBookSize() {
-+        maxBookPageSize = Math.min(8192, getInt("settings.book-size.page-max", maxBookPageSize));
-+        maxBookTotalSizeMultiplier = getDouble("settings.book-size.total-multiplier", maxBookTotalSizeMultiplier);
-+    }
-+
-     public static boolean asyncChunks = false;
-     private static void asyncChunks() {
-         ConfigurationSection section;
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -35,8 +17,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (!this.cserver.isPrimaryThread()) {
 +            List<String> pageList = packet.getPages();
 +            long byteTotal = 0;
-+            int maxBookPageSize = com.destroystokyo.paper.PaperConfig.maxBookPageSize;
++            int maxBookPageSize = io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.pageMax;
-+            double multiplier = Math.max(0.3D, Math.min(1D, com.destroystokyo.paper.PaperConfig.maxBookTotalSizeMultiplier));
++            double multiplier = Math.max(0.3D, Math.min(1D, io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.totalMultiplier));
 +            long byteAllowed = maxBookPageSize;
 +            for (String testString : pageList) {
 +                int byteLength = testString.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;

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

@@ -21,29 +21,6 @@ Splitting the field up and making it configurable allows for server owners
 to take the burden of this into their own hand without having to rely on
 plugins doing unsafe things.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-             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");
-         }
-     }
-+
-+    public static int tabSpamIncrement = 1;
-+    public static int tabSpamLimit = 500;
-+    private static void tabSpamLimiters() {
-+        tabSpamIncrement = getInt("settings.spam-limiter.tab-spam-increment", tabSpamIncrement);
-+        // Older versions used a smaller limit, which is too low for 1.13, we'll bump this up if default
-+        if (version < 14) {
-+            if (tabSpamIncrement == 10) {
-+                set("settings.spam-limiter.tab-spam-increment", 2);
-+                tabSpamIncrement = 2;
-+            }
-+        }
-+        tabSpamLimit = getInt("settings.spam-limiter.tab-spam-limit", tabSpamLimit);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -69,7 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // PlayerConnectionUtils.ensureMainThread(packetplayintabcomplete, this, this.player.getWorldServer()); // Paper - run this async
          // CraftBukkit start
 -        if (this.chatSpamTickCount.addAndGet(1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
-+        if (this.chatSpamTickCount.addAndGet(com.destroystokyo.paper.PaperConfig.tabSpamIncrement) > com.destroystokyo.paper.PaperConfig.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
++        if (this.chatSpamTickCount.addAndGet(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamIncrement) > io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
              server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]))); // Paper
              return;
          }

patches/server/Buffer-joins-to-world.patch

@@ -7,46 +7,22 @@ This patch buffers the number of logins which will attempt to join
 the world per tick, this attempts to reduce the impact that join floods
 has on the server
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-     }
- 
-+    public static int maxJoinsPerTick;
-+    private static void maxJoinsPerTick() {
-+        maxJoinsPerTick = getInt("settings.max-joins-per-tick", 3);
-+    }
-+
-     public static void registerCommands() {
-         for (Map.Entry<String, Command> entry : commands.entrySet()) {
-             MinecraftServer.getServer().server.getCommandMap().register(entry.getKey(), "Paper", entry.getValue());
 diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/Connection.java
 +++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ import net.minecraft.network.protocol.Packet;
- import net.minecraft.network.protocol.PacketFlow;
- import net.minecraft.network.protocol.game.ClientboundDisconnectPacket;
- import net.minecraft.network.protocol.login.ClientboundLoginDisconnectPacket;
-+import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.RunningOnDifferentThreadException;
- import net.minecraft.server.network.ServerGamePacketListenerImpl;
- import net.minecraft.server.network.ServerLoginPacketListenerImpl;
 @@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
      }
      // Paper end
  
-+    private static final int MAX_PER_TICK = com.destroystokyo.paper.PaperConfig.maxJoinsPerTick; // Paper
++    private static final int MAX_PER_TICK = io.papermc.paper.configuration.GlobalConfiguration.get().misc.maxJoinsPerTick; // Paper
 +    private static int joinAttemptsThisTick; // Paper
 +    private static int currTick; // Paper
      public void tick() {
          this.flushQueue();
 +        // Paper start
-+        if (currTick != MinecraftServer.currentTick) {
++        if (currTick != net.minecraft.server.MinecraftServer.currentTick) {
-+            currTick = MinecraftServer.currentTick;
++            currTick = net.minecraft.server.MinecraftServer.currentTick;
 +            joinAttemptsThisTick = 0;
 +        }
 +        // Paper end

patches/server/Cap-Entity-Collisions.patch

@@ -11,21 +11,6 @@ just as it does in Vanilla, but entity pushing logic will be capped.
 
 You can set this to 0 to disable collisions.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         treasureMapsAlreadyDiscoveredVillager = getBoolean("treasure-maps-find-already-discovered.villager-trade", treasureMapsAlreadyDiscoveredVillager);
-         treasureMapsAlreadyDiscoveredLootTable = getBooleanOrNull("treasure-maps-find-already-discovered.loot-tables", treasureMapsAlreadyDiscoveredLootTable);
-     }
-+
-+    public int maxCollisionsPerEntity = 8;
-+    private void maxEntityCollision() {
-+        maxCollisionsPerEntity = getInt( "max-entity-collisions", this.spigotConfig.getInt("max-entity-collisions", this.maxCollisionsPerEntity, false) );
-+        log( "Max Entity Collisions: " + maxCollisionsPerEntity );
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -47,8 +32,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            for (j = 0; j < list.size(); ++j) {
-+            this.numCollisions = Math.max(0, this.numCollisions - this.level.paperConfig.maxCollisionsPerEntity); // Paper
++            this.numCollisions = Math.max(0, this.numCollisions - this.level.paperConfig().collisions.maxEntityCollisions); // Paper
-+            for (j = 0; j < list.size() && this.numCollisions < this.level.paperConfig.maxCollisionsPerEntity; ++j) { // Paper
++            for (j = 0; j < list.size() && this.numCollisions < this.level.paperConfig().collisions.maxEntityCollisions; ++j) { // Paper
                  Entity entity = (Entity) list.get(j);
 +                entity.numCollisions++; // Paper
 +                this.numCollisions++; // Paper

patches/server/Chunk-debug-command.patch

@@ -71,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super(name);
 @@ -0,0 +0,0 @@ public class PaperCommand extends Command {
                  if (args.length == 3)
-                     return getListMatchingLast(sender, args, EntityType.getEntityNameList().stream().map(ResourceLocation::toString).sorted().toArray(String[]::new));
+                     return getListMatchingLast(sender, args, Registry.ENTITY_TYPE.keySet().stream().map(ResourceLocation::toString).sorted().toArray(String[]::new));
                  break;
 +            case "debug":
 +                if (args.length == 2) {
@@ -366,7 +366,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            worldData.addProperty("name", world.getWorld().getName());
 +            worldData.addProperty("view-distance", world.spigotConfig.viewDistance);
 +            worldData.addProperty("keep-spawn-loaded", world.keepSpawnInMemory);
-+            worldData.addProperty("keep-spawn-loaded-range", world.paperConfig.keepLoadedRange);
++            worldData.addProperty("keep-spawn-loaded-range", world.paperConfig().spawn.keepSpawnLoadedRange);
 +            worldData.addProperty("visible-chunk-count", visibleChunks.size());
 +            worldData.addProperty("loaded-chunk-count", chunkMap.entitiesInLevel.size());
 +            worldData.addProperty("verified-fully-loaded-chunks", fullLoadedChunks);

patches/server/Climbing-should-not-bypass-cramming-gamerule.patch

@@ -4,22 +4,6 @@ Date: Sun, 23 Aug 2020 20:59:00 +0200
 Subject: [PATCH] Climbing should not bypass cramming gamerule
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         wanderingTraderSpawnChanceMax = getInt("wandering-trader.spawn-chance-max", wanderingTraderSpawnChanceMax);
-     }
- 
-+    public boolean fixClimbingBypassingCrammingRule = false;
-+    private void fixClimbingBypassingCrammingRule() {
-+        fixClimbingBypassingCrammingRule = getBoolean("fix-climbing-bypassing-cramming-rule", fixClimbingBypassingCrammingRule);
-+    }
-+
-     public short keepLoadedRange;
-     private void keepLoadedRange() {
-         keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -69,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
          // Paper end - don't run getEntities if we're not going to use its result
 -        List<Entity> list = this.level.getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushableBy(this));
-+        List<Entity> list = this.level.getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushable(this, level.paperConfig.fixClimbingBypassingCrammingRule)); // Paper - fix climbing bypassing cramming rule
++        List<Entity> list = this.level.getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushable(this, level.paperConfig().collisions.fixClimbingBypassingCrammingRule)); // Paper - fix climbing bypassing cramming rule
  
          if (!list.isEmpty()) {
              // Paper - move up
@@ -81,7 +65,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean isPushable() {
 -        return this.isAlive() && !this.isSpectator() && !this.onClimbable() && this.collides; // CraftBukkit
-+        return this.isCollidable(level.paperConfig.fixClimbingBypassingCrammingRule);
++        return this.isCollidable(level.paperConfig().collisions.fixClimbingBypassingCrammingRule);
 +    }
 +
 +    @Override

patches/server/Collision-option-for-requiring-a-player-participant.patch

@@ -4,29 +4,6 @@ Date: Sat, 14 Nov 2020 16:48:37 +0100
 Subject: [PATCH] Collision option for requiring a player participant
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-     }
- 
-+    public boolean onlyPlayersCollide = false;
-+    public boolean allowVehicleCollisions = true;
-+    private void onlyPlayersCollide() {
-+        onlyPlayersCollide = getBoolean("only-players-collide", onlyPlayersCollide);
-+        allowVehicleCollisions = getBoolean("allow-vehicle-collisions", allowVehicleCollisions);
-+        if (onlyPlayersCollide && !allowVehicleCollisions) {
-+            log("Collisions will only work if a player is one of the two entities colliding.");
-+        } else if (onlyPlayersCollide) {
-+            log("Collisions will only work if a player OR a vehicle is one of the two entities colliding.");
-+        }
-+    }
-+
-     public int wanderingTraderSpawnMinuteTicks = 1200;
-     public int wanderingTraderSpawnDayTicks = 24000;
-     public int wanderingTraderSpawnChanceFailureIncrement = 25;
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -35,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void push(Entity entity) {
          if (!this.isPassengerOfSameVehicle(entity)) {
              if (!entity.noPhysics && !this.noPhysics) {
-+                if (this.level.paperConfig.onlyPlayersCollide && !(entity instanceof ServerPlayer || this instanceof ServerPlayer)) return; // Paper
++                if (this.level.paperConfig().collisions.onlyPlayersCollide && !(entity instanceof ServerPlayer || this instanceof ServerPlayer)) return; // Paper
                  double d0 = entity.getX() - this.getX();
                  double d1 = entity.getZ() - this.getZ();
                  double d2 = Mth.absMax(d0, d1);
@@ -47,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void push(Entity entity) {
          if (!this.level.isClientSide) {
              if (!entity.noPhysics && !this.noPhysics) {
-+                if (!this.level.paperConfig.allowVehicleCollisions && this.level.paperConfig.onlyPlayersCollide && !(entity instanceof Player)) return; // Paper
++                if (!this.level.paperConfig().collisions.allowVehicleCollisions && this.level.paperConfig().collisions.onlyPlayersCollide && !(entity instanceof Player)) return; // Paper
                  if (!this.hasPassenger(entity)) {
                      // CraftBukkit start
                      VehicleEntityCollisionEvent collisionEvent = new VehicleEntityCollisionEvent((Vehicle) this.getBukkitEntity(), entity.getBukkitEntity());
@@ -59,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void push(Entity entity) {
-+        if (!this.level.paperConfig.allowVehicleCollisions && this.level.paperConfig.onlyPlayersCollide && !(entity instanceof Player)) return; // Paper
++        if (!this.level.paperConfig().collisions.allowVehicleCollisions && this.level.paperConfig().collisions.onlyPlayersCollide && !(entity instanceof Player)) return; // Paper
          if (entity instanceof Boat) {
              if (entity.getBoundingBox().minY < this.getBoundingBox().maxY) {
                  // CraftBukkit start

patches/server/Config-option-for-Piglins-guarding-chests.patch

@@ -4,22 +4,6 @@ Date: Wed, 2 Dec 2020 03:07:58 -0800
 Subject: [PATCH] Config option for Piglins guarding chests
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         zombiesTargetTurtleEggs = getBoolean("zombies-target-turtle-eggs", zombiesTargetTurtleEggs);
-     }
- 
-+    public boolean piglinsGuardChests = true;
-+    private void piglinsGuardChests() {
-+        piglinsGuardChests = getBoolean("piglins-guard-chests", piglinsGuardChests);
-+    }
-+
-     public enum RedstoneImplementation {
-         VANILLA, EIGENCRAFT
-     }
 diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
@@ -28,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static void angerNearbyPiglins(Player player, boolean blockOpen) {
-+        if (!player.level.paperConfig.piglinsGuardChests) return; // Paper
++        if (!player.level.paperConfig().entities.behavior.piglinsGuardChests) return; // Paper
          List<Piglin> list = player.level.getEntitiesOfClass(Piglin.class, player.getBoundingBox().inflate(16.0D));
  
          list.stream().filter(PiglinAi::isIdle).filter((entitypiglin) -> {

patches/server/Configurable-Alternative-LootPool-Luck-Formula.patch

@@ -35,23 +35,6 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
@@ -69,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // This is vanilla
 +            float qualityModifer = (float) LootPoolSingletonContainer.this.quality * luck;
 +            double baseWeight = (LootPoolSingletonContainer.this.weight + qualityModifer);
-+            if (com.destroystokyo.paper.PaperConfig.useAlternativeLuckFormula) {
++            if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.useAlternativeLuckFormula) {
 +                // Random boost to avoid losing precision in the final int cast on return
 +                final int weightBoost = 100;
 +                baseWeight *= weightBoost;

patches/server/Configurable-Cartographer-Treasure-Maps.patch

@@ -8,48 +8,6 @@ Allow configuring for cartographers to return the same map location
 Also allow turning off treasure maps all together as they can eat up Map ID's
 which are limited in quantity.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             set("despawn-ranges.hard", null);
-         }
- 
-+        if (this.config.isSet("world-settings.default.treasure-maps-return-already-discovered") || this.config.isSet("world-settings." + worldName + ".treasure-maps-return-already-discovered")) {
-+            set("treasure-maps-return-already-discovered", null);
-+            needsSave = true;
-+        }
-+
-         if (needsSave) {
-             saveConfig();
-         }
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             Bukkit.getLogger().warning("Spawn Egg and Armor Stand NBT filtering disabled, this is a potential security risk");
-         }
-     }
-+
-+    public boolean enableTreasureMaps = true;
-+    public boolean treasureMapsAlreadyDiscoveredVillager = false;
-+    public Boolean treasureMapsAlreadyDiscoveredLootTable = null;
-+    private Boolean getBooleanOrNull(String path, Boolean defaultValue) {
-+        this.config.addDefault("world-settings.default." + path, defaultValue == null ? "default" : defaultValue);
-+        final Object value = this.config.get("world-settings." + worldName + "." + path, this.config.get("world-settings.default." + path));
-+        if (value instanceof Boolean bool) {
-+            return bool;
-+        }
-+        return null;
-+    }
-+    private void treasureMapsAlreadyDiscovered() {
-+        enableTreasureMaps = getBoolean("enable-treasure-maps", true);
-+        if (getBoolean("treasure-maps-return-already-discovered", false, false)) {
-+            treasureMapsAlreadyDiscoveredLootTable = true;
-+            treasureMapsAlreadyDiscoveredVillager = true;
-+        }
-+        treasureMapsAlreadyDiscoveredVillager = getBoolean("treasure-maps-find-already-discovered.villager-trade", treasureMapsAlreadyDiscoveredVillager);
-+        treasureMapsAlreadyDiscoveredLootTable = getBooleanOrNull("treasure-maps-find-already-discovered.loot-tables", treasureMapsAlreadyDiscoveredLootTable);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java b/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
@@ -59,8 +17,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              } else {
                  ServerLevel serverLevel = (ServerLevel)entity.level;
 -                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, true);
-+                if (!serverLevel.paperConfig.enableTreasureMaps) return null; // Paper
++                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) return null; // Paper
-+                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, !serverLevel.paperConfig.treasureMapsAlreadyDiscoveredVillager); // Paper
++                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, !serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredVillager); // Paper
                  if (blockPos != null) {
                      ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), (byte)2, true, true);
                      MapItem.renderBiomePreviewMap(serverLevel, itemStack);
@@ -74,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  ServerLevel serverLevel = context.getLevel();
 -                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, new BlockPos(vec3), this.searchRadius, this.skipKnownStructures);
 +                // Paper start
-+                if (!serverLevel.paperConfig.enableTreasureMaps) {
++                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) {
 +                    /*
 +                     * NOTE: I fear users will just get a plain map as their "treasure"
 +                     * This is preferable to disrespecting the config.
@@ -82,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    return stack;
 +                }
 +                // Paper end
-+                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, new BlockPos(vec3), this.searchRadius, serverLevel.paperConfig.treasureMapsAlreadyDiscoveredLootTable == null ? this.skipKnownStructures : serverLevel.paperConfig.treasureMapsAlreadyDiscoveredLootTable); // Paper
++                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, new BlockPos(vec3), this.searchRadius, serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredLootTable.or(this.skipKnownStructures)); // Paper
                  if (blockPos != null) {
                      ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), this.zoom, true, true);
                      MapItem.renderBiomePreviewMap(serverLevel, itemStack);

patches/server/Configurable-Chunk-Inhabited-Time.patch

@@ -10,25 +10,6 @@ For people who want all chunks to be treated equally, you can chose a fixed valu
 
 This allows to fine-tune vanilla gameplay.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             skeleHorseSpawnChance = 0.01D; // Vanilla value
-         }
-     }
-+
-+    public int fixedInhabitedTime;
-+    private void fixedInhabitedTime() {
-+        if (PaperConfig.version < 16) {
-+            if (!config.getBoolean("world-settings.default.use-chunk-inhabited-timer", true)) config.set("world-settings.default.fixed-chunk-inhabited-time", 0);
-+            if (!config.getBoolean("world-settings." + worldName + ".use-chunk-inhabited-timer", true)) config.set("world-settings." + worldName + ".fixed-chunk-inhabited-time", 0);
-+            set("use-chunk-inhabited-timer", null);
-+        }
-+        fixedInhabitedTime = getInt("fixed-chunk-inhabited-time", -1);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
@@ -40,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper start
 +    @Override
 +    public long getInhabitedTime() {
-+        return this.level.paperConfig.fixedInhabitedTime < 0 ? super.getInhabitedTime() : this.level.paperConfig.fixedInhabitedTime;
++        return this.level.paperConfig().chunks.fixedChunkInhabitedTime < 0 ? super.getInhabitedTime() : this.level.paperConfig().chunks.fixedChunkInhabitedTime;
 +    }
 +    // Paper end
 +

patches/server/Configurable-Disabling-Cat-Chest-Detection.patch

@@ -5,20 +5,6 @@ Subject: [PATCH] Configurable Disabling Cat Chest Detection
 
 Offers a gameplay feature to stop cats from blocking chests
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void containerUpdateTickRate() {
-         containerUpdateTickRate = getInt("container-update-tick-rate", 1);
-     }
-+
-+    public boolean disableChestCatDetection;
-+    private void disableChestCatDetection() {
-+        disableChestCatDetection = getBoolean("game-mechanics.disable-chest-cat-detection", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/block/ChestBlock.java b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
@@ -28,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      private static boolean isCatSittingOnChest(LevelAccessor world, BlockPos pos) {
 +        // Paper start - Option to disable chest cat detection
-+        if (((Level) world).paperConfig.disableChestCatDetection) {
++        if (world.getMinecraftWorld().paperConfig().entities.behavior.disableChestCatDetection) {
 +            return false;
 +        }
 +        // Paper end

patches/server/Configurable-Grass-Spread-Tick-Rate.patch

@@ -4,21 +4,6 @@ Date: Sun, 3 Apr 2016 16:28:17 -0400
 Subject: [PATCH] Configurable Grass Spread Tick Rate
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-         fixedInhabitedTime = getInt("fixed-chunk-inhabited-time", -1);
-     }
-+
-+    public int grassUpdateRate = 1;
-+    private void grassUpdateRate() {
-+        grassUpdateRate = Math.max(0, getInt("grass-spread-tick-rate", grassUpdateRate));
-+        log("Grass Spread Tick Rate: " + grassUpdateRate);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java b/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
@@ -35,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-+        if (this instanceof GrassBlock && world.paperConfig.grassUpdateRate != 1 && (world.paperConfig.grassUpdateRate < 1 || (MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig.grassUpdateRate != 0)) { return; } // Paper
++        if (this instanceof GrassBlock && world.paperConfig().tickRates.grassSpread != 1 && (world.paperConfig().tickRates.grassSpread < 1 || (MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig().tickRates.grassSpread != 0)) { return; } // Paper
          if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
              // CraftBukkit start
              if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {

patches/server/Configurable-Keep-Spawn-Loaded-range-per-world.patch

@@ -5,23 +5,6 @@ Subject: [PATCH] Configurable Keep Spawn Loaded range per world
 
 This lets you disable it for some worlds and lower it for others.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-     }
- 
-+    public short keepLoadedRange;
-+    private void keepLoadedRange() {
-+        keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
-+        log( "Keep Spawn Loaded Range: " + (keepLoadedRange/16));
-+    }
-+
-     private boolean getBoolean(String path, boolean def) {
-         return this.getBoolean(path, def, true);
-     }
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -55,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            }
 -        }
 +        // Paper start - configurable spawn reason
-+        int radiusBlocks = worldserver.paperConfig.keepLoadedRange;
++        int radiusBlocks = worldserver.paperConfig().spawn.keepSpawnLoadedRange;
 +        int radiusChunks = radiusBlocks / 16 + ((radiusBlocks & 15) != 0 ? 1 : 0);
 +        int totalChunks = ((radiusChunks) * 2 + 1);
 +        totalChunks *= totalChunks;
@@ -174,8 +157,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(pos), 11, Unit.INSTANCE);
 +        if (this.keepSpawnInMemory) {
 +            // if this keepSpawnInMemory is false a plugin has already removed our tickets, do not re-add
-+            this.removeTicketsForSpawn(this.paperConfig.keepLoadedRange, prevSpawn);
++            this.removeTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange, prevSpawn);
-+            this.addTicketsForSpawn(this.paperConfig.keepLoadedRange, pos);
++            this.addTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange, pos);
 +        }
          this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(pos, angle));
      }
@@ -235,12 +218,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          BlockPos chunkcoordinates = this.world.getSharedSpawnPos();
          if (keepLoaded) {
 -            this.world.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
-+            this.world.addTicketsForSpawn(this.world.paperConfig.keepLoadedRange, chunkcoordinates);
++            this.world.addTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange, chunkcoordinates);
          } else {
 -            // TODO: doesn't work well if spawn changed....
 -            this.world.getChunkSource().removeRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
 +            // TODO: doesn't work well if spawn changed.... // Paper - resolved
-+            this.world.removeTicketsForSpawn(this.world.paperConfig.keepLoadedRange, chunkcoordinates);
++            this.world.removeTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange, chunkcoordinates);
          }
 +        // Paper end
      }

patches/server/Configurable-Non-Player-Arrow-Despawn-Rate.patch

@@ -5,30 +5,6 @@ Subject: [PATCH] Configurable Non Player Arrow Despawn Rate
 
 Can set a much shorter despawn rate for arrows that players can not pick up.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void nonPlayerEntitiesOnScoreboards() {
-         nonPlayerEntitiesOnScoreboards = getBoolean("allow-non-player-entities-on-scoreboards", false);
-     }
-+
-+    public int nonPlayerArrowDespawnRate = -1;
-+    public int creativeArrowDespawnRate = -1;
-+    private void nonPlayerArrowDespawnRate() {
-+        nonPlayerArrowDespawnRate = getInt("non-player-arrow-despawn-rate", -1);
-+        if (nonPlayerArrowDespawnRate == -1) {
-+            nonPlayerArrowDespawnRate = spigotConfig.arrowDespawnRate;
-+        }
-+        creativeArrowDespawnRate = getInt("creative-arrow-despawn-rate", -1);
-+        if (creativeArrowDespawnRate == -1) {
-+            creativeArrowDespawnRate = spigotConfig.arrowDespawnRate;
-+        }
-+        log("Non Player Arrow Despawn Rate: " + nonPlayerArrowDespawnRate);
-+        log("Creative Arrow Despawn Rate: " + creativeArrowDespawnRate);
-+    }
- }
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
@@ -38,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      protected void tickDespawn() {
          ++this.life;
 -        if (this.life >= ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)) { // Spigot
-+        if (this.life >= (pickup == Pickup.CREATIVE_ONLY ? level.paperConfig.creativeArrowDespawnRate : (pickup == Pickup.DISALLOWED ? level.paperConfig.nonPlayerArrowDespawnRate : ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)))) { // Spigot // Paper - TODO: Extract this to init?
++        if (this.life >= (pickup == Pickup.CREATIVE_ONLY ? level.paperConfig().entities.spawning.creativeArrowDespawnRate.value() : (pickup == Pickup.DISALLOWED ? level.paperConfig().entities.spawning.nonPlayerArrowDespawnRate.value() : ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)))) { // Spigot // Paper - TODO: Extract this to init?
              this.discard();
          }
  

patches/server/Configurable-Player-Collision.patch

@@ -4,20 +4,6 @@ Date: Wed, 13 Apr 2016 02:10:49 -0400
 Subject: [PATCH] Configurable Player Collision
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void regionFileCacheSize() {
-         regionFileCacheSize = Math.max(getInt("settings.region-file-cache-size", 256), 4);
-     }
-+
-+    public static boolean enablePlayerCollisions = true;
-+    private static void enablePlayerCollisions() {
-+        enablePlayerCollisions = getBoolean("settings.enable-player-collisions", true);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              buf.writeByte(this.options);
              buf.writeUtf(this.nametagVisibility);
 -            buf.writeUtf(this.collisionRule);
-+            buf.writeUtf(!com.destroystokyo.paper.PaperConfig.enablePlayerCollisions ? "never" : this.collisionRule); // Paper
++            buf.writeUtf(!io.papermc.paper.configuration.GlobalConfiguration.get().collisions.enablePlayerCollisions ? "never" : this.collisionRule); // Paper
              buf.writeEnum(this.color);
              buf.writeComponent(this.playerPrefix);
              buf.writeComponent(this.playerSuffix);
@@ -35,28 +21,20 @@ diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.storage.loot.LootTables;
- import net.minecraft.world.level.storage.loot.PredicateManager;
- import net.minecraft.world.phys.Vec2;
- import net.minecraft.world.phys.Vec3;
-+import net.minecraft.world.scores.PlayerTeam; // Paper
- import org.apache.commons.lang3.Validate;
- import org.slf4j.Logger;
- 
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
              this.server.getPluginManager().callEvent(new org.bukkit.event.world.WorldLoadEvent(worldserver.getWorld()));
          }
  
 +        // Paper start - Handle collideRule team for player collision toggle
 +        final ServerScoreboard scoreboard = this.getScoreboard();
-+        final java.util.Collection<String> toRemove = scoreboard.getPlayerTeams().stream().filter(team -> team.getName().startsWith("collideRule_")).map(PlayerTeam::getName).collect(java.util.stream.Collectors.toList());
++        final java.util.Collection<String> toRemove = scoreboard.getPlayerTeams().stream().filter(team -> team.getName().startsWith("collideRule_")).map(net.minecraft.world.scores.PlayerTeam::getName).collect(java.util.stream.Collectors.toList());
 +        for (String teamName : toRemove) {
 +            scoreboard.removePlayerTeam(scoreboard.getPlayerTeam(teamName)); // Clean up after ourselves
 +        }
 +
-+        if (!com.destroystokyo.paper.PaperConfig.enablePlayerCollisions) {
++        if (!io.papermc.paper.configuration.GlobalConfiguration.get().collisions.enablePlayerCollisions) {
 +            this.getPlayerList().collideRuleTeamName = org.apache.commons.lang3.StringUtils.left("collideRule_" + java.util.concurrent.ThreadLocalRandom.current().nextInt(), 16);
-+            PlayerTeam collideTeam = scoreboard.addPlayerTeam(this.getPlayerList().collideRuleTeamName);
++            net.minecraft.world.scores.PlayerTeam collideTeam = scoreboard.addPlayerTeam(this.getPlayerList().collideRuleTeamName);
 +            collideTeam.setSeeFriendlyInvisibles(false); // Because we want to mimic them not being on a team at all
 +        }
 +        // Paper end

patches/server/Configurable-baby-zombie-movement-speed.patch

@@ -4,36 +4,15 @@ Date: Tue, 1 Mar 2016 13:09:16 -0600
 Subject: [PATCH] Configurable baby zombie movement speed
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         bambooMinHeight = getInt("max-growth-height.bamboo.min", 11);
-         log("Max height for cactus growth " + cactusMaxHeight + ". Max height for reed growth " + reedMaxHeight + ". Max height for bamboo growth " + bambooMaxHeight + ". Min height for fully-grown bamboo " + bambooMinHeight + ".");
-     }
-+
-+    public double babyZombieMovementModifier;
-+    private void babyZombieMovementModifier() {
-+        babyZombieMovementModifier = getDouble("baby-zombie-movement-modifier", 0.5D);
-+        if (PaperConfig.version < 20) {
-+            babyZombieMovementModifier = getDouble("baby-zombie-movement-speed", 0.5D);
-+            set("baby-zombie-movement-modifier", babyZombieMovementModifier);
-+        }
-+
-+        log("Baby zombies will move at the speed of " + babyZombieMovementModifier);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-@@ -0,0 +0,0 @@ import org.bukkit.event.entity.EntityTransformEvent;
+@@ -0,0 +0,0 @@ public class Zombie extends Monster {
- public class Zombie extends Monster {
  
      private static final UUID SPEED_MODIFIER_BABY_UUID = UUID.fromString("B9766B59-9566-4402-BC1F-2EE2A276D836");
--    private static final AttributeModifier SPEED_MODIFIER_BABY = new AttributeModifier(Zombie.SPEED_MODIFIER_BABY_UUID, "Baby speed boost", 0.5D, AttributeModifier.Operation.MULTIPLY_BASE);
+     private static final AttributeModifier SPEED_MODIFIER_BABY = new AttributeModifier(Zombie.SPEED_MODIFIER_BABY_UUID, "Baby speed boost", 0.5D, AttributeModifier.Operation.MULTIPLY_BASE);
-+    private final AttributeModifier SPEED_MODIFIER_BABY = new AttributeModifier(Zombie.SPEED_MODIFIER_BABY_UUID, "Baby speed boost", 0.5D, AttributeModifier.Operation.MULTIPLY_BASE); private final AttributeModifier babyModifier = this.SPEED_MODIFIER_BABY; // Paper - remove static - Make baby speed configurable
++    private final AttributeModifier babyModifier = new net.minecraft.world.entity.ai.attributes.AttributeModifier(SPEED_MODIFIER_BABY.getId(), SPEED_MODIFIER_BABY.getName(), this.level.paperConfig().entities.behavior.babyZombieMovementModifier, SPEED_MODIFIER_BABY.getOperation()); // Paper - Make baby speed configurable
      private static final EntityDataAccessor<Boolean> DATA_BABY_ID = SynchedEntityData.defineId(Zombie.class, EntityDataSerializers.BOOLEAN);
      private static final EntityDataAccessor<Integer> DATA_SPECIAL_TYPE_ID = SynchedEntityData.defineId(Zombie.class, EntityDataSerializers.INT);
      public static final EntityDataAccessor<Boolean> DATA_DROWNED_CONVERSION_ID = SynchedEntityData.defineId(Zombie.class, EntityDataSerializers.BOOLEAN);

patches/server/Configurable-cactus-bamboo-and-reed-growth-heights.patch

@@ -6,27 +6,6 @@ Subject: [PATCH] Configurable cactus bamboo and reed growth heights
 Bamboo - Both the minimum fully-grown heights and the maximum are configurable
 - Machine_Maker
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         config.addDefault("world-settings.default." + path, def.stream().map(Enum::name).collect(Collectors.toList()));
-         return ((List<String>) (config.getList("world-settings." + worldName + "." + path, config.getList("world-settings.default." + path)))).stream().map(s -> Enum.valueOf(type, s)).collect(Collectors.toList());
-     }
-+
-+    public int cactusMaxHeight;
-+    public int reedMaxHeight;
-+    public int bambooMaxHeight;
-+    public int bambooMinHeight;
-+    private void blockGrowthHeight() {
-+        cactusMaxHeight = getInt("max-growth-height.cactus", 3);
-+        reedMaxHeight = getInt("max-growth-height.reeds", 3);
-+        bambooMaxHeight = getInt("max-growth-height.bamboo.max", 16);
-+        bambooMinHeight = getInt("max-growth-height.bamboo.min", 11);
-+        log("Max height for cactus growth " + cactusMaxHeight + ". Max height for reed growth " + reedMaxHeight + ". Max height for bamboo growth " + bambooMaxHeight + ". Min height for fully-grown bamboo " + bambooMinHeight + ".");
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/block/BambooBlock.java b/src/main/java/net/minecraft/world/level/block/BambooBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/BambooBlock.java
@@ -36,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  int i = this.getHeightBelowUpToMax(world, pos) + 1;
  
 -                if (i < 16) {
-+                if (i < world.paperConfig.bambooMaxHeight) { // Paper
++                if (i < world.paperConfig().maxGrowthHeight.bamboo.max) { // Paper
                      this.growBamboo(state, world, pos, random, i);
                  }
              }
@@ -45,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          int j = this.getHeightBelowUpToMax(world, pos);
  
 -        return i + j + 1 < 16 && (Integer) world.getBlockState(pos.above(i)).getValue(BambooBlock.STAGE) != 1;
-+        return i + j + 1 < ((Level) world).paperConfig.bambooMaxHeight && (Integer) world.getBlockState(pos.above(i)).getValue(BambooBlock.STAGE) != 1; // Paper
++        return i + j + 1 < ((Level) world).paperConfig().maxGrowthHeight.bamboo.max && (Integer) world.getBlockState(pos.above(i)).getValue(BambooBlock.STAGE) != 1; // Paper
      }
  
      @Override
@@ -54,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              BlockState iblockdata1 = world.getBlockState(blockposition1);
  
 -            if (k >= 16 || !iblockdata1.is(Blocks.BAMBOO) || (Integer) iblockdata1.getValue(BambooBlock.STAGE) == 1 || !world.isEmptyBlock(blockposition1.above())) { // CraftBukkit - If the BlockSpreadEvent was cancelled, we have no bamboo here
-+            if (k >= world.paperConfig.bambooMaxHeight || !iblockdata1.is(Blocks.BAMBOO) || (Integer) iblockdata1.getValue(BambooBlock.STAGE) == 1 || !world.isEmptyBlock(blockposition1.above())) { // CraftBukkit - If the BlockSpreadEvent was cancelled, we have no bamboo here // Paper - Configurable cactus bamboo and reed growth heights
++            if (k >= world.paperConfig().maxGrowthHeight.bamboo.max || !iblockdata1.is(Blocks.BAMBOO) || (Integer) iblockdata1.getValue(BambooBlock.STAGE) == 1 || !world.isEmptyBlock(blockposition1.above())) { // CraftBukkit - If the BlockSpreadEvent was cancelled, we have no bamboo here // Paper - Configurable cactus bamboo and reed growth heights
                  return;
              }
  
@@ -63,7 +42,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          int j = (Integer) state.getValue(BambooBlock.AGE) != 1 && !iblockdata2.is(Blocks.BAMBOO) ? 0 : 1;
 -        int k = (height < 11 || random.nextFloat() >= 0.25F) && height != 15 ? 0 : 1;
-+        int k = (height < world.paperConfig.bambooMinHeight || random.nextFloat() >= 0.25F) && height != (world.paperConfig.bambooMaxHeight - 1) ? 0 : 1; // Paper
++        int k = (height < world.paperConfig().maxGrowthHeight.bamboo.min || random.nextFloat() >= 0.25F) && height != (world.paperConfig().maxGrowthHeight.bamboo.max - 1) ? 0 : 1; // Paper
  
          // CraftBukkit start
          if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, pos.above(), (BlockState) ((BlockState) ((BlockState) this.defaultBlockState().setValue(BambooBlock.AGE, j)).setValue(BambooBlock.LEAVES, blockpropertybamboosize)).setValue(BambooBlock.STAGE, k), 3)) {
@@ -72,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          int i;
  
 -        for (i = 0; i < 16 && world.getBlockState(pos.above(i + 1)).is(Blocks.BAMBOO); ++i) {
-+        for (i = 0; i < ((Level) world).paperConfig.bambooMaxHeight && world.getBlockState(pos.above(i + 1)).is(Blocks.BAMBOO); ++i) { // Paper
++        for (i = 0; i < ((Level) world).paperConfig().maxGrowthHeight.bamboo.max && world.getBlockState(pos.above(i + 1)).is(Blocks.BAMBOO); ++i) { // Paper
              ;
          }
  
@@ -81,7 +60,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          int i;
  
 -        for (i = 0; i < 16 && world.getBlockState(pos.below(i + 1)).is(Blocks.BAMBOO); ++i) {
-+        for (i = 0; i < ((Level) world).paperConfig.bambooMaxHeight && world.getBlockState(pos.below(i + 1)).is(Blocks.BAMBOO); ++i) { // Paper
++        for (i = 0; i < ((Level) world).paperConfig().maxGrowthHeight.bamboo.max && world.getBlockState(pos.below(i + 1)).is(Blocks.BAMBOO); ++i) { // Paper
              ;
          }
  
@@ -94,7 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            if (i < 3) {
-+            if (i < world.paperConfig.cactusMaxHeight) { // Paper - Configurable growth height
++            if (i < world.paperConfig().maxGrowthHeight.cactus) { // Paper - Configurable growth height
                  int j = (Integer) state.getValue(CactusBlock.AGE);
  
                  if (j >= (byte) range(3, ((100.0F / world.spigotConfig.cactusModifier) * 15) + 0.5F, 15)) { // Spigot
@@ -107,7 +86,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            if (i < 3) {
-+            if (i < world.paperConfig.reedMaxHeight) { // Paper - Configurable growth height
++            if (i < world.paperConfig().maxGrowthHeight.reeds) { // Paper - Configurable growth height
                  int j = (Integer) state.getValue(SugarCaneBlock.AGE);
  
                  if (j >= (byte) range(3, ((100.0F / world.spigotConfig.caneModifier) * 15) + 0.5F, 15)) { // Spigot

patches/server/Configurable-chance-of-villager-zombie-infection.patch

@@ -7,22 +7,6 @@ This allows you to solve an issue in vanilla behavior where:
 * On easy difficulty your villagers will NEVER get infected, meaning they will always die.
 * On normal difficulty they will have a 50% of getting infected or dying.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         nerfNetherPortalPigmen = getBoolean("game-mechanics.nerf-pigmen-from-nether-portals", nerfNetherPortalPigmen);
-     }
- 
-+    public double zombieVillagerInfectionChance = -1.0;
-+    private void zombieVillagerInfectionChance() {
-+        zombieVillagerInfectionChance = getDouble("zombie-villager-infection-chance", zombieVillagerInfectionChance);
-+    }
-+
-     public int lightQueueSize = 20;
-     private void lightQueueSize() {
-         lightQueueSize = getInt("light-queue-size", lightQueueSize);
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
@@ -34,11 +18,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if ((world.getDifficulty() == Difficulty.NORMAL || world.getDifficulty() == Difficulty.HARD) && other instanceof Villager) {
 -            if (world.getDifficulty() != Difficulty.HARD && this.random.nextBoolean()) {
 +        // Paper start
-+        if (level.paperConfig.zombieVillagerInfectionChance != 0.0 && (level.paperConfig.zombieVillagerInfectionChance != -1.0 || world.getDifficulty() == Difficulty.NORMAL || world.getDifficulty() == Difficulty.HARD) && other instanceof Villager) {
++        if (level.paperConfig().entities.behavior.zombieVillagerInfectionChance != 0.0 && (level.paperConfig().entities.behavior.zombieVillagerInfectionChance != -1.0 || world.getDifficulty() == Difficulty.NORMAL || world.getDifficulty() == Difficulty.HARD) && other instanceof Villager) {
-+            if (level.paperConfig.zombieVillagerInfectionChance == -1.0 && world.getDifficulty() != Difficulty.HARD && this.random.nextBoolean()) {
++            if (level.paperConfig().entities.behavior.zombieVillagerInfectionChance == -1.0 && world.getDifficulty() != Difficulty.HARD && this.random.nextBoolean()) {
                  return flag;
              }
-+            if (level.paperConfig.zombieVillagerInfectionChance != -1.0 && (this.random.nextDouble() * 100.0) > level.paperConfig.zombieVillagerInfectionChance) {
++            if (level.paperConfig().entities.behavior.zombieVillagerInfectionChance != -1.0 && (this.random.nextDouble() * 100.0) > level.paperConfig().entities.behavior.zombieVillagerInfectionChance) {
 +                return flag;
 +            } // Paper end
  

patches/server/Configurable-connection-throttle-kick-message.patch

@@ -4,22 +4,6 @@ Date: Tue, 2 Oct 2018 09:57:50 +0100
 Subject: [PATCH] Configurable connection throttle kick message
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         authenticationServersDownKickMessage = Strings.emptyToNull(getString("messages.kick.authentication-servers-down", authenticationServersDownKickMessage));
-     }
- 
-+    public static String connectionThrottleKickMessage = "Connection throttled! Please wait before reconnecting.";
-+    private static void connectionThrottleKickMessage() {
-+        connectionThrottleKickMessage = getString("messages.kick.connection-throttle", connectionThrottleKickMessage);
-+    }
-+
-     private static void savePlayerData() {
-         Object val = config.get("settings.save-player-data");
-         if (val instanceof Boolean) {
 diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
                              ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
 -                            MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
-+                            MutableComponent chatmessage = Component.literal(com.destroystokyo.paper.PaperConfig.connectionThrottleKickMessage); // Paper - Configurable connection throttle kick message
++                            MutableComponent chatmessage = Component.literal(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.connectionThrottle); // Paper - Configurable connection throttle kick message
                              this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
                              this.connection.disconnect(chatmessage);
                              return;

patches/server/Configurable-container-update-tick-rate.patch

@@ -4,20 +4,6 @@ Date: Wed, 2 Mar 2016 23:34:44 -0600
 Subject: [PATCH] Configurable container update tick rate
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void mobSpawnerTickRate() {
-         mobSpawnerTickRate = getInt("mob-spawner-tick-rate", 1);
-     }
-+
-+    public int containerUpdateTickRate;
-+    private void containerUpdateTickRate() {
-+        containerUpdateTickRate = getInt("container-update-tick-rate", 1);
-+    }
- }
 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
@@ -38,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start - Configurable container update tick rate
 +        if (--containerUpdateDelay <= 0) {
 +            this.containerMenu.broadcastChanges();
-+            containerUpdateDelay = level.paperConfig.containerUpdateTickRate;
++            containerUpdateDelay = level.paperConfig().tickRates.containerUpdate;
 +        }
 +        // Paper end
          if (!this.level.isClientSide && !this.containerMenu.stillValid(this)) {

patches/server/Configurable-door-breaking-difficulty.patch

@@ -5,38 +5,6 @@ Subject: [PATCH] Configurable door breaking difficulty
 
 Co-authored-by: Doc <nachito94@msn.com>
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableMobSpawnerSpawnEggTransformation() {
-         disableMobSpawnerSpawnEggTransformation = getBoolean("game-mechanics.disable-mob-spawner-spawn-egg-transformation", disableMobSpawnerSpawnEggTransformation);
-     }
-+    
-+    private final List<net.minecraft.world.entity.EntityType<?>> entitiesValidForBreakDoors = Arrays.asList(net.minecraft.world.entity.EntityType.ZOMBIE, net.minecraft.world.entity.EntityType.ZOMBIE_VILLAGER, net.minecraft.world.entity.EntityType.HUSK, net.minecraft.world.entity.EntityType.ZOMBIFIED_PIGLIN, net.minecraft.world.entity.EntityType.VINDICATOR);
-+    public java.util.Map<net.minecraft.world.entity.EntityType<?>, java.util.List<net.minecraft.world.Difficulty>> entitiesDifficultyBreakDoors = new it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap<>();
-+    private void setupEntityBreakingDoors() {
-+        for (net.minecraft.world.entity.EntityType<?> entityType : entitiesValidForBreakDoors) {
-+            java.util.function.Predicate<net.minecraft.world.Difficulty> difficultyPredicate = net.minecraft.world.entity.monster.Zombie.DOOR_BREAKING_PREDICATE;
-+            if (entityType == net.minecraft.world.entity.EntityType.VINDICATOR) {
-+                difficultyPredicate = net.minecraft.world.entity.monster.Vindicator.DOOR_BREAKING_PREDICATE;
-+            }
-+            entitiesDifficultyBreakDoors.put(
-+                entityType,
-+                getEnumList(
-+                    "door-breaking-difficulty." + entityType.id,
-+                    java.util.Arrays.stream(net.minecraft.world.Difficulty.values())
-+                        .filter(difficultyPredicate)
-+                        .collect(Collectors.toList()),
-+                    net.minecraft.world.Difficulty.class
-+                )
-+            );
-+        }
-+    }
- 
-     public short keepLoadedRange;
-     private void keepLoadedRange() {
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java
@@ -46,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      static class VindicatorBreakDoorGoal extends BreakDoorGoal {
          public VindicatorBreakDoorGoal(Mob mob) {
 -            super(mob, 6, Vindicator.DOOR_BREAKING_PREDICATE);
-+            super(mob, 6, com.google.common.base.Predicates.in(mob.level.paperConfig.entitiesDifficultyBreakDoors.getOrDefault(mob.getType(), mob.level.paperConfig.entitiesDifficultyBreakDoors.get(EntityType.VINDICATOR)))); // Paper
++            super(mob, 6, com.google.common.base.Predicates.in(mob.level.paperConfig().entities.behavior.doorBreakingDifficulty.getOrDefault(mob.getType(), mob.level.paperConfig().entities.behavior.doorBreakingDifficulty.get(EntityType.VINDICATOR)))); // Paper
              this.setFlags(EnumSet.of(Goal.Flag.MOVE));
          }
  
@@ -59,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public Zombie(EntityType<? extends Zombie> type, Level world) {
          super(type, world);
 -        this.breakDoorGoal = new BreakDoorGoal(this, Zombie.DOOR_BREAKING_PREDICATE);
-+        this.breakDoorGoal = new BreakDoorGoal(this, com.google.common.base.Predicates.in(world.paperConfig.entitiesDifficultyBreakDoors.getOrDefault(type, world.paperConfig.entitiesDifficultyBreakDoors.get(EntityType.ZOMBIE)))); // Paper
++        this.breakDoorGoal = new BreakDoorGoal(this, com.google.common.base.Predicates.in(world.paperConfig().entities.behavior.doorBreakingDifficulty.getOrDefault(type, world.paperConfig().entities.behavior.doorBreakingDifficulty.get(EntityType.ZOMBIE)))); // Paper
      }
  
      public Zombie(Level world) {

patches/server/Configurable-end-credits.patch

@@ -4,21 +4,6 @@ Date: Wed, 16 Mar 2016 02:21:39 -0500
 Subject: [PATCH] Configurable end credits
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             }
-         }
-     }
-+
-+    public boolean disableEndCredits;
-+    private void disableEndCredits() {
-+        disableEndCredits = getBoolean("game-mechanics.disable-end-credits", false);
-+        log("End credits disabled: " + disableEndCredits);
-+    }
- }
 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
@@ -27,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.unRide();
              this.getLevel().removePlayerImmediately(this, Entity.RemovalReason.CHANGED_DIMENSION);
              if (!this.wonGame) {
-+                if (level.paperConfig.disableEndCredits) this.seenCredits = true; // Paper - Toggle to always disable end credits
++                if (level.paperConfig().misc.disableEndCredits) this.seenCredits = true; // Paper - Toggle to always disable end credits
                  this.wonGame = true;
                  this.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.WIN_GAME, this.seenCredits ? 0.0F : 1.0F));
                  this.seenCredits = true;

patches/server/Configurable-feature-seeds.patch

@@ -18,66 +18,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  continue;
              }
              final Object val = config.get(key);
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         return table;
-     }
- 
-+    public it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<net.minecraft.resources.ResourceLocation> featureSeeds = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>();
-+    private void featureSeeds() {
-+        featureSeeds.defaultReturnValue(-1);
-+        final boolean randomise = getBoolean("feature-seeds.generate-random-seeds-for-all", false);
-+        final ConfigurationSection defaultSection = config.getConfigurationSection("world-settings.default.feature-seeds");
-+        final ConfigurationSection section = config.getConfigurationSection("world-settings." + worldName + ".feature-seeds");
-+        final net.minecraft.core.Registry<net.minecraft.world.level.levelgen.feature.ConfiguredFeature<?, ?>> registry
-+            = net.minecraft.server.MinecraftServer.getServer().registryAccess().registryOrThrow(net.minecraft.core.Registry.CONFIGURED_FEATURE_REGISTRY);
-+        if (section != null) {
-+            loadFeatureSeeds(section, registry);
-+        }
-+
-+        // Also use default set seeds if not already set per world
-+        loadFeatureSeeds(defaultSection, registry);
-+
-+        if (randomise) {
-+            final Map<String, Object> randomisedSeeds = new HashMap<>();
-+            final java.util.Random random = new java.security.SecureRandom();
-+            for (final net.minecraft.resources.ResourceLocation resourceLocation : registry.keySet()) {
-+                if (featureSeeds.containsKey(resourceLocation)) {
-+                    continue;
-+                }
-+
-+                final long seed = random.nextLong();
-+                randomisedSeeds.put("world-settings." + worldName + ".feature-seeds." + resourceLocation.getPath(), seed);
-+                featureSeeds.put(resourceLocation, seed);
-+            }
-+            if (!randomisedSeeds.isEmpty()) {
-+                config.addDefaults(randomisedSeeds);
-+            }
-+        }
-+    }
-+
-+    private void loadFeatureSeeds(final ConfigurationSection section, final net.minecraft.core.Registry<net.minecraft.world.level.levelgen.feature.ConfiguredFeature<?, ?>> registry) {
-+        for (final String key : section.getKeys(false)) {
-+            if (!(section.get(key) instanceof Number)) {
-+                continue;
-+            }
-+
-+            final net.minecraft.resources.ResourceLocation location = new net.minecraft.resources.ResourceLocation(key);
-+            if (!registry.containsKey(location)) {
-+                logError("Invalid feature resource location: " + location);
-+                continue;
-+            }
-+
-+            featureSeeds.putIfAbsent(location, section.getLong(key));
-+        }
-+    }
-+
-     public int getBehaviorTickRate(String typeName, String entityType, int def) {
-         return getIntOrDefault(behaviorTickRates, typeName, entityType, def);
-     }
 diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
@@ -99,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            // Paper start - change populationSeed used in random
 +                            long featurePopulationSeed = i;
 +                            final net.minecraft.resources.ResourceLocation location = iregistry1.getKey(placedfeature);
-+                            final long configFeatureSeed = generatoraccessseed.getMinecraftWorld().paperConfig.featureSeeds.getLong(location);
++                            final long configFeatureSeed = generatoraccessseed.getMinecraftWorld().paperConfig().featureSeeds.features.getLong(location); // TODO this wont work
 +                            if (configFeatureSeed != -1) {
 +                                featurePopulationSeed = seededrandom.setDecorationSeed(configFeatureSeed, blockposition.getX(), blockposition.getZ()); // See seededrandom.setDecorationSeed from above
 +                            }

patches/server/Configurable-fishing-time-ranges.patch

@@ -4,23 +4,6 @@ Date: Tue, 1 Mar 2016 13:14:11 -0600
 Subject: [PATCH] Configurable fishing time ranges
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
- 
-         log("Baby zombies will move at the speed of " + babyZombieMovementModifier);
-     }
-+
-+    public int fishingMinTicks;
-+    public int fishingMaxTicks;
-+    private void fishingTickRange() {
-+        fishingMinTicks = getInt("fishing-time-range.MinimumTicks", 100);
-+        fishingMaxTicks = getInt("fishing-time-range.MaximumTicks", 600);
-+        log("Fishing time ranges are between " + fishingMinTicks +" and " + fishingMaxTicks + " ticks");
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
@@ -30,8 +13,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.luck = Math.max(0, luckOfTheSeaLevel);
          this.lureSpeed = Math.max(0, lureLevel);
 +        // Paper start
-+        minWaitTime = world.paperConfig.fishingMinTicks;
++        minWaitTime = world.paperConfig().fishingTimeRange.minimum;
-+        maxWaitTime = world.paperConfig.fishingMaxTicks;
++        maxWaitTime = world.paperConfig().fishingTimeRange.maximum;
 +        // Paper end
      }
  

patches/server/Configurable-flying-kick-messages.patch

@@ -4,22 +4,6 @@ Date: Tue, 20 Sep 2016 00:58:01 +0000
 Subject: [PATCH] Configurable flying kick messages
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-         packetInSpamThreshold = getInt("settings.incoming-packet-spam-threshold", 300);
-     }
-+
-+    public static String flyingKickPlayerMessage = "Flying is not enabled on this server";
-+    public static String flyingKickVehicleMessage = "Flying is not enabled on this server";
-+    private static void flyingKickMessages() {
-+        flyingKickPlayerMessage = getString("messages.kick.flying-player", flyingKickPlayerMessage);
-+        flyingKickVehicleMessage = getString("messages.kick.flying-vehicle", flyingKickVehicleMessage);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (++this.aboveGroundTickCount > 80) {
                  ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating too long!", this.player.getName().getString());
 -                this.disconnect(Component.translatable("multiplayer.disconnect.flying"));
-+                this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickPlayerMessage); // Paper - use configurable kick message
++                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer); // Paper - use configurable kick message
                  return;
              }
          } else {
@@ -38,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (++this.aboveGroundVehicleTickCount > 80) {
                      ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating a vehicle too long!", this.player.getName().getString());
 -                    this.disconnect(Component.translatable("multiplayer.disconnect.flying"));
-+                    this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickVehicleMessage); // Paper - use configurable kick message
++                    this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingVehicle); // Paper - use configurable kick message
                      return;
                  }
              } else {

patches/server/Configurable-inter-world-teleportation-safety.patch

@@ -15,20 +15,6 @@ Example setup to perform the glitch: http://puu.sh/ng3PC/cf072dcbdb.png
 The wanted destination was on top of the emerald block however the player ended on top of the diamond block.
 This only is the case if the player is teleporting between worlds.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         portalCreateRadius = getInt("portal-create-radius", 16);
-         portalSearchVanillaDimensionScaling = getBoolean("portal-search-vanilla-dimension-scaling", true);
-     }
-+
-+    public boolean disableTeleportationSuffocationCheck;
-+    private void disableTeleportationSuffocationCheck() {
-+        disableTeleportationSuffocationCheck = getBoolean("disable-teleportation-suffocation-check", false);
-+    }
- }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
@@ -38,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              entity.connection.teleport(to);
          } else {
 -            server.getHandle().respawn(entity, toWorld, true, to, true);
-+            server.getHandle().respawn(entity, toWorld, true, to, !toWorld.paperConfig.disableTeleportationSuffocationCheck); // Paper
++            server.getHandle().respawn(entity, toWorld, true, to, !toWorld.paperConfig().environment.disableTeleportationSuffocationCheck); // Paper
          }
          return true;
      }

patches/server/Configurable-item-frame-map-cursor-update-interval.patch

@@ -4,22 +4,6 @@ Date: Fri, 13 Aug 2021 01:14:38 +0200
 Subject: [PATCH] Configurable item frame map cursor update interval
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit);
-     }
- 
-+    public int mapItemFrameCursorUpdateInterval = 10;
-+    private void itemFrameCursorUpdateInterval() {
-+        mapItemFrameCursorUpdateInterval = getInt("map-item-frame-cursor-update-interval", mapItemFrameCursorUpdateInterval);
-+    }
-+
-     public boolean fixItemsMergingThroughWalls;
-     private void fixItemsMergingThroughWalls() {
-         fixItemsMergingThroughWalls = getBoolean("fix-items-merging-through-walls", fixItemsMergingThroughWalls);
 diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerEntity.java
@@ -29,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  ItemStack itemstack = entityitemframe.getItem();
  
 -                if (this.tickCount % 10 == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks
-+                if (this.level.paperConfig.mapItemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig.mapItemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
++                if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
                      Integer integer = MapItem.getMapId(itemstack);
                      MapItemSavedData worldmap = MapItem.getSavedData(integer, this.level);
  

patches/server/Configurable-max-block-light-for-monster-spawning.patch

@@ -4,20 +4,6 @@ Date: Thu, 16 Dec 2021 09:40:39 +0100
 Subject: [PATCH] Configurable max block light for monster spawning
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         Integer rate = table.get(columnKey, rowKey);
-         return rate != null && rate > -1 ? rate : def;
-     }
-+
-+    public int maxBlockLightForMonsterSpawning = -1;
-+    private void minBlockLightForMobSpawning() {
-+        this.maxBlockLightForMonsterSpawning = getInt("monster-spawn-max-light-level", maxBlockLightForMonsterSpawning);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Monster.java b/src/main/java/net/minecraft/world/entity/monster/Monster.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Monster.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
              DimensionType dimensionType = world.dimensionType();
 -            int i = dimensionType.monsterSpawnBlockLightLimit();
-+            int i = world.getLevel().paperConfig.maxBlockLightForMonsterSpawning >= 0 ? world.getLevel().paperConfig.maxBlockLightForMonsterSpawning : dimensionType.monsterSpawnBlockLightLimit(); // Paper
++            int i = world.getLevel().paperConfig().entities.spawning.monsterSpawnMaxLightLevel >= 0 ? world.getLevel().paperConfig().entities.spawning.monsterSpawnMaxLightLevel : dimensionType.monsterSpawnBlockLightLimit(); // Paper
              if (i < 15 && world.getBrightness(LightLayer.BLOCK, pos) > i) {
                  return false;
              } else {

patches/server/Configurable-max-leash-distance.patch

@@ -4,23 +4,6 @@ Date: Sun, 3 Jan 2021 21:04:03 -0800
 Subject: [PATCH] Configurable max leash distance
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         }
-     }
- 
-+    public float maxLeashDistance = 10f;
-+    private void maxLeashDistance() {
-+        maxLeashDistance = getFloat("max-leash-distance", maxLeashDistance);
-+        log("Max leash distance: " + maxLeashDistance);
-+    }
-+
-     public boolean disableEndCredits;
-     private void disableEndCredits() {
-         disableEndCredits = getBoolean("game-mechanics.disable-end-credits", false);
 diff --git a/src/main/java/net/minecraft/world/entity/PathfinderMob.java b/src/main/java/net/minecraft/world/entity/PathfinderMob.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/PathfinderMob.java
@@ -30,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              if (this instanceof TamableAnimal && ((TamableAnimal) this).isInSittingPose()) {
 -                if (f > 10.0F) {
-+                if (f > entity.level.paperConfig.maxLeashDistance) { // Paper
++                if (f > entity.level.paperConfig().misc.maxLeashDistance) { // Paper
                      this.level.getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
                      this.dropLeash(true, true);
                  }
@@ -39,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              this.onLeashDistance(f);
 -            if (f > 10.0F) {
-+            if (f > entity.level.paperConfig.maxLeashDistance) { // Paper
++            if (f > entity.level.paperConfig().misc.maxLeashDistance) { // Paper
                  this.level.getCraftServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
                  this.dropLeash(true, true);
                  this.goalSelector.disableControlFlag(Goal.Flag.MOVE);

patches/server/Configurable-mob-spawner-tick-rate.patch

@@ -4,20 +4,6 @@ Date: Wed, 2 Mar 2016 15:03:53 -0600
 Subject: [PATCH] Configurable mob spawner tick rate
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableIceAndSnow(){
-         disableIceAndSnow = getBoolean("disable-ice-and-snow", false);
-     }
-+
-+    public int mobSpawnerTickRate;
-+    private void mobSpawnerTickRate() {
-+        mobSpawnerTickRate = getInt("mob-spawner-tick-rate", 1);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
@@ -36,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void serverTick(ServerLevel world, BlockPos pos) {
 +        // Paper start - Configurable mob spawner tick rate
 +        if (spawnDelay > 0 && --tickDelay > 0) return;
-+        tickDelay = world.paperConfig.mobSpawnerTickRate;
++        tickDelay = world.paperConfig().tickRates.mobSpawner;
 +        if (tickDelay == -1) { return; } // If disabled
 +        // Paper end
          if (this.isNearPlayer(world, pos)) {

patches/server/Configurable-packet-in-spam-threshold.patch

@@ -4,24 +4,6 @@ Date: Sun, 11 Sep 2016 14:30:57 -0500
 Subject: [PATCH] Configurable packet in spam threshold
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     public static boolean isProxyOnlineMode() {
-         return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode);
-     }
-+
-+    public static int packetInSpamThreshold = 300;
-+    private static void packetInSpamThreshold() {
-+        if (version < 11) {
-+            int oldValue = getInt("settings.play-in-use-item-spam-threshold", 300);
-+            set("settings.incoming-packet-spam-threshold", oldValue);
-+        }
-+        packetInSpamThreshold = getInt("settings.incoming-packet-spam-threshold", 300);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
@@ -30,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Spigot start - limit place/interactions
      private int limitedPackets;
      private long lastLimitedPacket = -1;
-+    private static final int THRESHOLD = com.destroystokyo.paper.PaperConfig.packetInSpamThreshold; // Paper - Configurable threshold
++    private static final int THRESHOLD = io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.incomingPacketThreshold; // Paper - Configurable threshold
  
      private boolean checkLimit(long timestamp) {
 -        if (this.lastLimitedPacket != -1 && timestamp - this.lastLimitedPacket < 30 && this.limitedPackets++ >= 4) {

patches/server/Configurable-projectile-relative-velocity.patch

@@ -24,21 +24,6 @@ efficient as just not applying the velocity in the first place.
 P3) Solutions for 1) and especially 2) might not be future-proof, while this
 server-internal fix makes this change future-proof.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             log("Using improved mob spawn limits (Only Natural Spawns impact spawn limits for more natural spawns)");
-         }
-     }
-+
-+    public boolean disableRelativeProjectileVelocity;
-+    private void disableRelativeProjectileVelocity() {
-+        disableRelativeProjectileVelocity = getBoolean("game-mechanics.disable-relative-projectile-velocity", false);
-+    }
- }
- 
 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
 --- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
@@ -48,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          Vec3 vec3d = shooter.getDeltaMovement();
  
 -        this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z));
-+        if (!shooter.level.paperConfig.disableRelativeProjectileVelocity) this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z)); // Paper - allow disabling relative velocity
++        if (!shooter.level.paperConfig().misc.disableRelativeProjectileVelocity) this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z)); // Paper - allow disabling relative velocity
      }
  
      // CraftBukkit start - call projectile hit event

patches/server/Configurable-spawn-chances-for-skeleton-horses.patch

@@ -4,23 +4,6 @@ Date: Tue, 22 Mar 2016 12:04:28 -0500
 Subject: [PATCH] Configurable spawn chances for skeleton horses
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         log("Non Player Arrow Despawn Rate: " + nonPlayerArrowDespawnRate);
-         log("Creative Arrow Despawn Rate: " + creativeArrowDespawnRate);
-     }
-+
-+    public double skeleHorseSpawnChance;
-+    private void skeleHorseSpawnChance() {
-+        skeleHorseSpawnChance = getDouble("skeleton-horse-thunder-spawn-chance", 0.01D);
-+        if (skeleHorseSpawnChance < 0) {
-+            skeleHorseSpawnChance = 0.01D; // Vanilla value
-+        }
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -30,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (this.isRainingAt(blockposition)) {
                  DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
 -                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * 0.01D && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD);
-+                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * paperConfig.skeleHorseSpawnChance && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
++                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * this.paperConfig().entities.spawning.skeletonHorseThunderSpawnChance.or(0.01D) && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
  
                  if (flag1) {
                      SkeletonHorse entityhorseskeleton = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);

patches/server/Configurable-speed-for-water-flowing-over-lava.patch

@@ -4,33 +4,10 @@ Date: Wed, 8 Aug 2018 16:33:21 -0600
 Subject: [PATCH] Configurable speed for water flowing over lava
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         this.armorStandTick = this.getBoolean("armor-stands-tick", this.armorStandTick);
-         log("ArmorStand ticking is " + (this.armorStandTick ? "enabled" : "disabled") + " by default");
-     }
-+
-+    public int waterOverLavaFlowSpeed;
-+    private void waterOverLavaFlowSpeed() {
-+        waterOverLavaFlowSpeed = getInt("water-over-lava-flow-speed", 5);
-+        log("Water over lava flow speed: " + waterOverLavaFlowSpeed);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.block.state.properties.BlockStateProperties;
- import net.minecraft.world.level.block.state.properties.IntegerProperty;
- import net.minecraft.world.level.material.FlowingFluid;
- import net.minecraft.world.level.material.FluidState;
-+import net.minecraft.world.level.material.Material;
- import net.minecraft.world.level.pathfinder.PathComputationType;
- import net.minecraft.world.level.storage.loot.LootContext;
- import net.minecraft.world.phys.shapes.CollisionContext;
 @@ -0,0 +0,0 @@ public class LiquidBlock extends Block implements BucketPickup {
      @Override
      public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
@@ -43,14 +20,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +    // Paper start - Get flow speed. Throttle if its water and flowing adjacent to lava
 +    public int getFlowSpeed(Level world, BlockPos blockposition) {
-+        if (this.material == Material.WATER) {
++        if (this.material == net.minecraft.world.level.material.Material.WATER) {
 +            if (
-+                world.getMaterialIfLoaded(blockposition.north(1)) == Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.north(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.south(1)) == Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.south(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.west(1)) == Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.west(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.east(1)) == Material.LAVA
++                world.getMaterialIfLoaded(blockposition.east(1)) == net.minecraft.world.level.material.Material.LAVA
 +            ) {
-+                return world.paperConfig.waterOverLavaFlowSpeed;
++                return world.paperConfig().environment.waterOverLavaFlowSpeed;
 +            }
 +        }
 +        return this.fluid.getTickDelay(world);

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

@@ -5,20 +5,6 @@ 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         disableCreeperLingeringEffect = getBoolean("disable-creeper-lingering-effect", false);
-         log("Creeper lingering effect: " + disableCreeperLingeringEffect);
-     }
-+
-+    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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
@@ -29,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                              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) {
++                            if (!level.paperConfig().misc.disableSprintInterruptionOnAttack) {
 +                                this.setSprinting(false);
 +                            }
 +                            // Paper end

patches/server/Configurable-top-of-nether-void-damage.patch

@@ -4,30 +4,6 @@ Date: Tue, 1 Mar 2016 23:58:50 -0600
 Subject: [PATCH] Configurable top of nether void damage
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         if (fallingBlockHeightNerf != 0) log("Falling Block Height Limit set to Y: " + fallingBlockHeightNerf);
-         if (entityTNTHeightNerf != 0) log("TNT Entity Height Limit set to Y: " + entityTNTHeightNerf);
-     }
-+
-+    public int netherVoidTopDamageHeight;
-+    public boolean doNetherTopVoidDamage() { return netherVoidTopDamageHeight > 0; }
-+    private void netherVoidTopDamageHeight() {
-+        netherVoidTopDamageHeight = getInt("nether-ceiling-void-damage-height", 0);
-+        log("Top of the nether void damage height: " + netherVoidTopDamageHeight);
-+
-+        if (PaperConfig.version < 18) {
-+            boolean legacy = getBoolean("nether-ceiling-void-damage", false);
-+            if (legacy) {
-+                netherVoidTopDamageHeight = 128;
-+                set("nether-ceiling-void-damage-height", netherVoidTopDamageHeight);
-+            }
-+        }
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -39,8 +15,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if (this.getY() < (double) (this.level.getMinBuildHeight() - 64)) {
 +        // Paper start - Configurable nether ceiling damage
 +        if (this.getY() < (double) (this.level.getMinBuildHeight() - 64) || (this.level.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER
-+            && level.paperConfig.doNetherTopVoidDamage()
++            && level.paperConfig().environment.netherCeilingVoidDamageHeight > 0
-+            && this.getY() >= this.level.paperConfig.netherVoidTopDamageHeight)) {
++            && this.getY() >= this.level.paperConfig().environment.netherCeilingVoidDamageHeight)) {
 +            // Paper end
              this.outOfWorld();
          }

patches/server/Default-loading-permissions.yml-before-plugins.patch

@@ -15,20 +15,6 @@ modify that. Under the previous logic, plugins were unable (cleanly) override pe
 
 A config option has been added for those who depend on the previous behavior, but I don't expect that.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-                 " - Length: " + timeSummary(Timings.getHistoryLength() / 20) +
-                 " - Server Name: " + timingsServerName);
-     }
-+
-+    public static boolean loadPermsBeforePlugins = true;
-+    private static void loadPermsBeforePlugins() {
-+        loadPermsBeforePlugins = getBoolean("settings.load-permissions-yml-before-plugins", true);
-+    }
- }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -37,7 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (type == PluginLoadOrder.STARTUP) {
              this.helpMap.clear();
              this.helpMap.initializeGeneralTopics();
-+            if (com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions(); // Paper
++            if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions(); // Paper
          }
  
          Plugin[] plugins = this.pluginManager.getPlugins();
@@ -46,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              DefaultPermissions.registerCorePermissions();
              CraftDefaultPermissions.registerCorePermissions();
 -            this.loadCustomPermissions();
-+            if (!com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) this.loadCustomPermissions(); // Paper
++            if (!io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) this.loadCustomPermissions(); // Paper
              this.helpMap.initializeCommands();
              this.syncCommands();
          }

patches/server/Delay-Chunk-Unloads-based-on-Player-Movement.patch

@@ -16,24 +16,6 @@ before it actually unloads, which will be handled by the ticket expiry process.
 This allows servers with smaller worlds who do less long distance exploring to stop
 wasting cpu cycles on saving/unloading/reloading chunks repeatedly.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         expMergeMaxValue = getInt("experience-merge-max-value", -1);
-         log("Experience Merge Max Value: " + expMergeMaxValue);
-     }
-+
-+    public long delayChunkUnloadsBy;
-+    private void delayChunkUnloadsBy() {
-+        delayChunkUnloadsBy = PaperConfig.getSeconds(getString("delay-chunk-unloads-by", "10s"));
-+        if (delayChunkUnloadsBy > 0) {
-+            log("Delaying chunk unloads by " + delayChunkUnloadsBy + " seconds");
-+            delayChunkUnloadsBy *= 20;
-+        }
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/level/DistanceManager.java b/src/main/java/net/minecraft/server/level/DistanceManager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/DistanceManager.java
@@ -43,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (arraysetsorted.remove(ticket)) {
              removed = true; // CraftBukkit
 +            // Paper start - delay chunk unloads for player tickets
-+            long delayChunkUnloadsBy = chunkMap.level.paperConfig.delayChunkUnloadsBy;
++            long delayChunkUnloadsBy = chunkMap.level.paperConfig().chunks.delayChunkUnloadsBy.ticks();
 +            if (ticket.getType() == TicketType.PLAYER && delayChunkUnloadsBy > 0) {
 +                boolean hasPlayer = false;
 +                for (Ticket<?> ticket1 : arraysetsorted) {

patches/server/Deobfuscate-stacktraces-in-log-messages-crash-report.patch

@@ -24,15 +24,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end
      implementation("org.apache.logging.log4j:log4j-iostreams:2.17.1") // Paper
      implementation("org.ow2.asm:asm:9.3")
-@@ -0,0 +0,0 @@ dependencies {
+     implementation("org.ow2.asm:asm-commons:9.3") // Paper - ASM event executor generation
-     runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.7.3")
+     implementation("org.spongepowered:configurate-yaml:4.1.2") // Paper - config files
-     runtimeOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.7.3")
+     implementation("commons-lang:commons-lang:2.6")
- 
 +    implementation("net.fabricmc:mapping-io:0.3.0") // Paper - needed to read mappings for stacktrace deobfuscation
-+
+     runtimeOnly("org.xerial:sqlite-jdbc:3.36.0.3")
-     testImplementation("junit:junit:4.13.2")
+     runtimeOnly("mysql:mysql-connector-java:8.0.29")
-     testImplementation("org.hamcrest:hamcrest-library:1.3")
+     runtimeOnly("com.lmax:disruptor:3.4.4") // Paper
- }
 @@ -0,0 +0,0 @@ tasks.shadowJar {
      }
  }
@@ -79,20 +77,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  tasks.test {
      exclude("org/bukkit/craftbukkit/inventory/ItemStack*Test.class")
  }
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-             log("Async Chunks: Enabled - Chunks will be loaded much faster, without lag.");
-         }
-     }
-+
-+    public static boolean deobfuscateStacktraces = true;
-+    private static void loggerSettings() {
-+        deobfuscateStacktraces = getBoolean("settings.loggers.deobfuscate-stacktraces", deobfuscateStacktraces);
-+    }
- }
 diff --git a/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java b/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
@@ -310,7 +294,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.util;
 +
-+import com.destroystokyo.paper.PaperConfig;
++import io.papermc.paper.configuration.GlobalConfiguration;
 +import it.unimi.dsi.fastutil.ints.IntArrayList;
 +import it.unimi.dsi.fastutil.ints.IntList;
 +import java.io.IOException;
@@ -340,7 +324,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    });
 +
 +    public void deobfuscateThrowable(final Throwable throwable) {
-+        if (!PaperConfig.deobfuscateStacktraces) {
++        if (GlobalConfiguration.get() != null && !GlobalConfiguration.get().logging.deobfuscateStacktraces) { // handle null as true
 +            return;
 +        }
 +
@@ -355,7 +339,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    public StackTraceElement[] deobfuscateStacktrace(final StackTraceElement[] traceElements) {
-+        if (!PaperConfig.deobfuscateStacktraces) {
++        if (GlobalConfiguration.get() != null && !GlobalConfiguration.get().logging.deobfuscateStacktraces) { // handle null as true
 +            return traceElements;
 +        }
 +
@@ -556,13 +540,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         }
+         org.spigotmc.SpigotConfig.registerCommands();
-         com.destroystokyo.paper.PaperConfig.registerCommands();
+         // Spigot end
-         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // load version history now
+         // Paper start
-+        io.papermc.paper.util.ObfHelper.INSTANCE.getClass(); // load mappings for stacktrace deobf and etc.
++        io.papermc.paper.util.ObfHelper.INSTANCE.getClass(); // Paper - load mappings for stacktrace deobf and etc.
-         // Paper end
+         paperConfigurations.initializeGlobalConfiguration();
- 
+         paperConfigurations.initializeWorldDefaultsConfiguration();
-         this.setPvpAllowed(dedicatedserverproperties.pvp);
+         org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash);
 diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java

patches/server/Disable-Scoreboards-for-non-players-by-default.patch

@@ -10,20 +10,6 @@ this setting.
 So avoid looking up scoreboards and short circuit to the "not on a team"
 logic which is most likely to be true.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableTeleportationSuffocationCheck() {
-         disableTeleportationSuffocationCheck = getBoolean("disable-teleportation-suffocation-check", false);
-     }
-+
-+    public boolean nonPlayerEntitiesOnScoreboards = false;
-+    private void nonPlayerEntitiesOnScoreboards() {
-+        nonPlayerEntitiesOnScoreboards = getBoolean("allow-non-player-entities-on-scoreboards", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -32,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Nullable
      public Team getTeam() {
-+        if (!this.level.paperConfig.nonPlayerEntitiesOnScoreboards && !(this instanceof Player)) { return null; } // Paper
++        if (!this.level.paperConfig().scoreboards.allowNonPlayerEntitiesOnScoreboards && !(this instanceof Player)) { return null; } // Paper
          return this.level.getScoreboard().getPlayersTeam(this.getScoreboardName());
      }
  
@@ -44,7 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (nbt.contains("Team", 8)) {
              String s = nbt.getString("Team");
              PlayerTeam scoreboardteam = this.level.getScoreboard().getPlayerTeam(s);
-+            if (!level.paperConfig.nonPlayerEntitiesOnScoreboards && !(this instanceof net.minecraft.world.entity.player.Player)) { scoreboardteam = null; } // Paper
++            if (!level.paperConfig().scoreboards.allowNonPlayerEntitiesOnScoreboards && !(this instanceof net.minecraft.world.entity.player.Player)) { scoreboardteam = null; } // Paper
              boolean flag = scoreboardteam != null && this.level.getScoreboard().addPlayerToTeam(this.getStringUUID(), scoreboardteam);
  
              if (!flag) {

patches/server/Disable-component-selector-resolving-in-books-by-def.patch

@@ -4,20 +4,6 @@ Date: Thu, 2 Jun 2022 20:35:58 +0200
 Subject: [PATCH] Disable component selector resolving in books by default
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void useProxyProtocol() {
-         useProxyProtocol = getBoolean("settings.proxy-protocol", false);
-     }
-+
-+    public static boolean resolveSelectorsInBooks;
-+    private static void resolveSelectorsInBooks() {
-+        resolveSelectorsInBooks = getBoolean("settings.resolve-selectors-in-books", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/item/WrittenBookItem.java b/src/main/java/net/minecraft/world/item/WrittenBookItem.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/WrittenBookItem.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static boolean resolveBookComponents(ItemStack book, @Nullable CommandSourceStack commandSource, @Nullable Player player) {
          CompoundTag compoundTag = book.getTag();
 -        if (compoundTag != null && !compoundTag.getBoolean("resolved")) {
-+        if (com.destroystokyo.paper.PaperConfig.resolveSelectorsInBooks && compoundTag != null && !compoundTag.getBoolean("resolved")) { // Paper
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.resolveSelectorsInBooks && compoundTag != null && !compoundTag.getBoolean("resolved")) { // Paper
              compoundTag.putBoolean("resolved", true);
              if (!makeSureTagIsValid(compoundTag)) {
                  return false;

patches/server/Disable-explosion-knockback.patch

@@ -4,20 +4,6 @@ Date: Wed, 2 Mar 2016 14:48:03 -0600
 Subject: [PATCH] Disable explosion knockback
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         optimizeExplosions = getBoolean("optimize-explosions", false);
-         log("Optimize explosions: " + optimizeExplosions);
-     }
-+
-+    public boolean disableExplosionKnockback;
-+    private void disableExplosionKnockback(){
-+        disableExplosionKnockback = getBoolean("disable-explosion-knockback", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
@@ -26,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
              }
  
-+            boolean knockbackCancelled = level.paperConfig.disableExplosionKnockback && source.isExplosion() && this instanceof net.minecraft.world.entity.player.Player; // Paper - Disable explosion knockback
++            boolean knockbackCancelled = level.paperConfig().environment.disableExplosionKnockback && source.isExplosion() && this instanceof net.minecraft.world.entity.player.Player; // Paper - Disable explosion knockback
              if (flag1) {
                  if (flag) {
                      this.level.broadcastEntityEvent(this, (byte) 29);
@@ -55,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                          if (entity instanceof LivingEntity) {
 -                            d14 = ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity) entity, d13);
-+                            d14 = entity instanceof Player && level.paperConfig.disableExplosionKnockback ? 0 : ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity) entity, d13); // Paper - Disable explosion knockback
++                            d14 = entity instanceof Player && level.paperConfig().environment.disableExplosionKnockback ? 0 : ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity) entity, d13); // Paper - Disable explosion knockback
                          }
  
                          entity.setDeltaMovement(entity.getDeltaMovement().add(d8 * d14, d9 * d14, d10 * d14));
@@ -63,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                              Player entityhuman = (Player) entity;
  
 -                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.getAbilities().flying)) {
-+                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.getAbilities().flying) && !level.paperConfig.disableExplosionKnockback) { // Paper - Disable explosion knockback
++                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.getAbilities().flying) && !level.paperConfig().environment.disableExplosionKnockback) { // Paper - Disable explosion knockback
                                  this.hitPlayers.put(entityhuman, new Vec3(d8 * d13, d9 * d13, d10 * d13));
                              }
                          }

patches/server/Disable-ice-and-snow.patch

@@ -4,20 +4,6 @@ Date: Wed, 2 Mar 2016 14:57:24 -0600
 Subject: [PATCH] Disable ice and snow
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableThunder() {
-         disableThunder = getBoolean("disable-thunder", false);
-     }
-+
-+    public boolean disableIceAndSnow;
-+    private void disableIceAndSnow(){
-+        disableIceAndSnow = getBoolean("disable-ice-and-snow", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          gameprofilerfiller.popPush("iceandsnow");
 -        if (this.random.nextInt(16) == 0) {
-+        if (!this.paperConfig.disableIceAndSnow && this.random.nextInt(16) == 0) { // Paper - Disable ice and snow
++        if (!this.paperConfig().environment.disableIceAndSnow && this.random.nextInt(16) == 0) { // Paper - Disable ice and snow
              blockposition = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, this.getBlockRandomPos(j, 0, k, 15));
              BlockPos blockposition1 = blockposition.below();
              Biome biomebase = (Biome) this.getBiome(blockposition).value();

patches/server/Disable-thunder.patch

@@ -4,20 +4,6 @@ Date: Wed, 2 Mar 2016 14:52:43 -0600
 Subject: [PATCH] Disable thunder
 
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void disableExplosionKnockback(){
-         disableExplosionKnockback = getBoolean("disable-explosion-knockback", false);
-     }
-+
-+    public boolean disableThunder;
-+    private void disableThunder() {
-+        disableThunder = getBoolean("disable-thunder", false);
-+    }
- }
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
@@ -27,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          BlockPos blockposition;
  
 -        if (flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot
-+        if (!this.paperConfig.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder
++        if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder
              blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
              if (this.isRainingAt(blockposition)) {
                  DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);

patches/server/Distance-manager-tick-timings.patch

@@ -37,4 +37,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        } finally { co.aikar.timings.MinecraftTimings.distanceManagerTick.stopTiming(); } // Paper - add timings for distance manager
      }
  
-     // Paper start - helper
+     // Paper start

patches/server/Don-t-apply-cramming-damage-to-players.patch

@@ -10,20 +10,6 @@ It does not make a lot of sense to damage players if they get crammed,
 
 For those who really want it a config option is provided.
 
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void showSignClickCommandFailureMessagesToPlayer() {
-         showSignClickCommandFailureMessagesToPlayer = getBoolean("show-sign-click-command-failure-msgs-to-player", showSignClickCommandFailureMessagesToPlayer);
-     }
-+
-+    public boolean allowPlayerCrammingDamage = false;
-+    private void playerCrammingDamage() {
-+        allowPlayerCrammingDamage = getBoolean("allow-player-cramming-damage", allowPlayerCrammingDamage);
-+    }
- }
 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
@@ -33,7 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean isInvulnerableTo(DamageSource damageSource) {
 -        return super.isInvulnerableTo(damageSource) || this.isChangingDimension() || this.getAbilities().invulnerable && damageSource == DamageSource.WITHER;
-+        return super.isInvulnerableTo(damageSource) || this.isChangingDimension() || this.getAbilities().invulnerable && damageSource == DamageSource.WITHER || !level.paperConfig.allowPlayerCrammingDamage && damageSource == DamageSource.CRAMMING; // Paper - disable player cramming
++        return super.isInvulnerableTo(damageSource) || this.isChangingDimension() || this.getAbilities().invulnerable && damageSource == DamageSource.WITHER || !level.paperConfig().collisions.allowPlayerCrammingDamage && damageSource == DamageSource.CRAMMING; // Paper - disable player cramming
      }
  
      @Override