Collisions patch, update paper repo url

.gitignore

@@ -19,3 +19,6 @@ gradle-app.setting
 # gradle/wrapper/gradle-wrapper.properties
 /commit.sh
 /publish.sh
+/slice-api/
+/slice-server/
+/generated/

build-data/mappings-patch.tiny

@@ -1,5 +0,0 @@
-tiny	2	0	spigot	mojang+yarn
-
-# Originally DistanceManager, which also implements DistanceManager, so clashes since the implemented class
-# is imported and not fully qualified. Easiest fix is to just change the name
-c	net/minecraft/server/level/PlayerChunkMap$a	net/minecraft/server/level/ChunkMap$ChunkDistanceManager

build-data/paper.at

@@ -1,18 +0,0 @@
-# You can use this file to change the access modifiers on a member
-# This line would make the field rollAmount public in Bee
-#public net.minecraft.world.entity.animal.Bee rollAmount
-# This line would make the field public and remove the final modifier
-#public-f net.minecraft.network.protocol.game.ClientboundChatPacket sender
-# Leave out the member and it will apply to the class itself
-# More info, see here https://mcforge.readthedocs.io/en/latest/advanced/accesstransformers/#access-modifiers
-
-# Remap/Decompile fix (unclear why this is happening)
-public net.minecraft.server.MinecraftServer doRunTask(Lnet/minecraft/server/TickTask;)V
-
-# AT remap issue? todo 1.18
-public net.minecraft.world.level.dimension.end.EndDragonFight findExitPortal()Lnet/minecraft/world/level/block/state/pattern/BlockPattern$BlockPatternMatch;
-public net.minecraft.nbt.TagParser readArrayTag()Lnet/minecraft/nbt/Tag;
-
-# TODO 1.20 remapSpigotAt.at doesn't remap the return type for this method for some reason
-public net/minecraft/world/entity/Display$TextDisplay getText()Lnet/minecraft/network/chat/Component;
-public net/minecraft/world/entity/Display$BlockDisplay getBlockState()Lnet/minecraft/world/level/block/state/BlockState;

build-data/reobf-mappings-patch.tiny

@@ -1,28 +0,0 @@
-# We would like for paperweight to generate 100% perfect reobf mappings (and deobf mappings for that matter).
-# But unfortunately it's not quite there yet - and it may be some time before that happens. Generating perfect mappings
-# from Spigot's mappings is extremely difficult due to Spigot's bad tooling and bad mappings. To add insult to injury
-# we remap Spigot's _source code_ which is a lot more complex and error-prone than bytecode remapping. So with all that
-# said, this file exists to help fill in the gap.
-#
-# We will continue to improve paperweight and will work on fixing these issues so they don't come up in the first place,
-# but these mappings exist to prevent these issues from holding everything else in Paper up while we work through all
-# of these issues. Due to the complex nature of mappings generation and the debugging difficulty involved it may take
-# a significant amount of time for us to track down every possible issue, so this file will likely be around and in
-# use - at least in some capacity - for a long time.
-
-tiny	2	0	mojang+yarn	spigot
-
-# CraftBukkit changes type
-c	net/minecraft/server/level/ServerLevel	net/minecraft/server/level/WorldServer
-	f	Lnet/minecraft/world/level/storage/PrimaryLevelData;	serverLevelData	K
-
-c	net/minecraft/world/level/chunk/LevelChunk	net/minecraft/world/level/chunk/Chunk
-	f	Lnet/minecraft/server/level/ServerLevel;	level	r
-
-# See mappings-patch.tiny
-c	net/minecraft/server/level/ChunkMap	net/minecraft/server/level/PlayerChunkMap
-	f	Lnet/minecraft/server/level/ChunkMap$ChunkDistanceManager;	distanceManager	F
-
-# The method is made public by Spigot, which then causes accidental overrides
-c	net/minecraft/world/entity/Entity	net/minecraft/world/entity/Entity
-	m	()Z	isInRain	isInRain0

build.gradle.kts

@@ -4,10 +4,10 @@ plugins {
     java
     `maven-publish`
     id("com.github.johnrengelman.shadow") version "8.1.1" apply false
-    id("io.papermc.paperweight.patcher") version "1.5.12"
+    id("io.papermc.paperweight.patcher") version "1.7.4"
 }
 
-val paperMavenPublicUrl = "https://papermc.io/repo/repository/maven-public/"
+val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
 
 repositories {
     mavenCentral()
@@ -17,9 +17,9 @@ repositories {
 }
 
 dependencies {
-    remapper("net.fabricmc:tiny-remapper:0.8.10:fat")
-    decompiler("net.minecraftforge:forgeflower:2.0.627.2")
-    paperclip("io.papermc:paperclip:3.0.3")
+    remapper("net.fabricmc:tiny-remapper:0.10.3:fat") // Must be kept in sync with upstream
+    decompiler("org.vineflower:vineflower:1.10.1") // Must be kept in sync with upstream
+    paperclip("io.papermc:paperclip:3.0.3") // You probably want this to be kept in sync with upstream
 }
 
 allprojects {
@@ -28,7 +28,7 @@ allprojects {
 
     java {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(17))
+            languageVersion.set(JavaLanguageVersion.of(21))
         }
     }
 }
