Too many nullchecks, idot

build.gradle.kts

@@ -78,7 +78,6 @@ tasks.generateDevelopmentBundle {
     libraryRepositories.set(
         listOf(
             "https://repo.maven.apache.org/maven2/",
-            "https://ysera.dyndns.org:444/releases", // This should be a repo hosting your API (in this example, 'com.example.paperfork:slice-api'),
             paperMavenPublicUrl
         )
     )
@@ -90,9 +89,8 @@ allprojects {
     publishing {
         repositories {
             maven {
-                name = "Ysera"
+                name = "jitpack"
-                url = uri("https://ysera.dyndns.org:444/releases")
+                url = uri("https://jitpack.io")
-                // See Gradle docs for how to provide credentials to PasswordCredentials
                 // https://docs.gradle.org/current/samples/sample_publishing_credentials.html
                 credentials(PasswordCredentials::class)
             }

patches/api/0006-World-Instance-flag.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] World Instance flag
 
 
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 340f3e569a411e7603fba8d38b79446da0ab4a93..dbb8718e7e62135dc05315be3db01d1a037c1f78 100644
+index d4c60cf8404641fa8580cb0653e6f7a10baed865..fde06c5d88ffb63910bcb06e3e70e3c0a4af92c7 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
-@@ -2600,6 +2600,11 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+@@ -2602,6 +2602,11 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
       */
      public void setAutoSave(boolean value);
  

patches/api/0011-Equipment-Packet-Caching.patch

@@ -0,0 +1,149 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 3 Oct 2022 08:17:50 -0500
+Subject: [PATCH] Equipment Packet Caching
+
+
+diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
+index 31353bd20404a8c2acf6bf0df524dc3cae324272..1a4309bcb529e4ca5cb3bf75e0bf3e65003a8006 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -910,4 +910,11 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+      */
+     void setHurtDirection(float hurtDirection);
+     // Paper end
++
++    // Slice start
++    /**
++     * @param p The player to send this entity's equipment packet to
++     */
++    void sendEquipment(Player p);
++    // Slice end
+ }
+diff --git a/src/main/java/org/bukkit/event/entity/EntityEquipmentItemLookup.java b/src/main/java/org/bukkit/event/entity/EntityEquipmentItemLookup.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6c329ca3c22d1fd712041334c5c1e7bd7e7201ac
+--- /dev/null
++++ b/src/main/java/org/bukkit/event/entity/EntityEquipmentItemLookup.java
+@@ -0,0 +1,54 @@
++package org.bukkit.event.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.event.HandlerList;
++import org.bukkit.inventory.EquipmentSlot;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when requesting a cached equipment item lookup
++ */
++public class EntityEquipmentItemLookup extends EntityEvent {
++    private static final HandlerList handlers = new HandlerList();
++    private final String tag;
++    private final EquipmentSlot equipmentSlot;
++    private ItemStack itemStack;
++
++    public EntityEquipmentItemLookup(@NotNull final Entity entity, @NotNull String tag, @NotNull EquipmentSlot slot, @NotNull final ItemStack itemStack) {
++        super(entity);
++        this.tag = tag;
++        this.equipmentSlot = slot;
++        this.itemStack = itemStack;
++    }
++
++    @NotNull
++    public ItemStack getItemStack() {
++        return itemStack;
++    }
++
++    public void setItemStack(ItemStack itemStack) {
++        this.itemStack = itemStack;
++    }
++
++    @NotNull
++    public EquipmentSlot getEquipmentSlot() {
++        return equipmentSlot;
++    }
++
++    @NotNull
++    public String getTag() {
++        return tag;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java b/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..513d62342d8e29e8d3c92fe932d0d77f659cf2f1
+--- /dev/null
++++ b/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java
+@@ -0,0 +1,61 @@
++package org.bukkit.event.player;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a player is about to receive an equipment packet about another player
++ */
++public class PlayerReceiveEquipmentEvent extends PlayerEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private final Entity tracked;
++    private boolean cancel;
++    private String tag;
++
++    public PlayerReceiveEquipmentEvent(@NotNull final Player player, @NotNull final Entity tracked) {
++        super(player);
++        this.tracked = tracked;
++    }
++
++    /**
++     * Gets the tracked entity
++     *
++     * @return Entity the player is now tracking
++     */
++    @NotNull
++    public Entity getTracked() {
++        return tracked;
++    }
++
++    public String getTag() {
++        return tag;
++    }
++
++    public void setTag(String tag) {
++        this.tag = tag;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancel;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/api/0012-AntiXray-Bypass.patch

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 6 Nov 2022 08:29:18 -0600
+Subject: [PATCH] AntiXray Bypass
+
+
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 6cd0b10d1dc4506cfb1e4db5e1260cb705566cec..b102687a9c6920b78d284f0531d2d80d6bf86a96 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -2493,6 +2493,10 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      */
+     boolean hasResourcePack();
+ 
++    // Slice start
++    void toggleAntiXrayBypass(boolean bypass);
++    // Slice end
++
+     /**
+      * Gets a copy of this players profile
+      * @return The players profile object

patches/api/0013-PlayerPreChunkLoadEvent.patch

@@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 7 Nov 2022 22:44:23 -0600
+Subject: [PATCH] PlayerPreChunkLoadEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/packet/PlayerPreChunkLoadEvent.java b/src/main/java/io/papermc/paper/event/packet/PlayerPreChunkLoadEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b5cc9538a70c7ce0b494d4878d51b52134c2fd75
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/packet/PlayerPreChunkLoadEvent.java
+@@ -0,0 +1,69 @@
++package io.papermc.paper.event.packet;
++
++import org.bukkit.Chunk;
++import org.bukkit.World;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Is called when a {@link Player} is about to receive a {@link Chunk}
++ * <p>
++ * Can be cancelled, but only use if you really really mean it.
++ */
++public class PlayerPreChunkLoadEvent extends Event implements Cancellable {
++
++    private static final HandlerList handlers = new HandlerList();
++    private final World world;
++    private final int chunkX;
++    private final int chunkZ;
++    private final Player player;
++    private boolean cancel;
++
++    public PlayerPreChunkLoadEvent(World world, int chunkX, int chunkZ, @NotNull Player player) {
++        this.world = world;
++        this.chunkX = chunkX;
++        this.chunkZ = chunkZ;
++        this.player = player;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    public World getWorld() {
++        return world;
++    }
++
++    public int getChunkX() {
++        return chunkX;
++    }
++
++    public int getChunkZ() {
++        return chunkZ;
++    }
++
++    @NotNull
++    public Player getPlayer() {
++        return player;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancel;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+\ No newline at end of file
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index fde06c5d88ffb63910bcb06e3e70e3c0a4af92c7..12d0d7355e7f15a073e1ee895f4fcaa935c4405e 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -526,6 +526,8 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     //@Deprecated // Paper
+     public boolean refreshChunk(int x, int z);
+ 
++    it.unimi.dsi.fastutil.longs.LongOpenHashSet getSentChunks(Player p); // Slice
++
+     /**
+      * Gets whether the chunk at the specified chunk coordinates is force
+      * loaded.

patches/server/0001-Build-changes.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Build changes
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index dd8f449dddbe0838835ae8f8d5033aa422db403d..8ef71d6f8c531841bbc8979f634277f7f7d19889 100644
+index 0282e3b75470e1a68ea1fc228082483514ba432e..73ce9e6171020fc4abc70d61c4587b9eeae9ae2f 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -9,8 +9,12 @@ plugins {
@@ -23,7 +23,7 @@ index dd8f449dddbe0838835ae8f8d5033aa422db403d..8ef71d6f8c531841bbc8979f634277f7
      // Paper start
      implementation("org.jline:jline-terminal-jansi:3.21.0")
      implementation("net.minecrell:terminalconsoleappender:1.3.0")
-@@ -59,7 +63,7 @@ tasks.jar {
+@@ -60,7 +64,7 @@ tasks.jar {
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
              "Implementation-Title" to "CraftBukkit",
@@ -32,7 +32,7 @@ index dd8f449dddbe0838835ae8f8d5033aa422db403d..8ef71d6f8c531841bbc8979f634277f7
              "Implementation-Vendor" to date, // Paper
              "Specification-Title" to "Bukkit",
              "Specification-Version" to project.version,
-@@ -147,7 +151,7 @@ fun TaskContainer.registerRunTask(
+@@ -148,7 +152,7 @@ fun TaskContainer.registerRunTask(
      name: String,
      block: JavaExec.() -> Unit
  ): TaskProvider<JavaExec> = register<JavaExec>(name) {
@@ -55,7 +55,7 @@ index c8d56947305c981a3268ce4ae3e975db350ceff2..ce51ebeb5df07abc4a8bb31bc737ab3e
  
      public SystemReport fillSystemReport(SystemReport details) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 15278bb897e6169bc5d02bf47b455634baec7be1..d107cb53b2b32d755692045abfd299c732ab045d 100644
+index ab843069ac0653d03cf3f925f49555016cad84fa..e09ae5f7684113d60d2672bc4bfc8543bce2f54f 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -249,7 +249,7 @@ import javax.annotation.Nullable; // Paper

patches/server/0006-Don-t-send-fire-packets-if-player-has-Fire-Resistanc.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Don't send fire packets if player has Fire Resistance
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 49cf3601df7b145d49b1fe9a71ba0bc60c5394b3..382d32045417174f5ef3fe556762146d07e30e17 100644
+index dfd1f37757af1bd808cc2e2d8bf97123adf638bb..7fcb2ecae7ec9a457e00a6a3ea1fb7b589360e02 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -780,7 +780,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -781,7 +781,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
  
          this.checkOutOfWorld();
          if (!this.level.isClientSide) {

patches/server/0012-Packet-obfuscation-and-reduction.patch

@@ -155,10 +155,10 @@ index f91e1a876ad4c46a7c92cead18947a941b4d9e68..13973b8803afefd491dc05e1df6e9b10
  
          if (this.entity instanceof LivingEntity) {
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 5b222edfda19c1446f1fe6ad67b2248f003ff0b0..be293253c6e90c1f109b5e270c527a4e2b0cff2f 100644
+index 7fcb2ecae7ec9a457e00a6a3ea1fb7b589360e02..75afbe3722d3e3ba7fe33f959ca40679c40b95dc 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -2986,7 +2986,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -2987,7 +2987,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
              this.entityData.markDirty(Entity.DATA_AIR_SUPPLY_ID);
              return;
          }
@@ -181,10 +181,10 @@ index 0156525637f8aa2e4e639bc493d8617b5af4cc32..1c598a97ed78a744907ae310f3568c44
  
      public void startAutoSpinAttack(int riptideTicks) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index f12efe51b14ed3637a8ba45def9c94634a6f5e8f..b3a7ec12abe8228e6394fc085059eaa3dd488a19 100644
+index ce78e024244c14530270b8276e5b0fd853f0a110..df22a1407f3d1e93f0f1d50b5dbec3df12b106d2 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2190,7 +2190,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2196,7 +2196,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
                  this.sendHealthUpdate();
              }
          }

patches/server/0014-World-Instance-flag.patch

@@ -17,10 +17,10 @@ index 98209532ad3e692d7e459640123f78bbd9a65889..9b3af8f2a433368d722cd442c07b2a2c
      public static Throwable getAddToWorldStackTrace(Entity entity) {
          return new Throwable(entity + " Added to world at " + new java.util.Date());
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 48825eaba9677a8b1e4fff80738e17d08e3307f8..64e2b9554d7a9911e1eff121d4f56d71e97aca68 100644
+index 15d740a605c7257bcc7117c7dfb3612b472ba664..9d400d82eeab062322acea81b87f6fc572151700 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -1274,6 +1274,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+@@ -1280,6 +1280,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
          world.noSave = !value;
      }
  

patches/server/0023-Set-multiple-Team-settings-with-a-single-packet.patch

@@ -106,10 +106,10 @@ index defff79eb28adc52851fa781d4d4a7745a884bdc..fb48bfbce1bca47d71a0ed35af1b1296
  
      @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-index d3d9641862f4746469bca946ef6d89a88f15698b..986d0dd921361a0dd8ca5ae6025521d086ec2143 100644
+index 67efb0d38ae369ff5254f7b1ec85d32d4eee8291..e4110e3a60242b958c9983a090b28aae540b2bdf 100644
 --- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
 +++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-@@ -346,6 +346,37 @@ final class CraftTeam extends CraftScoreboardComponent implements Team {
+@@ -347,6 +347,37 @@ final class CraftTeam extends CraftScoreboardComponent implements Team {
          }
      }
  

patches/server/0024-Debug-chunkloading.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 15 Apr 2022 09:36:18 -0500
-Subject: [PATCH] Debug chunkloading
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperCommand.java b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-index 5925feafad214333529bace2178f233f589e1a6e..a5db4e37aeb04f8fec2f9536bf2cd018af7ceef7 100644
---- a/src/main/java/com/destroystokyo/paper/PaperCommand.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-@@ -70,7 +70,7 @@ import java.util.stream.Collectors;
- 
- public class PaperCommand extends Command {
-     private static final String BASE_PERM = "bukkit.command.paper.";
--    private static final ImmutableSet<String> SUBCOMMANDS = ImmutableSet.<String>builder().add("heap", "entity", "reload", "version", "debug", "chunkinfo", "fixlight", "syncloadinfo", "dumpitem", "mobcaps", "playermobcaps", "debugsyncload").build(); // Slice
-+    private static final ImmutableSet<String> SUBCOMMANDS = ImmutableSet.<String>builder().add("heap", "entity", "reload", "version", "debug", "chunkinfo", "fixlight", "syncloadinfo", "dumpitem", "mobcaps", "playermobcaps", "debugsyncload", "debugchunks").build(); // Slice
- 
-     public PaperCommand(String name) {
-         super(name);
-@@ -208,6 +208,10 @@ public class PaperCommand extends Command {
-                 SyncLoadFinder.DEBUG = !SyncLoadFinder.DEBUG;
-                 MinecraftServer.LOGGER.info("Debugging sync chunk loads now " + (SyncLoadFinder.DEBUG ? "ON" : "OFF"));
-                 break;
-+            case "debugchunks":
-+                MinecraftServer.DEBUG_CHUNKS = !MinecraftServer.DEBUG_CHUNKS;
-+                MinecraftServer.LOGGER.info("Debugging chunk loading/sending now " + (MinecraftServer.DEBUG_CHUNKS ? "ON" : "OFF"));
-+                break;
-             // Slice end
-             case "mobcaps":
-                 this.printMobcaps(sender, args);
-diff --git a/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java b/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
-index 0f62a766a3249d8651a11dce6e9051b162693716..bae605ba25bb375273d506467ff5b38958e77aa5 100644
---- a/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
-+++ b/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
-@@ -548,6 +548,7 @@ public final class PlayerChunkLoader {
-             }
-             final int currSends = concurrentChunkSends.get();
-             if (currSends >= maxSends) {
-+                if (MinecraftServer.DEBUG_CHUNKS) org.bukkit.Bukkit.getServer().getLogger().log(java.util.logging.Level.WARNING, "currSends >= maxSends (" + currSends + " >= " + maxSends + ")"); // Slice
-                 break;
-             }
- 
-@@ -675,6 +676,7 @@ public final class PlayerChunkLoader {
-                 if (currentChunkLoads >= maxLoads || (PaperConfig.globalMaxChunkLoadRate > 0 && (TICKET_ADDITION_COUNTER_SHORT.getRate() >= PaperConfig.globalMaxChunkLoadRate || TICKET_ADDITION_COUNTER_LONG.getRate() >= PaperConfig.globalMaxChunkLoadRate))
-                     || (PaperConfig.playerMaxChunkLoadRate > 0.0 && (data.ticketAdditionCounterShort.getRate() >= PaperConfig.playerMaxChunkLoadRate || data.ticketAdditionCounterLong.getRate() >= PaperConfig.playerMaxChunkLoadRate))) {
-                     // don't poll, we didn't load it
-+                    if (MinecraftServer.DEBUG_CHUNKS) org.bukkit.Bukkit.getServer().getLogger().log(java.util.logging.Level.WARNING, "currentChunkLoads >= maxLoads (" + currentChunkLoads + " >= " + maxLoads + ")"); // Slice
-                     this.chunkLoadQueue.add(data);
-                     break;
-                 }
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index ce51ebeb5df07abc4a8bb31bc737ab3e4214ce83..8373298d673687f57b8f1a1509b79e94ad43de8d 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -308,6 +308,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     public volatile Thread shutdownThread; // Paper
-     public volatile boolean abnormalExit = false; // Paper
-+    public static boolean DEBUG_CHUNKS = false; // Slice
- 
-     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
-         AtomicReference<S> atomicreference = new AtomicReference();

patches/server/0024-Unfreeze-MappedRegistry.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Wed, 7 Sep 2022 17:37:47 -0500
+Subject: [PATCH] Unfreeze MappedRegistry
+
+
+diff --git a/src/main/java/net/minecraft/core/MappedRegistry.java b/src/main/java/net/minecraft/core/MappedRegistry.java
+index c3c0e52cfe8ef5fe9049c4582778040702131b47..c37676f6c70fcf21fc6e3b7322f9d73c4c128c06 100644
+--- a/src/main/java/net/minecraft/core/MappedRegistry.java
++++ b/src/main/java/net/minecraft/core/MappedRegistry.java
+@@ -306,6 +306,8 @@ public class MappedRegistry<T> extends WritableRegistry<T> {
+ 
+     @Override
+     public Registry<T> freeze() {
++        if (true) return this; // Slice (a TODO in Paper, thanks Owen)
++
+         this.frozen = true;
+         List<ResourceLocation> list = this.byKey.entrySet().stream().filter((entry) -> {
+             return !entry.getValue().isBound();

patches/server/0025-Equipment-Packet-Caching.patch

@@ -0,0 +1,279 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 3 Oct 2022 08:17:50 -0500
+Subject: [PATCH] Equipment Packet Caching
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java
+index 5a8f850b447fc3a4bd0eb0c505bbdfc8be7115e8..34d74735b7a7d258c6bd14bb7e5406934a208a31 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java
+@@ -18,6 +18,15 @@ public class ClientboundSetEquipmentPacket implements Packet<ClientGamePacketLis
+         this.slots = equipmentList;
+     }
+ 
++    public ClientboundSetEquipmentPacket(int id, List<Pair<EquipmentSlot, ItemStack>> equipmentList, net.minecraft.world.entity.LivingEntity entity, String tag) {
++        this.entity = id;
++        slots = new java.util.ArrayList<>(equipmentList.size());
++        for (Pair<EquipmentSlot, ItemStack> pair : equipmentList) {
++            EquipmentSlot slot = pair.getFirst();
++            slots.add(Pair.of(slot, entity.getOrCreateCachedEquipmentItem(tag, slot, pair.getSecond())));
++        }
++    }
++
+     public ClientboundSetEquipmentPacket(FriendlyByteBuf buf) {
+         this.entity = buf.readVarInt();
+         EquipmentSlot[] equipmentSlots = EquipmentSlot.values();
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index d9481017e36f607c6dee8ab833a36ac700267a9f..48830e44dcae2a5263dbae65506c5cb29e1ea2a7 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -3,12 +3,8 @@ package net.minecraft.server.level;
+ import com.google.common.collect.Lists;
+ import com.mojang.datafixers.util.Pair;
+ import com.mojang.logging.LogUtils;
+-import java.util.Collection;
+-import java.util.Collections;
+-import java.util.Iterator;
+-import java.util.List;
+-import java.util.Objects;
+-import java.util.Set;
++
++import java.util.*;
+ import java.util.function.Consumer;
+ import net.minecraft.network.protocol.Packet;
+ import net.minecraft.network.protocol.game.ClientboundAddMobPacket;
+@@ -310,27 +306,8 @@ public class ServerEntity {
+             consumer.accept(new ClientboundSetEntityMotionPacket(this.entity.getId(), this.ap));
+         }
+ 
+-        if (this.entity instanceof LivingEntity) {
+-            List<Pair<EquipmentSlot, ItemStack>> list = Lists.newArrayList();
+-            EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
+-            int i = aenumitemslot.length;
+-
+-            for (int j = 0; j < i; ++j) {
+-                EquipmentSlot enumitemslot = aenumitemslot[j];
+-                ItemStack itemstack = ((LivingEntity) this.entity).getItemBySlot(enumitemslot);
+-
+-                if (!itemstack.isEmpty()) {
+-                    // Paper start - prevent oversized data
+-                    final ItemStack sanitized = LivingEntity.sanitizeItemStack(itemstack.copy(), false);
+-                    list.add(Pair.of(enumitemslot, ((LivingEntity) this.entity).stripMeta(sanitized, false))); // Paper - remove unnecessary item meta
+-                    // Paper end
+-                }
+-            }
+-
+-            if (!list.isEmpty()) {
+-                consumer.accept(new ClientboundSetEquipmentPacket(this.entity.getId(), list));
+-            }
+-            ((LivingEntity) this.entity).detectEquipmentUpdates(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
++        if (this.entity instanceof LivingEntity livingEntity) {
++            livingEntity.sendEquipment(entityplayer); // Slice
+         }
+ 
+         // CraftBukkit start - Fix for nonsensical head yaw
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 44612616560c087ca80bd10c2077e955f5ce7c85..505d5de63dec642974ac8fda477450164b87caf6 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -6,14 +6,8 @@ import com.mojang.authlib.GameProfile;
+ import com.mojang.datafixers.util.Either;
+ import com.mojang.logging.LogUtils;
+ import com.mojang.serialization.DataResult;
+-import java.util.Collection;
+-import java.util.Iterator;
+-import java.util.List;
+-import java.util.Objects;
+-import java.util.Optional;
+-import java.util.OptionalInt;
+-import java.util.Random;
+-import java.util.UUID;
++
++import java.util.*;
+ import javax.annotation.Nullable;
+ import net.minecraft.BlockUtil;
+ import net.minecraft.ChatFormatting;
+@@ -2447,4 +2441,19 @@ public class ServerPlayer extends Player {
+     // CraftBukkit end
+ 
+     public final int getViewDistance() { throw new UnsupportedOperationException("Use PlayerChunkLoader"); } // Paper - placeholder
++
++    // Slice
++    public net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket setCachedEquipment(String tag, java.util.Map<org.bukkit.inventory.EquipmentSlot, org.bukkit.inventory.ItemStack> equipment) {
++        List<com.mojang.datafixers.util.Pair<net.minecraft.world.entity.EquipmentSlot, net.minecraft.world.item.ItemStack>> pairs = new ArrayList<>(equipment.size());
++        for (java.util.Map.Entry<org.bukkit.inventory.EquipmentSlot, org.bukkit.inventory.ItemStack> entry : equipment.entrySet()) {
++            com.mojang.datafixers.util.Pair<net.minecraft.world.entity.EquipmentSlot, net.minecraft.world.item.ItemStack> pair = com.mojang.datafixers.util.Pair.of(net.minecraft.world.entity.EquipmentSlot.byName(entry.getKey().name()),
++                    CraftItemStack.asNMSCopy(entry.getValue()));
++            pairs.add(pair);
++        }
++
++        net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket packet = new net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket(getId(), pairs);
++        cachedEquipmentMap.put(tag, packet);
++        return packet;
++    }
++    // Slice end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 9002ace5beb17b5a8b7efd0e83de17f2dbfc054a..6b504b854ccd9f0d63baf4cff4b1f279335b7dde 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -262,6 +262,8 @@ public abstract class LivingEntity extends Entity {
+     public boolean bukkitPickUpLoot;
+     public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
+     public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
++    private final com.google.common.collect.Table<String, ItemStack, ItemStack> equipmentPacketCache = com.google.common.collect.HashBasedTable.create(); // Slice
++    public java.util.Map<String, net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket> cachedEquipmentMap = new java.util.HashMap<>(); // Slice
+ 
+     @Override
+     public float getBukkitYaw() {
+@@ -3002,6 +3004,7 @@ public abstract class LivingEntity extends Entity {
+         if (map != null) {
+             this.handleHandSwap(map);
+             if (!map.isEmpty()) {
++                cachedEquipmentMap.clear(); // Slice - Must invalidate cached equipment map if we have changes
+                 this.handleEquipmentChanges(map);
+             }
+         }
+@@ -3090,7 +3093,25 @@ public abstract class LivingEntity extends Entity {
+             }
+ 
+         });
+-        ((ServerLevel) this.level).getChunkSource().broadcast(this, new ClientboundSetEquipmentPacket(this.getId(), list));
++
++        // Slice start
++        net.minecraft.server.level.ChunkMap.TrackedEntity entityTracker = ((ServerLevel) this.level).getChunkSource().chunkMap.entityMap.get(getId());
++        if (entityTracker != null) {
++            ClientboundSetEquipmentPacket packet = new ClientboundSetEquipmentPacket(this.getId(), list);
++            for (net.minecraft.server.network.ServerPlayerConnection playerConnection : entityTracker.seenBy) {
++                ServerPlayer player = playerConnection.getPlayer();
++                org.bukkit.event.player.PlayerReceiveEquipmentEvent event = new org.bukkit.event.player.PlayerReceiveEquipmentEvent(player.getBukkitEntity(), getBukkitEntity());
++                level.getCraftServer().getPluginManager().callEvent(event);
++
++                String tag = event.getTag();
++                if (tag != null) {
++                    playerConnection.send(new ClientboundSetEquipmentPacket(this.getId(), list, this, tag));
++                } else {
++                    playerConnection.send(packet);
++                }
++            }
++        }
++        // Slice end
+     }
+ 
+     // Paper start - hide unnecessary item meta
+@@ -4320,6 +4341,26 @@ public abstract class LivingEntity extends Entity {
+         this.setDeltaMovement((double) ((float) packet.getXd() / 8000.0F), (double) ((float) packet.getYd() / 8000.0F), (double) ((float) packet.getZd() / 8000.0F));
+     }
+ 
++    // Slice start
++    public ItemStack getOrCreateCachedEquipmentItem(String tag, EquipmentSlot slot, ItemStack itemStack) {
++        return equipmentPacketCache.row(tag).computeIfAbsent(itemStack, i -> {
++            String name = slot.name();
++
++            //How neat is this.
++            if (name.equals("MAINHAND")) {
++                name = "HAND";
++            } else if (name.equals("OFFHAND")) {
++                name = "OFF_HAND";
++            }
++
++            org.bukkit.event.entity.EntityEquipmentItemLookup event = new org.bukkit.event.entity.EntityEquipmentItemLookup(getBukkitEntity(), tag, org.bukkit.inventory.EquipmentSlot.valueOf(name), CraftItemStack.asBukkitCopy(i));
++            this.level.getCraftServer().getPluginManager().callEvent(event);
++            org.bukkit.inventory.ItemStack eventItem = event.getItemStack();
++            return CraftItemStack.asNMSCopy(eventItem);
++        });
++    }
++    // Slice end
++
+     // CraftBukkit start - decompile error
+     public static record Fallsounds(SoundEvent small, SoundEvent big) {
+ 
+@@ -4342,4 +4383,54 @@ public abstract class LivingEntity extends Entity {
+          */
+         // CraftBukkit end
+     }
++
++    // Slice start
++    public void sendEquipment(ServerPlayer p) {
++        org.bukkit.event.player.PlayerReceiveEquipmentEvent event = new org.bukkit.event.player.PlayerReceiveEquipmentEvent(p.getBukkitEntity(), getBukkitEntity());
++        level.getCraftServer().getPluginManager().callEvent(event);
++
++        boolean sendEquipment = !event.isCancelled();
++        String tag = event.getTag();
++        if (sendEquipment && this instanceof ServerPlayer player && tag != null) {
++            ClientboundSetEquipmentPacket equipmentPacket = player.cachedEquipmentMap.get(tag);
++            if (equipmentPacket != null) {
++                //Event says use a tag, and our tag exists; so we simply used our entire cached packet
++                p.connection.send(equipmentPacket);
++                sendEquipment = false;
++            }
++        }
++
++        if (sendEquipment) {
++            EquipmentSlot[] equipmentSlots = EquipmentSlot.values();
++            List<Pair<EquipmentSlot, ItemStack>> list = new ArrayList<>(equipmentSlots.length);
++
++            for (EquipmentSlot enumitemslot : equipmentSlots) {
++                ItemStack itemstack = getItemBySlot(enumitemslot);
++
++                if (!itemstack.isEmpty()) {
++                    // Paper start - prevent oversized data
++                    final ItemStack sanitized = LivingEntity.sanitizeItemStack(itemstack.copy(), false);
++                    ItemStack strippedItem = stripMeta(sanitized, false);
++
++                    if (tag != null) {
++                        strippedItem = getOrCreateCachedEquipmentItem(tag, enumitemslot, strippedItem);
++                    }
++
++                    list.add(Pair.of(enumitemslot, strippedItem)); // Paper - remove unnecessary item meta
++                    // Paper end
++                }
++            }
++
++            if (!list.isEmpty()) {
++                ClientboundSetEquipmentPacket equipmentPacket = new ClientboundSetEquipmentPacket(getId(), list);
++                if (tag != null) {
++                    cachedEquipmentMap.put(tag, equipmentPacket);
++                }
++                p.connection.send(equipmentPacket);
++            }
++
++            detectEquipmentUpdates(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
++        }
++    }
++    // Slice end
+ }
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 070dab06db870f3c67dffe7637fe1a92c7eaa6a8..1005f44dd5a6906351852ea5fb35360683765cc6 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -695,7 +695,9 @@ public final class ItemStack {
+     }
+ 
+     public static boolean isSameIgnoreDurability(ItemStack left, ItemStack right) {
+-        return left == right ? true : (!left.isEmpty() && !right.isEmpty() ? left.sameItemStackIgnoreDurability(right) : false);
++        boolean rightEmpty = right.isEmpty();
++        boolean leftEmpty = left.isEmpty();
++        return left == right || leftEmpty && rightEmpty ? true : (!leftEmpty && !rightEmpty ? left.sameItemStackIgnoreDurability(right) : false);
+     }
+ 
+     public boolean sameItem(ItemStack stack) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index c022751e3b45469cc0ad6732e2d6ff08918bafa4..04708105c6264bfacd0cc20a25178f7a62ebd78e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -920,4 +920,13 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         throw new IllegalArgumentException(entityCategory + " is an unrecognized entity category");
+     }
+     // Paper end
++
++    // Slice start
++    @Override
++    public void sendEquipment(Player p) {
++        if (entity instanceof net.minecraft.world.entity.LivingEntity livingEntity) {
++            livingEntity.sendEquipment(((CraftPlayer) p).getHandle());
++        }
++    }
++    // Slice end
+ }

patches/server/0026-AntiXray-Bypass.patch

@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 6 Nov 2022 08:29:18 -0600
+Subject: [PATCH] AntiXray Bypass
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
+index 8e2baa21f71e7105a8e72cba4ded6aa99370fca0..b295dcb214d54cd049e0b8e59c02b165714eacdd 100644
+--- a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
++++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
+@@ -161,6 +161,7 @@ public final class ChunkPacketBlockControllerAntiXray extends ChunkPacketBlockCo
+ 
+     @Override
+     public boolean shouldModify(ServerPlayer player, LevelChunk chunk) {
++        if (player.getBukkitEntity().hasAntiXrayBypass()) return false; // Slice
+         return !usePermission || !player.getBukkitEntity().hasPermission("paper.antixray.bypass");
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index df22a1407f3d1e93f0f1d50b5dbec3df12b106d2..2e7c1a99697c31f005a62b5d663708c9d4bc85df 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -174,6 +174,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private static final boolean DISABLE_CHANNEL_LIMIT = System.getProperty("paper.disableChannelLimit") != null; // Paper - add a flag to disable the channel limit
+     private long lastSaveTime;
+     // Paper end
++    private boolean antiXrayBypass; // Slice
+ 
+     public CraftPlayer(CraftServer server, ServerPlayer entity) {
+         super(server, entity);
+@@ -2432,6 +2433,17 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+     // Paper end
+ 
++    // Slice start
++    public boolean hasAntiXrayBypass() {
++        return this.antiXrayBypass;
++    }
++
++    @Override
++    public void toggleAntiXrayBypass(boolean bypass) {
++        this.antiXrayBypass = bypass;
++    }
++    // Slice end
++
+     @Override
+     public void updateCommands() {
+         if (this.getHandle().connection == null) return;

patches/server/0027-PlayerPreChunkLoadEvent.patch

@@ -0,0 +1,81 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 7 Nov 2022 22:44:22 -0600
+Subject: [PATCH] PlayerPreChunkLoadEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java b/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
+index 12bcf96ec1ba4314c7ea2eab9f3d140559f1dc08..d8773c7c36314b4f5953b9e7abc310c74401c23c 100644
+--- a/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
++++ b/src/main/java/io/papermc/paper/chunk/PlayerChunkLoader.java
+@@ -3,6 +3,7 @@ package io.papermc.paper.chunk;
+ import com.destroystokyo.paper.PaperConfig;
+ import com.destroystokyo.paper.util.misc.PlayerAreaMap;
+ import com.destroystokyo.paper.util.misc.PooledLinkedHashSets;
++import io.papermc.paper.event.packet.PlayerPreChunkLoadEvent;
+ import io.papermc.paper.util.CoordinateUtils;
+ import io.papermc.paper.util.IntervalledCounter;
+ import io.papermc.paper.util.TickThread;
+@@ -787,7 +788,7 @@ public final class PlayerChunkLoader {
+         // warning: modifications of this field must be aware that the loadQueue inside PlayerChunkLoader uses this field
+         // in a comparator!
+         protected final ArrayDeque<ChunkPriorityHolder> loadQueue = new ArrayDeque<>();
+-        protected final LongOpenHashSet sentChunks = new LongOpenHashSet();
++        public final LongOpenHashSet sentChunks = new LongOpenHashSet(); // Slice - public
+         protected final LongOpenHashSet chunksToBeSent = new LongOpenHashSet();
+ 
+         protected final TreeSet<ChunkPriorityHolder> sendQueue = new TreeSet<>((final ChunkPriorityHolder p1, final ChunkPriorityHolder p2) -> {
+@@ -871,7 +872,14 @@ public final class PlayerChunkLoader {
+         }
+ 
+         public void sendChunk(final int chunkX, final int chunkZ, final Runnable onChunkSend) {
+-            if (this.sentChunks.add(CoordinateUtils.getChunkKey(chunkX, chunkZ))) {
++            // Slice start
++            if (!new PlayerPreChunkLoadEvent(this.player.getBukkitEntity().getWorld(), chunkX, chunkZ, this.player.getBukkitEntity()).callEvent()) {
++                this.player.connection.connection.execute(onChunkSend);
++                return;
++            }
++            // Slice end
++
++            if (this.sentChunks.add(CoordinateUtils.getChunkKey(chunkX, chunkZ))) {  // Slice
+                 this.player.getLevel().getChunkSource().chunkMap.updateChunkTracking(this.player,
+                         new ChunkPos(chunkX, chunkZ), new MutableObject<>(), false, true); // unloaded, loaded
+                 this.player.connection.connection.execute(onChunkSend);
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 9d400d82eeab062322acea81b87f6fc572151700..ee35b5ac41d2016a775b320b1a84fceb6329c4be 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -528,6 +528,13 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         return true;
+     }
+ 
++    @Override
++    public it.unimi.dsi.fastutil.longs.LongOpenHashSet getSentChunks(Player p) {
++        CraftPlayer craftPlayer = (CraftPlayer) p;
++        io.papermc.paper.chunk.PlayerChunkLoader.PlayerLoaderData data = this.world.chunkSource.chunkMap.playerChunkManager.getData(craftPlayer.getHandle());
++        return data != null ? data.sentChunks : null;
++    }
++
+     @Override
+     public boolean isChunkInUse(int x, int z) {
+         return this.isChunkLoaded(x, z);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 2e7c1a99697c31f005a62b5d663708c9d4bc85df..b62a427b123f0573e15e6e38ff67029eadd69966 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2214,13 +2214,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+         // Paper end
+     }
+-    
++
+     @Override
+     public void sendHealthUpdate() {
+         this.sendHealthUpdate(this.getScaledHealth(), this.getHandle().getFoodData().getFoodLevel(), this.getHandle().getFoodData().getSaturationLevel());
+     }
+     // Paper end
+-    
++
+     public void injectScaledMaxHealth(Collection<AttributeInstance> collection, boolean force) {
+         if (!this.scaledHealth && !force) {
+             return;

patches/server/0028-Shared-Data-Folder-for-maps.patch

@@ -0,0 +1,130 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 14 Nov 2022 07:37:41 -0600
+Subject: [PATCH] Shared Data Folder for maps
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+index fafbebbb5e8c1a381b673f97f1fa210687b52823..8c846971b56930ff10740986d71ad47afc2b79d1 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
++++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+@@ -693,4 +693,11 @@ public class PaperConfig {
+     private static void useProxyProtocol() {
+         useProxyProtocol = getBoolean("settings.proxy-protocol", false);
+     }
++
++    // Slice start
++    public static String sharedDataFolder;
++    private static void sharedDataFolder() {
++        sharedDataFolder = getString("settings.shared-data-folder", null);
++    }
++    // Slice end
+ }
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index ce51ebeb5df07abc4a8bb31bc737ab3e4214ce83..8129c62692b9d1c4be85387dc52096b94956920e 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -308,6 +308,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     public volatile Thread shutdownThread; // Paper
+     public volatile boolean abnormalExit = false; // Paper
++    public @Nullable DimensionDataStorage sharedDataStorage; // Slice
+ 
+     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
+         AtomicReference<S> atomicreference = new AtomicReference();
+@@ -407,6 +408,12 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     }
+     // CraftBukkit end
+ 
++        // Slice start
++    public DimensionDataStorage getMapDataStorage() {
++        return sharedDataStorage != null ? sharedDataStorage : overworld().getDataStorage();
++    }
++    // Slice end
++
+     private void readScoreboard(DimensionDataStorage persistentStateManager) {
+         ServerScoreboard scoreboardserver = this.getScoreboard();
+ 
+@@ -919,6 +926,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.isSaving = true;
+             this.getPlayerList().saveAll(); // Diff on change
+             flag3 = this.saveAllChunks(suppressLogs, flush, force);
++            if (sharedDataStorage != null) sharedDataStorage.save(); // Slice
+         } finally {
+             this.isSaving = false;
+         }
+@@ -1161,6 +1169,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         try {
+             long serverStartTime = Util.getNanos(); // Paper
+             if (this.initServer()) {
++                // Slice start
++                String sharedDataFolder = com.destroystokyo.paper.PaperConfig.sharedDataFolder;
++                if (sharedDataFolder != null) {
++                    File sharedDir = new File(sharedDataFolder);
++                    sharedDir.mkdirs();
++                    this.sharedDataStorage = new DimensionDataStorage(sharedDir, fixerUpper);
++                }
++                // Slice end
++
+                 this.nextTickTime = Util.getMillis();
+                 this.status.setDescription(new TextComponent(this.motd));
+                 this.status.setVersion(new ServerStatus.Version(SharedConstants.getCurrentVersion().getName(), SharedConstants.getCurrentVersion().getProtocolVersion()));
+@@ -1492,6 +1509,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                     level.saveIncrementally(fullSave);
+                 }
+             }
++            if (sharedDataStorage != null) sharedDataStorage.save(); // Slice
+         } finally {
+             this.isSaving = false;
+         }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 9b3af8f2a433368d722cd442c07b2a2cfb16dc54..f460d21bcc7ba36763410851cf92a7053d85fc96 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1845,7 +1845,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     @Override
+     public MapItemSavedData getMapData(String id) {
+         // CraftBukkit start
+-        return (MapItemSavedData) this.getServer().overworld().getDataStorage().get((nbttagcompound) -> {
++        return (MapItemSavedData) this.getServer().getMapDataStorage().get((nbttagcompound) -> { // Slice
+             // We only get here when the data file exists, but is not a valid map
+             MapItemSavedData newMap = MapItemSavedData.load(nbttagcompound);
+             newMap.id = id;
+@@ -1859,12 +1859,22 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     @Override
+     public void setMapData(String id, MapItemSavedData state) {
+         state.id = id; // CraftBukkit
+-        this.getServer().overworld().getDataStorage().set(id, state);
++        this.getServer().getMapDataStorage().set(id, state); // Slice
+     }
+ 
+     @Override
+     public int getFreeMapId() {
+-        return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex::load, MapIndex::new, "idcounts")).getFreeAuxValueForMap();
++        // Slice start
++        DimensionDataStorage storage = this.getServer().getMapDataStorage();
++        MapIndex mapIndex = storage.readSavedData(MapIndex::load, "idcounts");
++        if (mapIndex == null) {
++            mapIndex = new MapIndex();
++        }
++        int newId = mapIndex.getFreeAuxValueForMap();
++        storage.set("idcounts", mapIndex);
++        storage.save();
++        return newId;
++        // Slice end
+     }
+ 
+     // Paper start - helper function for configurable spawn radius
+diff --git a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+index 0465b397b628b11a6fc52e3375945c94d68cfdd5..14296686772b74a45543227dc1e74a9c71c58cef 100644
+--- a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
++++ b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+@@ -58,7 +58,7 @@ public class DimensionDataStorage {
+     }
+ 
+     @Nullable
+-    private <T extends SavedData> T readSavedData(Function<CompoundTag, T> readFunction, String id) {
++    public <T extends SavedData> T readSavedData(Function<CompoundTag, T> readFunction, String id) { // Slice private -> public
+         try {
+             File file = this.getDataFile(id);
+             if (file.exists()) {