@@ -36,7 +36,7 @@ allprojects {
 subprojects {
     tasks.withType<JavaCompile> {
         options.encoding = Charsets.UTF_8.name()
-        options.release.set(17)
+        options.release.set(21)
     }
     tasks.withType<Javadoc> {
         options.encoding = Charsets.UTF_8.name()
@@ -83,7 +83,6 @@ paperweight {
 
 tasks.generateDevelopmentBundle {
     apiCoordinates.set("com.lokamc.slice:slice-api")
-    mojangApiCoordinates.set("io.papermc.paper:paper-mojangapi")
     libraryRepositories.set(
         listOf(
             "https://repo.maven.apache.org/maven2/",

gradle.properties

@@ -1,8 +1,8 @@
 group=com.lokamc.slice
-version=1.20.4-R0.1-SNAPSHOT
-
-mcVersion=1.20.4
-paperRef=5436d44bf2509ff89129f8790ee4643f09c72871
+version=1.21.3-R0.1-SNAPSHOT
+mcVersion=1.21.3
+paperRef=da7138233f6392e791d790d1c3407414c855f9c2
+updatingMinecraft=false
 
 org.gradle.caching=true
 org.gradle.parallel=true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

patches/api/0001-Add-BlockDestroyedByNeighborEvent.patch

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:30:30 -0500
+Date: Sat, 9 Nov 2024 09:48:21 -0600
 Subject: [PATCH] Add BlockDestroyedByNeighborEvent
 
 

patches/api/0001-Set-BlockData-without-light-updates.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:29:11 -0500
-Subject: [PATCH] Set BlockData without light updates
-
-
-diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
-index 49974558799830d827f9ccd65a8bafee3fb0376b..93fcb1562e58a3a613eccd28cae1e87e26a158c9 100644
---- a/src/main/java/org/bukkit/block/Block.java
-+++ b/src/main/java/org/bukkit/block/Block.java
-@@ -298,6 +298,28 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
-      */
-     void setBlockData(@NotNull BlockData data, boolean applyPhysics);
- 
-+    /**
-+     * Sets the complete data for this block
-+     *
-+     * <br>
-+     * Note that applyPhysics = false is not in general safe. It should only be
-+     * used when you need to avoid triggering a physics update of neighboring
-+     * blocks, for example when creating a {@link Bisected} block. If you are
-+     * using a custom populator, then this parameter may also be required to
-+     * prevent triggering infinite chunk loads on border blocks. This method
-+     * should NOT be used to "hack" physics by placing blocks in impossible
-+     * locations. Such blocks are liable to be removed on various events such as
-+     * world upgrades. Furthermore setting large amounts of such blocks in close
-+     * proximity may overload the server physics engine if an update is
-+     * triggered at a later point. If this occurs, the resulting behavior is
-+     * undefined.
-+     *
-+     * @param data new block specific data
-+     * @param applyPhysics false to cancel physics from the changed block
-+     * @param checkLight false to prevent a light-check update
-+     */
-+    void setBlockData(@NotNull BlockData data, boolean applyPhysics, boolean checkLight);
-+
-     /**
-      * Sets the type of this block
-      *

patches/api/0002-Add-provided-Material-to-getDrops.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:31:55 -0500
+Date: Sat, 9 Nov 2024 09:54:36 -0600
 Subject: [PATCH] Add provided Material to getDrops
 
 
 diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
-index 4d817cdebb6d6b3823c3a62aa9a0147ab720c5e0..c5017cd1bc1bea603a2e0b4f4d1541abb8a33911 100644
+index 0efd8bb70ebdb86372022c9e12ec89f229ab3b52..be4f8fc7e7d9b6fb3ef0f557c9f591431c902837 100644
 --- a/src/main/java/org/bukkit/block/Block.java
 +++ b/src/main/java/org/bukkit/block/Block.java
-@@ -675,6 +675,20 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
+@@ -677,6 +677,20 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
      @NotNull
      Collection<ItemStack> getDrops(@Nullable ItemStack tool, @Nullable Entity entity); // Paper
  

patches/api/0003-Add-Player-to-SpongeAbsorbEvent.patch

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:36:22 -0500
+Date: Sat, 9 Nov 2024 09:55:18 -0600
 Subject: [PATCH] Add Player to SpongeAbsorbEvent
 
 

patches/api/0004-Add-World-Instance-flag.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:37:06 -0500
+Date: Sat, 9 Nov 2024 09:56:09 -0600
 Subject: [PATCH] Add World Instance flag
 
 
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 35fb5047dd8a8521586a9ca9f8d70881355fb7f5..cac1f89dcca7cb613dcd3db5d9287ba2c61905fc 100644
+index 7a439c99fc4c5ee17d674460c8e58a9fe0c64e02..411e2153538f63f1ce3b3a10bb2829d1737d0597 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
-@@ -2713,6 +2713,11 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+@@ -2776,6 +2776,11 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
       */
      public void setAutoSave(boolean value);
  

patches/api/0005-Smooth-Teleports.patch

@@ -1,17 +1,18 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:55:36 -0500
+Date: Sun, 10 Nov 2024 09:34:07 -0600
 Subject: [PATCH] Smooth Teleports
 
 
 diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
-index c6cb4f17469a8f2e60dd3e28d41402851ce5fb21..7548f66864cd797d3dc51b91c6cf4a99cede4d34 100644
+index 95f0b3186e313c7fbd5c8531d52b82a69e525f94..f542265036bde4031c834e379a031d2821f32173 100644
 --- a/src/main/java/org/bukkit/entity/Player.java
 +++ b/src/main/java/org/bukkit/entity/Player.java
-@@ -3574,6 +3574,19 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+@@ -3721,6 +3721,19 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
      String getClientBrandName();
      // Paper end
  
++        // Slice start
 +    /**
 +     * This abuses some of how Minecraft works and allows teleporting a player to another world without
 +     * triggering typical respawn packets. All of natural state of chunk resends, entity adds/removes, etc still
@@ -20,7 +21,6 @@ index c6cb4f17469a8f2e60dd3e28d41402851ce5fb21..7548f66864cd797d3dc51b91c6cf4a99
 +     *
 +     * @param location New location to teleport this Player to
 +     */
-+    // Slice start
 +    @org.jetbrains.annotations.ApiStatus.Experimental
 +    void teleportWithoutRespawn(@NotNull Location location);
 +    // Slice end

patches/api/0006-Add-Force-Crit-to-PlayerPreAttackEntityEvent.patch

@@ -1,11 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:16:51 -0500
+Date: Wed, 13 Nov 2024 07:49:32 -0600
 Subject: [PATCH] Add Force Crit to PlayerPreAttackEntityEvent
 
 
 diff --git a/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
-index 148f46f4572a778f090b461808b53cf9cad10e11..abb2c6f8035c81bd2cb43bf5aa9b3744c10e5e48 100644
+index a6c5818bcdd8de5f2d0e9bf72d1e3816652e0199..196d790d766548a2e4afc31820658ba493a1fe83 100644
 --- a/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
 +++ b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
 @@ -28,6 +28,7 @@ public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellab
@@ -15,8 +15,8 @@ index 148f46f4572a778f090b461808b53cf9cad10e11..abb2c6f8035c81bd2cb43bf5aa9b3744
 +    private boolean forceCrit; // Slice
  
      @ApiStatus.Internal
-     public PrePlayerAttackEntityEvent(@NotNull Player player, @NotNull Entity attacked, boolean willAttack) {
-@@ -60,6 +61,16 @@ public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellab
+     public PrePlayerAttackEntityEvent(final Player player, final Entity attacked, final boolean willAttack) {
+@@ -59,6 +60,16 @@ public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellab
          return this.willAttack;
      }
  

patches/api/0007-Add-reason-to-PlayerConnectionCloseEvent.patch

@@ -1,21 +1,29 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 22 Aug 2023 06:22:17 -0500
+Date: Wed, 13 Nov 2024 08:04:09 -0600
 Subject: [PATCH] Add reason to PlayerConnectionCloseEvent
 
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java
-index d0fb13adc140f1ca74d0c3448f92baa60684f3e2..3c69210c2d665794fb77b6ff23d632a02e626875 100644
+index 5f5afcdb3c9e669ed0e730c720ad91d16b95602c..9447c571a514155cebc47a3bd9f6d0d79bdc8c97 100644
 --- a/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java
-@@ -42,13 +42,19 @@ public class PlayerConnectionCloseEvent extends Event {
-     @NotNull private final UUID playerUniqueId;
-     @NotNull private final String playerName;
-     @NotNull private final InetAddress ipAddress;
+@@ -7,6 +7,7 @@ import org.bukkit.event.HandlerList;
+ import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+ import org.bukkit.event.player.PlayerQuitEvent;
+ import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
+ import org.jspecify.annotations.NullMarked;
+ 
+ /**
+@@ -42,13 +43,19 @@ public class PlayerConnectionCloseEvent extends Event {
+     private final UUID playerUniqueId;
+     private final String playerName;
+     private final InetAddress ipAddress;
 +    @NotNull private final ConnectionCloseReason reason;
  
      @ApiStatus.Internal
-     public PlayerConnectionCloseEvent(@NotNull final UUID playerUniqueId, @NotNull final String playerName, @NotNull final InetAddress ipAddress, final boolean async) {
+     public PlayerConnectionCloseEvent(final UUID playerUniqueId, final String playerName, final InetAddress ipAddress, final boolean async) {
 +        this(playerUniqueId, playerName, ipAddress, ConnectionCloseReason.NORMAL, async);
 +    }
 +
@@ -28,11 +36,12 @@ index d0fb13adc140f1ca74d0c3448f92baa60684f3e2..3c69210c2d665794fb77b6ff23d632a0
      }
  
      /**
-@@ -85,4 +91,26 @@ public class PlayerConnectionCloseEvent extends Event {
+@@ -80,4 +87,27 @@ public class PlayerConnectionCloseEvent extends Event {
      public static HandlerList getHandlerList() {
          return HANDLER_LIST;
      }
 +
++
 +    /**
 +     * Returns the reason for the closed connection.
 +     */

patches/api/0008-ChunkStatusChangeEvent.patch

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 6 Nov 2023 08:19:46 -0600
+Date: Wed, 13 Nov 2024 08:07:59 -0600
 Subject: [PATCH] ChunkStatusChangeEvent
 
 

patches/api/0008-Set-multiple-team-settings-at-once.patch

@@ -1,35 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:52:54 -0500
-Subject: [PATCH] Set multiple team settings at once
-
-
-diff --git a/src/main/java/org/bukkit/scoreboard/Team.java b/src/main/java/org/bukkit/scoreboard/Team.java
-index cacb58d25c249e2ecd6083ed0f30d5ffb345220a..b0ed2c57321dae0d00b47dd23e67866592249993 100644
---- a/src/main/java/org/bukkit/scoreboard/Team.java
-+++ b/src/main/java/org/bukkit/scoreboard/Team.java
-@@ -514,6 +514,24 @@ public interface Team extends net.kyori.adventure.audience.ForwardingAudience {
-     boolean hasEntity(@NotNull org.bukkit.entity.Entity entity) throws IllegalStateException, IllegalArgumentException;
-     // Paper end - improve scoreboard entries
- 
-+    //Slice start
-+    /**
-+     * Fully set all team options, combining all 5 options into one packet send, rather than one packet sent
-+     * for every single option change.
-+     * @param displayName New display name
-+     * @param prefix New prefix
-+     * @param suffix New suffix
-+     * @param color new color
-+     * @param options A Paired list of options
-+     * @throws IllegalStateException
-+     */
-+    void teamOptions(@Nullable net.kyori.adventure.text.Component displayName,
-+                     @Nullable net.kyori.adventure.text.Component prefix,
-+                     @Nullable net.kyori.adventure.text.Component suffix,
-+                     @Nullable net.kyori.adventure.text.format.NamedTextColor color,
-+                     @Nullable java.util.List<org.apache.commons.lang3.tuple.Pair<Option, OptionStatus>> options) throws IllegalStateException;
-+    //Slice end
-+
-     /**
-      * Represents an option which may be applied to this team.
-      */

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

@@ -1,17 +1,17 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 07:36:40 -0500
+Date: Wed, 13 Nov 2024 08:29:41 -0600
 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 65112eae8b92344796850b1e4c89e75443eab2fe..b263b8620e1119baa519cc225ff7fcfd02b9fa54 100644
+index 68c08e7a212bc3e3885f9b5a4d9aef85fcb3b029..5395ec5d6ec33495516e792bdbbc97a7cef3038d 100644
 --- a/src/main/java/org/bukkit/entity/LivingEntity.java
 +++ b/src/main/java/org/bukkit/entity/LivingEntity.java
-@@ -1445,4 +1445,11 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
-      */
+@@ -1458,6 +1458,14 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
      void setBodyYaw(float bodyYaw);
      // Paper end - body yaw API
+ 
 +
 +    // Slice start
 +    /**
@@ -19,7 +19,10 @@ index 65112eae8b92344796850b1e4c89e75443eab2fe..b263b8620e1119baa519cc225ff7fcfd
 +     */
 +    void sendEquipment(@NotNull Player p);
 +    // Slice end
- }
++
+     // Paper start - Expose canUseSlot
+     /**
+      * Checks whether this entity can use the equipment slot.
 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..48d2eb3bbb8dbcb6714ee47c4159c0604657a78c

patches/api/0010-Add-Vanish.patch

@@ -1,17 +1,17 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Sun, 7 Jan 2024 08:27:00 -0600
-Subject: [PATCH] Vanish
+Date: Sat, 16 Nov 2024 09:10:35 -0600
+Subject: [PATCH] Add Vanish
 
 
 diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
-index a1484708c2af2be5c94a0dff1394e8bdf1f90e2e..8172e1e32fc86389273f5c326ce600dd65427898 100644
+index d0ae8a94db20281d3664d74718c65234eb2e5f83..6324e8f11a382288fc0a6c30f47760ea50e231d5 100644
 --- a/src/main/java/org/bukkit/entity/Entity.java
 +++ b/src/main/java/org/bukkit/entity/Entity.java
-@@ -1159,4 +1159,19 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+@@ -1172,4 +1172,19 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
       */
-     void setSaveable(boolean saveable);
-     // Slice end
+     void broadcastHurtAnimation(@NotNull java.util.Collection<Player> players);
+     // Paper end - broadcast hurt animation
 +
 +    // Slice start
 +    /**

patches/api/0010-AntiXray-Bypass.patch

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 08:46:54 -0500
-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 7548f66864cd797d3dc51b91c6cf4a99cede4d34..d1920e61d3c9afb1d99379bfb9849adad2c8c06f 100644
---- a/src/main/java/org/bukkit/entity/Player.java
-+++ b/src/main/java/org/bukkit/entity/Player.java
-@@ -3082,6 +3082,10 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
-      */
-     public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, double offsetX, double offsetY, double offsetZ, double extra);
- 
-+    // Slice start
-+    void toggleAntiXrayBypass(boolean bypass);
-+    // Slice end
-+
-     /**
-      * Spawns the particle (the number of times specified by count)
-      * at the target location. The position of each particle will be

patches/api/0011-Add-ObjectId.patch

@@ -1,15 +1,15 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Wed, 24 Jan 2024 11:39:14 -0600
-Subject: [PATCH] Expose getBlockPosBelowThatAffectsMyMovement
+Date: Sat, 16 Nov 2024 09:22:24 -0600
+Subject: [PATCH] Add ObjectId
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 04853c43b99951bf0d4c96ef73724625bdaf018f..504b1b57ba604d261f5f59dc204350f75d1777f8 100644
+index e29e5024fa693baae469d47fe77b57118f14627c..5770f7c756d033076e0fb629d6aa11fb97ccb0f2 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
-@@ -56,6 +56,8 @@ dependencies {
-     implementation("org.ow2.asm:asm-commons:9.7")
+@@ -69,6 +69,8 @@ dependencies {
+     implementation("org.ow2.asm:asm-commons:9.7.1")
      // Paper end
  
 +    implementation("org.mongodb:bson:4.11.1") // Slice - MongoDB Bson Library for ObjectIds
@@ -67,25 +67,8 @@ index 0000000000000000000000000000000000000000..4c28994757812f9c7f59d9eb827908bb
 +    }
 +
 +}
-diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
-index 8172e1e32fc86389273f5c326ce600dd65427898..e62e57a8dcd418683fdfb909a8ca22a2ff16dbf7 100644
---- a/src/main/java/org/bukkit/entity/Entity.java
-+++ b/src/main/java/org/bukkit/entity/Entity.java
-@@ -1174,4 +1174,12 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
-      */
-     void setVanished(boolean vanished);
-     // Slice end
-+
-+    // Slice start
-+    /**
-+     * Returns the Block that is currently supporting the player, particularly in the case of
-+     * crouching over the edge of a block.
-+     */
-+    org.bukkit.block.Block getBlockStandingOn();
-+    // Slice end
- }
 diff --git a/src/main/java/org/bukkit/entity/HumanEntity.java b/src/main/java/org/bukkit/entity/HumanEntity.java
-index ee866f3497ed56708d4062685f5585ca06a03955..93d1ea4b4edb422e962d0b3d12a4a496c00d9df2 100644
+index 488604ba1a516b477693877c74712e4a45624a8b..2a3e40b0b7f058713634d99f61755b368e05fa74 100644
 --- a/src/main/java/org/bukkit/entity/HumanEntity.java
 +++ b/src/main/java/org/bukkit/entity/HumanEntity.java
 @@ -22,6 +22,11 @@ import org.jetbrains.annotations.Nullable;

patches/api/0011-Add-PlayerPreChunkLoadEvent.patch

@@ -1,97 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 08:47:44 -0500
-Subject: [PATCH] Add 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..946af80dd54f602b5ceb61365ca98b06411f8177
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/event/packet/PlayerPreChunkLoadEvent.java
-@@ -0,0 +1,70 @@
-+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(@NotNull 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;
-+    }
-+
-+    @NotNull
-+    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 671321b77475f20ec1cf682a184d42497160dce3..2b9547dd059cb1e6dd224de813ba2193e2440135 100644
---- a/src/main/java/org/bukkit/World.java
-+++ b/src/main/java/org/bukkit/World.java
-@@ -527,6 +527,9 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
-     //@Deprecated // Paper
-     public boolean refreshChunk(int x, int z);
- 
-+    @NotNull
-+    it.unimi.dsi.fastutil.longs.LongOpenHashSet getSentChunks(@NotNull Player p); // Slice
-+
-     /**
-      * Gets whether the chunk at the specified chunk coordinates is force
-      * loaded.

patches/api/0012-Add-PlayerLoadStatsEvent-Fix-patch.patch

@@ -1,12 +1,12 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:25:26 -0500
-Subject: [PATCH] PlayerLoadStatsEvent
+Date: Sat, 16 Nov 2024 09:34:15 -0600
+Subject: [PATCH] Add PlayerLoadStatsEvent Fix patch
 
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadStatsEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadStatsEvent.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..80b67d390152b114ad385f7eb6af5ef975b7ca20
+index 0000000000000000000000000000000000000000..13c627b73520d862f864834732f0cad35532298b
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadStatsEvent.java
 @@ -0,0 +1,54 @@
@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..80b67d390152b114ad385f7eb6af5ef9
 +public class PlayerLoadStatsEvent extends Event {
 +    private static final HandlerList handlers = new HandlerList();
 +    private final UUID playerId;
-+    private JsonObject statistics;
++    private JsonObject json;
 +
 +    public PlayerLoadStatsEvent(@NotNull UUID playerId) {
 +        super(!Bukkit.isPrimaryThread());
@@ -46,11 +46,11 @@ index 0000000000000000000000000000000000000000..80b67d390152b114ad385f7eb6af5ef9
 +
 +    @Nullable
 +    public JsonObject getStatistics() {
-+        return statistics;
++        return json;
 +    }
 +
-+    public void setStatistics(@NotNull JsonObject statistics) {
-+        this.statistics = statistics;
++    public void setStatistics(@NotNull JsonObject json) {
++        this.json = json;
 +    }
 +
 +    @NotNull

patches/api/0013-Expose-getBlockPosBelowThatAffectsMyMovement.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 17 Nov 2024 08:24:22 -0600
+Subject: [PATCH] Expose getBlockPosBelowThatAffectsMyMovement
+
+
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 6324e8f11a382288fc0a6c30f47760ea50e231d5..8188b3a27fddac18cf49db5a8049149e784f4cbc 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -1187,4 +1187,12 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+      */
+     void setVanished(boolean vanished);
+     // Slice end
++
++    // Slice start
++    /**
++     * Returns the Block that is currently supporting the player, particularly in the case of
++     * crouching over the edge of a block.
++     */
++    org.bukkit.block.Block getBlockStandingOn();
++    // Slice end
+ }

patches/api/0014-Add-DimensionDataStorageEvents.patch

@@ -0,0 +1,140 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 17 Nov 2024 09:19:41 -0600
+Subject: [PATCH] Add DimensionDataStorageEvents
+
+
+diff --git a/src/main/java/io/papermc/paper/event/server/DimensionDataStorageLoadEvent.java b/src/main/java/io/papermc/paper/event/server/DimensionDataStorageLoadEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f85074ae3bb7eb558fc07a4e1877f130aec33d39
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/server/DimensionDataStorageLoadEvent.java
+@@ -0,0 +1,61 @@
++package io.papermc.paper.event.server;
++
++import com.google.gson.JsonElement;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.server.ServerEvent;
++import org.jetbrains.annotations.ApiStatus;
++import org.jspecify.annotations.NullMarked;
++
++import java.nio.file.Path;
++
++/**
++ * Called when resources such as datapacks are reloaded (e.g. /minecraft:reload)
++ * <p>
++ * Intended for use to re-register custom recipes, advancements that may be lost during a reload like this.
++ */
++@NullMarked
++public class DimensionDataStorageLoadEvent extends ServerEvent implements Cancellable {
++    public static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Path path;
++    private final JsonElement json;
++    private boolean cancelled;
++    @ApiStatus.Internal
++    public DimensionDataStorageLoadEvent(final Path path, final JsonElement json) {
++        this.path = path;
++        this.json = json;
++    }
++
++    public Path getPath() {
++        return path;
++    }
++
++    public JsonElement getJson() {
++        return json;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(final boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public enum Cause {
++        COMMAND,
++        PLUGIN,
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/event/server/DimensionDataStorageSaveEvent.java b/src/main/java/io/papermc/paper/event/server/DimensionDataStorageSaveEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2b29981621c959dd6027a072dab06339ebf315bf
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/server/DimensionDataStorageSaveEvent.java
+@@ -0,0 +1,61 @@
++package io.papermc.paper.event.server;
++
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.server.ServerEvent;
++import org.jetbrains.annotations.ApiStatus;
++import org.jspecify.annotations.NullMarked;
++
++import java.io.ByteArrayOutputStream;
++import java.nio.file.Path;
++
++/**
++ * Called when resources such as datapacks are reloaded (e.g. /minecraft:reload)
++ * <p>
++ * Intended for use to re-register custom recipes, advancements that may be lost during a reload like this.
++ */
++@NullMarked
++public class DimensionDataStorageSaveEvent extends ServerEvent implements Cancellable {
++    public static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final String id;
++    private final ByteArrayOutputStream output;
++    private boolean cancelled;
++    @ApiStatus.Internal
++    public DimensionDataStorageSaveEvent(final String id, final ByteArrayOutputStream output) {
++        this.id = id;
++        this.output = output;
++    }
++
++    public String getId() {
++        return id;
++    }
++
++    public ByteArrayOutputStream getOutput() {
++        return output;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(final boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public enum Cause {
++        COMMAND,
++        PLUGIN,
++    }
++}

patches/api/0014-Add-Preventing-KB-Bonus-to-PlayerPreAttackEntityEven.patch

@@ -1,34 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:17:39 -0500
-Subject: [PATCH] Add Preventing KB Bonus to PlayerPreAttackEntityEvent
-
-
-diff --git a/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
-index abb2c6f8035c81bd2cb43bf5aa9b3744c10e5e48..0ad3d64b0b0281a9afc998faff371bbdf000d864 100644
---- a/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
-+++ b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
-@@ -29,6 +29,7 @@ public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellab
- 
-     private boolean cancelled;
-     private boolean forceCrit; // Slice
-+    private boolean preventKnockbackBonus; // Slice
- 
-     @ApiStatus.Internal
-     public PrePlayerAttackEntityEvent(@NotNull Player player, @NotNull Entity attacked, boolean willAttack) {
-@@ -69,6 +70,15 @@ public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellab
-     public void setForceCrit(boolean forceCrit) {
-         this.forceCrit = forceCrit;
-     }
-+
-+    public boolean isPreventKnockbackBonus() {
-+        return preventKnockbackBonus;
-+    }
-+
-+    public void setPreventKnockbackBonus(boolean preventKnockbackBonus) {
-+        this.preventKnockbackBonus = preventKnockbackBonus;
-+    }
-+
-     // Slice end
- 
-     @Override

patches/api/0015-Add-PlayerData-Events.patch

@@ -1,18 +1,19 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Tom <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:38:40 -0500
+Date: Mon, 18 Nov 2024 08:34:27 -0600
 Subject: [PATCH] Add PlayerData Events
 
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadDataEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadDataEvent.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..ae0132d9c7ae17b478d1d504961e1fd6b479f6d0
+index 0000000000000000000000000000000000000000..2501922ea0fe84ed07e33503d84dd74a423e39e3
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadDataEvent.java
-@@ -0,0 +1,63 @@
+@@ -0,0 +1,64 @@
 +package com.destroystokyo.paper.event.player;
 +
 +import com.google.gson.JsonObject;
++import org.bukkit.Bukkit;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.jetbrains.annotations.NotNull;
@@ -30,7 +31,7 @@ index 0000000000000000000000000000000000000000..ae0132d9c7ae17b478d1d504961e1fd6
 +    private JsonObject statistics;
 +
 +    public PlayerLoadDataEvent(@NotNull UUID playerId) {
-+        super();
++        super(!Bukkit.isPrimaryThread());
 +        this.playerId = playerId;
 +    }
 +

patches/api/0016-Non-saveable-entities.patch

@@ -1,17 +1,18 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Thu, 28 Dec 2023 09:11:49 -0600
+Date: Mon, 18 Nov 2024 11:20:07 -0600
 Subject: [PATCH] Non-saveable-entities
 
 
 diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
-index 23def071492ccd715693d534cc506936e18f0f46..a1484708c2af2be5c94a0dff1394e8bdf1f90e2e 100644
+index 8188b3a27fddac18cf49db5a8049149e784f4cbc..a189034515b4361c39b60915e38f35d808a503d0 100644
 --- a/src/main/java/org/bukkit/entity/Entity.java
 +++ b/src/main/java/org/bukkit/entity/Entity.java
-@@ -1144,4 +1144,19 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+@@ -1195,4 +1195,20 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
       */
-     @NotNull String getScoreboardEntryName();
-     // Paper end - entity scoreboard name
+     org.bukkit.block.Block getBlockStandingOn();
+     // Slice end
++
 +
 +    // Slice start
 +    /**

patches/api/0016-Warden-setCanDespawn-API.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 23 Jun 2023 11:21:27 -0500
-Subject: [PATCH] Warden setCanDespawn API
-
-
-diff --git a/src/main/java/org/bukkit/entity/Warden.java b/src/main/java/org/bukkit/entity/Warden.java
-index efaa45f41bc1dc8df6665c55b4e5ade343d60d4c..36ea5429b9a18a857fd1fea30b52f69a182c7ede 100644
---- a/src/main/java/org/bukkit/entity/Warden.java
-+++ b/src/main/java/org/bukkit/entity/Warden.java
-@@ -111,4 +111,6 @@ public interface Warden extends Monster {
-          */
-         ANGRY;
-     }
--}
-+
-+    void setCanDespawn(boolean canDespawn); // Slice
-+}
-\ No newline at end of file

patches/api/0017-Map-Events.patch

@@ -0,0 +1,114 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 2 Dec 2024 11:52:34 -0600
+Subject: [PATCH] Map Events
+
+
+diff --git a/src/main/java/io/papermc/paper/event/server/MapGetFreeIndexEvent.java b/src/main/java/io/papermc/paper/event/server/MapGetFreeIndexEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..25999adb10ed0f3514332d64f27ea118bfccbfb4
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/server/MapGetFreeIndexEvent.java
+@@ -0,0 +1,41 @@
++package io.papermc.paper.event.server;
++
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.server.ServerEvent;
++import org.jetbrains.annotations.ApiStatus;
++import org.jspecify.annotations.NullMarked;
++
++/**
++ * Called when we try to fetch a new index for a newly-created map.
++ */
++@NullMarked
++public class MapGetFreeIndexEvent extends ServerEvent {
++    public static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private int index = -1;
++    @ApiStatus.Internal
++    public MapGetFreeIndexEvent() {
++    }
++
++    public int getIndex() {
++        return index;
++    }
++
++    public void setIndex(int index) {
++        this.index = index;
++    }
++
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public enum Cause {
++        COMMAND,
++        PLUGIN,
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/event/server/MapLoadEvent.java b/src/main/java/io/papermc/paper/event/server/MapLoadEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0dfab37f18b797003b932a8a8b16943c1dd7677c
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/server/MapLoadEvent.java
+@@ -0,0 +1,55 @@
++package io.papermc.paper.event.server;
++
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.server.ServerEvent;
++import org.jetbrains.annotations.ApiStatus;
++import org.jspecify.annotations.NullMarked;
++import org.jspecify.annotations.Nullable;
++
++import java.io.ByteArrayInputStream;
++import java.io.ByteArrayOutputStream;
++
++/**
++ * Called when we want to load a Map from disk
++ */
++@NullMarked
++public class MapLoadEvent extends ServerEvent {
++    public static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private int id;
++    private ByteArrayInputStream buf;
++    @ApiStatus.Internal
++    public MapLoadEvent(int id) {
++        this.id = id;
++    }
++
++    public int getIndex() {
++        return id;
++    }
++
++    public void setIndex(int index) {
++        this.id = index;
++    }
++
++    public @Nullable ByteArrayInputStream getBuf() {
++        return buf;
++    }
++
++    public void setBuf(ByteArrayInputStream buf) {
++        this.buf = buf;
++    }
++
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public enum Cause {
++        COMMAND,
++        PLUGIN,
++    }
++}

patches/api/0018-Add-timeDamaged-to-EntityDamageEvent.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sun, 10 Sep 2023 07:41:26 -0500
-Subject: [PATCH] Add timeDamaged to EntityDamageEvent
-
-
-diff --git a/src/main/java/org/bukkit/event/entity/EntityDamageEvent.java b/src/main/java/org/bukkit/event/entity/EntityDamageEvent.java
-index 446b3ffd5caca5344be1c250475679834cd0d4a2..f2beba90acfd251817eb218c35dcf58309d808b1 100644
---- a/src/main/java/org/bukkit/event/entity/EntityDamageEvent.java
-+++ b/src/main/java/org/bukkit/event/entity/EntityDamageEvent.java
-@@ -30,6 +30,7 @@ public class EntityDamageEvent extends EntityEvent implements Cancellable {
-     private boolean cancelled;
-     private final DamageCause cause;
-     private final DamageSource damageSource;
-+    private long timeDamaged = System.currentTimeMillis(); // Slice
- 
-     @Deprecated(forRemoval = true)
-     public EntityDamageEvent(@NotNull final Entity damagee, @NotNull final DamageCause cause, final double damage) {
-@@ -221,6 +222,22 @@ public class EntityDamageEvent extends EntityEvent implements Cancellable {
-         return damageSource;
-     }
- 
-+    // Slice start
-+    /**
-+     * @return Get the time the damage event happened.
-+     */
-+    public long getTimeDamaged() {
-+        return timeDamaged;
-+    }
-+
-+    /**
-+     * @param timeDamaged Set the time the damage event happened, if you so choose.
-+     */
-+    public void setTimeDamaged(long timeDamaged) {
-+        this.timeDamaged = timeDamaged;
-+    }
-+    // Slice end
-+
-     @NotNull
-     @Override
-     public HandlerList getHandlers() {

patches/api/0018-PlayerInsertBundleItemEvent.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 15 Dec 2024 17:55:31 -0600
+Subject: [PATCH] PlayerInsertBundleItemEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerInsertBundleItemEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerInsertBundleItemEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f715b36826591c5b19408c96119892a935eca27f
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerInsertBundleItemEvent.java
+@@ -0,0 +1,54 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
++import org.jspecify.annotations.NullMarked;
++
++@NullMarked
++public class PlayerInsertBundleItemEvent extends PlayerEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private ItemStack bundle;
++    private ItemStack itemStack;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public PlayerInsertBundleItemEvent(final Player player, final ItemStack bundle, final ItemStack itemStack) {
++        super(player);
++        this.bundle = bundle;
++        this.itemStack = itemStack;
++    }
++
++    public ItemStack getItemStack() {
++        return itemStack;
++    }
++
++    public ItemStack getBundle() {
++        return bundle;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(final boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}

patches/api/0019-Add-PlayerPreRespawnEvent.patch

@@ -1,33 +1,39 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:46:19 -0500
-Subject: [PATCH] Add PlayerGetRespawnLocationEvent
+Date: Sat, 28 Dec 2024 07:59:54 -0600
+Subject: [PATCH] Add PlayerPreRespawnEvent
 
 
-diff --git a/src/main/java/org/bukkit/event/player/PlayerGetRespawnLocationEvent.java b/src/main/java/org/bukkit/event/player/PlayerGetRespawnLocationEvent.java
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerPreRespawnEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerPreRespawnEvent.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..7eca4d6929fc7a75974d182c1ea692d3823a19c0
+index 0000000000000000000000000000000000000000..53b830c7a349d58b1bb8b242b3edd144c6dcbdb0
 --- /dev/null
-+++ b/src/main/java/org/bukkit/event/player/PlayerGetRespawnLocationEvent.java
-@@ -0,0 +1,53 @@
-+package org.bukkit.event.player;
++++ b/src/main/java/io/papermc/paper/event/player/PlayerPreRespawnEvent.java
+@@ -0,0 +1,76 @@
++package io.papermc.paper.event.player;
 +
 +import org.apache.commons.lang3.Validate;
 +import org.bukkit.Location;
 +import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.event.player.PlayerRespawnEvent;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
-+ * Called when a respawn event tries to determine the location of a respawn
++ * Called before a player's respawn location is determined.
 + */
-+public class PlayerGetRespawnLocationEvent extends PlayerEvent {
++public class PlayerPreRespawnEvent extends PlayerEvent implements Cancellable {
 +    private static final HandlerList handlers = new HandlerList();
++    private final PlayerRespawnEvent.RespawnReason respawnReason;
 +    private Location respawnLocation;
++    private boolean cancelled;
 +
-+    public PlayerGetRespawnLocationEvent(@NotNull final Player respawnPlayer) {
++    public PlayerPreRespawnEvent(@NotNull final Player respawnPlayer, PlayerRespawnEvent.RespawnReason respawnReason) {
 +        super(respawnPlayer);
++        this.respawnReason = respawnReason;
 +    }
 +
 +    /**
@@ -52,6 +58,13 @@ index 0000000000000000000000000000000000000000..7eca4d6929fc7a75974d182c1ea692d3
 +        this.respawnLocation = respawnLocation;
 +    }
 +
++    /**
++     * @return Returns the reason the player was respawned.
++     */
++    public PlayerRespawnEvent.RespawnReason getRespawnReason() {
++        return respawnReason;
++    }
++
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
@@ -62,4 +75,14 @@ index 0000000000000000000000000000000000000000..7eca4d6929fc7a75974d182c1ea692d3
 +    public static HandlerList getHandlerList() {
 +        return handlers;
 +    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
 +}

patches/server/0001-Build-Changes.patch

@@ -1,82 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MiniDigger <admin@minidigger.me>
-Date: Fri, 12 Aug 2022 08:07:34 -0500
-Subject: [PATCH] Build Changes
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index bcfe59b6efb628ee1e7f9d60667360d4d885fb6a..8aaee003050df9bd20e9f3e0263a47350c9840b1 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -13,8 +13,12 @@ configurations.named(log4jPlugins.compileClasspathConfigurationName) {
- val alsoShade: Configuration by configurations.creating
- 
- dependencies {
--    implementation(project(":paper-api"))
--    implementation(project(":paper-mojangapi"))
-+    // Slice start
-+    implementation(project(":slice-api"))
-+    implementation("io.papermc.paper:paper-mojangapi:1.20.4-R0.1-SNAPSHOT") {
-+        exclude("io.papermc.paper", "paper-api")
-+    }
-+    // Slice end
-     // Paper start
-     implementation("org.jline:jline-terminal-jansi:3.21.0")
-     implementation("net.minecrell:terminalconsoleappender:1.3.0")
-@@ -71,7 +75,7 @@ tasks.jar {
-         attributes(
-             "Main-Class" to "org.bukkit.craftbukkit.Main",
-             "Implementation-Title" to "CraftBukkit",
--            "Implementation-Version" to "git-Paper-$implementationVersion",
-+            "Implementation-Version" to "git-Slice-$implementationVersion", // Slice
-             "Implementation-Vendor" to date, // Paper
-             "Specification-Title" to "Bukkit",
-             "Specification-Version" to project.version,
-@@ -150,7 +154,7 @@ fun TaskContainer.registerRunTask(
-     name: String,
-     block: JavaExec.() -> Unit
- ): TaskProvider<JavaExec> = register<JavaExec>(name) {
--    group = "paper"
-+    group = "paperweight"
-     mainClass.set("org.bukkit.craftbukkit.Main")
-     standardInput = System.`in`
-     workingDir = rootProject.layout.projectDirectory
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index c8772c773f9933ed1d1debfe707af4373c458152..9ce9af857a5f2414658027ff5bb765cc4233899b 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -1865,7 +1865,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @DontObfuscate
-     public String getServerModName() {
--        return "Paper"; // Paper
-+        return "Slice"; // Slice - Slice > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-     }
- 
-     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 c490a29bcf7410bc54959ee71375605964379ed5..93fde7271340d157ed12129930656aeedd95ea79 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -266,7 +266,7 @@ import javax.annotation.Nullable; // Paper
- import javax.annotation.Nonnull; // Paper
- 
- public final class CraftServer implements Server {
--    private final String serverName = "Paper"; // Paper
-+    private final String serverName = "Slice"; // Slice // Paper
-     private final String serverVersion;
-     private final String bukkitVersion = Versioning.getBukkitVersion();
-     private final Logger logger = Logger.getLogger("Minecraft");
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-index 774556a62eb240da42e84db4502e2ed43495be17..fdd8fa9ec021b4846b59e1693e32d4d02a712efe 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-@@ -11,7 +11,7 @@ public final class Versioning {
-     public static String getBukkitVersion() {
-         String result = "Unknown-Version";
- 
--        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/io.papermc.paper/paper-api/pom.properties");
-+        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/com.lokamc.slice/slice-api/pom.properties"); // Slice
-         Properties properties = new Properties();
- 
-         if (stream != null) {

patches/server/0001-Build-changes.patch

@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 9 Nov 2024 09:30:20 -0600
+Subject: [PATCH] Build changes
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index faf3e3fd72e8c915e7a4803dacbe1bb576c6663e..63aa7a91dad0903383405c2cccf894d23a2ede54 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -25,7 +25,7 @@ abstract class MockitoAgentProvider : CommandLineArgumentProvider {
+ // Paper end - configure mockito agent that is needed in newer java versions
+ 
+ dependencies {
+-    implementation(project(":paper-api"))
++    implementation(project(":slice-api"))
+     // Paper start
+     implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
+     implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21
+@@ -99,14 +99,14 @@ tasks.jar {
+         val gitBranch = git("rev-parse", "--abbrev-ref", "HEAD").getText().trim() // Paper
+         attributes(
+             "Main-Class" to "org.bukkit.craftbukkit.Main",
+-            "Implementation-Title" to "Paper",
++            "Implementation-Title" to "Slice",
+             "Implementation-Version" to implementationVersion,
+             "Implementation-Vendor" to date, // Paper
+-            "Specification-Title" to "Paper",
++            "Specification-Title" to "Slice",
+             "Specification-Version" to project.version,
+-            "Specification-Vendor" to "Paper Team",
++            "Specification-Vendor" to "Loka",
+             "Brand-Id" to "papermc:paper",
+-            "Brand-Name" to "Paper",
++            "Brand-Name" to "Slice",
+             "Build-Number" to (build ?: ""),
+             "Build-Time" to Instant.now().toString(),
+             "Git-Branch" to gitBranch, // Paper
+@@ -172,7 +172,7 @@ fun TaskContainer.registerRunTask(
+     name: String,
+     block: JavaExec.() -> Unit
+ ): TaskProvider<JavaExec> = register<JavaExec>(name) {
+-    group = "paper"
++    group = "slice"
+     mainClass.set("org.bukkit.craftbukkit.Main")
+     standardInput = System.`in`
+     workingDir = rootProject.layout.projectDirectory
+diff --git a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java
+index 790bad0494454ca12ee152e3de6da3da634d9b20..f4099ed9f6076d4fc216730878134c5e194fc017 100644
+--- a/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java
++++ b/src/main/java/io/papermc/paper/ServerBuildInfoImpl.java
+@@ -30,7 +30,7 @@ public record ServerBuildInfoImpl(
+     private static final String ATTRIBUTE_GIT_BRANCH = "Git-Branch";
+     private static final String ATTRIBUTE_GIT_COMMIT = "Git-Commit";
+ 
+-    private static final String BRAND_PAPER_NAME = "Paper";
++    private static final String BRAND_SLICE_NAME = "Slice";
+ 
+     private static final String BUILD_DEV = "DEV";
+ 
+@@ -44,7 +44,7 @@ public record ServerBuildInfoImpl(
+                 .map(Key::key)
+                 .orElse(BRAND_PAPER_ID),
+             getManifestAttribute(manifest, ATTRIBUTE_BRAND_NAME)
+-                .orElse(BRAND_PAPER_NAME),
++                .orElse(BRAND_SLICE_NAME),
+             SharedConstants.getCurrentVersion().getId(),
+             SharedConstants.getCurrentVersion().getName(),
+             getManifestAttribute(manifest, ATTRIBUTE_BUILD_NUMBER)
+@@ -61,7 +61,7 @@ public record ServerBuildInfoImpl(
+ 
+     @Override
+     public boolean isBrandCompatible(final @NotNull Key brandId) {
+-        return brandId.equals(this.brandId);
++        return brandId.equals(this.brandId) || brandId.equals(BRAND_PAPER_ID);
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
+index 774556a62eb240da42e84db4502e2ed43495be17..7cf4712a774ff73818991c5fd7fe067ff2b83d35 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
+@@ -11,7 +11,7 @@ public final class Versioning {
+     public static String getBukkitVersion() {
+         String result = "Unknown-Version";
+ 
+-        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/io.papermc.paper/paper-api/pom.properties");
++        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/com.lokamc.slice/slice-api/pom.properties");
+         Properties properties = new Properties();
+ 
+         if (stream != null) {

patches/server/0002-Add-BlockDestroyedByNeighborEvent.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:30:29 -0500
+Date: Sat, 9 Nov 2024 09:48:21 -0600
 Subject: [PATCH] Add BlockDestroyedByNeighborEvent
 
 
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index a7b217ddbcbf92513bd38101fdfca2075505e267..92c8cb4fe9c82e32876fa75134a6009c874f6594 100644
+index a96f859a5d0c6ec692d4627a69f3c9ee49199dbc..7fe358dac8740ac6338a942f4189bca300d1f1be 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -419,6 +419,7 @@ public class ServerPlayerGameMode {
+@@ -425,6 +425,7 @@ public class ServerPlayerGameMode {
                  this.level.captureDrops = new ArrayList<>();
                  // CraftBukkit end
                  BlockState iblockdata1 = block.playerWillDestroy(this.level, pos, iblockdata, this.player);
@@ -16,7 +16,7 @@ index a7b217ddbcbf92513bd38101fdfca2075505e267..92c8cb4fe9c82e32876fa75134a6009c
                  boolean flag = this.level.removeBlock(pos, false);
  
                  if (flag) {
-@@ -446,6 +447,7 @@ public class ServerPlayerGameMode {
+@@ -452,6 +453,7 @@ public class ServerPlayerGameMode {
                  // CraftBukkit start
                  java.util.List<net.minecraft.world.entity.item.ItemEntity> itemsToDrop = this.level.captureDrops; // Paper - capture all item additions to the world
                  this.level.captureDrops = null; // Paper - capture all item additions to the world; Remove this earlier so that we can actually drop stuff
@@ -25,11 +25,11 @@ index a7b217ddbcbf92513bd38101fdfca2075505e267..92c8cb4fe9c82e32876fa75134a6009c
                      org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDropItemEvent(bblock, state, this.player, itemsToDrop); // Paper - capture all item additions to the world
                  }
 diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
-index 1ad126d992d95062a3db08374db7a927f23a0cac..7648e43a77b06b9f4a31b216824cdd9c1d79788f 100644
+index 33e7d2884195677c4d6340d8b84c1dd85c636ec1..04f8269abe339610795237652edcd54ba31bc5fc 100644
 --- a/src/main/java/net/minecraft/world/item/ItemStack.java
 +++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -379,6 +379,7 @@ public final class ItemStack {
-             CompoundTag oldData = this.getTagClone();
+@@ -424,6 +424,7 @@ public final class ItemStack implements DataComponentHolder {
+             DataComponentPatch oldData = this.components.asPatch();
              int oldCount = this.getCount();
              ServerLevel world = (ServerLevel) context.getLevel();
 +            if (entityhuman != null) world.pendingPlayerBlockEvents.put(blockposition, new Level.PendingBlockEvent(blockposition, entityhuman)); // Paper
@@ -37,11 +37,11 @@ index 1ad126d992d95062a3db08374db7a927f23a0cac..7648e43a77b06b9f4a31b216824cdd9c
              if (!(item instanceof BucketItem/* || item instanceof SolidBucketItem*/)) { // if not bucket // Paper - Fix cancelled powdered snow bucket placement
                  world.captureBlockStates = true;
 diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index a67bf805d7a078192987dbeb80af7d29df236d38..5cdadd4cf103af239a46aeb82b7d56f37672ded3 100644
+index 022de445bbbb869c38be4972c98dcf1c665539ec..abdbfb6bc3989bdc9332712be3c71b2afbf43c48 100644
 --- a/src/main/java/net/minecraft/world/level/Level.java
 +++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -181,6 +181,27 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     public final Map<Explosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
+@@ -181,6 +181,28 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+     public final Map<ServerExplosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
      public java.util.ArrayDeque<net.minecraft.world.level.block.RedstoneTorchBlock.Toggle> redstoneUpdateInfos; // Paper - Faster redstone torch rapid clock removal; Move from Map in BlockRedstoneTorch to here
  
 +    // Paper start - Holder class used to track what Player is responsible the last block event
@@ -65,10 +65,11 @@ index a67bf805d7a078192987dbeb80af7d29df236d38..5cdadd4cf103af239a46aeb82b7d56f3
 +    public final Map<BlockPos, PendingBlockEvent> pendingPlayerBlockEvents = new HashMap<>();
 +    // Paper end
 +
-     // Paper start - fix and optimise world upgrading
-     // copied from below
-     public static ResourceKey<DimensionType> getDimensionKey(DimensionType manager) {
-@@ -1055,6 +1076,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
++
+     public CraftWorld getWorld() {
+         return this.world;
+     }
+@@ -1225,6 +1247,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
              if (!this.preventPoiUpdated) {
                  this.onBlockStateChange(blockposition, iblockdata1, iblockdata2);
              }
@@ -76,7 +77,7 @@ index a67bf805d7a078192987dbeb80af7d29df236d38..5cdadd4cf103af239a46aeb82b7d56f3
              // CraftBukkit end
          }
      }
-@@ -1076,6 +1098,17 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+@@ -1246,6 +1269,17 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
          if (iblockdata.isAir()) {
              return false;
          } else {
@@ -95,10 +96,10 @@ index a67bf805d7a078192987dbeb80af7d29df236d38..5cdadd4cf103af239a46aeb82b7d56f3
              // Paper start - BlockDestroyEvent; while the above setAir method is named same and looks very similar
              // they are NOT used with same intent and the above should not fire this event. The above method is more of a BlockSetToAirEvent,
 diff --git a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-index 03b5ab8251497c0c94467f90e6663a0dc766babb..0be28c971bbd88268af4dfdd4489d4fb309ad03a 100644
+index 4fe83bd0f355549847b66afb7e61f6f2a6d97016..be6e6247d1a94271926544b128a52f501bc2cad5 100644
 --- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-@@ -112,6 +112,15 @@ public class DoublePlantBlock extends BushBlock {
+@@ -114,6 +114,15 @@ public class DoublePlantBlock extends BushBlock {
              BlockPos blockposition1 = pos.below();
              BlockState iblockdata1 = world.getBlockState(blockposition1);
  
@@ -115,10 +116,10 @@ index 03b5ab8251497c0c94467f90e6663a0dc766babb..0be28c971bbd88268af4dfdd4489d4fb
                  BlockState iblockdata2 = iblockdata1.getFluidState().is((Fluid) Fluids.WATER) ? Blocks.WATER.defaultBlockState() : Blocks.AIR.defaultBlockState();
  
 diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
-index 2892e586146cbc560f0bcf4b9af6d0575cb0a82e..b665a8f932ddae519cdefade555f9ea31fe8f4ac 100644
+index 99fd67a78539133adf78d65e2c520ff3dd260301..12d9c6769c8cb705d232bc01b50b04df503e4c3a 100644
 --- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
 +++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
-@@ -1242,11 +1242,22 @@ public abstract class BlockBehaviour implements FeatureElement {
+@@ -1237,11 +1237,22 @@ public abstract class BlockBehaviour implements FeatureElement {
              BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
              Direction[] aenumdirection = BlockBehaviour.UPDATE_SHAPE_ORDER;
              int k = aenumdirection.length;
@@ -138,6 +139,6 @@ index 2892e586146cbc560f0bcf4b9af6d0575cb0a82e..b665a8f932ddae519cdefade555f9ea3
 +                    }
 +                }
 +                // Paper end
-                 world.neighborShapeChanged(enumdirection.getOpposite(), this.asState(), blockposition_mutableblockposition, pos, flags, maxUpdateDepth);
+                 world.neighborShapeChanged(enumdirection.getOpposite(), blockposition_mutableblockposition, pos, this.asState(), flags, maxUpdateDepth);
              }
  

patches/server/0002-Set-BlockData-without-light-updates.patch

@@ -1,230 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:29:11 -0500
-Subject: [PATCH] Set BlockData without light updates
-
-
-diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-index 5ece375eaf6bcc61864997a389bb5e24625e4505..2d61315c9ab87a216e235f1586618b11511b2620 100644
---- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-+++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-@@ -256,7 +256,7 @@ public class WorldGenRegion implements WorldGenLevel {
-                 Block.dropResources(iblockdata, this.level, pos, tileentity, breakingEntity, ItemStack.EMPTY);
-             }
- 
--            return this.setBlock(pos, Blocks.AIR.defaultBlockState(), 3, maxUpdateDepth);
-+            return this.setBlock(pos, Blocks.AIR.defaultBlockState(), 3, maxUpdateDepth, true); // Slice
-         }
-     }
- 
-@@ -331,7 +331,7 @@ public class WorldGenRegion implements WorldGenLevel {
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight) { // Slice
-         if (!this.ensureCanWrite(pos)) {
-             return false;
-         } else {
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index bc89f9e90af3d69872a58c47a4c2545ba91b6ba5..a67bf805d7a078192987dbeb80af7d29df236d38 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -905,12 +905,12 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     }
- 
-     @Override
--    public final boolean setBlock(BlockPos pos, BlockState state, int flags) { // Paper - final for inline
--        return this.setBlock(pos, state, flags, 512);
-+    public final boolean setBlock(BlockPos pos, BlockState state, int flags, boolean checkLight) { // Paper - final for inline
-+        return this.setBlock(pos, state, flags, 512, checkLight);
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight) {
-         // CraftBukkit start - tree generation
-         if (this.captureTreeGeneration) {
-             // Paper start - Protect Bedrock and End Portal/Frames from being destroyed
-@@ -1106,7 +1106,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-                 iblockdata.getBlock().popExperience((ServerLevel) this, pos, xp, breakingEntity); // Paper - Properly handle xp dropping; custom amount
-             }
- 
--            boolean flag1 = this.setBlock(pos, fluid.createLegacyBlock(), 3, maxUpdateDepth);
-+            boolean flag1 = this.setBlock(pos, fluid.createLegacyBlock(), 3, maxUpdateDepth, true);
- 
-             if (flag1) {
-                 this.gameEvent(GameEvent.BLOCK_DESTROY, pos, GameEvent.Context.of(breakingEntity, iblockdata));
-diff --git a/src/main/java/net/minecraft/world/level/LevelWriter.java b/src/main/java/net/minecraft/world/level/LevelWriter.java
-index 134e5ec79bf2dddd4e31930f8a7cb2c02fa29518..fd72d278a2719911a46b6bc9e7da2dc24bbe681e 100644
---- a/src/main/java/net/minecraft/world/level/LevelWriter.java
-+++ b/src/main/java/net/minecraft/world/level/LevelWriter.java
-@@ -7,10 +7,14 @@ import net.minecraft.world.level.block.state.BlockState;
- 
- public interface LevelWriter {
- 
--    boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth);
-+    boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight);
- 
-     default boolean setBlock(BlockPos pos, BlockState state, int flags) {
--        return this.setBlock(pos, state, flags, 512);
-+        return this.setBlock(pos, state, flags, 512, true);
-+    }
-+
-+    default boolean setBlock(BlockPos pos, BlockState state, int flags, boolean checkLight) {
-+        return this.setBlock(pos, state, flags, 512, checkLight);
-     }
- 
-     boolean removeBlock(BlockPos pos, boolean move);
-diff --git a/src/main/java/net/minecraft/world/level/block/Block.java b/src/main/java/net/minecraft/world/level/block/Block.java
-index 22036ed3ea0629bc12981a8d91a03e55cc2117d6..4dcbaddc99225e8cfe9b8dbbf2196bfca9d057f6 100644
---- a/src/main/java/net/minecraft/world/level/block/Block.java
-+++ b/src/main/java/net/minecraft/world/level/block/Block.java
-@@ -201,7 +201,7 @@ public class Block extends BlockBehaviour implements ItemLike {
-                     world.destroyBlock(pos, (flags & 32) == 0, (Entity) null, maxUpdateDepth);
-                 }
-             } else {
--                world.setBlock(pos, newState, flags & -33, maxUpdateDepth);
-+                world.setBlock(pos, newState, flags & -33, maxUpdateDepth, true); // Slice
-             }
-         }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-index 35f7de6b50d3adae7bdd0da5f779f0a466d25522..e2aad3f47e0789f123e689bf2fcdee6bf207407e 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-@@ -149,7 +149,7 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
-         BlockPos pos = new BlockPos(x, y, z);
-         net.minecraft.world.level.block.state.BlockState old = this.getHandle().getBlockState(pos);
- 
--        CraftBlock.setTypeAndData(world, pos, old, ((CraftBlockData) blockData).getState(), true);
-+        CraftBlock.setTypeAndData(world, pos, old, ((CraftBlockData) blockData).getState(), true, true);
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 4b42ef2a876ea210d948238e63fd7a2b7035bb5b..7cdd76f87a10529df5b9476bd2728eb8db9448b1 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -183,15 +183,20 @@ public class CraftBlock implements Block {
- 
-     @Override
-     public void setBlockData(BlockData data, boolean applyPhysics) {
-+        setBlockData(data, applyPhysics, true);
-+    }
-+
-+    @Override
-+    public void setBlockData(BlockData data, boolean applyPhysics, boolean checkLight) {
-         Preconditions.checkArgument(data != null, "BlockData cannot be null");
--        this.setTypeAndData(((CraftBlockData) data).getState(), applyPhysics);
-+        this.setTypeAndData(((CraftBlockData) data).getState(), applyPhysics, checkLight);
-     }
- 
--    boolean setTypeAndData(final net.minecraft.world.level.block.state.BlockState blockData, final boolean applyPhysics) {
--        return CraftBlock.setTypeAndData(this.world, this.position, this.getNMS(), blockData, applyPhysics);
-+    boolean setTypeAndData(final net.minecraft.world.level.block.state.BlockState blockData, final boolean applyPhysics, boolean checkLight) {
-+        return CraftBlock.setTypeAndData(this.world, this.position, this.getNMS(), blockData, applyPhysics, checkLight);
-     }
- 
--    public static boolean setTypeAndData(LevelAccessor world, BlockPos position, net.minecraft.world.level.block.state.BlockState old, net.minecraft.world.level.block.state.BlockState blockData, boolean applyPhysics) {
-+    public static boolean setTypeAndData(LevelAccessor world, BlockPos position, net.minecraft.world.level.block.state.BlockState old, net.minecraft.world.level.block.state.BlockState blockData, boolean applyPhysics, boolean checkLight) {
-         // SPIGOT-611: need to do this to prevent glitchiness. Easier to handle this here (like /setblock) than to fix weirdness in tile entity cleanup
-         if (old.hasBlockEntity() && blockData.getBlock() != old.getBlock()) { // SPIGOT-3725 remove old tile entity if block changes
-             // SPIGOT-4612: faster - just clear tile
-@@ -205,7 +210,7 @@ public class CraftBlock implements Block {
-         if (applyPhysics) {
-             return world.setBlock(position, blockData, 3);
-         } else {
--            boolean success = world.setBlock(position, blockData, 2 | 16 | 1024); // NOTIFY | NO_OBSERVER | NO_PLACE (custom)
-+            boolean success = world.setBlock(position, blockData, 2 | 16 | 1024, checkLight); // NOTIFY | NO_OBSERVER | NO_PLACE (custom)
-             if (success && world instanceof net.minecraft.world.level.Level) {
-                 world.getMinecraftWorld().sendBlockUpdated(
-                         position,
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
-index d11d854ae90b99aa2ce227994d07fe1fe9b4a60a..1989d8755b422095b3d1ff9a07adf1bc582d5abf 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
-@@ -217,7 +217,7 @@ public class CraftBlockState implements BlockState {
-         }
- 
-         net.minecraft.world.level.block.state.BlockState newBlock = this.data;
--        block.setTypeAndData(newBlock, applyPhysics);
-+        block.setTypeAndData(newBlock, applyPhysics, true);
-         if (access instanceof net.minecraft.world.level.Level) {
-             this.world.getHandle().sendBlockUpdated(
-                     this.position,
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/DelegatedGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DelegatedGeneratorAccess.java
-index 86a20c91beff6b27e6ec886e49ba902b216106f2..42cd06f0166755cbce19d2dd2d8dcbf297cbcfb1 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/DelegatedGeneratorAccess.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/DelegatedGeneratorAccess.java
-@@ -803,8 +803,8 @@ public abstract class DelegatedGeneratorAccess implements WorldGenLevel {
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
--        return this.handle.setBlock(pos, state, flags, maxUpdateDepth);
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight) {
-+        return this.handle.setBlock(pos, state, flags, maxUpdateDepth, checkLight);
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-index 819a67aa19c6bd624f5ed28d09b35ff2c151749a..e33584c405beb97aac284e53020d1e9156e65e54 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-@@ -245,7 +245,7 @@ public class DummyGeneratorAccess implements WorldGenLevel {
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight) {
-         return false;
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/TransformerGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/TransformerGeneratorAccess.java
-index 7482dfe64458320d44089c0778591694202e9f70..2f4cde7a89fd47d5f4739bfda9b3033a57898928 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/TransformerGeneratorAccess.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/TransformerGeneratorAccess.java
-@@ -57,14 +57,14 @@ public class TransformerGeneratorAccess extends DelegatedGeneratorAccess {
-     // }
-     // Paper end - Don't fire sync event during generation; don't override these methods
- 
--    public boolean setCraftBlock(BlockPos position, CraftBlockState craftBlockState, int i, int j) {
-+    public boolean setCraftBlock(BlockPos position, CraftBlockState craftBlockState, int i, int j, boolean checkLight) {
-         if (this.structureTransformer != null) {
-             craftBlockState = this.structureTransformer.transformCraftState(craftBlockState);
-         }
-         // This code is based on the method 'net.minecraft.world.level.levelgen.structure.StructurePiece#placeBlock'
-         // It ensures that any kind of block is updated correctly upon placing it
-         BlockState iblockdata = craftBlockState.getHandle();
--        boolean result = super.setBlock(position, iblockdata, i, j);
-+        boolean result = super.setBlock(position, iblockdata, i, j, checkLight);
-         FluidState fluid = this.getFluidState(position);
-         if (!fluid.isEmpty()) {
-             this.scheduleTick(position, fluid.getType(), 0);
-@@ -80,19 +80,19 @@ public class TransformerGeneratorAccess extends DelegatedGeneratorAccess {
-     }
- 
-     public boolean setCraftBlock(BlockPos position, CraftBlockState craftBlockState, int i) {
--        return this.setCraftBlock(position, craftBlockState, i, 512);
-+        return this.setCraftBlock(position, craftBlockState, i, 512, true);
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth, boolean checkLight) {
-         if (this.structureTransformer == null || !this.structureTransformer.canTransformBlocks()) {
--            return super.setBlock(pos, state, flags, maxUpdateDepth);
-+            return super.setBlock(pos, state, flags, maxUpdateDepth, checkLight);
-         }
--        return this.setCraftBlock(pos, (CraftBlockState) CraftBlockStates.getBlockState(pos, state, null), flags, maxUpdateDepth);
-+        return this.setCraftBlock(pos, (CraftBlockState) CraftBlockStates.getBlockState(pos, state, null), flags, maxUpdateDepth, checkLight);
-     }
- 
-     @Override
--    public boolean setBlock(BlockPos pos, BlockState state, int flags) {
--        return this.setBlock(pos, state, flags, 512);
-+    public boolean setBlock(BlockPos pos, BlockState state, int flags, boolean checkLight) {
-+        return this.setBlock(pos, state, flags, 512, checkLight);
-     }
- }

patches/server/0003-Add-provided-Material-to-getDrops.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:31:54 -0500
+Date: Sat, 9 Nov 2024 09:54:36 -0600
 Subject: [PATCH] Add provided Material to getDrops
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 7cdd76f87a10529df5b9476bd2728eb8db9448b1..88ac6604decf8711ffba07bec4851ba6b75084b3 100644
+index 5cb69d0b822e11a99a96aef4f59986d083b079f4..632f9d98eb0a7a641ce879afcf838b6a96077ef6 100644
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
 +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -591,7 +591,18 @@ public class CraftBlock implements Block {
+@@ -592,7 +592,18 @@ public class CraftBlock implements Block {
  
      @Override
      public Collection<ItemStack> getDrops(ItemStack item, Entity entity) {
@@ -28,7 +28,7 @@ index 7cdd76f87a10529df5b9476bd2728eb8db9448b1..88ac6604decf8711ffba07bec4851ba6
          net.minecraft.world.item.ItemStack nms = CraftItemStack.asNMSCopy(item);
  
          // Modelled off EntityHuman#hasBlock
-@@ -602,6 +613,7 @@ public class CraftBlock implements Block {
+@@ -603,6 +614,7 @@ public class CraftBlock implements Block {
              return Collections.emptyList();
          }
      }

patches/server/0004-Add-Player-to-SpongeAbsorbEvent.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:36:21 -0500
+Date: Sat, 9 Nov 2024 09:55:18 -0600
 Subject: [PATCH] Add Player to SpongeAbsorbEvent
 
 
 diff --git a/src/main/java/net/minecraft/world/level/block/SpongeBlock.java b/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
-index c4667bea0708d12e228ec2a4c84fcee7e48ca08c..ad2a9c6d91ebeda5bd9cffdf5471e19353348f65 100644
+index 59cf905b1b5686f6f4f2bad94730ffa69d3a2834..7a8c80fe0df7a758751e2109e69934d5abfa0060 100644
 --- a/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
-@@ -114,7 +114,8 @@ public class SpongeBlock extends Block {
+@@ -117,7 +117,8 @@ public class SpongeBlock extends Block {
          if (!blocks.isEmpty()) {
              final org.bukkit.block.Block bblock = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
  

patches/server/0005-Add-World-Instance-flag.patch

@@ -1,26 +1,26 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:37:05 -0500
+Date: Sat, 9 Nov 2024 09:56:09 -0600
 Subject: [PATCH] Add World Instance flag
 
 
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 502bdc726b7890b00ee36871d905dea44e8719e3..4653878c059a15491eb54d7211311db7e2fe570a 100644
+index 585e2b43a0326f0b81597fa1234d3c67c76af550..e256e5ff5c167c6cff5b9e985cdc80d5c9203708 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -223,6 +223,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     public final UUID uuid;
+@@ -231,6 +231,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
      public boolean hasPhysicsEvent = true; // Paper - BlockPhysicsEvent
      public boolean hasEntityMoveEvent; // Paper - Add EntityMoveEvent
-+    public boolean instance; // Slice
      private final alternate.current.wire.WireHandler wireHandler = new alternate.current.wire.WireHandler(this); // Paper - optimize redstone (Alternate Current)
++    public boolean instance; // Slice
  
      public LevelChunk getChunkIfLoaded(int x, int z) {
+         return this.chunkSource.getChunkAtIfLoadedImmediately(x, z); // Paper - Use getChunkIfLoadedImmediately
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 01797d9791f19dfda4b168218eadeaae97f11eab..2e5fae21dcf511c18d309780fcc3204d3bfa7af2 100644
+index 57da11c0da7322e74810e7108e9c8000b0c36520..68e3dee346fe013f8e69900a0911583f851d2782 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -1333,6 +1333,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+@@ -1330,6 +1330,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
          this.world.noSave = !value;
      }
  

patches/server/0006-Smooth-Teleports.patch

@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 10 Nov 2024 09:34:07 -0600
+Subject: [PATCH] Smooth Teleports
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 5a8f396d47577f087abb415c972fd4f51e50faba..69c9cec8b397832340d683fc38d04c7ecd469a05 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -329,6 +329,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
+     public com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
+     public @Nullable String clientBrandName = null; // Paper - Brand support
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
++    public boolean smoothWorldTeleport = false; // Slice
+ 
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 30de3d1a7792c38ae946f19cb0e14637919b5001..b775de1732238954e9bbbd072277254d2dc91b18 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -844,8 +844,7 @@ public abstract class PlayerList {
+         ServerLevel worldserver1 = entityplayer1.serverLevel();
+         LevelData worlddata = worldserver1.getLevelData();
+ 
+-        entityplayer1.connection.send(new ClientboundRespawnPacket(entityplayer1.createCommonSpawnInfo(worldserver1), (byte) i));
+-        entityplayer1.connection.send(new ClientboundSetChunkCacheRadiusPacket(worldserver1.spigotConfig.viewDistance)); // Spigot
++        if (!entityplayer1.smoothWorldTeleport) entityplayer1.connection.send(new ClientboundRespawnPacket(entityplayer1.createCommonSpawnInfo(worldserver1), (byte) i)); // Slice
+         entityplayer1.connection.send(new ClientboundSetSimulationDistancePacket(worldserver1.spigotConfig.simulationDistance)); // Spigot
+         entityplayer1.connection.teleport(CraftLocation.toBukkit(entityplayer1.position(), worldserver1.getWorld(), entityplayer1.getYRot(), entityplayer1.getXRot())); // CraftBukkit
+         entityplayer1.connection.send(new ClientboundSetDefaultSpawnPositionPacket(worldserver.getSharedSpawnPos(), worldserver.getSharedSpawnAngle()));
+@@ -1213,7 +1212,7 @@ public abstract class PlayerList {
+             // CraftBukkit end
+         }
+ 
+-        player.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.LEVEL_CHUNKS_LOAD_START, 0.0F));
++        if (!player.smoothWorldTeleport) player.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.LEVEL_CHUNKS_LOAD_START, 0.0F)); // Slice
+         this.server.tickRateManager().updateJoiningPlayer(player);
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 554714e449d1d2439b05d7e15f72afccd17d4df5..adf8f0ddde16f08b10cd733eeabf9d40db77001b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1361,6 +1361,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         // Paper end - Teleportation API
+     }
+ 
++    // Slice start
++    public void teleportWithoutRespawn(Location location) {
++        ServerPlayer serverPlayer = getHandle();
++        serverPlayer.smoothWorldTeleport = true;
++        teleport(location);
++        serverPlayer.smoothWorldTeleport = false;
++    }
++    // Slice end
++
+     @Override
+     public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
+         // Paper start - Teleport API

patches/server/0007-Add-PlayerData-Events.patch

@@ -1,123 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:38:40 -0500
-Subject: [PATCH] Add PlayerData Events
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 92c8cb4fe9c82e32876fa75134a6009c874f6594..9637ed39f3022a9d8d0b45a7bd5895657783bed5 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -601,6 +601,8 @@ public class ServerPlayerGameMode {
-                     enuminteractionresult1 = stack.useOn(itemactioncontext);
-                 }
- 
-+                world.pendingPlayerBlockEvents.remove(blockposition); // Paper
-+
-                 if (enuminteractionresult1.consumesAction()) {
-                     CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger(player, blockposition, itemstack1);
-                 }
-diff --git a/src/main/java/net/minecraft/stats/ServerStatsCounter.java b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-index f890738d3bb9fb5e70a9d323c6cec97f9948f9cf..0e02785ec35e635bef33cc89c54b146c8e7dac99 100644
---- a/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-+++ b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-@@ -204,7 +204,12 @@ public class ServerStatsCounter extends StatsCounter {
-         return nbttagcompound;
-     }
- 
--    protected String toJson() {
-+    // Slice start - OBFHELPER
-+    public String toJson() {
-+        return serialize().toString();
-+    }
-+
-+    public JsonObject serialize() { // Slice end
-         Map<StatType<?>, JsonObject> map = Maps.newHashMap();
-         ObjectIterator objectiterator = this.stats.object2IntEntrySet().iterator();
- 
-@@ -230,7 +235,7 @@ public class ServerStatsCounter extends StatsCounter {
- 
-         jsonobject1.add("stats", jsonobject);
-         jsonobject1.addProperty("DataVersion", SharedConstants.getCurrentVersion().getDataVersion().getVersion());
--        return jsonobject1.toString();
-+        return jsonobject1; // Slice
-     }
- 
-     private static <T> ResourceLocation getKey(Stat<T> stat) {
-diff --git a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
-index 63e187c65cb855031f286aad0d25ac4694f7a331..b0f3aa2b90e2dc5dd7b450cae9ce4eba3d04e568 100644
---- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
-+++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
-@@ -36,6 +36,7 @@ public class PlayerDataStorage {
- 
-     public void save(Player player) {
-         if (org.spigotmc.SpigotConfig.disablePlayerDataSaving) return; // Spigot
-+        if (!new com.destroystokyo.paper.event.player.PlayerSaveDataEvent((org.bukkit.entity.Player) player.getBukkitEntity()).callEvent()) return; // Slice
-         try {
-             CompoundTag nbttagcompound = player.saveWithoutId(new CompoundTag());
-             Path path = this.playerDir.toPath();
-@@ -56,33 +57,41 @@ public class PlayerDataStorage {
-     public CompoundTag load(Player player) {
-         CompoundTag nbttagcompound = null;
- 
--        try {
--            File file = new File(this.playerDir, player.getStringUUID() + ".dat");
--            // Spigot Start
--            boolean usingWrongFile = false;
--            if ( org.bukkit.Bukkit.getOnlineMode() && !file.exists() ) // Paper - Check online mode first
--            {
--                file = new File( this.playerDir, java.util.UUID.nameUUIDFromBytes( ( "OfflinePlayer:" + player.getScoreboardName() ).getBytes( "UTF-8" ) ).toString() + ".dat");
--                if ( file.exists() )
-+        // Slice start - If event supplies playerdata, use it. Otherwise just load from disk as usual
-+        com.destroystokyo.paper.event.player.PlayerLoadDataEvent event = new com.destroystokyo.paper.event.player.PlayerLoadDataEvent(player.getUUID());
-+        org.bukkit.Bukkit.getPluginManager().callEvent(event);
-+
-+        Object playerData = event.getPlayerData();
-+        if (playerData != null) {
-+            nbttagcompound = (CompoundTag) playerData;
-+        } else {
-+            try {
-+                File file = new File(this.playerDir, player.getStringUUID() + ".dat");
-+                // Spigot Start
-+                boolean usingWrongFile = false;
-+                if (org.bukkit.Bukkit.getOnlineMode() && !file.exists()) // Paper - Check online mode first
-                 {
--                    usingWrongFile = true;
--                    org.bukkit.Bukkit.getServer().getLogger().warning( "Using offline mode UUID file for player " + player.getScoreboardName() + " as it is the only copy we can find." );
-+                    file = new File(this.playerDir, java.util.UUID.nameUUIDFromBytes(("OfflinePlayer:" + player.getScoreboardName()).getBytes("UTF-8")).toString() + ".dat");
-+                    if (file.exists()) {
-+                        usingWrongFile = true;
-+                        org.bukkit.Bukkit.getServer().getLogger().warning("Using offline mode UUID file for player " + player.getScoreboardName() + " as it is the only copy we can find.");
-+                    }
-                 }
--            }
--            // Spigot End
-+                // Spigot End
- 
--            if (file.exists() && file.isFile()) {
--                nbttagcompound = NbtIo.readCompressed(file.toPath(), NbtAccounter.unlimitedHeap());
--            }
--            // Spigot Start
--            if ( usingWrongFile )
--            {
--                file.renameTo( new File( file.getPath() + ".offline-read" ) );
-+                if (file.exists() && file.isFile()) {
-+                    nbttagcompound = NbtIo.readCompressed(file.toPath(), NbtAccounter.unlimitedHeap());
-+                }
-+                // Spigot Start
-+                if (usingWrongFile) {
-+                    file.renameTo(new File(file.getPath() + ".offline-read"));
-+                }
-+                // Spigot End
-+            } catch (Exception exception) {
-+                PlayerDataStorage.LOGGER.warn("Failed to load player data for {}", player.getName().getString());
-             }
--            // Spigot End
--        } catch (Exception exception) {
--            PlayerDataStorage.LOGGER.warn("Failed to load player data for {}", player.getName().getString());
--        }
-+        } // Slice end
-+
- 
-         if (nbttagcompound != null) {
-             // CraftBukkit start

patches/server/0007-Allow-opening-covered-chests.patch

@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Wed, 13 Nov 2024 07:44:28 -0600
+Subject: [PATCH] Allow opening covered chests
+
+
+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 edef8fc62f8dba1b57214d8d7d805ff0d83f4114..c948eb36db7f902ce65523e19651057e39a1a8ad 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+@@ -341,9 +341,7 @@ public class ChestBlock extends AbstractChestBlock<ChestBlockEntity> implements
+     }
+ 
+     public static boolean isBlockedChestByBlock(BlockGetter world, BlockPos pos) {
+-        BlockPos blockposition1 = pos.above();
+-
+-        return world.getBlockState(blockposition1).isRedstoneConductor(world, blockposition1);
++        return false; // Slice
+     }
+ 
+     private static boolean isCatSittingOnChest(LevelAccessor world, BlockPos pos) {
+diff --git a/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java b/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
+index 2a207fb2e1c26b562de42240e11c856bd2a23458..601746d00c1afd85ca8a0c5578ef587e6a231bcf 100644
+--- a/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
+@@ -83,7 +83,7 @@ public class EnderChestBlock extends AbstractChestBlock<EnderChestBlockEntity> i
+         PlayerEnderChestContainer playerEnderChestContainer = player.getEnderChestInventory();
+         if (playerEnderChestContainer != null && world.getBlockEntity(pos) instanceof EnderChestBlockEntity enderChestBlockEntity) {
+             BlockPos blockPos = pos.above();
+-            if (world.getBlockState(blockPos).isRedstoneConductor(world, blockPos)) { // Paper - diff on change; make sure that EnderChest#isBlocked uses the same logic
++            if (false) { // Slice - allow block on top to not block opening // world.getBlockState(blockPos).isRedstoneConductor(world, blockPos)) { // Paper - diff on change; make sure that EnderChest#isBlocked uses the same logic
+                 return InteractionResult.SUCCESS;
+             } else {
+                 // Paper start - Fix InventoryOpenEvent cancellation - moved up;
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftEnderChest.java b/src/main/java/org/bukkit/craftbukkit/block/CraftEnderChest.java
+index f45ee675a10729845bf376fa95e648b23b9aac12..bb59827851262051bc832f32bf54877b6a896990 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftEnderChest.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftEnderChest.java
+@@ -62,9 +62,7 @@ public class CraftEnderChest extends CraftBlockEntityState<EnderChestBlockEntity
+     // Paper start - More Chest Block API
+     @Override
+     public boolean isBlocked() {
+-        // Uses the same logic as EnderChestBlock's check for opening container
+-        final net.minecraft.core.BlockPos abovePos = this.getPosition().above();
+-        return this.isPlaced() && this.getWorldHandle().getBlockState(abovePos).isRedstoneConductor(this.getWorldHandle(), abovePos);
++        return false; // Slice
+     }
+     // Paper end - More Chest Block API
+ }

patches/server/0008-Add-Force-Crit-to-PlayerPreAttackEntityEvent.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Wed, 13 Nov 2024 07:49:32 -0600
+Subject: [PATCH] Add Force Crit to PlayerPreAttackEntityEvent
+
+
+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 61d412c4f1ebd55661cc3f0260468e3ac0efe0bb..551da84c834132d106457c123e1b195e4be904b8 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1269,7 +1269,7 @@ public abstract class Player extends LivingEntity {
+                     }
+ 
+                     f += itemstack.getItem().getAttackDamageBonus(target, f, damagesource);
+-                    boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting();
++                    boolean flag2 = playerAttackEntityEvent.isForceCrit() || (flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting()); // Slice
+ 
+                     flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
+                     if (flag2) {

patches/server/0008-Add-PlayerGetRespawnLocationEvent.patch

@@ -1,102 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:46:18 -0500
-Subject: [PATCH] Add PlayerGetRespawnLocationEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 1e5f709115007ff19901c0a6c3cf884d9e4d3a6c..81c28b63e9dfe21d8f17f465468c40cf5ef84e9a 100644
---- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -867,49 +867,57 @@ public abstract class PlayerList {
- 
-         // CraftBukkit start - fire PlayerRespawnEvent
-         if (location == null) {
--            // boolean isBedSpawn = false; // Paper - Add PlayerPostRespawnEvent; moved up
--            ServerLevel worldserver1 = this.server.getLevel(entityplayer.getRespawnDimension());
--            if (worldserver1 != null) {
--                Optional optional;
-+            // Slice start
-+            Player respawnPlayer = entityplayer1.getBukkitEntity();
-+            org.bukkit.event.player.PlayerGetRespawnLocationEvent preRespawnEvent = new org.bukkit.event.player.PlayerGetRespawnLocationEvent(respawnPlayer);
-+            preRespawnEvent.callEvent();
-+            location = preRespawnEvent.getRespawnLocation();
- 
--                if (blockposition != null) {
--                    optional = net.minecraft.world.entity.player.Player.findRespawnPositionAndUseSpawnBlock(worldserver1, blockposition, f, flag1, true); // Paper - Fix SPIGOT-5989
--                } else {
--                    optional = Optional.empty();
--                }
-+            if (location == null) {
-+                // Slice end
-+                // boolean isBedSpawn = false; // Paper - Add PlayerPostRespawnEvent; moved up
-+                ServerLevel worldserver1 = this.server.getLevel(entityplayer.getRespawnDimension());
-+                if (worldserver1 != null) {
-+                    Optional optional;
-+
-+                    if (blockposition != null) {
-+                        optional = net.minecraft.world.entity.player.Player.findRespawnPositionAndUseSpawnBlock(worldserver1, blockposition, f, flag1, true); // Paper - Fix SPIGOT-5989
-+                    } else {
-+                        optional = Optional.empty();
-+                    }
- 
--                if (optional.isPresent()) {
--                    BlockState iblockdata = worldserver1.getBlockState(blockposition);
--                    boolean flag3 = iblockdata.is(Blocks.RESPAWN_ANCHOR);
--                    isAnchorSpawn = flag3; // Paper - Fix PlayerRespawnEvent
--                    Vec3 vec3d = (Vec3) optional.get();
--                    float f1;
-+                    if (optional.isPresent()) {
-+                        BlockState iblockdata = worldserver1.getBlockState(blockposition);
-+                        boolean flag3 = iblockdata.is(Blocks.RESPAWN_ANCHOR);
-+                        isAnchorSpawn = flag3; // Paper - Fix PlayerRespawnEvent
-+                        Vec3 vec3d = (Vec3) optional.get();
-+                        float f1;
- 
--                    if (!iblockdata.is(BlockTags.BEDS) && !flag3) {
--                        f1 = f;
--                    } else {
--                        Vec3 vec3d1 = Vec3.atBottomCenterOf(blockposition).subtract(vec3d).normalize();
-+                        if (!iblockdata.is(BlockTags.BEDS) && !flag3) {
-+                            f1 = f;
-+                        } else {
-+                            Vec3 vec3d1 = Vec3.atBottomCenterOf(blockposition).subtract(vec3d).normalize();
- 
--                        f1 = (float) Mth.wrapDegrees(Mth.atan2(vec3d1.z, vec3d1.x) * 57.2957763671875D - 90.0D);
--                    }
-+                            f1 = (float) Mth.wrapDegrees(Mth.atan2(vec3d1.z, vec3d1.x) * 57.2957763671875D - 90.0D);
-+                        }
- 
--                    // entityplayer1.setRespawnPosition(worldserver1.dimension(), blockposition, f, flag1, false); // CraftBukkit - not required, just copies old location into reused entity
--                    flag2 = !flag && flag3;
--                    isBedSpawn = true;
--                    location = CraftLocation.toBukkit(vec3d, worldserver1.getWorld(), f1, 0.0F);
--                } else if (blockposition != null) {
--                    entityplayer1.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.NO_RESPAWN_BLOCK_AVAILABLE, 0.0F));
--                    entityplayer1.setRespawnPosition(null, null, 0f, false, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLAYER_RESPAWN); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed // Paper - Add PlayerSetSpawnEvent
-+                        // entityplayer1.setRespawnPosition(worldserver1.dimension(), blockposition, f, flag1, false); // CraftBukkit - not required, just copies old location into reused entity
-+                        flag2 = !flag && flag3;
-+                        isBedSpawn = true;
-+                        location = CraftLocation.toBukkit(vec3d, worldserver1.getWorld(), f1, 0.0F);
-+                    } else if (blockposition != null) {
-+                        entityplayer1.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.NO_RESPAWN_BLOCK_AVAILABLE, 0.0F));
-+                        entityplayer1.setRespawnPosition(null, null, 0f, false, false, com.destroystokyo.paper.event.player.PlayerSetSpawnEvent.Cause.PLAYER_RESPAWN); // CraftBukkit - SPIGOT-5988: Clear respawn location when obstructed // Paper - Add PlayerSetSpawnEvent
-+                    }
-                 }
--            }
- 
--            if (location == null) {
--                worldserver1 = this.server.getLevel(Level.OVERWORLD);
--                blockposition = entityplayer1.getSpawnPoint(worldserver1);
--                location = CraftLocation.toBukkit(blockposition, worldserver1.getWorld(), worldserver1.levelData.getSpawnAngle(), 0.0F).add(0.5F, 0.1F, 0.5F); // Paper - Expose world spawn angle
-+                if (location == null) {
-+                    worldserver1 = this.server.getLevel(Level.OVERWORLD);
-+                    blockposition = entityplayer1.getSpawnPoint(worldserver1);
-+                    location = CraftLocation.toBukkit(blockposition, worldserver1.getWorld(), worldserver1.levelData.getSpawnAngle(), 0.0F).add(0.5F, 0.1F, 0.5F); // Paper - Expose world spawn angle
-+                }
-             }
- 
--            Player respawnPlayer = entityplayer1.getBukkitEntity();
-             PlayerRespawnEvent respawnEvent = new PlayerRespawnEvent(respawnPlayer, location, isBedSpawn && !isAnchorSpawn, isAnchorSpawn, reason, com.google.common.collect.ImmutableSet.<org.bukkit.event.player.PlayerRespawnEvent.RespawnFlag>builder().add(respawnFlags)); // Paper - PlayerRespawnEvent changes
-             this.cserver.getPluginManager().callEvent(respawnEvent);
-             // Spigot Start

patches/server/0009-Allow-access-to-LightEngine.patch

@@ -1,15 +1,15 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 18 Apr 2023 07:52:19 -0500
+Date: Wed, 13 Nov 2024 07:54:14 -0600
 Subject: [PATCH] Allow access to LightEngine
 
 
 diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 5637dcf1f6c76df33988c3279171aafbc1868a82..22ec85fb9e5313b94f1dc55c3cfbfe88eded0db6 100644
+index 5b3a886c624b36557cbfaccdc3fb05a46a4ba36a..50a5514c9109f71926594d3f4786bd0995fc2d84 100644
 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
 +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -434,7 +434,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         // Paper end - rewrite player chunk loader
+@@ -298,7 +298,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         return ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getPlayerChunkLoader().isChunkSent(player, chunkX, chunkZ, true); // Paper - rewrite chunk system
      }
  
 -    protected ThreadedLevelLightEngine getLightEngine() {

patches/server/0009-Set-multiple-team-settings-at-once.patch

@@ -1,149 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:52:53 -0500
-Subject: [PATCH] Set multiple team settings at once
-
-
-diff --git a/src/main/java/net/minecraft/world/scores/PlayerTeam.java b/src/main/java/net/minecraft/world/scores/PlayerTeam.java
-index 9464054912e19fc78dd965b71fce20a18564b351..1624a0f8ea211a4c43fd01612674ca501c10d7e6 100644
---- a/src/main/java/net/minecraft/world/scores/PlayerTeam.java
-+++ b/src/main/java/net/minecraft/world/scores/PlayerTeam.java
-@@ -28,6 +28,7 @@ public class PlayerTeam extends Team {
-     private ChatFormatting color = ChatFormatting.RESET;
-     private Team.CollisionRule collisionRule = Team.CollisionRule.ALWAYS;
-     private final Style displayNameStyle;
-+    private boolean updateTeamChangeInstantly = true; // Slice
- 
-     public PlayerTeam(Scoreboard scoreboard, String name) {
-         this.scoreboard = scoreboard;
-@@ -36,6 +37,12 @@ public class PlayerTeam extends Team {
-         this.displayNameStyle = Style.EMPTY.withInsertion(name).withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal(name)));
-     }
- 
-+    // Slice start
-+    public void setUpdateTeamChangeInstantly(boolean updateTeamChangeInstantly) {
-+        this.updateTeamChangeInstantly = updateTeamChangeInstantly;
-+    }
-+    // Slice end
-+
-     public Scoreboard getScoreboard() {
-         return this.scoreboard;
-     }
-@@ -64,13 +71,13 @@ public class PlayerTeam extends Team {
-             throw new IllegalArgumentException("Name cannot be null");
-         } else {
-             this.displayName = displayName;
--            this.scoreboard.onTeamChanged(this);
-+            if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-         }
-     }
- 
-     public void setPlayerPrefix(@Nullable Component prefix) {
-         this.playerPrefix = prefix == null ? CommonComponents.EMPTY : prefix;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     public Component getPlayerPrefix() {
-@@ -79,7 +86,7 @@ public class PlayerTeam extends Team {
- 
-     public void setPlayerSuffix(@Nullable Component suffix) {
-         this.playerSuffix = suffix == null ? CommonComponents.EMPTY : suffix;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     public Component getPlayerSuffix() {
-@@ -113,7 +120,7 @@ public class PlayerTeam extends Team {
- 
-     public void setAllowFriendlyFire(boolean friendlyFire) {
-         this.allowFriendlyFire = friendlyFire;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     @Override
-@@ -123,7 +130,7 @@ public class PlayerTeam extends Team {
- 
-     public void setSeeFriendlyInvisibles(boolean showFriendlyInvisible) {
-         this.seeFriendlyInvisibles = showFriendlyInvisible;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     @Override
-@@ -138,12 +145,12 @@ public class PlayerTeam extends Team {
- 
-     public void setNameTagVisibility(Team.Visibility nameTagVisibilityRule) {
-         this.nameTagVisibility = nameTagVisibilityRule;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     public void setDeathMessageVisibility(Team.Visibility deathMessageVisibilityRule) {
-         this.deathMessageVisibility = deathMessageVisibilityRule;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     @Override
-@@ -153,7 +160,7 @@ public class PlayerTeam extends Team {
- 
-     public void setCollisionRule(Team.CollisionRule collisionRule) {
-         this.collisionRule = collisionRule;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     public int packOptions() {
-@@ -176,7 +183,7 @@ public class PlayerTeam extends Team {
- 
-     public void setColor(ChatFormatting color) {
-         this.color = color;
--        this.scoreboard.onTeamChanged(this);
-+        if (updateTeamChangeInstantly) this.scoreboard.onTeamChanged(this); // Slice
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-index 2b335c750ce5f9ccc2651a8701497ca9b8f46704..c508b2003cb7980b41dce542e5c3053b2fb9d1d8 100644
---- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-@@ -341,6 +341,37 @@ final class CraftTeam extends CraftScoreboardComponent implements Team {
-         }
-     }
- 
-+    //Slice start
-+    @Override
-+    public void teamOptions(net.kyori.adventure.text.Component displayName,
-+                            net.kyori.adventure.text.Component prefix,
-+                            net.kyori.adventure.text.Component suffix,
-+                            net.kyori.adventure.text.format.NamedTextColor color,
-+                            java.util.List<org.apache.commons.lang3.tuple.Pair<Option, OptionStatus>> options) throws IllegalStateException {
-+        checkState();
-+        team.setUpdateTeamChangeInstantly(false);
-+
-+        if (displayName == null) displayName = net.kyori.adventure.text.Component.empty();
-+        team.setDisplayName(io.papermc.paper.adventure.PaperAdventure.asVanilla(displayName));
-+
-+        if (prefix == null) prefix = net.kyori.adventure.text.Component.empty();
-+        team.setPlayerPrefix(io.papermc.paper.adventure.PaperAdventure.asVanilla(prefix));
-+
-+        if (suffix == null) suffix = net.kyori.adventure.text.Component.empty();
-+        team.setPlayerSuffix(io.papermc.paper.adventure.PaperAdventure.asVanilla(suffix));
-+
-+        if (color == null) color = net.kyori.adventure.text.format.NamedTextColor.WHITE;
-+        team.setColor(io.papermc.paper.adventure.PaperAdventure.asVanilla(color));
-+
-+        for (org.apache.commons.lang3.tuple.Pair<Option, OptionStatus> pair : options) {
-+            setOption(pair.getLeft(), pair.getRight());
-+        }
-+
-+        team.setUpdateTeamChangeInstantly(true);
-+        team.getScoreboard().onTeamChanged(team);
-+    }
-+    //Slice end
-+
-     // Paper start
-     @Override
-     public void addEntity(org.bukkit.entity.Entity entity) throws IllegalStateException, IllegalArgumentException {

patches/server/0010-Don-t-send-fire-packets-if-player-has-FR.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 18 Apr 2023 07:50:34 -0500
+Date: Wed, 13 Nov 2024 07:55:27 -0600
 Subject: [PATCH] Don't send fire packets if player has FR
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 45439b0cc4ea69e409fd41d4684403c0e0feab12..007055909e4f11a6c2805b8118d092e8b6f0a982 100644
+index a15546e433ebba6c0de01bdaaef201a3d99a87b5..55b9b33ce85cdff75de8753e6294c99bb1b1f7ee 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -890,7 +890,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -949,7 +949,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
          this.checkBelowWorld();
          if (!this.level().isClientSide) {

patches/server/0010-Smooth-Teleports.patch

@@ -1,75 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 07:55:35 -0500
-Subject: [PATCH] Smooth Teleports
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index b3781efbd3edcf102fe1bda5d6149915dc1127c6..134792abe368cf92308ce34f7aea83fac6cd33b3 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -281,6 +281,7 @@ public class ServerPlayer extends Player {
-     public com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
-     public @Nullable String clientBrandName = null; // Paper - Brand support
-     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
-+    public boolean smoothWorldTeleport; // Slice
- 
-     // Paper start - replace player chunk loader
-     private final java.util.concurrent.atomic.AtomicReference<io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances> viewDistances = new java.util.concurrent.atomic.AtomicReference<>(new io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances(-1, -1, -1));
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 81c28b63e9dfe21d8f17f465468c40cf5ef84e9a..f96e4e958d631c42d3538d35202d59c77ddf2467 100644
---- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -953,12 +953,14 @@ public abstract class PlayerList {
-         ServerLevel worldserver2 = entityplayer1.serverLevel();
-         LevelData worlddata = worldserver2.getLevelData();
- 
-+        if (!entityplayer.smoothWorldTeleport) {
-         entityplayer1.connection.send(new ClientboundRespawnPacket(entityplayer1.createCommonSpawnInfo(worldserver2), (byte) i));
-         entityplayer1.connection.send(new ClientboundSetChunkCacheRadiusPacket(worldserver1.getWorld().getSendViewDistance())); // Spigot // Paper - replace old player chunk management
-         entityplayer1.connection.send(new ClientboundSetSimulationDistancePacket(worldserver1.getWorld().getSimulationDistance())); // Spigot // Paper - replace old player chunk management
-         entityplayer1.connection.teleport(CraftLocation.toBukkit(entityplayer1.position(), worldserver2.getWorld(), entityplayer1.getYRot(), entityplayer1.getXRot())); // CraftBukkit
-         entityplayer1.connection.send(new ClientboundSetDefaultSpawnPositionPacket(worldserver1.getSharedSpawnPos(), worldserver1.getSharedSpawnAngle()));
-         entityplayer1.connection.send(new ClientboundChangeDifficultyPacket(worlddata.getDifficulty(), worlddata.isDifficultyLocked()));
-+        }
-         entityplayer1.connection.send(new ClientboundSetExperiencePacket(entityplayer1.experienceProgress, entityplayer1.totalExperience, entityplayer1.experienceLevel));
-         this.sendLevelInfo(entityplayer1, worldserver1);
-         this.sendPlayerPermissionLevel(entityplayer1);
-@@ -1282,7 +1284,7 @@ public abstract class PlayerList {
- 
-         player.connection.send(new ClientboundInitializeBorderPacket(worldborder));
-         player.connection.send(new ClientboundSetTimePacket(world.getGameTime(), world.getDayTime(), world.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)));
--        player.connection.send(new ClientboundSetDefaultSpawnPositionPacket(world.getSharedSpawnPos(), world.getSharedSpawnAngle()));
-+        if (!player.smoothWorldTeleport) player.connection.send(new ClientboundSetDefaultSpawnPositionPacket(world.getSharedSpawnPos(), world.getSharedSpawnAngle()));
-         if (world.isRaining()) {
-             // CraftBukkit start - handle player weather
-             // entityplayer.connection.send(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.START_RAINING, 0.0F));
-@@ -1293,7 +1295,7 @@ public abstract class PlayerList {
-             // CraftBukkit end
-         }
- 
--        player.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.LEVEL_CHUNKS_LOAD_START, 0.0F));
-+        if (!player.smoothWorldTeleport) player.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.LEVEL_CHUNKS_LOAD_START, 0.0F));
-         this.server.tickRateManager().updateJoiningPlayer(player);
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index e77bf7f432387bdfa7f69d31b014e8cd254fd4ca..bbafd70973b36fefe4f0228d6ca7b24f9771ead7 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -1255,6 +1255,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         // Paper end
-     }
- 
-+    // Slice start
-+    public void teleportWithoutRespawn(Location location) {
-+        ServerPlayer serverPlayer = getHandle();
-+        serverPlayer.smoothWorldTeleport = true;
-+        teleport(location);
-+        serverPlayer.smoothWorldTeleport = false;
-+    }
-+    // Slice end
-+
-     @Override
-     public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
-         // Paper start - Teleport API

patches/server/0011-Allow-inventory-clicks-in-Spectator.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 22 May 2023 08:21:18 -0500
+Date: Wed, 13 Nov 2024 07:58:14 -0600
 Subject: [PATCH] Allow inventory clicks in Spectator
 
 
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index a7e40f72a3b56916620a7f089410ec3a6db0cffc..de421ee333ab796a7b9c077045c16e994f72bb4f 100644
+index b5d5dbc50a7b8c40739a15f164ffd08fdc534f9c..7644dfe30a51295ac3fa59384153c839fa781c01 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -2872,7 +2872,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+@@ -2991,7 +2991,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
          if (this.player.isImmobile()) return; // CraftBukkit
          this.player.resetLastActionTime();
          if (this.player.containerMenu.containerId == packet.getContainerId() && this.player.containerMenu.stillValid(this.player)) { // CraftBukkit

patches/server/0011-Disable-Azalea-generation.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 08:45:12 -0500
-Subject: [PATCH] Disable Azalea generation
-
-
-diff --git a/src/main/java/net/minecraft/data/worldgen/BiomeDefaultFeatures.java b/src/main/java/net/minecraft/data/worldgen/BiomeDefaultFeatures.java
-index b9b7d2e668d9f7f36ac3cf1e1716460c4ad5ed3a..9fdd765b65777a1a82b54326bc7ad152416c617e 100644
---- a/src/main/java/net/minecraft/data/worldgen/BiomeDefaultFeatures.java
-+++ b/src/main/java/net/minecraft/data/worldgen/BiomeDefaultFeatures.java
-@@ -162,7 +162,7 @@ public class BiomeDefaultFeatures {
-         builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.CAVE_VINES);
-         builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.LUSH_CAVES_CLAY);
-         builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.LUSH_CAVES_VEGETATION);
--        builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.ROOTED_AZALEA_TREE);
-+//        builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.ROOTED_AZALEA_TREE); // Slice
-         builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.SPORE_BLOSSOM);
-         builder.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, CavePlacements.CLASSIC_VINES);
-     }
-diff --git a/src/main/java/net/minecraft/data/worldgen/features/CaveFeatures.java b/src/main/java/net/minecraft/data/worldgen/features/CaveFeatures.java
-index c1f4a722b57bdc1ee516951c9341b146eb0fb34e..9d81f1e3e64edfcd5e8a2885dda3187386941cb8 100644
---- a/src/main/java/net/minecraft/data/worldgen/features/CaveFeatures.java
-+++ b/src/main/java/net/minecraft/data/worldgen/features/CaveFeatures.java
-@@ -110,7 +110,7 @@ public class CaveFeatures {
-         RandomizedIntStateProvider randomizedIntStateProvider = new RandomizedIntStateProvider(new WeightedStateProvider(SimpleWeightedRandomList.<BlockState>builder().add(Blocks.CAVE_VINES.defaultBlockState(), 4).add(Blocks.CAVE_VINES.defaultBlockState().setValue(CaveVines.BERRIES, Boolean.valueOf(true)), 1)), CaveVinesBlock.AGE, UniformInt.of(23, 25));
-         FeatureUtils.register(featureRegisterable, CAVE_VINE, Feature.BLOCK_COLUMN, new BlockColumnConfiguration(List.of(BlockColumnConfiguration.layer(new WeightedListInt(SimpleWeightedRandomList.<IntProvider>builder().add(UniformInt.of(0, 19), 2).add(UniformInt.of(0, 2), 3).add(UniformInt.of(0, 6), 10).build()), weightedStateProvider), BlockColumnConfiguration.layer(ConstantInt.of(1), randomizedIntStateProvider)), Direction.DOWN, BlockPredicate.ONLY_IN_AIR_PREDICATE, true));
-         FeatureUtils.register(featureRegisterable, CAVE_VINE_IN_MOSS, Feature.BLOCK_COLUMN, new BlockColumnConfiguration(List.of(BlockColumnConfiguration.layer(new WeightedListInt(SimpleWeightedRandomList.<IntProvider>builder().add(UniformInt.of(0, 3), 5).add(UniformInt.of(1, 7), 1).build()), weightedStateProvider), BlockColumnConfiguration.layer(ConstantInt.of(1), randomizedIntStateProvider)), Direction.DOWN, BlockPredicate.ONLY_IN_AIR_PREDICATE, true));
--        FeatureUtils.register(featureRegisterable, MOSS_VEGETATION, Feature.SIMPLE_BLOCK, new SimpleBlockConfiguration(new WeightedStateProvider(SimpleWeightedRandomList.<BlockState>builder().add(Blocks.FLOWERING_AZALEA.defaultBlockState(), 4).add(Blocks.AZALEA.defaultBlockState(), 7).add(Blocks.MOSS_CARPET.defaultBlockState(), 25).add(Blocks.SHORT_GRASS.defaultBlockState(), 50).add(Blocks.TALL_GRASS.defaultBlockState(), 10))));
-+        FeatureUtils.register(featureRegisterable, MOSS_VEGETATION, Feature.SIMPLE_BLOCK, new SimpleBlockConfiguration(new WeightedStateProvider(SimpleWeightedRandomList.<BlockState>builder().add(Blocks.MOSS_CARPET.defaultBlockState(), 25).add(Blocks.SHORT_GRASS.defaultBlockState(), 50).add(Blocks.TALL_GRASS.defaultBlockState(), 10))));
-         FeatureUtils.register(featureRegisterable, MOSS_PATCH, Feature.VEGETATION_PATCH, new VegetationPatchConfiguration(BlockTags.MOSS_REPLACEABLE, BlockStateProvider.simple(Blocks.MOSS_BLOCK), PlacementUtils.inlinePlaced(holderGetter.getOrThrow(MOSS_VEGETATION)), CaveSurface.FLOOR, ConstantInt.of(1), 0.0F, 5, 0.8F, UniformInt.of(4, 7), 0.3F));
-         FeatureUtils.register(featureRegisterable, MOSS_PATCH_BONEMEAL, Feature.VEGETATION_PATCH, new VegetationPatchConfiguration(BlockTags.MOSS_REPLACEABLE, BlockStateProvider.simple(Blocks.MOSS_BLOCK), PlacementUtils.inlinePlaced(holderGetter.getOrThrow(MOSS_VEGETATION)), CaveSurface.FLOOR, ConstantInt.of(1), 0.0F, 5, 0.6F, UniformInt.of(1, 2), 0.75F));
-         FeatureUtils.register(featureRegisterable, DRIPLEAF, Feature.SIMPLE_RANDOM_SELECTOR, new SimpleRandomFeatureConfiguration(HolderSet.direct(makeSmallDripleaf(), makeDripleaf(Direction.EAST), makeDripleaf(Direction.WEST), makeDripleaf(Direction.SOUTH), makeDripleaf(Direction.NORTH))));

patches/server/0012-Add-reason-to-PlayerConnectionCloseEvent.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 22 Aug 2023 06:22:16 -0500
+Date: Wed, 13 Nov 2024 08:04:09 -0600
 Subject: [PATCH] Add reason to PlayerConnectionCloseEvent
 
 
 diff --git a/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
-index 87c5690774363edc1b7ebff10b041e48c0a6d56d..cf018b276c674f49c2aaa0084ecdcdc4dc6edbd4 100644
+index 880e5c52746e9e3a9a1f42ec6461be54e3ee136c..e8eeb1aaeec6d87af949e249d0ffd0856bfd71b1 100644
 --- a/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
-@@ -142,6 +142,7 @@ public class ServerConfigurationPacketListenerImpl extends ServerCommonPacketLis
+@@ -180,6 +180,7 @@ public class ServerConfigurationPacketListenerImpl extends ServerCommonPacketLis
              // Paper end - Debugging
              this.connection.send(new ClientboundDisconnectPacket(ServerConfigurationPacketListenerImpl.DISCONNECT_REASON_INVALID_DATA));
              this.connection.disconnect(ServerConfigurationPacketListenerImpl.DISCONNECT_REASON_INVALID_DATA);

patches/server/0012-AntiXray-Bypass.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 08:46:54 -0500
-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 e7fe98ea30ae6d0baea3ec1f9f98a89502a49a12..7e2651aa63cc9ddbe28fb9ecbc5188358d52e607 100644
---- a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
-+++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java
-@@ -169,6 +169,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 bbafd70973b36fefe4f0228d6ca7b24f9771ead7..a86600e01572ee14f35ecf1b7e71dbac369632e1 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -199,6 +199,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     public org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus; // Paper - more resource pack API
-     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 - getLastPlayed replacement API
-+    private boolean antiXrayBypass; // Slice
- 
-     public CraftPlayer(CraftServer server, ServerPlayer entity) {
-         super(server, entity);
-@@ -2952,6 +2953,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/0013-Add-PlayerPreChunkLoadEvent.patch

@@ -1,37 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 10 Apr 2023 08:47:43 -0500
-Subject: [PATCH] Add PlayerPreChunkLoadEvent
-
-
-diff --git a/src/main/java/io/papermc/paper/chunk/system/RegionizedPlayerChunkLoader.java b/src/main/java/io/papermc/paper/chunk/system/RegionizedPlayerChunkLoader.java
-index 1b090f1e79b996e52097afc49c1cec85936653e6..5185bcbf5363fa2c7e2b0226706cc66d46fa16ee 100644
---- a/src/main/java/io/papermc/paper/chunk/system/RegionizedPlayerChunkLoader.java
-+++ b/src/main/java/io/papermc/paper/chunk/system/RegionizedPlayerChunkLoader.java
-@@ -410,7 +410,7 @@ public class RegionizedPlayerChunkLoader {
-         private boolean canGenerateChunks = true;
- 
-         private final ArrayDeque<ChunkHolderManager.TicketOperation<?, ?>> delayedTicketOps = new ArrayDeque<>();
--        private final LongOpenHashSet sentChunks = new LongOpenHashSet();
-+        public final LongOpenHashSet sentChunks = new LongOpenHashSet(); // Slice -> public
- 
-         private static final byte CHUNK_TICKET_STAGE_NONE           = 0;
-         private static final byte CHUNK_TICKET_STAGE_LOADING        = 1;
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 2e5fae21dcf511c18d309780fcc3204d3bfa7af2..fd8c6a3aaba37bb7439e74b9fc765dd7332041d9 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -547,6 +547,13 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         return true;
-     }
- 
-+    @Override
-+    @NotNull
-+    public it.unimi.dsi.fastutil.longs.LongOpenHashSet getSentChunks(@NotNull Player p) {
-+        ServerPlayer craftPlayer = ((CraftPlayer) p).getHandle();
-+        return craftPlayer.chunkLoader.sentChunks;
-+    }
-+
-     @Override
-     public boolean isChunkInUse(int x, int z) {
-         return this.isChunkLoaded(x, z);

patches/server/0013-Change-KeepAlive-interval.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Wed, 13 Nov 2024 08:04:58 -0600
+Subject: [PATCH] Change KeepAlive interval
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index b0bc66dc7248aae691dcab68b925b52a1695e63f..7096cbc201cd18e71b5da6b825fca83201ada1a3 100644
+--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -261,7 +261,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         long currentTime = Util.getMillis();
+         long elapsedTime = currentTime - this.keepAliveTime;
+ 
+-        if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // Paper - use vanilla's 15000L between keep alive packets
++        if (!this.isSingleplayerOwner() && elapsedTime >= 5000L) { // Paper - use vanilla's 15000L between keep alive packets // Slice -> 5s
+             if (this.keepAlivePending && !this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // Paper - check keepalive limit, don't fire if already disconnected
+                 this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE, PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
+             } else if (this.checkIfClosed(currentTime)) { // Paper

patches/server/0014-Allow-opening-covered-chests.patch

@@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 18 Apr 2023 07:49:59 -0500
-Subject: [PATCH] Allow opening covered chests
-
-
-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 9804ee2020e5cef23d3f5174d153fc149e611503..8baeb4cb4a6e24e8099a0a98779dc50073d5d0b4 100644
---- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
-@@ -358,9 +358,10 @@ public class ChestBlock extends AbstractChestBlock<ChestBlockEntity> implements
-     }
- 
-     private static boolean isBlockedChestByBlock(BlockGetter world, BlockPos pos) {
--        BlockPos blockposition1 = pos.above();
--
--        return world.getBlockState(blockposition1).isRedstoneConductor(world, blockposition1);
-+        return false;
-+//        BlockPos blockposition1 = pos.above();
-+//
-+//        return world.getBlockState(blockposition1).isRedstoneConductor(world, blockposition1);
-     }
- 
-     private static boolean isCatSittingOnChest(LevelAccessor world, BlockPos pos) {
-diff --git a/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java b/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
-index ddca14f1224327a738415fb8b37398d8df0aa9c8..cfd9bfd30d4b1787dacc95215e823603537131fd 100644
---- a/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
-@@ -83,10 +83,10 @@ public class EnderChestBlock extends AbstractChestBlock<EnderChestBlockEntity> i
-         PlayerEnderChestContainer playerEnderChestContainer = player.getEnderChestInventory();
-         BlockEntity blockEntity = world.getBlockEntity(pos);
-         if (playerEnderChestContainer != null && blockEntity instanceof EnderChestBlockEntity) {
--            BlockPos blockPos = pos.above();
--            if (world.getBlockState(blockPos).isRedstoneConductor(world, blockPos)) {
--                return InteractionResult.sidedSuccess(world.isClientSide);
--            } else if (world.isClientSide) {
-+//            BlockPos blockPos = pos.above();
-+//            if (world.getBlockState(blockPos).isRedstoneConductor(world, blockPos)) {
-+//                return InteractionResult.sidedSuccess(world.isClientSide);
-+            if (world.isClientSide) {
-                 return InteractionResult.SUCCESS;
-             } else {
-                 EnderChestBlockEntity enderChestBlockEntity = (EnderChestBlockEntity)blockEntity;

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

@@ -1,19 +1,20 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Mon, 12 Jun 2023 14:14:48 -0500
+Date: Wed, 13 Nov 2024 08:07:59 -0600
 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
+index 830bd76916e26a3a54954d3cf7b7520af52a2258..dc9c7a844c2aee1dae80006eafe085c6fa126ae1 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
+@@ -30,6 +30,16 @@ 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) {
++    public ClientboundSetEquipmentPacket(int id, List<Pair<EquipmentSlot, ItemStack>> equipmentList, net.minecraft.world.entity.LivingEntity entity, boolean sanitize, String tag) {
 +        this.entity = id;
++        this.sanitize = sanitize;
 +        slots = new java.util.ArrayList<>(equipmentList.size());
 +        for (Pair<EquipmentSlot, ItemStack> pair : equipmentList) {
 +            EquipmentSlot slot = pair.getFirst();
@@ -21,64 +22,42 @@ index 5a8f850b447fc3a4bd0eb0c505bbdfc8be7115e8..34d74735b7a7d258c6bd14bb7e540693
 +        }
 +    }
 +
-     public ClientboundSetEquipmentPacket(FriendlyByteBuf buf) {
+     private ClientboundSetEquipmentPacket(RegistryFriendlyByteBuf buf) {
          this.entity = buf.readVarInt();
-         EquipmentSlot[] equipmentSlots = EquipmentSlot.values();
+         this.slots = Lists.newArrayList();
 diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index e3e0f306ebed31ce4742e7d2f15ab102b93a9dff..4f4ea6dcef4e1960ac69271fbd771dd3ad6af275 100644
+index 90eb4927fa51ce3df86aa7b6c71f49150a03e337..a6c3beb9d5ab87fca882e1761983ebe385011296 100644
 --- a/src/main/java/net/minecraft/server/level/ServerEntity.java
 +++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -331,27 +331,8 @@ public class ServerEntity {
-             sender.accept(new ClientboundSetEntityMotionPacket(this.entity.getId(), this.ap));
-         }
+@@ -388,22 +388,7 @@ public class ServerEntity {
+         Entity entity = this.entity;
  
--        if (this.entity instanceof LivingEntity) {
+         if (entity instanceof LivingEntity entityliving) {
 -            List<Pair<EquipmentSlot, ItemStack>> list = Lists.newArrayList();
--            EquipmentSlot[] aenumitemslot = EquipmentSlot.values();
--            int i = aenumitemslot.length;
+-            Iterator iterator = EquipmentSlot.VALUES.iterator();
 -
--            for (int j = 0; j < i; ++j) {
--                EquipmentSlot enumitemslot = aenumitemslot[j];
--                ItemStack itemstack = ((LivingEntity) this.entity).getItemBySlot(enumitemslot);
+-            while (iterator.hasNext()) {
+-                EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
+-                ItemStack itemstack = entityliving.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 - Hide unnecessary item meta
--                    // Paper end - prevent oversized data
+-                    list.add(Pair.of(enumitemslot, itemstack.copy()));
 -                }
 -            }
 -
 -            if (!list.isEmpty()) {
--                sender.accept(new ClientboundSetEquipmentPacket(this.entity.getId(), list));
+-                sender.accept(new ClientboundSetEquipmentPacket(this.entity.getId(), list, true)); // Paper - data sanitization
 -            }
 -            ((LivingEntity) this.entity).detectEquipmentUpdatesPublic(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
-+        if (this.entity instanceof LivingEntity livingEntity) {
-+            livingEntity.sendEquipment(sender, player); // Slice
++            entityliving.sendEquipment(sender, player);
          }
  
          if (!this.entity.getPassengers().isEmpty()) {
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d0136eb87 100644
+index f36a075dbee2b96d01899e02460b1d8443e91749..0634626d4a0bda9ac58f1fd16265ca866ee9f5c3 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -1,6 +1,7 @@
- package net.minecraft.world.entity;
- 
- import com.google.common.base.Objects;
-+import com.google.common.cache.Cache;
- import com.google.common.collect.ImmutableList;
- import com.google.common.collect.ImmutableMap;
- import com.google.common.collect.Lists;
-@@ -143,7 +144,6 @@ import org.bukkit.event.entity.EntityTeleportEvent;
- import org.bukkit.event.player.PlayerItemConsumeEvent;
- // CraftBukkit end
- 
--import co.aikar.timings.MinecraftTimings; // Paper
- 
- public abstract class LivingEntity extends Entity implements Attackable {
- 
-@@ -264,6 +264,11 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -298,6 +298,11 @@ public abstract class LivingEntity extends Entity implements Attackable {
      public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
      public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // Paper - Friction API
  
@@ -90,7 +69,7 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
      @Override
      public float getBukkitYaw() {
          return this.getYHeadRot();
-@@ -3133,6 +3138,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -3383,6 +3388,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
          if (map != null) {
              this.handleHandSwap(map);
              if (!map.isEmpty()) {
@@ -98,11 +77,11 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
                  this.handleEquipmentChanges(map);
              }
          }
-@@ -3225,7 +3231,25 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -3507,7 +3513,25 @@ public abstract class LivingEntity extends Entity implements Attackable {
              }
  
          });
--        ((ServerLevel) this.level()).getChunkSource().broadcast(this, new ClientboundSetEquipmentPacket(this.getId(), list));
+-        ((ServerLevel) this.level()).getChunkSource().broadcast(this, new ClientboundSetEquipmentPacket(this.getId(), list, true)); // Paper - data sanitization
 +
 +        // Slice start
 +        net.minecraft.server.level.ChunkMap.TrackedEntity entityTracker = ((ServerLevel) this.level()).getChunkSource().chunkMap.entityMap.get(getId());
@@ -115,7 +94,7 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
 +
 +                String tag = event.getTag();
 +                if (tag != null) {
-+                    playerConnection.send(new ClientboundSetEquipmentPacket(this.getId(), list, this, tag));
++                    playerConnection.send(new ClientboundSetEquipmentPacket(this.getId(), list, this, false, tag));
 +                } else {
 +                    playerConnection.send(packet);
 +                }
@@ -124,20 +103,20 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
 +        // Slice end
      }
  
-     // Paper start - Hide unnecessary item meta
-@@ -4565,4 +4589,85 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     private ItemStack getLastArmorItem(EquipmentSlot slot) {
+@@ -4803,4 +4827,84 @@ public abstract class LivingEntity extends Entity implements Attackable {
      public static record Fallsounds(SoundEvent small, SoundEvent big) {
  
      }
 +
 +    // Slice start
 +    public static void invalidateCachedEquipment(String tag) {
-+        Cache<Integer, ItemStack> removedCache = equipmentPacketCache.remove(tag);
++        com.google.common.cache.Cache<Integer, ItemStack> removedCache = equipmentPacketCache.remove(tag);
 +        if (removedCache != null) {
 +            removedCache.asMap().clear();
 +        }
 +    }
-+    
++
 +    public ItemStack getOrCreateCachedEquipmentItem(String tag, EquipmentSlot slot, ItemStack itemStack) {
 +        return equipmentPacketCache.computeIfAbsent(tag,  s -> com.google.common.cache.CacheBuilder.newBuilder()
 +                        .expireAfterAccess(10, java.util.concurrent.TimeUnit.MINUTES)
@@ -169,7 +148,7 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
 +        boolean sendEquipment = !event.isCancelled();
 +        String tag = event.getTag();
 +        if (sendEquipment && this instanceof ServerPlayer player && tag != null) {
-+            ClientboundSetEquipmentPacket equipmentPacket = player.cachedEquipmentPacket.get(tag);
++        ClientboundSetEquipmentPacket equipmentPacket = player.cachedEquipmentPacket.get(tag);
 +            if (equipmentPacket != null) {
 +                //Event says use a tag, and our tag exists; so we simply used our entire cached packet
 +                consumer.accept(equipmentPacket);
@@ -178,28 +157,27 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
 +        }
 +
 +        if (sendEquipment) {
-+            EquipmentSlot[] equipmentSlots = EquipmentSlot.values();
-+            List<Pair<EquipmentSlot, ItemStack>> list = new ArrayList<>(equipmentSlots.length);
++            List<Pair<EquipmentSlot, ItemStack>> list = Lists.newArrayList();
++            Iterator iterator = EquipmentSlot.VALUES.iterator();
 +
-+            for (EquipmentSlot enumitemslot : equipmentSlots) {
++            while (iterator.hasNext()) {
++                EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
 +                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);
-+
++                    ItemStack finalItemStack;
 +                    if (tag != null) {
-+                        strippedItem = getOrCreateCachedEquipmentItem(tag, enumitemslot, strippedItem);
++                        finalItemStack = getOrCreateCachedEquipmentItem(tag, enumitemslot, itemstack);
++                    } else {
++                        finalItemStack = itemstack.copy();
 +                    }
 +
-+                    list.add(Pair.of(enumitemslot, strippedItem)); // Paper - remove unnecessary item meta
-+                    // Paper end - prevent oversized data
++                    list.add(Pair.of(enumitemslot, finalItemStack));
 +                }
 +            }
 +
 +            if (!list.isEmpty()) {
-+                ClientboundSetEquipmentPacket equipmentPacket = new ClientboundSetEquipmentPacket(getId(), list);
++                ClientboundSetEquipmentPacket equipmentPacket = new ClientboundSetEquipmentPacket(getId(), list, true);
 +                if (tag != null) {
 +                    cachedEquipmentPacket.put(tag, equipmentPacket);
 +                }
@@ -212,14 +190,13 @@ index e9bb7feb591032904516d1b9374f486d8a7d066c..d6c23f52fdbcf55cb69b75ed95e7e83d
 +    // Slice end
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index c4a166a0c226c6083c25c58145d9631d4296e615..187cea96bbe0f1c157484ad42e74951bc714d199 100644
+index d0c409f4efad289e3e325f44b500fc72589d89d4..baecf1c7bb459786bdbe6f7381ef148e0dad0ef5 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -1210,4 +1210,14 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         this.getHandle().setYBodyRot(bodyYaw);
+@@ -1205,6 +1205,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
      }
      // Paper end - body yaw API
-+
+ 
 +    // Slice start
 +    @Override
 +    public void sendEquipment(Player p) {
@@ -229,4 +206,7 @@ index c4a166a0c226c6083c25c58145d9631d4296e615..187cea96bbe0f1c157484ad42e74951b
 +        }
 +    }
 +    // Slice end
- }
++
+     // Paper start - Expose canUseSlot
+     @Override
+     public boolean canUseEquipmentSlot(org.bukkit.inventory.EquipmentSlot slot) {

patches/server/0015-Add-ChunkStatusChangeEvent.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 16 Nov 2024 08:48:20 -0600
+Subject: [PATCH] Add ChunkStatusChangeEvent
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
+index eafa4e6d55cd0f9314ac0f2b96a7f48fbb5e1a4c..ee5f51bc5f31f269bdac239cb48265ae355db1ff 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
+@@ -1261,6 +1261,13 @@ public final class NewChunkHolder {
+                 // note: currentChunk must be LevelChunk, as current != pending which means that at least one is not ACCESSIBLE
+                 final LevelChunk chunk = (LevelChunk)this.currentChunk;
+ 
++                // Slice start
++                new com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent(new org.bukkit.craftbukkit.CraftChunk(chunk),
++                        com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent.ChunkStatus.valueOf(current.name()),
++                        com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent.ChunkStatus.valueOf(current.name()))
++                        .callEvent();
++                // Slice end
++
+                 // Note: we assume that only load/unload contain plugin logic
+                 // plugin logic is anything stupid enough to possibly change the chunk status while it is already
+                 // being changed (i.e during load it is possible it will try to set to full ticking)

patches/server/0016-Biome-freeze-override.patch

@@ -1,27 +1,27 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 29 Aug 2023 09:23:11 -0500
+Date: Sat, 16 Nov 2024 08:58:56 -0600
 Subject: [PATCH] Biome freeze override
 
 
 diff --git a/src/main/java/net/minecraft/world/level/biome/Biome.java b/src/main/java/net/minecraft/world/level/biome/Biome.java
-index 4f9187d9d640618c40a2fa528f36b845017b4777..86372a10ab41bf0f5b7b88dc4d71c6802cd93b7d 100644
+index b725eea9d3ca81d2ef7802f5d0346d924aa1f808..1d903fa83432ed971f784b8cb244b0c5b163830e 100644
 --- a/src/main/java/net/minecraft/world/level/biome/Biome.java
 +++ b/src/main/java/net/minecraft/world/level/biome/Biome.java
-@@ -76,6 +76,7 @@ public final class Biome {
+@@ -71,6 +71,7 @@ public final class Biome {
+             long2FloatLinkedOpenHashMap.defaultReturnValue(Float.NaN);
              return long2FloatLinkedOpenHashMap;
-         });
-     });
+         }));
 +    public Boolean canFreeze = null; // Slice
  
      Biome(Biome.ClimateSettings weather, BiomeSpecialEffects effects, BiomeGenerationSettings generationSettings, MobSpawnSettings spawnSettings) {
          this.climateSettings = weather;
-@@ -138,6 +139,8 @@ public final class Biome {
+@@ -120,6 +121,8 @@ public final class Biome {
      }
  
      public boolean shouldFreeze(LevelReader world, BlockPos pos, boolean doWaterCheck) {
 +        if (canFreeze != null) return canFreeze; // Slice
 +
-         if (this.warmEnoughToRain(pos)) {
+         if (this.warmEnoughToRain(pos, world.getSeaLevel())) {
              return false;
          } else {

patches/server/0017-Add-Vanish.patch

@@ -0,0 +1,84 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 16 Nov 2024 09:10:35 -0600
+Subject: [PATCH] Add Vanish
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 55b9b33ce85cdff75de8753e6294c99bb1b1f7ee..9bb19124498370c5b5ecaff10f523ee6e391b767 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -389,6 +389,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
+     public boolean fixedPose = false; // Paper - Expand Pose API
+     private final int despawnTime; // Paper - entity despawn time limit
++    public boolean vanished; // Slice
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -1389,7 +1390,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+ 
+     private boolean vibrationAndSoundEffectsFromBlock(BlockPos pos, BlockState state, boolean playSound, boolean emitEvent, Vec3 movement) {
+-        if (state.isAir()) {
++        if (vanished || state.isAir()) { // Slice
+             return false;
+         } else {
+             boolean flag2 = this.isStateClimbable(state);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index ddabaed899c755925ad8618b78c33dacaf2126ac..aefa94ffd630e2dd6aefd547664ae25d2a81420c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1306,4 +1306,16 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         }
+     }
+     // Paper end - broadcast hurt animation
++
++    // Slice start
++    @Override
++    public boolean isVanished() {
++        return this.entity.vanished;
++    }
++
++    @Override
++    public void setVanished(boolean vanished) {
++        this.entity.vanished = vanished;
++    }
++    // Slice end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
+index da1c1fe0faf6819b15a81d6ad53370948e5f984f..84eff85e98484c9701e203bb1fa61435ee88bab4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
+@@ -69,6 +69,14 @@ public class CraftInventoryCustom extends CraftInventory {
+     }
+     // Paper end
+ 
++    // Slice start
++    public void setLocation(Location location) {
++        if (this.inventory instanceof MinecraftInventory minecraftInventory) {
++            minecraftInventory.location = location;
++        }
++    }
++    // Slice end
++
+     static class MinecraftInventory implements Container {
+         private final NonNullList<ItemStack> items;
+         private int maxStack = MAX_STACK;
+@@ -77,6 +85,7 @@ public class CraftInventoryCustom extends CraftInventory {
+         private final net.kyori.adventure.text.Component adventure$title; // Paper
+         private InventoryType type;
+         private final InventoryHolder owner;
++        private Location location; // Slice
+ 
+         // Paper start
+         public MinecraftInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) {
+@@ -239,7 +248,7 @@ public class CraftInventoryCustom extends CraftInventory {
+ 
+         @Override
+         public Location getLocation() {
+-            return null;
++            return location;
+         }
+ 
+         // Paper start

patches/server/0017-Disable-geode-and-monsterspawners-generation.patch

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 18 Apr 2023 07:56:32 -0500
-Subject: [PATCH] Disable geode and monsterspawners generation
-
-
-diff --git a/src/main/java/net/minecraft/data/worldgen/biome/OverworldBiomes.java b/src/main/java/net/minecraft/data/worldgen/biome/OverworldBiomes.java
-index 84aa56cbcaa5539b556f42eb284d3dd2e200e358..a6d2ead225841192c2eb80b3b2e54ceeaa76546b 100644
---- a/src/main/java/net/minecraft/data/worldgen/biome/OverworldBiomes.java
-+++ b/src/main/java/net/minecraft/data/worldgen/biome/OverworldBiomes.java
-@@ -54,8 +54,8 @@ public class OverworldBiomes {
- 
-     private static void globalOverworldGeneration(BiomeGenerationSettings.Builder generationSettings) {
-         BiomeDefaultFeatures.addDefaultCarversAndLakes(generationSettings);
--        BiomeDefaultFeatures.addDefaultCrystalFormations(generationSettings);
--        BiomeDefaultFeatures.addDefaultMonsterRoom(generationSettings);
-+//        BiomeDefaultFeatures.addDefaultCrystalFormations(generationSettings); // Slice - Don't generate Geodes in our chunk generation
-+//        BiomeDefaultFeatures.addDefaultMonsterRoom(generationSettings);
-         BiomeDefaultFeatures.addDefaultUndergroundVariety(generationSettings);
-         BiomeDefaultFeatures.addDefaultSprings(generationSettings);
-         BiomeDefaultFeatures.addSurfaceFreezing(generationSettings);

patches/server/0018-Add-jackson.patch

@@ -1,17 +1,17 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 2 May 2023 07:54:02 -0500
+Date: Sat, 16 Nov 2024 09:14:26 -0600
 Subject: [PATCH] Add jackson
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index c9868e781ce212285a9621236efa65788c7a1cca..223e80ea0ede575cf8f73191ef2799ae0ee41ba7 100644
+index 63aa7a91dad0903383405c2cccf894d23a2ede54..fcc93b891c04d8b340b29a8b96e939df9b58839a 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
-@@ -19,6 +19,13 @@ dependencies {
-         exclude("io.papermc.paper", "paper-api")
-     }
-     // Slice end
+@@ -26,6 +26,13 @@ abstract class MockitoAgentProvider : CommandLineArgumentProvider {
+ 
+ dependencies {
+     implementation(project(":slice-api"))
 +
 +    // Slice start - JSON logging for DataDog ingestion
 +    implementation("com.fasterxml.jackson.core:jackson-core:2.13.0")
@@ -20,5 +20,5 @@ index c9868e781ce212285a9621236efa65788c7a1cca..223e80ea0ede575cf8f73191ef2799ae
 +    // Slice end
 +
      // Paper start
-     implementation("org.jline:jline-terminal-jansi:3.21.0")
-     implementation("net.minecrell:terminalconsoleappender:1.3.0")
+     implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
+     implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21

patches/server/0018-Set-Mutton-nutrition-equal-to-beef.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 18 Apr 2023 07:58:01 -0500
-Subject: [PATCH] Set Mutton nutrition equal to beef
-
-
-diff --git a/src/main/java/net/minecraft/world/food/Foods.java b/src/main/java/net/minecraft/world/food/Foods.java
-index b16d9e2eaa589f19c563ee70b1a56d67dbcdecb0..c6ff08efc7f0c0e782f8e78e01b9d9cea5cdcaed 100644
---- a/src/main/java/net/minecraft/world/food/Foods.java
-+++ b/src/main/java/net/minecraft/world/food/Foods.java
-@@ -17,7 +17,7 @@ public class Foods {
-     public static final FoodProperties COOKED_BEEF = (new FoodProperties.Builder()).nutrition(8).saturationMod(0.8F).meat().build();
-     public static final FoodProperties COOKED_CHICKEN = (new FoodProperties.Builder()).nutrition(6).saturationMod(0.6F).meat().build();
-     public static final FoodProperties COOKED_COD = (new FoodProperties.Builder()).nutrition(5).saturationMod(0.6F).build();
--    public static final FoodProperties COOKED_MUTTON = (new FoodProperties.Builder()).nutrition(6).saturationMod(0.8F).meat().build();
-+    public static final FoodProperties COOKED_MUTTON = (new FoodProperties.Builder()).nutrition(8).saturationMod(0.8F).meat().build();
-     public static final FoodProperties COOKED_PORKCHOP = (new FoodProperties.Builder()).nutrition(8).saturationMod(0.8F).meat().build();
-     public static final FoodProperties COOKED_RABBIT = (new FoodProperties.Builder()).nutrition(5).saturationMod(0.6F).meat().build();
-     public static final FoodProperties COOKED_SALMON = (new FoodProperties.Builder()).nutrition(6).saturationMod(0.8F).build();

patches/server/0019-Add-ObjectId.patch

@@ -1,27 +1,27 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Wed, 24 Jan 2024 11:39:13 -0600
-Subject: [PATCH] PlayerResolveObjectIdEvent
+Date: Sat, 16 Nov 2024 09:22:24 -0600
+Subject: [PATCH] Add ObjectId
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 85c077a53422e1c2dc1ff550ac117016c3d8e3f0..46980b062980be8c564a215a2ae67e0d1fe5251e 100644
+index fcc93b891c04d8b340b29a8b96e939df9b58839a..4893e10810583c12f6b34ec63d96bc8477264415 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
-@@ -26,6 +26,8 @@ dependencies {
+@@ -33,6 +33,8 @@ dependencies {
      implementation("com.fasterxml.jackson.core:jackson-annotations:2.13.0")
      // Slice end
  
 +    implementation("org.mongodb:bson:4.11.1") // Slice - MongoDB Bson Library for ObjectIds
 +
      // Paper start
-     implementation("org.jline:jline-terminal-jansi:3.21.0")
-     implementation("net.minecrell:terminalconsoleappender:1.3.0")
+     implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
+     implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index e858d24061ce8fad612c12adac205c7ad59b8767..ad2567133405744abcf20d8572d6c7afc37581af 100644
+index 9bb19124498370c5b5ecaff10f523ee6e391b767..77cc9ae3f5d71454c3b75c44cf53bcfbc5f3eb84 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -252,7 +252,17 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -223,7 +223,17 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              // Paper start - Folia schedulers
              synchronized (this) {
                  if (this.bukkitEntity == null) {
@@ -41,32 +41,10 @@ index e858d24061ce8fad612c12adac205c7ad59b8767..ad2567133405744abcf20d8572d6c7af
              }
              // Paper end - Folia schedulers
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 7984365c8290ac9e526a413b56e1c8c0841e330c..933fc8295b3b697c9f8cd8516ccac13348dcb843 100644
+index e345cdbfab44a0f5da80d738798dbb4424b7ab5c..ba1280382f2b95ea2cb412d3a15789affc65bb12 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -7,6 +7,8 @@ import java.util.Arrays;
- import java.util.Collection;
- import java.util.Optional;
- import java.util.Set;
-+
-+import io.papermc.paper.event.player.PlayerResolveObjectIdEvent;
- import net.minecraft.core.BlockPos;
- import net.minecraft.nbt.CompoundTag;
- import net.minecraft.network.chat.Component;
-@@ -31,10 +33,8 @@ import net.minecraft.world.level.block.CraftingTableBlock;
- import net.minecraft.world.level.block.EnchantmentTableBlock;
- import net.minecraft.world.level.block.entity.BlockEntity;
- import net.minecraft.world.level.block.state.BlockState;
--import org.bukkit.GameMode;
--import org.bukkit.Location;
--import org.bukkit.Material;
--import org.bukkit.NamespacedKey;
-+import org.bson.types.ObjectId;
-+import org.bukkit.*;
- import org.bukkit.block.Block;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.craftbukkit.entity.memory.CraftMemoryMapper;
-@@ -75,6 +75,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+@@ -73,6 +73,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
      protected final PermissibleBase perm = new PermissibleBase(this);
      private boolean op;
      private GameMode mode;
@@ -74,18 +52,18 @@ index 7984365c8290ac9e526a413b56e1c8c0841e330c..933fc8295b3b697c9f8cd8516ccac133
  
      public CraftHumanEntity(final CraftServer server, final Player entity) {
          super(server, entity);
-@@ -83,6 +84,18 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+@@ -81,6 +82,18 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
          this.enderChest = new CraftInventory(entity.getEnderChestInventory());
      }
  
 +    // Slice start
 +    @Override
-+    public ObjectId getObjectId() {
++    public org.bson.types.ObjectId getObjectId() {
 +        return objectId;
 +    }
 +
 +    @Override
-+    public void setObjectId(ObjectId objectId) {
++    public void setObjectId(org.bson.types.ObjectId objectId) {
 +        this.objectId = objectId;
 +    }
 +    // Slice end

patches/server/0020-Add-Force-Crit-to-PlayerPreAttackEntityEvent.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:16:50 -0500
-Subject: [PATCH] Add Force Crit to PlayerPreAttackEntityEvent
-
-
-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 567704f61034363e48ef2a5b5566ebdc91682297..7c80c0a4a6ab953d4d2aaf44b8d38b7f4839ebc7 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -1280,10 +1280,11 @@ public abstract class Player extends LivingEntity {
-                         flag1 = true;
-                     }
- 
--                    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; diff on change
-+                    boolean forceCrit = playerAttackEntityEvent.isForceCrit();
-+                    boolean flag2 = forceCrit || (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; diff on change
- 
-                     flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
--                    flag2 = flag2 && !this.isSprinting();
-+                    flag2 = forceCrit || (flag2 && !this.isSprinting()); // Slice
-                     if (flag2) {
-                         f *= 1.5F;
-                     }

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

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 6 Jun 2023 07:51:32 -0500
+Date: Sat, 16 Nov 2024 09:26:55 -0600
 Subject: [PATCH] Packet obfuscation and reduction
 
 
 diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
-index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58547b1021 100644
+index 0f99733660f91280e4c6262cf75b3c9cae86f65a..8845497071ca3be0e439b454f1f2d14f0f74e842 100644
 --- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
 +++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
-@@ -165,15 +165,29 @@ public class SynchedEntityData {
+@@ -63,15 +63,29 @@ public class SynchedEntityData {
      }
  
      public <T> void set(EntityDataAccessor<T> key, T value, boolean force) {
@@ -39,8 +39,8 @@ index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58
      }
  
      // CraftBukkit start - add method from above
-@@ -215,6 +229,26 @@ public class SynchedEntityData {
-         return list;
+@@ -108,6 +122,26 @@ public class SynchedEntityData {
+         }
      }
  
 +    // Slice start
@@ -48,7 +48,7 @@ index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58
 +    public List<SynchedEntityData.DataValue<?>> packForeignDirty() {
 +        List<SynchedEntityData.DataValue<?>> list = null;
 +
-+        for (DataItem<?> dataItem : this.itemsById.values()) {
++        for (DataItem<?> dataItem : this.itemsById) {
 +            if (dataItem.isDirty(true)) {
 +                dataItem.setForeignDirty(false);
 +                if (list == null) {
@@ -66,7 +66,7 @@ index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58
      @Nullable
      public List<SynchedEntityData.DataValue<?>> getNonDefaultValues() {
          List<SynchedEntityData.DataValue<?>> list = null;
-@@ -339,11 +373,14 @@ public class SynchedEntityData {
+@@ -171,11 +205,14 @@ public class SynchedEntityData {
          T value;
          private final T initialValue;
          private boolean dirty;
@@ -81,11 +81,12 @@ index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58
          }
  
          public EntityDataAccessor<T> getAccessor() {
-@@ -373,6 +410,35 @@ public class SynchedEntityData {
+@@ -205,6 +242,36 @@ public class SynchedEntityData {
          public SynchedEntityData.DataValue<T> value() {
              return SynchedEntityData.DataValue.create(this.accessor, this.value);
          }
 +
++
 +        // Slice start
 +        public SynchedEntityData.DataValue<T> foreignValue() {
 +            return SynchedEntityData.DataValue.create(this.accessor, this.foreignValue);
@@ -116,12 +117,12 @@ index 58b602e550258c1062ee940bc46538dac95d8979..3ad5950d05fed7ff8810a8a7969fcb58
 +        // Slice end
      }
  
-     public static record DataValue<T>(int id, EntityDataSerializer<T> serializer, T value) { // CraftBukkit - decompile error
+     public static record DataValue<T>(int id, EntityDataSerializer<T> serializer, T value) {
 diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 529ab44baaf573b97cf7e89560c548642733188f..e3e0f306ebed31ce4742e7d2f15ab102b93a9dff 100644
+index a6c3beb9d5ab87fca882e1761983ebe385011296..112a8c0840ded4156782a6bab7550d4696b02c6f 100644
 --- a/src/main/java/net/minecraft/server/level/ServerEntity.java
 +++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -380,7 +380,20 @@ public class ServerEntity {
+@@ -434,7 +434,20 @@ public class ServerEntity {
  
          if (list != null) {
              this.trackedDataValues = datawatcher.getNonDefaultValues();
@@ -144,10 +145,10 @@ index 529ab44baaf573b97cf7e89560c548642733188f..e3e0f306ebed31ce4742e7d2f15ab102
  
          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 a2aa1f3f52b165e8815e5d5ba58453e02f3ed330..a23c584ce1f9abcc911aa6a39715b8eeca4ff0af 100644
+index 77cc9ae3f5d71454c3b75c44cf53bcfbc5f3eb84..a46df2ccbae85cdbdb7a19825a89c1797337d270 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -3405,7 +3405,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -3670,7 +3670,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              this.entityData.markDirty(Entity.DATA_AIR_SUPPLY_ID);
              return;
          }
@@ -157,10 +158,10 @@ index a2aa1f3f52b165e8815e5d5ba58453e02f3ed330..a23c584ce1f9abcc911aa6a39715b8ee
      }
  
 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 de8b794575dfad2ced1b44fab8dffc248ba47d19..7e2fa586ae255cb94e302c14d0811e36e860f188 100644
+index 551da84c834132d106457c123e1b195e4be904b8..e4041c58a23d3eaefd01402635f714404f3c82cf 100644
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
 +++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -646,7 +646,7 @@ public abstract class Player extends LivingEntity {
+@@ -676,7 +676,7 @@ public abstract class Player extends LivingEntity {
      public void increaseScore(int score) {
          int j = this.getScore();
  
@@ -168,12 +169,12 @@ index de8b794575dfad2ced1b44fab8dffc248ba47d19..7e2fa586ae255cb94e302c14d0811e36
 +        this.entityData.set(Player.DATA_SCORE_ID, j + score, 0); // Slice
      }
  
-     public void startAutoSpinAttack(int riptideTicks) {
+     public void startAutoSpinAttack(int riptideTicks, float riptideAttackDamage, ItemStack stack) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index a86600e01572ee14f35ecf1b7e71dbac369632e1..83b3f00d0570d7909931434cb425cb9baff513b6 100644
+index 973726a3429498b19bf36915b2e84ff29a203704..b4d72cbcbb9caa10e07fc07278d85fdc87f40102 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2755,7 +2755,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2864,7 +2864,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
                  this.sendHealthUpdate();
              }
          }

patches/server/0021-Add-PlayerLoadStatsEvent-Fix-patch.patch

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:15:23 -0500
-Subject: [PATCH] PlayerLoadStatsEvent
+Date: Sat, 16 Nov 2024 09:34:15 -0600
+Subject: [PATCH] Add PlayerLoadStatsEvent Fix patch
 
 
 diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index f96e4e958d631c42d3538d35202d59c77ddf2467..670e69b8728d47739083d087c35628c16441453f 100644
+index 2c1781a45828ef8018e976a445984197f0df1445..46f060f33fcbc6a4568a7fcfba29e83a4d192578 100644
 --- a/src/main/java/net/minecraft/server/players/PlayerList.java
 +++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -1497,7 +1497,7 @@ public abstract class PlayerList {
+@@ -1414,7 +1414,7 @@ public abstract class PlayerList {
                  }
              }
  
@@ -18,7 +18,7 @@ index f96e4e958d631c42d3538d35202d59c77ddf2467..670e69b8728d47739083d087c35628c1
          }
  
 diff --git a/src/main/java/net/minecraft/stats/ServerStatsCounter.java b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-index 0e02785ec35e635bef33cc89c54b146c8e7dac99..5f13740dbf354291bca33fe91ba581562531f6fe 100644
+index da7e1a69ecb4e6b3be2d8544ac406aa519bd196e..6947650f299f99402a4a8d9c8384eb9f71a8e3a6 100644
 --- a/src/main/java/net/minecraft/stats/ServerStatsCounter.java
 +++ b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
 @@ -45,10 +45,16 @@ public class ServerStatsCounter extends StatsCounter {
@@ -33,17 +33,25 @@ index 0e02785ec35e635bef33cc89c54b146c8e7dac99..5f13740dbf354291bca33fe91ba58156
 +        // Slice start - If event supplies stats, use it. Otherwise just load from disk as usual
 +        com.destroystokyo.paper.event.player.PlayerLoadStatsEvent event = new com.destroystokyo.paper.event.player.PlayerLoadStatsEvent(uuid);
 +        org.bukkit.Bukkit.getPluginManager().callEvent(event);
-+        JsonObject providedStats = event.getStatistics();
-+        if (providedStats != null) {
-+            readStats(server.getFixerUpper(), fromJson(providedStats));
++        JsonObject providedJson = event.getStatistics();
++        if (providedJson != null) {
++            parseLocal(server.getFixerUpper(), providedJson);
 +        } else if (file.isFile()) { // Slice end
              try {
                  this.parseLocal(server.getFixerUpper(), FileUtils.readFileToString(file));
              } catch (IOException ioexception) {
-@@ -109,46 +115,8 @@ public class ServerStatsCounter extends StatsCounter {
+@@ -101,77 +107,59 @@ public class ServerStatsCounter extends StatsCounter {
+         try {
+             JsonReader jsonreader = new JsonReader(new StringReader(json));
  
-                     if (!jsonelement.isJsonNull()) {
-                         CompoundTag nbttagcompound = ServerStatsCounter.fromJson(jsonelement.getAsJsonObject());
+-            label48:
+-            {
+-                try {
+-                    jsonreader.setLenient(false);
+-                    JsonElement jsonelement = Streams.parse(jsonreader);
+-
+-                    if (!jsonelement.isJsonNull()) {
+-                        CompoundTag nbttagcompound = ServerStatsCounter.fromJson(jsonelement.getAsJsonObject());
 -
 -                        nbttagcompound = DataFixTypes.STATS.updateToCurrentVersion(dataFixer, nbttagcompound, NbtUtils.getDataVersion(nbttagcompound, 1343));
 -                        if (!nbttagcompound.contains("stats", 10)) {
@@ -61,7 +69,7 @@ index 0e02785ec35e635bef33cc89c54b146c8e7dac99..5f13740dbf354291bca33fe91ba58156
 -                            String s1 = (String) iterator.next();
 -
 -                            if (nbttagcompound1.contains(s1, 10)) {
--                                Util.ifElse(BuiltInRegistries.STAT_TYPE.getOptional(new ResourceLocation(s1)), (statisticwrapper) -> {
+-                                Util.ifElse(BuiltInRegistries.STAT_TYPE.getOptional(ResourceLocation.parse(s1)), (statisticwrapper) -> {
 -                                    CompoundTag nbttagcompound2 = nbttagcompound1.getCompound(s1);
 -                                    Iterator iterator1 = nbttagcompound2.getAllKeys().iterator();
 -
@@ -84,57 +92,71 @@ index 0e02785ec35e635bef33cc89c54b146c8e7dac99..5f13740dbf354291bca33fe91ba58156
 -                                });
 -                            }
 -                        }
-+                        readStats(dataFixer, nbttagcompound);
-+                        break label48;
-                     }
+-                    }
+-
+-                    ServerStatsCounter.LOGGER.error("Unable to parse Stat data from {}", this.file);
+-                } catch (Throwable throwable) {
+-                    try {
+-                        jsonreader.close();
+-                    } catch (Throwable throwable1) {
+-                        throwable.addSuppressed(throwable1);
+-                    }
++            // Slice start
++            try {
++                jsonreader.setLenient(false);
++                JsonElement jsonelement = Streams.parse(jsonreader);
  
-                     ServerStatsCounter.LOGGER.error("Unable to parse Stat data from {}", this.file);
-@@ -173,6 +141,48 @@ public class ServerStatsCounter extends StatsCounter {
+-                    throw throwable;
++                if (!jsonelement.isJsonNull()) {
++                    parseLocal(dataFixer, jsonelement.getAsJsonObject()); // Slice
++                }
++            } catch (Throwable throwable) {
++                try {
++                    jsonreader.close();
++                } catch (Throwable throwable1) {
++                    throwable.addSuppressed(throwable1);
+                 }
  
-     }
+-                jsonreader.close();
+-                return;
++                throw throwable;
+             }
  
-+    private void readStats(DataFixer dataFixer, CompoundTag nbttagcompound) {
+             jsonreader.close();
+         } catch (IOException | JsonParseException jsonparseexception) {
+             ServerStatsCounter.LOGGER.error("Unable to parse Stat data from {}", this.file, jsonparseexception);
+         }
++    }
++
++    public void parseLocal(DataFixer dataFixer, JsonObject jsonObject) {
++        CompoundTag nbttagcompound = ServerStatsCounter.fromJson(jsonObject);
 +        nbttagcompound = DataFixTypes.STATS.updateToCurrentVersion(dataFixer, nbttagcompound, NbtUtils.getDataVersion(nbttagcompound, 1343));
 +        if (!nbttagcompound.contains("stats", 10)) {
++            ServerStatsCounter.LOGGER.error("Unable to parse Stat data from {}", jsonObject);
 +            return;
 +        }
-+
+ 
 +        CompoundTag nbttagcompound1 = nbttagcompound.getCompound("stats");
-+        Iterator iterator = nbttagcompound1.getAllKeys().iterator();
-+
-+        while (true) {
-+            if (!iterator.hasNext()) {
-+                return;
-+            }
-+
-+            String s1 = (String) iterator.next();
 +
++        for (String s1 : nbttagcompound1.getAllKeys()) {
 +            if (nbttagcompound1.contains(s1, 10)) {
-+                Util.ifElse(BuiltInRegistries.STAT_TYPE.getOptional(new ResourceLocation(s1)), (statisticwrapper) -> {
++                Util.ifElse(BuiltInRegistries.STAT_TYPE.getOptional(ResourceLocation.parse(s1)), (statisticwrapper) -> {
 +                    CompoundTag nbttagcompound2 = nbttagcompound1.getCompound(s1);
-+                    Iterator iterator1 = nbttagcompound2.getAllKeys().iterator();
-+
-+                    while (iterator1.hasNext()) {
-+                        String s2 = (String) iterator1.next();
-+
++                    for (String s2 : nbttagcompound2.getAllKeys()) {
 +                        if (nbttagcompound2.contains(s2, 99)) {
-+                            Util.ifElse(this.getStat(statisticwrapper, s2), (statistic) -> {
-+                                this.stats.put(statistic, nbttagcompound2.getInt(s2));
-+                            }, () -> {
-+                                ServerStatsCounter.LOGGER.warn("Invalid statistic in {}: Don't know what {} is", this.file, s2);
-+                            });
++                            Util.ifElse(this.getStat(statisticwrapper, s2),
++                                    (statistic) -> this.stats.put(statistic, nbttagcompound2.getInt(s2)),
++                                    () -> ServerStatsCounter.LOGGER.warn("Invalid statistic in {}: Don't know what {} is", this.file, s2));
 +                        } else {
 +                            ServerStatsCounter.LOGGER.warn("Invalid statistic value in {}: Don't know what {} is for key {}", new Object[]{this.file, nbttagcompound2.get(s2), s2});
 +                        }
 +                    }
 +
-+                }, () -> {
-+                    ServerStatsCounter.LOGGER.warn("Invalid statistic type in {}: Don't know what {} is", this.file, s1);
-+                });
++                }, () -> ServerStatsCounter.LOGGER.warn("Invalid statistic type in {}: Don't know what {} is", this.file, s1));
 +            }
 +        }
-+    }
-+
+     }
++    // Slice end
+ 
      private <T> Optional<Stat<T>> getStat(StatType<T> type, String id) {
          // CraftBukkit - decompile error start
-         Optional<ResourceLocation> optional = Optional.ofNullable(ResourceLocation.tryParse(id));

patches/server/0021-Add-Preventing-KB-Bonus-to-PlayerPreAttackEntityEven.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:17:39 -0500
-Subject: [PATCH] Add Preventing KB Bonus to PlayerPreAttackEntityEvent
-
-
-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 7c80c0a4a6ab953d4d2aaf44b8d38b7f4839ebc7..de8b794575dfad2ced1b44fab8dffc248ba47d19 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -1272,7 +1272,11 @@ public abstract class Player extends LivingEntity {
-                     boolean flag = f2 > 0.9F;
-                     boolean flag1 = false;
-                     byte b0 = 0;
--                    int i = b0 + EnchantmentHelper.getKnockbackBonus(this);
-+                    int i = b0; // Slice start
-+                    if (!playerAttackEntityEvent.isPreventKnockbackBonus()) {
-+                        i += EnchantmentHelper.getKnockbackBonus(this);
-+                    }
-+                    // Slice end
- 
-                     if (this.isSprinting() && flag) {
-                         sendSoundEffect(this, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_KNOCKBACK, this.getSoundSource(), 1.0F, 1.0F); // Paper - send while respecting visibility

patches/server/0022-Expose-getBlockPosBelowThatAffectsMyMovement.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 17 Nov 2024 08:24:22 -0600
+Subject: [PATCH] Expose getBlockPosBelowThatAffectsMyMovement
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index aefa94ffd630e2dd6aefd547664ae25d2a81420c..0a34c8fb259ac9d3bfba518521d9137495509b96 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -28,6 +28,7 @@ import org.bukkit.Location;
+ import org.bukkit.Server;
+ import org.bukkit.Sound;
+ import org.bukkit.World;
++import org.bukkit.block.Block;
+ import org.bukkit.block.BlockFace;
+ import org.bukkit.block.PistonMoveReaction;
+ import org.bukkit.craftbukkit.CraftServer;
+@@ -1318,4 +1319,12 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         this.entity.vanished = vanished;
+     }
+     // Slice end
++
++    // Slice start
++    @Override
++    public Block getBlockStandingOn() {
++        net.minecraft.core.BlockPos pos = this.entity.getBlockPosBelowThatAffectsMyMovement();
++        return this.entity.level().getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
++    }
++    // Slice end
+ }

patches/server/0022-noEntityCollisions-for-Entity.patch

@@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 08:21:03 -0500
-Subject: [PATCH] noEntityCollisions for Entity
-
-
-diff --git a/src/main/java/io/papermc/paper/util/CollisionUtil.java b/src/main/java/io/papermc/paper/util/CollisionUtil.java
-index ee0331a6bc40cdde08d926fd8eb1dc642630c2e5..d1094f6a61976a81f400ab5b2b604f9608209b28 100644
---- a/src/main/java/io/papermc/paper/util/CollisionUtil.java
-+++ b/src/main/java/io/papermc/paper/util/CollisionUtil.java
-@@ -1753,7 +1753,7 @@ public final class CollisionUtil {
-     public static boolean getEntityHardCollisions(final CollisionGetter getter, final Entity entity, AABB aabb,
-                                                   final List<AABB> into, final int collisionFlags, final Predicate<Entity> predicate) {
-         final boolean checkOnly = (collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0;
--        if (!(getter instanceof EntityGetter entityGetter)) {
-+        if ((entity != null && entity.noEntityCollisions) || !(getter instanceof EntityGetter entityGetter)) {
-             return false;
-         }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 007055909e4f11a6c2805b8118d092e8b6f0a982..20f8e96110a3a6401e71dc9b61fb5678e17fc428 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -521,6 +521,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-      * Overriding this field will cause memory leaks.
-      */
-     private final boolean hardCollides;
-+    public boolean noEntityCollisions; // Slice
- 
-     private static final java.util.Map<Class<? extends Entity>, Boolean> cachedOverrides = java.util.Collections.synchronizedMap(new java.util.WeakHashMap<>());
-     {

patches/server/0023-Add-DimensionDataStorageEvents.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 17 Nov 2024 09:19:41 -0600
+Subject: [PATCH] Add DimensionDataStorageEvents
+
+
+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 d16f124e0371ce943298c8d7d9bfac21e98cf885..74de7e040ebccb000aa258238ed0bc41dec3754f 100644
+--- a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
++++ b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+@@ -1,12 +1,12 @@
+ package net.minecraft.world.level.storage;
+ 
++import ca.spottedleaf.dataconverter.minecraft.converters.custom.V3818_Commands;
+ import com.mojang.datafixers.DataFixer;
+ import com.mojang.logging.LogUtils;
++import io.papermc.paper.event.server.DimensionDataStorageSaveEvent;
+ import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
+-import java.io.DataInputStream;
+-import java.io.IOException;
+-import java.io.InputStream;
+-import java.io.PushbackInputStream;
++
++import java.io.*;
+ import java.nio.file.Files;
+ import java.nio.file.Path;
+ import java.util.HashMap;
+@@ -128,29 +128,34 @@ public class DimensionDataStorage implements AutoCloseable {
+     }
+ 
+     public CompletableFuture<?> scheduleSave() {
+-        Map<Path, CompoundTag> map = this.collectDirtyTagsToSave();
++        Map<String, CompoundTag> map = this.collectDirtyTagsToSave();
+         if (map.isEmpty()) {
+             return CompletableFuture.completedFuture(null);
+         } else {
+             this.pendingWriteFuture = this.pendingWriteFuture
+                 .thenCompose(
+                     v -> CompletableFuture.allOf(
+-                            map.entrySet().stream().map(entry -> tryWriteAsync(entry.getKey(), entry.getValue())).toArray(CompletableFuture[]::new)
++                            map.entrySet().stream().map(entry -> tryWriteAsync(entry.getKey(), this.getDataFile(entry.getKey()), entry.getValue())).toArray(CompletableFuture[]::new)
+                         )
+                 );
+             return this.pendingWriteFuture;
+         }
+     }
+ 
+-    private Map<Path, CompoundTag> collectDirtyTagsToSave() {
+-        Map<Path, CompoundTag> map = new Object2ObjectArrayMap<>();
+-        this.cache.forEach((id, state) -> state.filter(SavedData::isDirty).ifPresent(state2 -> map.put(this.getDataFile(id), state2.save(this.registries))));
++    private Map<String, CompoundTag> collectDirtyTagsToSave() {
++        Map<String, CompoundTag> map = new Object2ObjectArrayMap<>();
++        this.cache.forEach((id, state) -> state.filter(SavedData::isDirty).ifPresent(state2 -> map.put(id, state2.save(this.registries))));
+         return map;
+     }
+ 
+-    private static CompletableFuture<Void> tryWriteAsync(Path path, CompoundTag nbt) {
++    private static CompletableFuture<Void> tryWriteAsync(String id, Path path, CompoundTag nbt) {
+         return CompletableFuture.runAsync(() -> {
+             try {
++                ByteArrayOutputStream buf = new ByteArrayOutputStream();
++                NbtIo.writeCompressed(nbt, buf);
++                DimensionDataStorageSaveEvent event = new DimensionDataStorageSaveEvent(id, buf);
++                if (!event.callEvent()) return;
++
+                 NbtIo.writeCompressed(nbt, path);
+             } catch (IOException var3) {
+                 LOGGER.error("Could not save data to {}", path.getFileName(), var3);

patches/server/0023-Do-not-freeze-MappedRegistry.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 25 Apr 2023 09:05:16 -0500
-Subject: [PATCH] Do not freeze MappedRegistry
-
-
-diff --git a/src/main/java/net/minecraft/core/MappedRegistry.java b/src/main/java/net/minecraft/core/MappedRegistry.java
-index 742af4feb3986ca7d8f5ed136b556a41cbe0722f..d8fd0627b781e4b66ad0882304ec417fbb5c9b20 100644
---- a/src/main/java/net/minecraft/core/MappedRegistry.java
-+++ b/src/main/java/net/minecraft/core/MappedRegistry.java
-@@ -334,7 +334,7 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
-         if (this.frozen) {
-             return this;
-         } else {
--            this.frozen = true;
-+//            this.frozen = true; // Slice
-             this.byValue.forEach((value, entry) -> {
-                 entry.bindValue(value);
-             });
-@@ -361,14 +361,16 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
- 
-     @Override
-     public Holder.Reference<T> createIntrusiveHolder(T value) {
-+        // Slice start
-         if (this.unregisteredIntrusiveHolders == null) {
--            throw new IllegalStateException("This registry can't create intrusive holders");
--        } else {
--            this.validateWrite();
--            return this.unregisteredIntrusiveHolders.computeIfAbsent(value, (valuex) -> {
--                return Holder.Reference.createIntrusive(this.asLookup(), valuex);
--            });
-+            this.unregisteredIntrusiveHolders = new HashMap<>();
-         }
-+        // Slice end
-+
-+        this.validateWrite();
-+        return this.unregisteredIntrusiveHolders.computeIfAbsent(value, (valuex) -> {
-+            return Holder.Reference.createIntrusive(this.asLookup(), valuex);
-+        });
-     }
- 
-     @Override

patches/server/0024-Add-PlayerData-Events.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tom <cryptite@gmail.com>
+Date: Mon, 18 Nov 2024 08:34:27 -0600
+Subject: [PATCH] Add PlayerData Events
+
+
+diff --git a/src/main/java/net/minecraft/stats/ServerStatsCounter.java b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+index 6947650f299f99402a4a8d9c8384eb9f71a8e3a6..299fcc2ecb17f8d42ff3480ec9868127faa9b0fc 100644
+--- a/src/main/java/net/minecraft/stats/ServerStatsCounter.java
++++ b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+@@ -192,7 +192,12 @@ public class ServerStatsCounter extends StatsCounter {
+         return nbttagcompound;
+     }
+ 
+-    protected String toJson() {
++    // Slice start - OBFHELPER
++    public String toJson() {
++        return serialize().toString();
++    }
++
++    public JsonObject serialize() { // Slice end
+         Map<StatType<?>, JsonObject> map = Maps.newHashMap();
+         ObjectIterator objectiterator = this.stats.object2IntEntrySet().iterator();
+ 
+@@ -218,7 +223,7 @@ public class ServerStatsCounter extends StatsCounter {
+ 
+         jsonobject1.add("stats", jsonobject);
+         jsonobject1.addProperty("DataVersion", SharedConstants.getCurrentVersion().getDataVersion().getVersion());
+-        return jsonobject1.toString();
++        return jsonobject1; // Slice
+     }
+ 
+     private static <T> ResourceLocation getKey(Stat<T> stat) {
+diff --git a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+index b148cf247acdd36f856d0495cde4cc5ad32b5a2f..f9403d73ae2400e148a76bf79661e2e96fe7a6cc 100644
+--- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
++++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+@@ -36,6 +36,7 @@ public class PlayerDataStorage {
+ 
+     public void save(Player player) {
+         if (org.spigotmc.SpigotConfig.disablePlayerDataSaving) return; // Spigot
++        if (!new com.destroystokyo.paper.event.player.PlayerSaveDataEvent((org.bukkit.entity.Player) player.getBukkitEntity()).callEvent()) return; // Slice
+         try {
+             CompoundTag nbttagcompound = player.saveWithoutId(new CompoundTag());
+             Path path = this.playerDir.toPath();
+@@ -108,6 +109,21 @@ public class PlayerDataStorage {
+     }
+ 
+     public Optional<CompoundTag> load(Player player) {
++        // Slice start - If event supplies playerdata, use it. Otherwise just load from disk as usual
++        com.destroystokyo.paper.event.player.PlayerLoadDataEvent event = new com.destroystokyo.paper.event.player.PlayerLoadDataEvent(player.getUUID());
++        org.bukkit.Bukkit.getPluginManager().callEvent(event);
++
++        Object playerData = event.getPlayerData();
++        if (playerData instanceof CompoundTag data) {
++            data = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.PLAYER,
++                    data,
++                    NbtUtils.getDataVersion(data, -1),
++                    net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion()); // Paper - rewrite data conversion system
++            player.load(data);
++            return Optional.of(data);
++        }
++        // Slice end
++
+         // CraftBukkit start
+         return this.load(player.getName().getString(), player.getStringUUID()).map((nbttagcompound) -> {
+             if (player instanceof ServerPlayer) {

patches/server/0025-Non-saveable-entities.patch

@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 18 Nov 2024 11:20:07 -0600
+Subject: [PATCH] Non-saveable-entities
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
+index b3c993a790fc3fab6a408c731deb297f74c959ce..7c1d4b08cbd41b70e712a636321ff9d73541ed8c 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
+@@ -161,7 +161,7 @@ public final class ChunkEntitySlices {
+                 // removed by us below
+                 continue;
+             }
+-            if (entity.shouldBeSaved()) {
++            if (entity.shouldBeSaved() || !entity.saveable) { // Slice
+                 PlatformHooks.get().unloadEntity(entity);
+                 if (entity.isVehicle()) {
+                     // we cannot assume that these entities are contained within this chunk, because entities can
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index a46df2ccbae85cdbdb7a19825a89c1797337d270..b878b2559d3957055702d8281846196732909ebd 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -400,6 +400,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public boolean fixedPose = false; // Paper - Expand Pose API
+     private final int despawnTime; // Paper - entity despawn time limit
+     public boolean vanished; // Slice
++    public boolean saveable = true; // Slice
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -5210,6 +5211,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+     @Override
+     public boolean shouldBeSaved() {
++        if (!this.saveable) return false; // Slice
+         return this.removalReason != null && !this.removalReason.shouldSave() ? false : (this.isPassenger() ? false : !this.isVehicle() || !((ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity)this).moonrise$hasAnyPlayerPassengers()); // Paper - rewrite chunk system
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 0a34c8fb259ac9d3bfba518521d9137495509b96..1f0a4a89815bf8110e7c02d2d3325e47fc9c2abe 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1327,4 +1327,17 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return this.entity.level().getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
+     }
+     // Slice end
++
++
++    // Slice start
++    @Override
++    public boolean isSaveable() {
++        return this.entity.saveable;
++    }
++
++    @Override
++    public void setSaveable(boolean saveable) {
++        this.entity.saveable = saveable;
++    }
++    // Slice end
+ }

patches/server/0026-Map-Events.patch

@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Mon, 2 Dec 2024 11:52:34 -0600
+Subject: [PATCH] Map Events
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index e256e5ff5c167c6cff5b9e985cdc80d5c9203708..5f0439860468283dcdcce17fefc22c5e088b8dc4 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2119,6 +2119,14 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
+     @Override
+     public MapId getFreeMapId() {
++        // Slice start
++        io.papermc.paper.event.server.MapGetFreeIndexEvent event = new io.papermc.paper.event.server.MapGetFreeIndexEvent();
++        event.callEvent();
++        int newIndex = event.getIndex();
++        if (newIndex != -1) {
++            return new MapId(newIndex);
++        }
++        // Slice end
+         return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex.factory(), "idcounts")).getFreeAuxValueForMap();
+     }
+ 
+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 4f256e61f858020f32e7a66664375ba05a57826b..f1eefed0282c2f5af125c6579fd5311d6e7f78b9 100644
+--- a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
++++ b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+@@ -70,6 +70,23 @@ public class DimensionDataStorage implements AutoCloseable {
+     @Nullable
+     private <T extends SavedData> T readSavedData(BiFunction<CompoundTag, HolderLookup.Provider, T> readFunction, DataFixTypes dataFixTypes, String id) {
+         try {
++            // Slice start
++            if (id.startsWith("map_")) {
++                int mapId = Integer.parseInt(id.split("map_")[1]);
++                io.papermc.paper.event.server.MapLoadEvent event = new io.papermc.paper.event.server.MapLoadEvent(mapId);
++                event.callEvent();
++                ByteArrayInputStream buf = event.getBuf();
++                if (buf != null) {
++                    try {
++                        CompoundTag tag = NbtIo.readCompressed(buf, NbtAccounter.unlimitedHeap());
++                        return readFunction.apply(tag.getCompound("data"), this.registries);
++                    } catch (IOException e) {
++                        LOGGER.error("Error loading saved data: {}", id, e);
++                    }
++                }
++            }
++            // Slice end
++
+             Path path = this.getDataFile(id);
+             if (Files.exists(path)) {
+                 CompoundTag compoundTag = this.readTagFromDisk(id, dataFixTypes, SharedConstants.getCurrentVersion().getDataVersion().getVersion());

patches/server/0027-Long-distance-tracking.patch

@@ -1,85 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 6 Jun 2023 08:14:08 -0500
-Subject: [PATCH] Long distance tracking
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 6b755f07ca62a8bb9ad3b1a2aee5fa07bacb134c..94d2f22d374f899d29576c927798a6de66120a41 100644
---- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -1411,6 +1411,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-                 // Paper end - remove allocation of Vec3D here
-                 int i = ChunkMap.this.getPlayerViewDistance(player);
-                 double d0 = (double) Math.min(this.getEffectiveRange(), i * 16);
-+                if (this.entity instanceof ServerPlayer serverPlayer && player.canSeeFromLongDistance(serverPlayer)) d0 = Math.min(level.spigotConfig.flyingPlayerTrackingRange, d0); // Slice
-                 double d1 = vec3d_dx * vec3d_dx + vec3d_dz * vec3d_dz; // Paper
-                 double d2 = d0 * d0;
-                 boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(player) && ChunkMap.this.isChunkTracked(player, this.entity.chunkPosition().x, this.entity.chunkPosition().z);
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index d9b9dd6023532a26f5d8173fb1fccf10a9dfec8c..dec8e20a8132e601ed0db3352d22fad968ed555a 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -282,6 +282,7 @@ public class ServerPlayer extends Player {
-     public @Nullable String clientBrandName = null; // Paper - Brand support
-     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
-     public boolean smoothWorldTeleport; // Slice
-+    public boolean hasLongDistanceTracking; // Slice
- 
-     // Paper start - replace player chunk loader
-     private final java.util.concurrent.atomic.AtomicReference<io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances> viewDistances = new java.util.concurrent.atomic.AtomicReference<>(new io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances(-1, -1, -1));
-@@ -2758,4 +2759,18 @@ public class ServerPlayer extends Player {
-         return (CraftPlayer) super.getBukkitEntity();
-     }
-     // CraftBukkit end
-+
-+    // Slice start
-+    public boolean canSeeFromLongDistance(ServerPlayer other) {
-+        if (hasLongDistanceTracking) return true;
-+
-+        CraftPlayer bukkitEntity = other.getBukkitEntity();
-+        return bukkitEntity.isGliding() || bukkitEntity.isFlying();
-+    }
-+
-+    public boolean canBeSeenLongDistance() {
-+        CraftPlayer bukkitEntity = getBukkitEntity();
-+        return bukkitEntity.isGliding() || bukkitEntity.isFlying();
-+    }
-+    // Slice end
- }
-diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-index 1cf6d4f854d89c515e48e1fb365eb95ff9340765..6dab8b76bef3c97936fc337e813bcb60c7f2026d 100644
---- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-@@ -271,6 +271,7 @@ public class SpigotWorldConfig
-     }
- 
-     public int playerTrackingRange = 48;
-+    public int flyingPlayerTrackingRange = 64; // Slice
-     public int animalTrackingRange = 48;
-     public int monsterTrackingRange = 48;
-     public int miscTrackingRange = 32;
-@@ -279,6 +280,7 @@ public class SpigotWorldConfig
-     private void trackingRange()
-     {
-         this.playerTrackingRange = this.getInt( "entity-tracking-range.players", this.playerTrackingRange );
-+        this.flyingPlayerTrackingRange = this.getInt( "entity-tracking-range.flying-players", this.flyingPlayerTrackingRange ); // Slice
-         this.animalTrackingRange = this.getInt( "entity-tracking-range.animals", this.animalTrackingRange );
-         this.monsterTrackingRange = this.getInt( "entity-tracking-range.monsters", this.monsterTrackingRange );
-         this.miscTrackingRange = this.getInt( "entity-tracking-range.misc", this.miscTrackingRange );
-diff --git a/src/main/java/org/spigotmc/TrackingRange.java b/src/main/java/org/spigotmc/TrackingRange.java
-index e4425b242fe73d1fd2bd10c313aa16925432329f..b3252aa5bb4ce9fac0b914e0b2fe74d2c7ac3bce 100644
---- a/src/main/java/org/spigotmc/TrackingRange.java
-+++ b/src/main/java/org/spigotmc/TrackingRange.java
-@@ -26,9 +26,9 @@ public class TrackingRange
-             return defaultRange;
-         }
-         SpigotWorldConfig config = entity.level().spigotConfig;
--        if ( entity instanceof ServerPlayer )
-+        if ( entity instanceof ServerPlayer serverPlayer)
-         {
--            return config.playerTrackingRange;
-+            return serverPlayer.canBeSeenLongDistance() ? config.flyingPlayerTrackingRange : config.playerTrackingRange;
-         // Paper start - Simplify and set water mobs to animal tracking range
-         }
-         switch (entity.activationType) {

patches/server/0027-PlayerInsertBundleItemEvent.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Thu, 12 Dec 2024 15:20:17 -0600
+Subject: [PATCH] PlayerInsertBundleItemEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index d021cd5b6136f0125076513977f430c6d4dd4f9f..e134cdebde3e3afa6ddce177c949b4fb7a3ed277 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -582,6 +582,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+         if (flag && (this.spawnEnemies || this.spawnFriendlies)) {
+             // Paper start - PlayerNaturallySpawnCreaturesEvent
+             for (ServerPlayer entityPlayer : this.level.players()) {
++                if (entityPlayer.spawnsOwnMobs) continue; // Slice
+                 int chunkRange = Math.min(level.spigotConfig.mobSpawnRange, entityPlayer.getBukkitEntity().getViewDistance());
+                 chunkRange = Math.min(chunkRange, 8);
+                 entityPlayer.playerNaturallySpawnedEvent = new com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent(entityPlayer.getBukkitEntity(), (byte) chunkRange);
+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 e4041c58a23d3eaefd01402635f714404f3c82cf..6eb9155c3227ae2a69bb7a379af94d6a73cdc6c7 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -198,6 +198,8 @@ public abstract class Player extends LivingEntity {
+     public boolean affectsSpawning = true; // Paper - Affects Spawning API
+     public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
+ 
++    public boolean spawnsOwnMobs = false; // Slice
++
+     // CraftBukkit start
+     public boolean fauxSleeping;
+     public int oldLevel = -1;
+diff --git a/src/main/java/net/minecraft/world/item/BundleItem.java b/src/main/java/net/minecraft/world/item/BundleItem.java
+index f1999d904ac66f5349346ad8157f5401fb395e11..56159a23d231028ba671f441fed0f601eedec7be 100644
+--- a/src/main/java/net/minecraft/world/item/BundleItem.java
++++ b/src/main/java/net/minecraft/world/item/BundleItem.java
+@@ -67,6 +67,7 @@ public class BundleItem extends Item {
+             ItemStack itemStack = slot.getItem();
+             BundleContents.Mutable mutable = new BundleContents.Mutable(bundleContents);
+             if (clickType == ClickAction.PRIMARY && !itemStack.isEmpty()) {
++                if (!new io.papermc.paper.event.player.PlayerInsertBundleItemEvent((org.bukkit.entity.Player) player.getBukkitEntity(), stack.getBukkitStack(), itemStack.getBukkitStack()).callEvent()) return false; // Slice
+                 if (mutable.tryTransfer(slot, player) > 0) {
+                     playInsertSound(player);
+                 } else {
+@@ -110,6 +111,7 @@ public class BundleItem extends Item {
+             } else {
+                 BundleContents.Mutable mutable = new BundleContents.Mutable(bundleContents);
+                 if (clickType == ClickAction.PRIMARY && !otherStack.isEmpty()) {
++                    if (!new io.papermc.paper.event.player.PlayerInsertBundleItemEvent((org.bukkit.entity.Player) player.getBukkitEntity(), stack.getBukkitStack(), otherStack.getBukkitStack()).callEvent()) return false; // Slice
+                     if (slot.allowModification(player) && mutable.tryInsert(otherStack) > 0) {
+                         playInsertSound(player);
+                     } else {

patches/server/0028-Mute-bee-logger-warn.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Fri, 20 Dec 2024 07:17:20 -0600
+Subject: [PATCH] Mute bee logger warn
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index c8c2394558952d7ca57d29874485251b8f2b3400..4317275aeb5b3519b6b9a7195e3d997f386349ce 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -660,7 +660,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+             if (generation) entity.generation = true; // Paper - Don't fire sync event during generation
+             entity.load(nbt);
+         }, () -> {
+-            EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.getString("id"));
++//            EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.getString("id")); // Slice - something about bees
+         });
+     }
+ 

patches/server/0029-Add-PlayerPreRespawnEvent.patch

@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 28 Dec 2024 07:59:54 -0600
+Subject: [PATCH] Add PlayerPreRespawnEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 46f060f33fcbc6a4568a7fcfba29e83a4d192578..28b1ec198970b88515b37ef651c90916f3aef347 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -808,19 +808,31 @@ public abstract class PlayerList {
+         // Paper end - Add PlayerPostRespawnEvent
+ 
+         // CraftBukkit start - fire PlayerRespawnEvent
+-        TeleportTransition teleporttransition;
++        TeleportTransition teleporttransition = null;
+         if (location == null) {
+-            teleporttransition = entityplayer.findRespawnPositionAndUseSpawnBlock(!flag, TeleportTransition.DO_NOTHING, reason);
++            // Slice start
++            io.papermc.paper.event.player.PlayerPreRespawnEvent preRespawnEvent = new io.papermc.paper.event.player.PlayerPreRespawnEvent(entityplayer.getBukkitEntity(), reason);
++            if (!preRespawnEvent.callEvent()) return entityplayer;
++            
++            Location respawnLocation = preRespawnEvent.getRespawnLocation();
++            if (respawnLocation != null) {
++                location = respawnLocation;
++                teleporttransition = new TeleportTransition(((CraftWorld) respawnLocation.getWorld()).getHandle(), CraftLocation.toVec3D(respawnLocation), Vec3.ZERO, respawnLocation.getYaw(), respawnLocation.getPitch(), TeleportTransition.DO_NOTHING);
++            } else {
++                teleporttransition = entityplayer.findRespawnPositionAndUseSpawnBlock(!flag, TeleportTransition.DO_NOTHING, reason);
++            }
++            // Slice end
+ 
+             if (!flag) entityplayer.reset(); // SPIGOT-4785
+-           // Paper start - Add PlayerPostRespawnEvent
+-           if (teleporttransition == null) return entityplayer; // Early exit, mirrors belows early return for disconnected players in respawn event
+-           isRespawn = true;
+-           location = CraftLocation.toBukkit(teleporttransition.position(), teleporttransition.newLevel().getWorld(), teleporttransition.yRot(), teleporttransition.xRot());
+-           // Paper end - Add PlayerPostRespawnEvent
++            // Paper start - Add PlayerPostRespawnEvent
++            if (teleporttransition == null || entityplayer.connection.isDisconnected()) return entityplayer; // Early exit, mirrors belows early return for disconnected players in respawn event
++            isRespawn = true;
++            location = CraftLocation.toBukkit(teleporttransition.position(), teleporttransition.newLevel().getWorld(), teleporttransition.yRot(), teleporttransition.xRot());
++            // Paper end - Add PlayerPostRespawnEvent
+         } else {
+             teleporttransition = new TeleportTransition(((CraftWorld) location.getWorld()).getHandle(), CraftLocation.toVec3D(location), Vec3.ZERO, location.getYaw(), location.getPitch(), TeleportTransition.DO_NOTHING);
+         }
++
+         // Spigot Start
+         if (teleporttransition == null) { // Paper - Add PlayerPostRespawnEvent - diff on change - spigot early returns if respawn pos is null, that is how they handle disconnected player in respawn event
+             return entityplayer;

patches/server/0029-Add-canDespawn-to-Warden.patch

@@ -1,66 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 23 Jun 2023 08:22:19 -0500
-Subject: [PATCH] Add canDespawn to Warden
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
-index 09e8445a3f8c6b3ebc852a75a9a25b41a51ba659..a6ef7eda2cecaca50c63801b58ec59d43e1f306a 100644
---- a/src/main/java/net/minecraft/world/entity/EntityType.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
-@@ -595,7 +595,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
-             if (generation) entity.generation = true; // Paper - Don't fire sync event during generation
-             entity.load(nbt);
-         }, () -> {
--            EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.getString("id"));
-+            //EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.toString());
-         });
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-index 937f81a859953498abe73bea560c86e6560e1c33..b925176496639524d80de33c2b4e7a42877c4bca 100644
---- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-@@ -112,6 +112,7 @@ public class Warden extends Monster implements VibrationSystem {
-     private final VibrationSystem.User vibrationUser = new Warden.VibrationUser();
-     private VibrationSystem.Data vibrationData = new VibrationSystem.Data();
-     AngerManagement angerManagement = new AngerManagement(this::canTargetEntity, Collections.emptyList());
-+    public boolean canDespawn; // Slice
- 
-     public Warden(EntityType<? extends Monster> type, Level world) {
-         super(type, world);
-diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/WardenAi.java b/src/main/java/net/minecraft/world/entity/monster/warden/WardenAi.java
-index 03f16a5541de6bc95407aaa24741570c1993dc9e..07600fdd32a058d0e3f9828efdc18f5e76448663 100644
---- a/src/main/java/net/minecraft/world/entity/monster/warden/WardenAi.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/warden/WardenAi.java
-@@ -139,7 +139,13 @@ public class WardenAi {
- 
-     public static void setDigCooldown(LivingEntity warden) {
-         if (warden.getBrain().hasMemoryValue(MemoryModuleType.DIG_COOLDOWN)) {
--            warden.getBrain().setMemoryWithExpiry(MemoryModuleType.DIG_COOLDOWN, Unit.INSTANCE, 1200L);
-+            // Slice start
-+            if (warden instanceof Warden nmsWarden && !nmsWarden.canDespawn) {
-+                warden.getBrain().setMemory(MemoryModuleType.DIG_COOLDOWN, Unit.INSTANCE);
-+            } else {
-+                warden.getBrain().setMemoryWithExpiry(MemoryModuleType.DIG_COOLDOWN, Unit.INSTANCE, 1200L);
-+            }
-+            // Slice end
-         }
- 
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWarden.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWarden.java
-index c284eb96a1e330078076cbe61f0f6e2ff4ed89bd..b9ffe3d49f0253353fb2b726f974effe18e521ec 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWarden.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWarden.java
-@@ -86,4 +86,11 @@ public class CraftWarden extends CraftMonster implements org.bukkit.entity.Warde
-             case ANGRY -> AngerLevel.ANGRY;
-         };
-     }
-+
-+    // Slice start
-+    @Override
-+    public void setCanDespawn(boolean canDespawn) {
-+        this.getHandle().canDespawn = canDespawn;
-+    }
-+    // Slice end
- }

patches/server/0030-Fix-authorless-book-loading.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sun, 29 Dec 2024 09:09:41 -0600
+Subject: [PATCH] Fix authorless book loading
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+index 507f908916cbeb592496f963b46e4c2121a7b5e3..429eea868c749c5aece3e1afb96da760c154cfe1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -24,6 +24,7 @@ import net.minecraft.commands.Commands;
+ import net.minecraft.commands.arguments.item.ItemParser;
+ import net.minecraft.core.registries.BuiltInRegistries;
+ import net.minecraft.core.registries.Registries;
++import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.nbt.NbtOps;
+ import net.minecraft.nbt.StringTag;
+ import net.minecraft.nbt.Tag;
+@@ -524,6 +525,15 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data);
+         final int dataVersion = compound.getInt("DataVersion");
+         compound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ITEM_STACK, compound, dataVersion, this.getDataVersion()); // Paper - replace data conversion system
++
++        CompoundTag components = compound.getCompound("components");
++        if (!components.isEmpty()) {
++            CompoundTag bookContent = components.getCompound("minecraft:written_book_content");
++            if (!bookContent.isEmpty() && !bookContent.getAllKeys().contains("author")) {
++                bookContent.putString("author", "");
++            }
++        }
++
+         return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.parse(MinecraftServer.getServer().registryAccess(), compound).orElseThrow());
+     }
+ 

patches/server/0031-Disable-feature-generation.patch

@@ -1,314 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sat, 26 Aug 2023 07:39:46 -0500
-Subject: [PATCH] Disable feature generation
-
-
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
-index f945fae50983424091b58f83ed14f2e8f2621619..b4c16e355ebadf06b9405c06e2b598e7a478f6ab 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
-@@ -33,139 +33,5 @@ public class GeodeFeature extends Feature<GeodeConfiguration> {
-     }
- 
-     @Override
--    public boolean place(FeaturePlaceContext<GeodeConfiguration> context) {
--        GeodeConfiguration geodeConfiguration = context.config();
--        RandomSource randomSource = context.random();
--        BlockPos blockPos = context.origin();
--        WorldGenLevel worldGenLevel = context.level();
--        int i = geodeConfiguration.minGenOffset;
--        int j = geodeConfiguration.maxGenOffset;
--        List<Pair<BlockPos, Integer>> list = Lists.newLinkedList();
--        int k = geodeConfiguration.distributionPoints.sample(randomSource);
--        WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(worldGenLevel.getSeed()));
--        NormalNoise normalNoise = NormalNoise.create(worldgenRandom, -4, 1.0D);
--        List<BlockPos> list2 = Lists.newLinkedList();
--        double d = (double)k / (double)geodeConfiguration.outerWallDistance.getMaxValue();
--        GeodeLayerSettings geodeLayerSettings = geodeConfiguration.geodeLayerSettings;
--        GeodeBlockSettings geodeBlockSettings = geodeConfiguration.geodeBlockSettings;
--        GeodeCrackSettings geodeCrackSettings = geodeConfiguration.geodeCrackSettings;
--        double e = 1.0D / Math.sqrt(geodeLayerSettings.filling);
--        double f = 1.0D / Math.sqrt(geodeLayerSettings.innerLayer + d);
--        double g = 1.0D / Math.sqrt(geodeLayerSettings.middleLayer + d);
--        double h = 1.0D / Math.sqrt(geodeLayerSettings.outerLayer + d);
--        double l = 1.0D / Math.sqrt(geodeCrackSettings.baseCrackSize + randomSource.nextDouble() / 2.0D + (k > 3 ? d : 0.0D));
--        boolean bl = (double)randomSource.nextFloat() < geodeCrackSettings.generateCrackChance;
--        int m = 0;
--
--        for(int n = 0; n < k; ++n) {
--            int o = geodeConfiguration.outerWallDistance.sample(randomSource);
--            int p = geodeConfiguration.outerWallDistance.sample(randomSource);
--            int q = geodeConfiguration.outerWallDistance.sample(randomSource);
--            BlockPos blockPos2 = blockPos.offset(o, p, q);
--            BlockState blockState = worldGenLevel.getBlockState(blockPos2);
--            if (blockState.isAir() || blockState.is(BlockTags.GEODE_INVALID_BLOCKS)) {
--                ++m;
--                if (m > geodeConfiguration.invalidBlocksThreshold) {
--                    return false;
--                }
--            }
--
--            list.add(Pair.of(blockPos2, geodeConfiguration.pointOffset.sample(randomSource)));
--        }
--
--        if (bl) {
--            int r = randomSource.nextInt(4);
--            int s = k * 2 + 1;
--            if (r == 0) {
--                list2.add(blockPos.offset(s, 7, 0));
--                list2.add(blockPos.offset(s, 5, 0));
--                list2.add(blockPos.offset(s, 1, 0));
--            } else if (r == 1) {
--                list2.add(blockPos.offset(0, 7, s));
--                list2.add(blockPos.offset(0, 5, s));
--                list2.add(blockPos.offset(0, 1, s));
--            } else if (r == 2) {
--                list2.add(blockPos.offset(s, 7, s));
--                list2.add(blockPos.offset(s, 5, s));
--                list2.add(blockPos.offset(s, 1, s));
--            } else {
--                list2.add(blockPos.offset(0, 7, 0));
--                list2.add(blockPos.offset(0, 5, 0));
--                list2.add(blockPos.offset(0, 1, 0));
--            }
--        }
--
--        List<BlockPos> list3 = Lists.newArrayList();
--        Predicate<BlockState> predicate = isReplaceable(geodeConfiguration.geodeBlockSettings.cannotReplace);
--
--        for(BlockPos blockPos3 : BlockPos.betweenClosed(blockPos.offset(i, i, i), blockPos.offset(j, j, j))) {
--            double t = normalNoise.getValue((double)blockPos3.getX(), (double)blockPos3.getY(), (double)blockPos3.getZ()) * geodeConfiguration.noiseMultiplier;
--            double u = 0.0D;
--            double v = 0.0D;
--
--            for(Pair<BlockPos, Integer> pair : list) {
--                u += Mth.invSqrt(blockPos3.distSqr(pair.getFirst()) + (double)pair.getSecond().intValue()) + t;
--            }
--
--            for(BlockPos blockPos4 : list2) {
--                v += Mth.invSqrt(blockPos3.distSqr(blockPos4) + (double)geodeCrackSettings.crackPointOffset) + t;
--            }
--
--            if (!(u < h)) {
--                if (bl && v >= l && u < e) {
--                    this.safeSetBlock(worldGenLevel, blockPos3, Blocks.AIR.defaultBlockState(), predicate);
--
--                    for(Direction direction : DIRECTIONS) {
--                        BlockPos blockPos5 = blockPos3.relative(direction);
--                        FluidState fluidState = worldGenLevel.getFluidState(blockPos5);
--                        if (!fluidState.isEmpty()) {
--                            worldGenLevel.scheduleTick(blockPos5, fluidState.getType(), 0);
--                        }
--                    }
--                } else if (u >= e) {
--                    this.safeSetBlock(worldGenLevel, blockPos3, geodeBlockSettings.fillingProvider.getState(randomSource, blockPos3), predicate);
--                } else if (u >= f) {
--                    boolean bl2 = (double)randomSource.nextFloat() < geodeConfiguration.useAlternateLayer0Chance;
--                    if (bl2) {
--                        this.safeSetBlock(worldGenLevel, blockPos3, geodeBlockSettings.alternateInnerLayerProvider.getState(randomSource, blockPos3), predicate);
--                    } else {
--                        this.safeSetBlock(worldGenLevel, blockPos3, geodeBlockSettings.innerLayerProvider.getState(randomSource, blockPos3), predicate);
--                    }
--
--                    if ((!geodeConfiguration.placementsRequireLayer0Alternate || bl2) && (double)randomSource.nextFloat() < geodeConfiguration.usePotentialPlacementsChance) {
--                        list3.add(blockPos3.immutable());
--                    }
--                } else if (u >= g) {
--                    this.safeSetBlock(worldGenLevel, blockPos3, geodeBlockSettings.middleLayerProvider.getState(randomSource, blockPos3), predicate);
--                } else if (u >= h) {
--                    this.safeSetBlock(worldGenLevel, blockPos3, geodeBlockSettings.outerLayerProvider.getState(randomSource, blockPos3), predicate);
--                }
--            }
--        }
--
--        List<BlockState> list4 = geodeBlockSettings.innerPlacements;
--
--        for(BlockPos blockPos6 : list3) {
--            BlockState blockState2 = Util.getRandom(list4, randomSource);
--
--            for(Direction direction2 : DIRECTIONS) {
--                if (blockState2.hasProperty(BlockStateProperties.FACING)) {
--                    blockState2 = blockState2.setValue(BlockStateProperties.FACING, direction2);
--                }
--
--                BlockPos blockPos7 = blockPos6.relative(direction2);
--                BlockState blockState3 = worldGenLevel.getBlockState(blockPos7);
--                if (blockState2.hasProperty(BlockStateProperties.WATERLOGGED)) {
--                    blockState2 = blockState2.setValue(BlockStateProperties.WATERLOGGED, Boolean.valueOf(blockState3.getFluidState().isSource()));
--                }
--
--                if (BuddingAmethystBlock.canClusterGrowAtState(blockState3)) {
--                    this.safeSetBlock(worldGenLevel, blockPos7, blockState2, predicate);
--                    break;
--                }
--            }
--        }
--
--        return true;
--    }
-+    public boolean place(FeaturePlaceContext<GeodeConfiguration> context) {return false;}
- }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/MonsterRoomFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/MonsterRoomFeature.java
-index 7c252dd2bd314f06703ac9356410c52b21198d12..7a34e16db1b51f4283112c8c99a84322213823fa 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/feature/MonsterRoomFeature.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/MonsterRoomFeature.java
-@@ -30,103 +30,7 @@ public class MonsterRoomFeature extends Feature<NoneFeatureConfiguration> {
-     }
- 
-     @Override
--    public boolean place(FeaturePlaceContext<NoneFeatureConfiguration> context) {
--        Predicate<BlockState> predicate = Feature.isReplaceable(BlockTags.FEATURES_CANNOT_REPLACE);
--        BlockPos blockPos = context.origin();
--        RandomSource randomSource = context.random();
--        WorldGenLevel worldGenLevel = context.level();
--        int i = 3;
--        int j = randomSource.nextInt(2) + 2;
--        int k = -j - 1;
--        int l = j + 1;
--        int m = -1;
--        int n = 4;
--        int o = randomSource.nextInt(2) + 2;
--        int p = -o - 1;
--        int q = o + 1;
--        int r = 0;
--
--        for(int s = k; s <= l; ++s) {
--            for(int t = -1; t <= 4; ++t) {
--                for(int u = p; u <= q; ++u) {
--                    BlockPos blockPos2 = blockPos.offset(s, t, u);
--                    boolean bl = worldGenLevel.getBlockState(blockPos2).isSolid();
--                    if (t == -1 && !bl) {
--                        return false;
--                    }
--
--                    if (t == 4 && !bl) {
--                        return false;
--                    }
--
--                    if ((s == k || s == l || u == p || u == q) && t == 0 && worldGenLevel.isEmptyBlock(blockPos2) && worldGenLevel.isEmptyBlock(blockPos2.above())) {
--                        ++r;
--                    }
--                }
--            }
--        }
--
--        if (r >= 1 && r <= 5) {
--            for(int v = k; v <= l; ++v) {
--                for(int w = 3; w >= -1; --w) {
--                    for(int x = p; x <= q; ++x) {
--                        BlockPos blockPos3 = blockPos.offset(v, w, x);
--                        BlockState blockState = worldGenLevel.getBlockState(blockPos3);
--                        if (v != k && w != -1 && x != p && v != l && w != 4 && x != q) {
--                            if (!blockState.is(Blocks.CHEST) && !blockState.is(Blocks.SPAWNER)) {
--                                this.safeSetBlock(worldGenLevel, blockPos3, AIR, predicate);
--                            }
--                        } else if (blockPos3.getY() >= worldGenLevel.getMinBuildHeight() && !worldGenLevel.getBlockState(blockPos3.below()).isSolid()) {
--                            worldGenLevel.setBlock(blockPos3, AIR, 2);
--                        } else if (blockState.isSolid() && !blockState.is(Blocks.CHEST)) {
--                            if (w == -1 && randomSource.nextInt(4) != 0) {
--                                this.safeSetBlock(worldGenLevel, blockPos3, Blocks.MOSSY_COBBLESTONE.defaultBlockState(), predicate);
--                            } else {
--                                this.safeSetBlock(worldGenLevel, blockPos3, Blocks.COBBLESTONE.defaultBlockState(), predicate);
--                            }
--                        }
--                    }
--                }
--            }
--
--            for(int y = 0; y < 2; ++y) {
--                for(int z = 0; z < 3; ++z) {
--                    int aa = blockPos.getX() + randomSource.nextInt(j * 2 + 1) - j;
--                    int ab = blockPos.getY();
--                    int ac = blockPos.getZ() + randomSource.nextInt(o * 2 + 1) - o;
--                    BlockPos blockPos4 = new BlockPos(aa, ab, ac);
--                    if (worldGenLevel.isEmptyBlock(blockPos4)) {
--                        int ad = 0;
--
--                        for(Direction direction : Direction.Plane.HORIZONTAL) {
--                            if (worldGenLevel.getBlockState(blockPos4.relative(direction)).isSolid()) {
--                                ++ad;
--                            }
--                        }
--
--                        if (ad == 1) {
--                            this.safeSetBlock(worldGenLevel, blockPos4, StructurePiece.reorient(worldGenLevel, blockPos4, Blocks.CHEST.defaultBlockState()), predicate);
--                            RandomizableContainer.setBlockEntityLootTable(worldGenLevel, randomSource, blockPos4, BuiltInLootTables.SIMPLE_DUNGEON);
--                            break;
--                        }
--                    }
--                }
--            }
--
--            this.safeSetBlock(worldGenLevel, blockPos, Blocks.SPAWNER.defaultBlockState(), predicate);
--            BlockEntity blockEntity = worldGenLevel.getBlockEntity(blockPos);
--            if (blockEntity instanceof SpawnerBlockEntity) {
--                SpawnerBlockEntity spawnerBlockEntity = (SpawnerBlockEntity)blockEntity;
--                spawnerBlockEntity.setEntityId(this.randomEntityId(randomSource), randomSource);
--            } else {
--                LOGGER.error("Failed to fetch mob spawner entity at ({}, {}, {})", blockPos.getX(), blockPos.getY(), blockPos.getZ());
--            }
--
--            return true;
--        } else {
--            return false;
--        }
--    }
-+    public boolean place(FeaturePlaceContext<NoneFeatureConfiguration> context) {return false;}
- 
-     private EntityType<?> randomEntityId(RandomSource random) {
-         return Util.getRandom(MOBS, random);
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/SculkPatchFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/SculkPatchFeature.java
-index f5aea54f81dcd3072e36ddf3c4c6ded848c2c540..1539a644d89b2fee67a5534870ca177b4992409d 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/feature/SculkPatchFeature.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/SculkPatchFeature.java
-@@ -19,48 +19,7 @@ public class SculkPatchFeature extends Feature<SculkPatchConfiguration> {
-     }
- 
-     @Override
--    public boolean place(FeaturePlaceContext<SculkPatchConfiguration> context) {
--        WorldGenLevel worldGenLevel = context.level();
--        BlockPos blockPos = context.origin();
--        if (!this.canSpreadFrom(worldGenLevel, blockPos)) {
--            return false;
--        } else {
--            SculkPatchConfiguration sculkPatchConfiguration = context.config();
--            RandomSource randomSource = context.random();
--            SculkSpreader sculkSpreader = SculkSpreader.createWorldGenSpreader();
--            int i = sculkPatchConfiguration.spreadRounds() + sculkPatchConfiguration.growthRounds();
--
--            for(int j = 0; j < i; ++j) {
--                for(int k = 0; k < sculkPatchConfiguration.chargeCount(); ++k) {
--                    sculkSpreader.addCursors(blockPos, sculkPatchConfiguration.amountPerCharge());
--                }
--
--                boolean bl = j < sculkPatchConfiguration.spreadRounds();
--
--                for(int l = 0; l < sculkPatchConfiguration.spreadAttempts(); ++l) {
--                    sculkSpreader.updateCursors(worldGenLevel, blockPos, randomSource, bl);
--                }
--
--                sculkSpreader.clear();
--            }
--
--            BlockPos blockPos2 = blockPos.below();
--            if (randomSource.nextFloat() <= sculkPatchConfiguration.catalystChance() && worldGenLevel.getBlockState(blockPos2).isCollisionShapeFullBlock(worldGenLevel, blockPos2)) {
--                worldGenLevel.setBlock(blockPos, Blocks.SCULK_CATALYST.defaultBlockState(), 3);
--            }
--
--            int m = sculkPatchConfiguration.extraRareGrowths().sample(randomSource);
--
--            for(int n = 0; n < m; ++n) {
--                BlockPos blockPos3 = blockPos.offset(randomSource.nextInt(5) - 2, 0, randomSource.nextInt(5) - 2);
--                if (worldGenLevel.getBlockState(blockPos3).isAir() && worldGenLevel.getBlockState(blockPos3.below()).isFaceSturdy(worldGenLevel, blockPos3.below(), Direction.UP)) {
--                    worldGenLevel.setBlock(blockPos3, Blocks.SCULK_SHRIEKER.defaultBlockState().setValue(SculkShriekerBlock.CAN_SUMMON, Boolean.valueOf(true)), 3);
--                }
--            }
--
--            return true;
--        }
--    }
-+    public boolean place(FeaturePlaceContext<SculkPatchConfiguration> context) { return false; }
- 
-     private boolean canSpreadFrom(LevelAccessor world, BlockPos pos) {
-         BlockState blockState = world.getBlockState(pos);

patches/server/0031-noEntityCollisions-for-Entity.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Tue, 31 Dec 2024 15:21:45 -0600
+Subject: [PATCH] noEntityCollisions for Entity
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+index fb251665cdbafab90c6ff5e1bcb34fc17124d4d9..0fa6c37eae00d8921d885eae2b777e21bdb4cad2 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+@@ -2099,6 +2099,7 @@ public final class CollisionUtil {
+ 
+     public static boolean getEntityHardCollisions(final Level world, final Entity entity, AABB aabb,
+                                                   final List<AABB> into, final int collisionFlags, final Predicate<Entity> predicate) {
++        if (entity != null && entity.noEntityCollisions) return false; // Slice
+         final boolean checkOnly = (collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0;
+ 
+         boolean ret = false;
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index b878b2559d3957055702d8281846196732909ebd..5497e03bf49d87ce1d3418c4815f107c3d194800 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -438,6 +438,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     private int sectionY = Integer.MIN_VALUE;
+     private int sectionZ = Integer.MIN_VALUE;
+     private boolean updatingSectionStatus;
++    public boolean noEntityCollisions; // Slice
+ 
+     @Override
+     public final boolean moonrise$isHardColliding() {

patches/server/0033-Change-KeepAlive-interval.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 3 Oct 2023 09:18:59 -0500
-Subject: [PATCH] Change KeepAlive interval
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index 0306771b8f90dcdd77f151c19c6c2d75c41f8feb..4563117ce775d6c73a604f512ab595b87a10ddb3 100644
---- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-@@ -215,7 +215,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
-                 this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
-             }
-         } else {
--            if (elapsedTime >= 15000L) { // 15 seconds
-+            if (elapsedTime >= 5000L) { // 15 seconds // Slice -> 5s
-                 this.keepAlivePending = true;
-                 this.keepAliveTime = currentTime;
-                 this.keepAliveChallenge = currentTime;

patches/server/0034-Non-saveable-entities.patch

@@ -1,61 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sat, 21 Oct 2023 11:27:52 -0500
-Subject: [PATCH] Non-saveable entities
-
-
-diff --git a/src/main/java/io/papermc/paper/world/ChunkEntitySlices.java b/src/main/java/io/papermc/paper/world/ChunkEntitySlices.java
-index c78cbec447032de9fe69748591bef6be300160ed..bb3f14d00a8894fc4dfa12b29c27ef56cc44848d 100644
---- a/src/main/java/io/papermc/paper/world/ChunkEntitySlices.java
-+++ b/src/main/java/io/papermc/paper/world/ChunkEntitySlices.java
-@@ -119,7 +119,7 @@ public final class ChunkEntitySlices {
-                 // removed by us below
-                 continue;
-             }
--            if (entity.shouldBeSaved()) {
-+            if (entity.shouldBeSaved() || !entity.saveable) { // Slice
-                 entity.setRemoved(Entity.RemovalReason.UNLOADED_TO_CHUNK, EntityRemoveEvent.Cause.UNLOAD);
-                 if (entity.isVehicle()) {
-                     // we cannot assume that these entities are contained within this chunk, because entities can
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index a23c584ce1f9abcc911aa6a39715b8eeca4ff0af..e25ca5a3f2b7c4573fefba976bc0e79d7a491b62 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -424,6 +424,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-     private UUID originWorld;
-     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
-     public boolean fixedPose = false; // Paper - Expand Pose API
-+    public boolean saveable = true; // Slice
- 
-     public void setOrigin(@javax.annotation.Nonnull Location location) {
-         this.origin = location.toVector();
-@@ -4844,7 +4845,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
- 
-     @Override
-     public boolean shouldBeSaved() {
--        return this.removalReason != null && !this.removalReason.shouldSave() ? false : (this.isPassenger() ? false : !this.isVehicle() || !this.hasAnyPlayerPassengers()); // Paper - rewrite chunk system - it should check if the entity has ANY player passengers
-+        return this.saveable && this.removalReason != null && !this.removalReason.shouldSave() ? false : (this.isPassenger() ? false : !this.isVehicle() || !this.hasAnyPlayerPassengers()); // Paper - rewrite chunk system - it should check if the entity has ANY player passengers // Slice - add saveable check
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index e8e4489bcd64fde1b3226bdc7a7cc612508bda3f..56044646165af2abefc6ab1b73feda4a8778de87 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -1270,4 +1270,16 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         return this.getHandle().getScoreboardName();
-     }
-     // Paper end - entity scoreboard name
-+
-+    // Slice start
-+    @Override
-+    public boolean isSaveable() {
-+        return this.entity.saveable;
-+    }
-+
-+    @Override
-+    public void setSaveable(boolean saveable) {
-+        this.entity.saveable = saveable;
-+    }
-+    // Slice end
- }

patches/server/0035-ChunkStatusChangeEvent.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sun, 22 Oct 2023 08:41:08 -0500
-Subject: [PATCH] ChunkStatusChangeEvent
-
-
-diff --git a/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java b/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
-index b66a7d4aab887309579154815a0d4abf9de506b0..050a667d79df28570f95fe616696d0915257cc89 100644
---- a/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
-+++ b/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
-@@ -1324,6 +1324,13 @@ public final class NewChunkHolder {
-                 // chunks cannot downgrade state while status is pending a change
-                 final LevelChunk chunk = (LevelChunk)this.currentChunk;
- 
-+                // Slice start
-+                new com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent(new org.bukkit.craftbukkit.CraftChunk(chunk),
-+                        com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent.ChunkStatus.valueOf(currState.name()),
-+                        com.destroystokyo.paper.event.chunk.ChunkStatusChangeEvent.ChunkStatus.valueOf(nextState.name()))
-+                        .callEvent();
-+                // Slice end
-+
-                 // Note: we assume that only load/unload contain plugin logic
-                 // plugin logic is anything stupid enough to possibly change the chunk status while it is already
-                 // being changed (i.e during load it is possible it will try to set to full ticking)

patches/server/0036-Disable-sending-Entity-Movement-Packets.patch

@@ -1,49 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Wed, 25 Oct 2023 17:05:29 -0500
-Subject: [PATCH] Disable sending Entity Movement Packets
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 4f4ea6dcef4e1960ac69271fbd771dd3ad6af275..81371980e0eaa362ea1fff9813f632db93021bda 100644
---- a/src/main/java/net/minecraft/server/level/ServerEntity.java
-+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -151,7 +151,7 @@ public class ServerEntity {
-                 boolean flag = Math.abs(i - this.yRotp) >= 1 || Math.abs(j - this.xRotp) >= 1;
- 
-                 if (flag) {
--                    this.broadcast.accept(new ClientboundMoveEntityPacket.Rot(this.entity.getId(), (byte) i, (byte) j, this.entity.onGround()));
-+                    if (entity.sendMovementPackets) this.broadcast.accept(new ClientboundMoveEntityPacket.Rot(this.entity.getId(), (byte) i, (byte) j, this.entity.onGround())); // Slice
-                     this.yRotp = i;
-                     this.xRotp = j;
-                 }
-@@ -186,14 +186,14 @@ public class ServerEntity {
-                     if (!flag6 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.onGround()&& !(io.papermc.paper.configuration.GlobalConfiguration.get().collisions.sendFullPosForHardCollidingEntities && this.entity.hardCollides())) { // Paper - send full pos for hard colliding entities to prevent collision problems due to desync
-                         if ((!flag2 || !flag3) && !(this.entity instanceof AbstractArrow)) {
-                             if (flag2) {
--                                packet1 = new ClientboundMoveEntityPacket.Pos(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), this.entity.onGround());
-+                                if (entity.sendMovementPackets) packet1 = new ClientboundMoveEntityPacket.Pos(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), this.entity.onGround()); // Slice
-                                 flag4 = true;
-                             } else if (flag3) {
--                                packet1 = new ClientboundMoveEntityPacket.Rot(this.entity.getId(), (byte) i, (byte) j, this.entity.onGround());
-+                                if (entity.sendMovementPackets) packet1 = new ClientboundMoveEntityPacket.Rot(this.entity.getId(), (byte) i, (byte) j, this.entity.onGround()); // Slice
-                                 flag5 = true;
-                             }
-                         } else {
--                            packet1 = new ClientboundMoveEntityPacket.PosRot(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), (byte) i, (byte) j, this.entity.onGround());
-+                            if (entity.sendMovementPackets) packet1 = new ClientboundMoveEntityPacket.PosRot(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), (byte) i, (byte) j, this.entity.onGround()); // Slice
-                             flag4 = true;
-                             flag5 = true;
-                         }
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 1d35db213e7ac7518c587cc0dd0c80c3f99a0c41..297e2b8438dde1c1903505e8e7bbc94c3340d2d1 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -425,6 +425,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
-     public boolean fixedPose = false; // Paper - Expand Pose API
-     public boolean saveable = true; // Slice
-+    public boolean sendMovementPackets = true; // Slice
- 
-     public void setOrigin(@javax.annotation.Nonnull Location location) {
-         this.origin = location.toVector();

patches/server/0037-Player-spawnsOwnMobs.patch

@@ -1,66 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Thu, 7 Dec 2023 08:48:41 -0600
-Subject: [PATCH] Player spawnsOwnMobs
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 366c0c9b45a819f7f94ebe3e49b8ab7f9edf9ce7..55281d6dc09ebdd262e05973e4d9c1e82681e05d 100644
---- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -549,7 +549,7 @@ public class ServerChunkCache extends ChunkSource {
-                 // Paper start - optimise chunk tick iteration
-                 ChunkMap playerChunkMap = this.chunkMap;
-                 for (ServerPlayer player : this.level.players) {
--                    if (!player.affectsSpawning || player.isSpectator()) {
-+                    if (!player.affectsSpawning || player.isSpectator() || player.spawnsOwnMobs) {
-                         playerChunkMap.playerMobSpawnMap.remove(player);
-                         player.playerNaturallySpawnedEvent = null;
-                         player.lastEntitySpawnRadiusSquared = -1.0;
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
-index 4e2c23ccdf4e4a4d65b291dbe20952bae1838bff..b7c6ec93244da6ebba116ab5d17179f291314b29 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
-@@ -2,7 +2,12 @@ package net.minecraft.world.entity.ai.goal;
- 
- import java.util.EnumSet;
- import java.util.function.Predicate;
-+
-+import com.destroystokyo.paper.util.maplist.ReferenceList;
-+import io.papermc.paper.util.player.NearbyPlayers;
- import net.minecraft.core.BlockPos;
-+import net.minecraft.server.level.ServerLevel;
-+import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.world.entity.Mob;
- import net.minecraft.world.level.GameRules;
- import net.minecraft.world.level.Level;
-@@ -31,11 +36,12 @@ public class EatBlockGoal extends Goal {
- 
-     @Override
-     public boolean canUse() {
--        // Paper start - Fix MC-210802
--        if (!((net.minecraft.server.level.ServerLevel) this.level).chunkSource.chunkMap.anyPlayerCloseEnoughForSpawning(this.mob.chunkPosition())) {
-+        // Paper start - Fix MC-210802 // Slice start - adjust due to our spawnsOwnMobs logic
-+        NearbyPlayers nearbyPlayers = ((ServerLevel) this.level).chunkSource.chunkMap.getNearbyPlayers();
-+        ReferenceList<ServerPlayer> generalNearbyPlayers = nearbyPlayers.getPlayers(this.mob.chunkPosition(), NearbyPlayers.NearbyMapType.GENERAL);
-+        if (generalNearbyPlayers == null || generalNearbyPlayers.size() == 0) {
-             return false;
--        }
--        // Paper end
-+        } // Slice end
-         if (this.mob.getRandom().nextInt(this.mob.isBaby() ? 50 : 1000) != 0) {
-             return false;
-         } else {
-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 7e2fa586ae255cb94e302c14d0811e36e860f188..55791ab44fd7c11ceedb4bdcc2c9c45cbe916a98 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -184,6 +184,8 @@ public abstract class Player extends LivingEntity {
-     public boolean affectsSpawning = true; // Paper - Affects Spawning API
-     public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
- 
-+    public boolean spawnsOwnMobs = false; // Slice
-+
-     // CraftBukkit start
-     public boolean fauxSleeping;
-     public int oldLevel = -1;

patches/server/0038-Set-location-on-a-Custom-Inventory.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 8 Dec 2023 08:02:07 -0600
-Subject: [PATCH] Set location on a Custom Inventory
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
-index da1c1fe0faf6819b15a81d6ad53370948e5f984f..84eff85e98484c9701e203bb1fa61435ee88bab4 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
-@@ -69,6 +69,14 @@ public class CraftInventoryCustom extends CraftInventory {
-     }
-     // Paper end
- 
-+    // Slice start
-+    public void setLocation(Location location) {
-+        if (this.inventory instanceof MinecraftInventory minecraftInventory) {
-+            minecraftInventory.location = location;
-+        }
-+    }
-+    // Slice end
-+
-     static class MinecraftInventory implements Container {
-         private final NonNullList<ItemStack> items;
-         private int maxStack = MAX_STACK;
-@@ -77,6 +85,7 @@ public class CraftInventoryCustom extends CraftInventory {
-         private final net.kyori.adventure.text.Component adventure$title; // Paper
-         private InventoryType type;
-         private final InventoryHolder owner;
-+        private Location location; // Slice
- 
-         // Paper start
-         public MinecraftInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) {
-@@ -239,7 +248,7 @@ public class CraftInventoryCustom extends CraftInventory {
- 
-         @Override
-         public Location getLocation() {
--            return null;
-+            return location;
-         }
- 
-         // Paper start

patches/server/0039-Shared-Data-Storage.patch

@@ -1,122 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Wed, 3 Jan 2024 11:03:33 -0600
-Subject: [PATCH] Shared Data Storage
-
-
-diff --git a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
-index 0cc2307636279915c1f8529e62174cc696e185ee..220e5ede5752a4b9ab7e35c3ee4f0b4a26b2986c 100644
---- a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
-+++ b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
-@@ -336,6 +336,7 @@ public class GlobalConfiguration extends ConfigurationPart {
-         public boolean useDimensionTypeForCustomSpawners = false;
-         public boolean strictAdvancementDimensionCheck = false;
-         public IntOr.Default compressionLevel = IntOr.Default.USE_DEFAULT;
-+        public String sharedDataFolder = ""; // Slice
-     }
- 
-     public BlockUpdates blockUpdates;
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 9ce9af857a5f2414658027ff5bb765cc4233899b..b8a43a2833b9f014067681277edad3b96a6d63cd 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -2,6 +2,7 @@ package net.minecraft.server;
- 
- import com.google.common.base.Preconditions;
- import com.google.common.base.Splitter;
-+import com.google.common.base.Strings;
- import com.google.common.collect.ImmutableList;
- import co.aikar.timings.Timings;
- import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
-@@ -313,6 +314,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-     public volatile boolean abnormalExit = false; // Paper
-     public static final long SERVER_INIT = System.nanoTime(); // Paper - Lag compensation
- 
-+    @Nullable DimensionDataStorage sharedDataStorage; // Slice
-+
-     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
-         AtomicReference<S> atomicreference = new AtomicReference();
-         Thread thread = new io.papermc.paper.util.TickThread(() -> { // Paper - rewrite chunk system
-@@ -414,6 +417,12 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         this.paperConfigurations = services.paperConfigurations(); // Paper - add paper configuration files
-     }
- 
-+    // Slice start
-+    public DimensionDataStorage getMapDataStorage() {
-+        return sharedDataStorage != null ? sharedDataStorage : overworld().getDataStorage();
-+    }
-+    // Slice end
-+
-     private void readScoreboard(DimensionDataStorage persistentStateManager) {
-         persistentStateManager.computeIfAbsent(this.getScoreboard().dataFactory(), "scoreboard");
-     }
-@@ -917,6 +926,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.isSaving = true;
-             this.getPlayerList().saveAll(); // Paper - Incremental chunk and player saving; diff on change
-             flag3 = this.saveAllChunks(suppressLogs, flush, force);
-+            if (sharedDataStorage != null) sharedDataStorage.save(true); // Slice
-         } finally {
-             this.isSaving = false;
-         }
-@@ -1132,6 +1142,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-                 throw new IllegalStateException("Failed to initialize server");
-             }
- 
-+            // Slice start
-+            String sharedDataFolder = io.papermc.paper.configuration.GlobalConfiguration.get().misc.sharedDataFolder;
-+            if (!Strings.isNullOrEmpty(sharedDataFolder)) {
-+                File sharedDir = new File(sharedDataFolder);
-+                sharedDir.mkdirs();
-+                this.sharedDataStorage = new DimensionDataStorage(sharedDir, fixerUpper);
-+            }
-+            // Slice end
-+
-             this.nextTickTimeNanos = Util.getNanos();
-             this.statusIcon = (ServerStatus.Favicon) this.loadStatusIcon().orElse(null); // CraftBukkit - decompile error
-             this.status = this.buildServerStatus();
-@@ -1546,6 +1565,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-                     level.saveIncrementally(fullSave);
-                 }
-             }
-+            if (sharedDataStorage != null) sharedDataStorage.save(true); // 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 4653878c059a15491eb54d7211311db7e2fe570a..d60d1fe0261c79d77df982b76bfe96b91f6970de 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -2127,7 +2127,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     @Override
-     public MapItemSavedData getMapData(String id) {
-         // Paper start - Call missing map initialize event and set id
--        final DimensionDataStorage storage = this.getServer().overworld().getDataStorage();
-+        final DimensionDataStorage storage = this.getServer().getMapDataStorage(); // Slice
- 
-         final net.minecraft.world.level.saveddata.SavedData existing = storage.cache.get(id);
-         if (existing == null && !storage.cache.containsKey(id)) {
-@@ -2154,12 +2154,22 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         MapInitializeEvent event = new MapInitializeEvent(state.mapView);
-         Bukkit.getServer().getPluginManager().callEvent(event);
-         // CraftBukkit end
--        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.factory(), "idcounts")).getFreeAuxValueForMap();
-+        // Slice start
-+        DimensionDataStorage storage = this.getServer().getMapDataStorage();
-+        MapIndex mapIndex = storage.readSavedData(MapIndex::load, MapItemSavedData.factory().type(), "idcounts");
-+        if (mapIndex == null) {
-+            mapIndex = new MapIndex();
-+        }
-+        int newId = mapIndex.getFreeAuxValueForMap();
-+        storage.set("idcounts", mapIndex);
-+        storage.save(true);
-+        return newId;
-+        // Slice end
-     }
- 
-     // Paper start - Configurable Keep Spawn Loaded range per world

patches/server/0040-Vanish.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sun, 7 Jan 2024 08:26:59 -0600
-Subject: [PATCH] Vanish
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 3a520677dce5cba5a348ec295ea07cd090e541f9..e858d24061ce8fad612c12adac205c7ad59b8767 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -426,6 +426,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-     public boolean fixedPose = false; // Paper - Expand Pose API
-     public boolean saveable = true; // Slice
-     public boolean sendMovementPackets = true; // Slice
-+    public boolean vanished; // Slice
- 
-     public void setOrigin(@javax.annotation.Nonnull Location location) {
-         this.origin = location.toVector();
-@@ -1325,7 +1326,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-     }
- 
-     private boolean vibrationAndSoundEffectsFromBlock(BlockPos pos, BlockState state, boolean playSound, boolean emitEvent, Vec3 movement) {
--        if (state.isAir()) {
-+        if (vanished || state.isAir()) { // Slice
-             return false;
-         } else {
-             boolean flag2 = this.isStateClimbable(state);
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 56044646165af2abefc6ab1b73feda4a8778de87..8af60900f5e385546bb452cd0bc0c702d5df0a46 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -1282,4 +1282,16 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         this.entity.saveable = saveable;
-     }
-     // Slice end
-+
-+    // Slice start
-+    @Override
-+    public boolean isVanished() {
-+        return this.entity.vanished;
-+    }
-+
-+    @Override
-+    public void setVanished(boolean vanished) {
-+        this.entity.vanished = vanished;
-+    }
-+    // Slice end
- }

patches/server/0042-Make-AdvancementProgress-Map-ctor-public.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Thu, 29 Feb 2024 08:34:20 -0600
-Subject: [PATCH] Make AdvancementProgress Map ctor public
-
-
-diff --git a/src/main/java/net/minecraft/advancements/AdvancementProgress.java b/src/main/java/net/minecraft/advancements/AdvancementProgress.java
-index 2adba57cb01fc95d414570ef86777228247fae53..9c040d0ecc7a53761856ecf1e9dd35b2b06fd5f1 100644
---- a/src/main/java/net/minecraft/advancements/AdvancementProgress.java
-+++ b/src/main/java/net/minecraft/advancements/AdvancementProgress.java
-@@ -46,9 +46,9 @@ public class AdvancementProgress implements Comparable<AdvancementProgress> {
-     private final Map<String, CriterionProgress> criteria;
-     private AdvancementRequirements requirements = AdvancementRequirements.EMPTY;
- 
--    private AdvancementProgress(Map<String, CriterionProgress> criteriaProgresses) {
-+    public AdvancementProgress(Map<String, CriterionProgress> criteriaProgresses) {
-         this.criteria = criteriaProgresses;
--    }
-+    } // Slice
- 
-     public AdvancementProgress() {
-         this.criteria = Maps.newHashMap();

patches/server/0043-Improve-map-saving-performance.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: cryptite <cryptite@gmail.com>
-Date: Fri, 15 Mar 2024 08:51:06 -0500
-Subject: [PATCH] Improve map-saving performance
-
-
-diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-index 45269115e63cfc3bd7dc740a5694e2cc7c35bcb1..c09e6d89b1595ce26c3489ca9e84a7c2bdf80286 100644
---- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-+++ b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-@@ -331,7 +331,7 @@ public class MapItemSavedData extends SavedData {
-             --this.trackedDecorationCount;
-         }
- 
--        this.setDecorationsDirty();
-+        if (mapicon != null) this.setDecorationsDirty(); // Paper - We should not be dirtying this over unless there was mutation.
-     }
- 
-     public static void addTargetDecoration(ItemStack stack, BlockPos pos, String id, MapDecoration.Type type) {

patches/server/0044-Set-LevelChunkSections.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Thu, 2 May 2024 08:51:50 -0500
-Subject: [PATCH] Set LevelChunkSections
-
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-index f7e5e016a7028a9196e689e950805b0d5b31fe38..9ca07bf5bf68749970258d611013bec425a3c48c 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-@@ -80,7 +80,7 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom
-     protected final Map<BlockPos, CompoundTag> pendingBlockEntities = Maps.newHashMap();
-     public final Map<BlockPos, BlockEntity> blockEntities = Maps.newHashMap();
-     protected final LevelHeightAccessor levelHeightAccessor;
--    protected final LevelChunkSection[] sections;
-+    protected LevelChunkSection[] sections; // Slice - Remove final
- 
-     // CraftBukkit start - SPIGOT-6814: move to IChunkAccess to account for 1.17 to 1.18 chunk upgrading.
-     private static final org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry();
-@@ -217,6 +217,8 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom
-         return this.getSections()[yIndex];
-     }
- 
-+    public void setSections(LevelChunkSection[] sections) { this.sections = sections; } // Slice
-+
-     public Collection<Entry<Heightmap.Types, Heightmap>> getHeightmaps() {
-         return Collections.unmodifiableSet(this.heightmaps.entrySet());
-     }

patches/server/0045-Freeze-Chunk-Loading.patch

@@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 3 May 2024 08:27:49 -0500
-Subject: [PATCH] Freeze Chunk Loading
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index d60d1fe0261c79d77df982b76bfe96b91f6970de..d48f4a8db6fffd84f9a68c7da2c06c0730678b71 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -224,6 +224,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     public boolean hasPhysicsEvent = true; // Paper - BlockPhysicsEvent
-     public boolean hasEntityMoveEvent; // Paper - Add EntityMoveEvent
-     public boolean instance; // Slice
-+    public boolean freezeChunkLoading = true; // Slice
-     private final alternate.current.wire.WireHandler wireHandler = new alternate.current.wire.WireHandler(this); // Paper - optimize redstone (Alternate Current)
- 
-     public LevelChunk getChunkIfLoaded(int x, int z) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index fd8c6a3aaba37bb7439e74b9fc765dd7332041d9..e2947f1dbf2ccb8aeade513b79232506ab7c3706 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -561,6 +561,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public boolean loadChunk(int x, int z, boolean generate) {
-+        if (world.freezeChunkLoading) return false; // Slice
-         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
-         warnUnsafeChunk("loading a faraway chunk", x, z); // Paper
-         // Paper start - Optimize this method

patches/server/0046-Expose-getBlockPosBelowThatAffectsMyMovement-Fix-pat.patch

@@ -1,70 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 May 2024 08:11:40 -0500
-Subject: [PATCH] Expose getBlockPosBelowThatAffectsMyMovement Fix patch
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index ad2567133405744abcf20d8572d6c7afc37581af..afde18e38484f7f3d6041cef54168d5ae7a1d901 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -1401,7 +1401,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
-         return this.getOnPos(0.2F);
-     }
- 
--    protected BlockPos getBlockPosBelowThatAffectsMyMovement() {
-+    public BlockPos getBlockPosBelowThatAffectsMyMovement() {
-         return this.getOnPos(0.500001F);
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 36422fb394a158f36c84ba0ee03cc704956c91b2..78dbed58541c33749a2fbd12b6f521e31d7eb907 100644
---- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -192,7 +192,7 @@ public class ExperienceOrb extends Entity {
-     }
- 
-     @Override
--    protected BlockPos getBlockPosBelowThatAffectsMyMovement() {
-+    public BlockPos getBlockPosBelowThatAffectsMyMovement() {
-         return this.getOnPos(0.999999F);
-     }
- 
-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 29ce703a79f7893ac990ad80e0f1c1cf63546e6c..0033125e504df35e907cab8acd7d0d7f7ff982a4 100644
---- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -257,7 +257,7 @@ public class ItemEntity extends Entity implements TraceableEntity {
-     // Spigot end
- 
-     @Override
--    protected BlockPos getBlockPosBelowThatAffectsMyMovement() {
-+    public BlockPos getBlockPosBelowThatAffectsMyMovement() {
-         return this.getOnPos(0.999999F);
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 8af60900f5e385546bb452cd0bc0c702d5df0a46..25e721d069f350b93559a0bb8841415d51bc09b7 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -25,6 +25,7 @@ import org.bukkit.Location;
- import org.bukkit.Server;
- import org.bukkit.Sound;
- import org.bukkit.World;
-+import org.bukkit.block.Block;
- import org.bukkit.block.BlockFace;
- import org.bukkit.block.PistonMoveReaction;
- import org.bukkit.craftbukkit.CraftServer;
-@@ -1294,4 +1295,12 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         this.entity.vanished = vanished;
-     }
-     // Slice end
-+
-+    // Slice start
-+    @Override
-+    public Block getBlockStandingOn() {
-+        net.minecraft.core.BlockPos pos = this.entity.getBlockPosBelowThatAffectsMyMovement();
-+        return this.entity.level().getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ());
-+    }
-+    // Slice end
- }

patches/server/0047-Affinity-Locks.patch

@@ -1,81 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 5 Aug 2024 15:07:31 -0500
-Subject: [PATCH] Affinity Locks
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 46980b062980be8c564a215a2ae67e0d1fe5251e..2b1fd2cd7046f283510cd6e801abd8f49b0e8870 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -24,6 +24,9 @@ dependencies {
-     implementation("com.fasterxml.jackson.core:jackson-core:2.13.0")
-     implementation("com.fasterxml.jackson.core:jackson-databind:2.13.0")
-     implementation("com.fasterxml.jackson.core:jackson-annotations:2.13.0")
-+
-+    // https://mvnrepository.com/artifact/net.openhft/Java-Thread-Affinity
-+    implementation("net.openhft:affinity:3.26ea5")
-     // Slice end
- 
-     implementation("org.mongodb:bson:4.11.1") // Slice - MongoDB Bson Library for ObjectIds
-diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
-index bc391d27399d8c22e78735ca39aa8ab45efb6413..fc1002b11f38ab31ff4148dbb8398f41389a3980 100644
---- a/src/main/java/net/minecraft/server/Main.java
-+++ b/src/main/java/net/minecraft/server/Main.java
-@@ -342,7 +342,7 @@ public class Main {
-                 }
- 
-                 return dedicatedserver1;
--            });
-+            }, dedicatedserversettings.getProperties().pinnedCPU);
-             /* CraftBukkit start
-             Thread thread = new Thread("Server Shutdown Thread") {
-                 public void run() {
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index b8a43a2833b9f014067681277edad3b96a6d63cd..5c874b36dc8fd2c31192888bead8bc685d391ea0 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -316,10 +316,10 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @Nullable DimensionDataStorage sharedDataStorage; // Slice
- 
--    public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
-+    public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory, int pinnedCPU) {
-         AtomicReference<S> atomicreference = new AtomicReference();
-         Thread thread = new io.papermc.paper.util.TickThread(() -> { // Paper - rewrite chunk system
--            ((MinecraftServer) atomicreference.get()).runServer();
-+            ((MinecraftServer) atomicreference.get()).runServer(pinnedCPU);
-         }, "Server thread");
- 
-         thread.setUncaughtExceptionHandler((thread1, throwable) -> {
-@@ -1135,8 +1135,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     public static volatile RuntimeException chunkSystemCrash; // Paper - rewrite chunk system
- 
--    protected void runServer() {
--        try {
-+    protected void runServer(int pinnedCPU) {
-+        try (net.openhft.affinity.AffinityLock al = net.openhft.affinity.AffinityLock.acquireLock(pinnedCPU)) {
-             long serverStartTime = Util.getNanos(); // Paper
-             if (!this.initServer()) {
-                 throw new IllegalStateException("Failed to initialize server");
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-index bab2471616404821671264ccefd729cab8d0bf58..ae69751c8ae5a288337b750f400e4af24506838d 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-@@ -107,6 +107,7 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
-     public final boolean logIPs;
-     private final DedicatedServerProperties.WorldDimensionData worldDimensionData;
-     public final WorldOptions worldOptions;
-+    public final int pinnedCPU;
- 
-     public final String rconIp; // Paper - Configurable rcon ip
- 
-@@ -172,6 +173,7 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
-         final String rconIp = this.getStringRaw("rcon.ip");
-         this.rconIp = rconIp == null ? this.serverIp : rconIp;
-         // Paper end - Configurable rcon ip
-+        this.pinnedCPU = this.get("pinned-cpu", -1);
-     }
- 
-     // CraftBukkit start

settings.gradle.kts

@@ -1,10 +1,59 @@
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-        maven("https://repo.papermc.io/repository/maven-public/")
-    }
+import java.util.Locale
+
+        pluginManagement {
+            repositories {
+                gradlePluginPortal()
+                maven("https://repo.papermc.io/repository/maven-public/")
+            }
+        }
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+
+if (!file(".git").exists()) {
+    val errorText = """
+        
+        =====================[ ERROR ]=====================
+         The Paper project directory is not a properly cloned Git repository.
+         
+         In order to build Paper from source you must clone
+         the Paper repository using Git, not download a code
+         zip from GitHub.
+         
+         Built Paper jars are available for download at
+         https://papermc.io/downloads/paper
+         
+         See https://github.com/PaperMC/Paper/blob/master/CONTRIBUTING.md
+         for further information on building and modifying Paper.
+        ===================================================
+    """.trimIndent()
+    error(errorText)
 }
 
 rootProject.name = "slice"
 
-include("slice-api", "slice-server")
+for (name in listOf("slice-api", "slice-server")) {
+    val projName = name.lowercase(Locale.ENGLISH)
+    include(projName)
+    findProject(":$projName")!!.projectDir = file(name)
+}
+
+optionalInclude("test-plugin")
+optionalInclude("paper-api-generator")
+
+fun optionalInclude(name: String, op: (ProjectDescriptor.() -> Unit)? = null) {
+    val settingsFile = file("$name.settings.gradle.kts")
+    if (settingsFile.exists()) {
+        apply(from = settingsFile)
+        findProject(":$name")?.let { op?.invoke(it) }
+    } else {
+        settingsFile.writeText(
+            """
+            // Uncomment to enable the '$name' project
+            // include(":$name")
+
+            """.trimIndent()
+        )
+    }
+}