Collisions patch, update paper repo url

- Key by hashCode Integer, rather than full ItemStack which should save a notable amount of memory.
- Also switch cache to expireAfterAccess. These things shouldn't ever change when largely used, so to expire them 15m after first write almost guarantees they'll just be re-cached the same, again

.github/workflows/build.yml

@@ -1,32 +0,0 @@
-name: Patch and Build
-on: [ push, pull_request ]
-jobs:
-  build:
-    # Only run on PRs if the source branch is on someone else's repo
-    if: ${{ github.event_name != 'pull_request' || github.repository != github.event.pull_request.head.repo.full_name }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Git Repository
-        uses: actions/checkout@v2
-      - name: Validate Gradle wrapper
-        uses: gradle/wrapper-validation-action@v1
-      - name: Cache Gradle
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', '**/gradle.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-      - name: Set up JDK
-        uses: actions/setup-java@v2.3.0
-        with:
-          distribution: 'temurin'
-          java-version: '16'
-      - name: Configure Git User Details
-        run: git config --global user.email "actions@github.com" && git config --global user.name "Github Actions"
-      - name: Apply Patches
-        run: ./gradlew applyPatches --stacktrace
-      - name: Build
-        run: ./gradlew build --stacktrace

.gitignore

@@ -1,5 +1,10 @@
 .gradle
 /build/
+.idea
+run
+slice-api
+slice-server
+paper-api-generator
 
 # Ignore Gradle GUI config
 gradle-app.setting
@@ -12,3 +17,8 @@ gradle-app.setting
 
 # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
 # gradle/wrapper/gradle-wrapper.properties
+/commit.sh
+/publish.sh
+/slice-api/
+/slice-server/
+/generated/

build-data/dev-imports.txt

@@ -8,3 +8,7 @@
 # To import classes from the vanilla Minecraft jar use `minecraft` as the artifactId:
 #     minecraft net.minecraft.world.level.entity.LevelEntityGetterAdapter
 #     minecraft net/minecraft/world/level/entity/LevelEntityGetter.java
+# To import minecraft data files, like the default chat type, use `mc_data` as the prefix:
+#     mc_data chat_type/chat.json
+#     mc_data dimension_type/overworld.json
+#

build.gradle.kts

@@ -3,21 +3,23 @@ import io.papermc.paperweight.util.constants.*
 plugins {
     java
     `maven-publish`
-    id("com.github.johnrengelman.shadow") version "7.1.0" apply false
-    id("io.papermc.paperweight.patcher") version "1.2.0"
+    id("com.github.johnrengelman.shadow") version "8.1.1" apply false
+    id("io.papermc.paperweight.patcher") version "1.7.4"
 }
 
+val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
+
 repositories {
     mavenCentral()
-    maven("https://papermc.io/repo/repository/maven-public/") {
-        content { onlyForConfigurations(PAPERCLIP_CONFIG) }
+    maven(paperMavenPublicUrl) {
+        content { onlyForConfigurations(configurations.paperclip.name) }
     }
 }
 
 dependencies {
-    remapper("net.fabricmc:tiny-remapper:0.6.0:fat")
-    decompiler("net.minecraftforge:forgeflower:1.5.498.12")
-    paperclip("io.papermc:paperclip:2.0.1")
+    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 {
@@ -26,7 +28,7 @@ allprojects {
 
     java {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(16))
+            languageVersion.set(JavaLanguageVersion.of(21))
         }
     }
 }
@@ -34,7 +36,7 @@ allprojects {
 subprojects {
     tasks.withType<JavaCompile> {
         options.encoding = Charsets.UTF_8.name()
-        options.release.set(16)
+        options.release.set(21)
     }
     tasks.withType<Javadoc> {
         options.encoding = Charsets.UTF_8.name()
@@ -45,28 +47,32 @@ subprojects {
 
     repositories {
         mavenCentral()
-        maven("https://oss.sonatype.org/content/groups/public/")
-        maven("https://papermc.io/repo/repository/maven-public/")
-        maven("https://ci.emc.gs/nexus/content/groups/aikar/")
-        maven("https://repo.aikar.co/content/groups/aikar")
-        maven("https://repo.md-5.net/content/repositories/releases/")
-        maven("https://hub.spigotmc.org/nexus/content/groups/public/")
+        maven(paperMavenPublicUrl)
     }
 }
 
 paperweight {
-    serverProject.set(project(":Slice-Server"))
+    serverProject.set(project(":slice-server"))
 
-    remapRepo.set("https://maven.fabricmc.net/")
-    decompileRepo.set("https://files.minecraftforge.net/maven/")
+    remapRepo.set(paperMavenPublicUrl)
+    decompileRepo.set(paperMavenPublicUrl)
 
     usePaperUpstream(providers.gradleProperty("paperRef")) {
         withPaperPatcher {
             apiPatchDir.set(layout.projectDirectory.dir("patches/api"))
-            apiOutputDir.set(layout.projectDirectory.dir("Slice-API"))
+            apiOutputDir.set(layout.projectDirectory.dir("slice-api"))
 
             serverPatchDir.set(layout.projectDirectory.dir("patches/server"))
-            serverOutputDir.set(layout.projectDirectory.dir("Slice-Server"))
+            serverOutputDir.set(layout.projectDirectory.dir("slice-server"))
+        }
+
+        patchTasks {
+            register("generatedApi") {
+                isBareDirectory.set(true)
+                upstreamDirPath.set("paper-api-generator/generated")
+                patchDir.set(layout.projectDirectory.dir("patches/generatedApi"))
+                outputDir.set(layout.projectDirectory.dir("paper-api-generator/generated"))
+            }
         }
     }
 }
@@ -77,36 +83,14 @@ paperweight {
 
 tasks.generateDevelopmentBundle {
     apiCoordinates.set("com.lokamc.slice:slice-api")
-    mojangApiCoordinates.set("io.papermc.paper:paper-mojangapi")
     libraryRepositories.set(
         listOf(
-            "https://libraries.minecraft.net/",
-            "https://maven.quiltmc.org/repository/release/",
-            "https://repo.aikar.co/content/groups/aikar",
-            "https://ci.emc.gs/nexus/content/groups/aikar/",
-            "https://papermc.io/repo/repository/maven-public/",
-            "https://repo.velocitypowered.com/snapshots/",
-            "https://ysera.dyndns.org:444/releases/"
+            "https://repo.maven.apache.org/maven2/",
+            paperMavenPublicUrl
         )
     )
 }
 
-allprojects {
-    // Publishing API:
-    // ./gradlew :Slice-API:publish[ToMavenLocal]
-    publishing {
-        repositories {
-            maven {
-                name = "Ysera"
-                url = uri("https://ysera.dyndns.org:444/releases")
-                // See Gradle docs for how to provide credentials to PasswordCredentials
-                // https://docs.gradle.org/current/samples/sample_publishing_credentials.html
-                credentials(PasswordCredentials::class)
-            }
-        }
-    }
-}
-
 publishing {
     // Publishing dev bundle:
     // ./gradlew publishDevBundlePublicationTo(MavenLocal|MyRepoSnapshotsRepository) -PpublishDevBundle

gradle.properties

@@ -1,8 +1,8 @@
 group=com.lokamc.slice
-version=1.17.1-R0.1-SNAPSHOT
-
-mcVersion=1.17.1
-paperRef=bf23668bc56a31ccf9ff7c7b290bb0442afebff6
+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

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

gradlew

@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

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: Sun, 26 Sep 2021 09:00:51 -0500
+Date: Sat, 9 Nov 2024 09:48:21 -0600
 Subject: [PATCH] Add BlockDestroyedByNeighborEvent
 
 

patches/api/0001-Add-PlayerShieldDisableEvent.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 Sep 2021 08:33:45 -0500
-Subject: [PATCH] Add PlayerShieldDisableEvent
-
-
-diff --git a/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..f0f3a57a0ce76b4736219c6ece52b8bc47a7a4ec
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java
-@@ -0,0 +1,50 @@
-+package io.papermc.paper.event.player;
-+
-+import org.bukkit.entity.Entity;
-+import org.bukkit.entity.Player;
-+import org.bukkit.event.Cancellable;
-+import org.bukkit.event.Event;
-+import org.bukkit.event.HandlerList;
-+import org.bukkit.event.player.PlayerEvent;
-+import org.jetbrains.annotations.NotNull;
-+import org.jetbrains.annotations.Nullable;
-+
-+/**
-+ * Thrown whenever a Player's shield is disabled
-+ */
-+public class PlayerShieldDisableEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private final Entity damager;
-+    private boolean cancelled = false;
-+
-+    public PlayerShieldDisableEvent(@NotNull final Player player, @Nullable final Entity damager) {
-+        super(player);
-+        this.damager = damager;
-+    }
-+
-+    @Nullable
-+    public Entity getDamager() {
-+        return damager;
-+    }
-+
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
-+    }
-+}

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

@@ -1,16 +1,16 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Wed, 29 Sep 2021 08:40:37 -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 cd63406809aadbcc53857aaef31053915278dfc0..ab4982d52185bbc80d506da2a961345d46710efa 100644
+index 0efd8bb70ebdb86372022c9e12ec89f229ab3b52..be4f8fc7e7d9b6fb3ef0f557c9f591431c902837 100644
 --- a/src/main/java/org/bukkit/block/Block.java
 +++ b/src/main/java/org/bukkit/block/Block.java
-@@ -602,6 +602,20 @@ public interface Block extends Metadatable, net.kyori.adventure.translation.Tran
+@@ -677,6 +677,20 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
      @NotNull
-     Collection<ItemStack> getDrops(@NotNull ItemStack tool, @Nullable Entity entity);
+     Collection<ItemStack> getDrops(@Nullable ItemStack tool, @Nullable Entity entity); // Paper
  
 +    // Slice start
 +    /**

patches/api/0002-Multiple-Entries-with-Scoreboards.patch

@@ -1,58 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 Sep 2021 15:20:16 -0500
-Subject: [PATCH] Multiple Entries with Scoreboards
-
-
-diff --git a/src/main/java/org/bukkit/scoreboard/Team.java b/src/main/java/org/bukkit/scoreboard/Team.java
-index d5b39fb4fc16a342b5661e08df1506858168d20d..9ec00b045fe85701ce29c0ad10eb9921733107b3 100644
---- a/src/main/java/org/bukkit/scoreboard/Team.java
-+++ b/src/main/java/org/bukkit/scoreboard/Team.java
-@@ -1,5 +1,6 @@
- package org.bukkit.scoreboard;
- 
-+import java.util.Collection; // Paper
- import java.util.Set;
- import org.bukkit.ChatColor;
- import org.bukkit.OfflinePlayer;
-@@ -317,6 +318,20 @@ public interface Team {
-      */
-     void addEntry(@NotNull String entry) throws IllegalStateException, IllegalArgumentException;
- 
-+    // Paper start
-+    /**
-+     * This puts a collection of entries onto this team for the scoreboard which results in one
-+     * packet for the updates rather than a packet-per-entry.
-+     * <p>
-+     * Entries on other teams will be removed from their respective teams.
-+     *
-+     * @param entries the entries to add
-+     * @throws IllegalArgumentException if entries are null
-+     * @throws IllegalStateException if this team has been unregistered
-+     */
-+    void addEntries(@NotNull Collection<String> entries) throws IllegalStateException, IllegalArgumentException;
-+    // Paper end
-+
-     /**
-      * Removes the player from this team.
-      *
-@@ -340,6 +355,19 @@ public interface Team {
-      */
-     boolean removeEntry(@NotNull String entry) throws IllegalStateException, IllegalArgumentException;
- 
-+    // Paper start
-+    /**
-+     * Removes a collection of entries from this team  which results in one
-+     * packet for the updates rather than a packet-per-entry.
-+     *
-+     * @param entries the entries to remove
-+     * @return if any of the entries were a part of this team
-+     * @throws IllegalArgumentException if entry is null
-+     * @throws IllegalStateException if this team has been unregistered
-+     */
-+    boolean removeEntries(@NotNull Collection<String> entries) throws IllegalStateException, IllegalArgumentException;
-+    // Paper end
-+
-     /**
-      * Unregisters this team from the Scoreboard
-      *

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

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Sun, 26 Sep 2021 16:36:29 -0500
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 9 Nov 2024 09:55:18 -0600
 Subject: [PATCH] Add Player to SpongeAbsorbEvent
 
 

patches/api/0003-Set-BlockData-without-light-update.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Wed, 22 Sep 2021 09:41:27 -0500
-Subject: [PATCH] Set BlockData without light update
-
-
-diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
-index ad8bce01ba459a036cd4ebbbe4fc974021924fe2..6ef43ae39a8ad4ed0e9a7bf68c17840576e235ea 100644
---- a/src/main/java/org/bukkit/block/Block.java
-+++ b/src/main/java/org/bukkit/block/Block.java
-@@ -287,6 +287,28 @@ public interface Block extends Metadatable, net.kyori.adventure.translation.Tran
-      */
-     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/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, 18 Oct 2021 08:52:40 -0500
-Subject: [PATCH] World Instance Flag
+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 4f673e9123145dc78564dc3eef0edf75795dafc2..c840fccc7d5eab215886c3281be3a6257fa01aad 100644
+index 7a439c99fc4c5ee17d674460c8e58a9fe0c64e02..411e2153538f63f1ce3b3a10bb2829d1737d0597 100644
 --- a/src/main/java/org/bukkit/World.java
 +++ b/src/main/java/org/bukkit/World.java
-@@ -2606,6 +2606,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

@@ -0,0 +1,30 @@
+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/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 95f0b3186e313c7fbd5c8531d52b82a69e525f94..f542265036bde4031c834e379a031d2821f32173 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -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
++     * happen but the visual "refresh" of a world change is hidden. Depending on the destination location/world,
++     * this can act as a "smooth teleport" to a world if the new world is very similar looking to the old one.
++     *
++     * @param location New location to teleport this Player to
++     */
++    @org.jetbrains.annotations.ApiStatus.Experimental
++    void teleportWithoutRespawn(@NotNull Location location);
++    // Slice end
++
+     // Paper start - Teleport API
+     /**
+      * Sets the player's rotation.

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

@@ -0,0 +1,35 @@
+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/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
+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
+     private final boolean willAttack;
+ 
+     private boolean cancelled;
++    private boolean forceCrit; // Slice
+ 
+     @ApiStatus.Internal
+     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;
+     }
+ 
++    // Slice start
++    public boolean isForceCrit() {
++        return forceCrit;
++    }
++
++    public void setForceCrit(boolean forceCrit) {
++        this.forceCrit = forceCrit;
++    }
++    // Slice end
++
+     @Override
+     public boolean isCancelled() {
+         return this.cancelled;

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

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 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
+@@ -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(final UUID playerUniqueId, final String playerName, final InetAddress ipAddress, final boolean async) {
++        this(playerUniqueId, playerName, ipAddress, ConnectionCloseReason.NORMAL, async);
++    }
++
++    public PlayerConnectionCloseEvent(@NotNull final UUID playerUniqueId, @NotNull final String playerName, @NotNull final InetAddress ipAddress, @NotNull ConnectionCloseReason reason, final boolean async) {
+         super(async);
+         this.playerUniqueId = playerUniqueId;
+         this.playerName = playerName;
+         this.ipAddress = ipAddress;
++        this.reason = reason;
+     }
+ 
+     /**
+@@ -80,4 +87,27 @@ public class PlayerConnectionCloseEvent extends Event {
+     public static HandlerList getHandlerList() {
+         return HANDLER_LIST;
+     }
++
++
++    /**
++     * Returns the reason for the closed connection.
++     */
++    @NotNull
++    public ConnectionCloseReason getReason() {
++        return this.reason;
++    }
++
++    public enum ConnectionCloseReason {
++        /**
++         * Player disconnected normally
++         */
++        NORMAL,
++
++        /**
++         * Player has invalid data for some reason.
++         * <p>
++         * One example of this is a player logging into an unloaded world.
++         */
++        INVALID_PLAYER_DATA,
++    }
+ }

patches/api/0008-ChunkStatusChangeEvent.patch

@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Wed, 13 Nov 2024 08:07:59 -0600
+Subject: [PATCH] ChunkStatusChangeEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/chunk/ChunkStatusChangeEvent.java b/src/main/java/com/destroystokyo/paper/event/chunk/ChunkStatusChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9154bc8a072d8e5f3fd9790606508af048a612eb
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/chunk/ChunkStatusChangeEvent.java
+@@ -0,0 +1,61 @@
++package com.destroystokyo.paper.event.chunk;
++
++import org.bukkit.Chunk;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when the Full Status of a Chunk changes
++ */
++public class ChunkStatusChangeEvent extends Event {
++
++    private static final HandlerList handlers = new HandlerList();
++    private final Chunk chunk;
++    private final ChunkStatus currentState;
++    private final ChunkStatus newState;
++
++    public ChunkStatusChangeEvent(@NotNull Chunk chunk, @NotNull ChunkStatus currentState, @NotNull ChunkStatus newState) {
++        super();
++        this.chunk = chunk;
++        this.currentState = currentState;
++        this.newState = newState;
++    }
++
++    @NotNull
++    public Chunk getChunk() {
++        return chunk;
++    }
++
++    @NotNull
++    public ChunkStatus getCurrentState() {
++        return currentState;
++    }
++
++    @NotNull
++    public ChunkStatus getNewState() {
++        return newState;
++    }
++
++    public boolean isUpgrade() {
++        return newState.ordinal() > currentState.ordinal();
++    }
++
++    @Override
++    @NotNull
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++    public enum ChunkStatus {
++        INACCESSIBLE,
++        FULL,
++        BLOCK_TICKING,
++        ENTITY_TICKING;
++    }
++}

patches/api/0008-PlayerTrackEntityEvent.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 30 Nov 2021 12:04:50 -0600
-Subject: [PATCH] PlayerTrackEntityEvent
-
-
-diff --git a/src/main/java/org/bukkit/event/player/PlayerTrackEntityEvent.java b/src/main/java/org/bukkit/event/player/PlayerTrackEntityEvent.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0532a7986a8091e82f1fc64b9654be26d6c8ea5e
---- /dev/null
-+++ b/src/main/java/org/bukkit/event/player/PlayerTrackEntityEvent.java
-@@ -0,0 +1,40 @@
-+package org.bukkit.event.player;
-+
-+import org.bukkit.entity.Entity;
-+import org.bukkit.entity.Player;
-+import org.bukkit.event.HandlerList;
-+import org.jetbrains.annotations.NotNull;
-+
-+/**
-+ * Called when a player tracks an entity.
-+ */
-+public class PlayerTrackEntityEvent extends PlayerEvent {
-+    private static final HandlerList handlers = new HandlerList();
-+    private final Entity tracked;
-+
-+    public PlayerTrackEntityEvent(@NotNull final Player player, @NotNull final Entity tracked) {
-+        super(player);
-+        this.tracked = tracked;
-+    }
-+
-+    /**
-+     * Gets the entity newly tracked by the Player
-+     *
-+     * @return Entity the player is now tracking
-+     */
-+    @NotNull
-+    public Entity getTracked() {
-+        return tracked;
-+    }
-+
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+}

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

@@ -0,0 +1,154 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 68c08e7a212bc3e3885f9b5a4d9aef85fcb3b029..5395ec5d6ec33495516e792bdbbc97a7cef3038d 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -1458,6 +1458,14 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+     void setBodyYaw(float bodyYaw);
+     // Paper end - body yaw API
+ 
++
++    // Slice start
++    /**
++     * @param p The player to send this entity's equipment packet to
++     */
++    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
+--- /dev/null
++++ b/src/main/java/org/bukkit/event/entity/EntityEquipmentItemLookup.java
+@@ -0,0 +1,54 @@
++package org.bukkit.event.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.event.HandlerList;
++import org.bukkit.inventory.EquipmentSlot;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when requesting a cached equipment item lookup
++ */
++public class EntityEquipmentItemLookup extends EntityEvent {
++    private static final HandlerList handlers = new HandlerList();
++    private final String tag;
++    private final EquipmentSlot equipmentSlot;
++    private ItemStack itemStack;
++
++    public EntityEquipmentItemLookup(@NotNull final Entity entity, @NotNull String tag, @NotNull EquipmentSlot slot, @NotNull final ItemStack itemStack) {
++        super(entity);
++        this.tag = tag;
++        this.equipmentSlot = slot;
++        this.itemStack = itemStack;
++    }
++
++    @NotNull
++    public ItemStack getItemStack() {
++        return itemStack;
++    }
++
++    public void setItemStack(@NotNull ItemStack itemStack) {
++        this.itemStack = itemStack;
++    }
++
++    @NotNull
++    public EquipmentSlot getEquipmentSlot() {
++        return equipmentSlot;
++    }
++
++    @NotNull
++    public String getTag() {
++        return tag;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java b/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a8f83d19341c2f3024ba8113478ed482657b8589
+--- /dev/null
++++ b/src/main/java/org/bukkit/event/player/PlayerReceiveEquipmentEvent.java
+@@ -0,0 +1,63 @@
++package org.bukkit.event.player;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when a player is about to receive an equipment packet about another player
++ */
++public class PlayerReceiveEquipmentEvent extends PlayerEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private final Entity tracked;
++    private boolean cancel;
++    private String tag;
++
++    public PlayerReceiveEquipmentEvent(@NotNull final Player player, @NotNull final Entity tracked) {
++        super(player);
++        this.tracked = tracked;
++    }
++
++    /**
++     * Gets the tracked entity
++     *
++     * @return Entity the player is now tracking
++     */
++    @NotNull
++    public Entity getTracked() {
++        return tracked;
++    }
++
++    @Nullable
++    public String getTag() {
++        return tag;
++    }
++
++    public void setTag(@Nullable String tag) {
++        this.tag = tag;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancel;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/api/0010-Add-Vanish.patch

@@ -0,0 +1,30 @@
+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/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index d0ae8a94db20281d3664d74718c65234eb2e5f83..6324e8f11a382288fc0a6c30f47760ea50e231d5 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -1172,4 +1172,19 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+      */
+     void broadcastHurtAnimation(@NotNull java.util.Collection<Player> players);
+     // Paper end - broadcast hurt animation
++
++    // Slice start
++    /**
++     * Returns true if the entity is vanished and cannot emit sounds, effects, etc.
++     */
++    boolean isVanished();
++
++    /**
++     * Sets whether the entity is vanished and cannot emit sounds, effects, etc.
++     *
++     * @param vanished the saveable status
++     * @see #isVanished()
++     */
++    void setVanished(boolean vanished);
++    // Slice end
+ }

patches/api/0011-Add-ObjectId.patch

@@ -0,0 +1,85 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 16 Nov 2024 09:22:24 -0600
+Subject: [PATCH] Add ObjectId
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index e29e5024fa693baae469d47fe77b57118f14627c..5770f7c756d033076e0fb629d6aa11fb97ccb0f2 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -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
++
+     api("org.apache.maven:maven-resolver-provider:3.9.6") // Paper - make API dependency for Paper Plugins
+     compileOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.9.18")
+     compileOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.9.18")
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerResolveObjectIdEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerResolveObjectIdEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4c28994757812f9c7f59d9eb827908bb64e63118
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerResolveObjectIdEvent.java
+@@ -0,0 +1,44 @@
++package io.papermc.paper.event.player;
++
++import org.bson.types.ObjectId;
++import org.bukkit.Bukkit;
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.Objects;
++
++/**
++ * Called when a player trades with a standalone merchant GUI.
++ */
++public class PlayerResolveObjectIdEvent extends PlayerEvent {
++    private static final HandlerList handlers = new HandlerList();
++    private ObjectId objectId;
++
++    public PlayerResolveObjectIdEvent(@NotNull Player player) {
++        super(player, !Bukkit.isPrimaryThread());
++    }
++
++    @Nullable
++    public ObjectId getObjectId() {
++        return this.objectId;
++    }
++
++    public void setObjectId(@NotNull ObjectId objectId) {
++        this.objectId = Objects.requireNonNull(objectId, "ObjectId cannot be null!");
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++}
+diff --git a/src/main/java/org/bukkit/entity/HumanEntity.java b/src/main/java/org/bukkit/entity/HumanEntity.java
+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;
+  */
+ public interface HumanEntity extends LivingEntity, AnimalTamer, InventoryHolder {
+ 
++    // Slice start
++    org.bson.types.@Nullable ObjectId getObjectId();
++    void setObjectId(@Nullable org.bson.types.ObjectId objectId);
++    // Slice end
++
+     // Paper start
+     @Override
+     org.bukkit.inventory.@NotNull EntityEquipment getEquipment();

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

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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..13c627b73520d862f864834732f0cad35532298b
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLoadStatsEvent.java
+@@ -0,0 +1,54 @@
++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;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.UUID;
++
++/**
++ * Calls an event in which player stats can be provided. If null, will load from disk, otherwise will use provided data
++ */
++public class PlayerLoadStatsEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++    private final UUID playerId;
++    private JsonObject json;
++
++    public PlayerLoadStatsEvent(@NotNull UUID playerId) {
++        super(!Bukkit.isPrimaryThread());
++        this.playerId = playerId;
++    }
++
++    /**
++     * Gets the player's unique ID.
++     *
++     * @return The unique ID
++     */
++    @NotNull
++    public UUID getUniqueId() {
++        return playerId;
++    }
++
++    @Nullable
++    public JsonObject getStatistics() {
++        return json;
++    }
++
++    public void setStatistics(@NotNull JsonObject json) {
++        this.json = json;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

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/0015-Add-PlayerData-Events.patch

@@ -1,18 +1,19 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Tom <cryptite@gmail.com>
-Date: Tue, 7 Dec 2021 07:59:41 -0600
-Subject: [PATCH] Add player data saving events
+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

@@ -0,0 +1,31 @@
+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/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 8188b3a27fddac18cf49db5a8049149e784f4cbc..a189034515b4361c39b60915e38f35d808a503d0 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -1195,4 +1195,20 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+      */
+     org.bukkit.block.Block getBlockStandingOn();
+     // Slice end
++
++
++    // Slice start
++    /**
++     * Returns true if the entity can be saved. If false, the entity will never be serialized or saved.
++     */
++    boolean isSaveable();
++
++    /**
++     * Sets whether the entity can be serialized and saved to disk.
++     *
++     * @param saveable the saveable status
++     * @see #isSaveable()
++     */
++    void setSaveable(boolean saveable);
++    // Slice end
+ }

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-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

@@ -0,0 +1,88 @@
+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/io/papermc/paper/event/player/PlayerPreRespawnEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerPreRespawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..53b830c7a349d58b1bb8b242b3edd144c6dcbdb0
+--- /dev/null
++++ 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 before a player's respawn location is determined.
++ */
++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 PlayerPreRespawnEvent(@NotNull final Player respawnPlayer, PlayerRespawnEvent.RespawnReason respawnReason) {
++        super(respawnPlayer);
++        this.respawnReason = respawnReason;
++    }
++
++    /**
++     * Gets the current respawn location
++     *
++     * @return Location current respawn location
++     */
++    @Nullable
++    public Location getRespawnLocation() {
++        return this.respawnLocation;
++    }
++
++    /**
++     * Sets the new respawn location
++     *
++     * @param respawnLocation new location for the respawn
++     */
++    public void setRespawnLocation(@NotNull Location respawnLocation) {
++        Validate.notNull(respawnLocation, "Respawn location can not be null");
++        Validate.notNull(respawnLocation.getWorld(), "Respawn world can not be null");
++
++        this.respawnLocation = respawnLocation;
++    }
++
++    /**
++     * @return Returns the reason the player was respawned.
++     */
++    public PlayerRespawnEvent.RespawnReason getRespawnReason() {
++        return respawnReason;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    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,78 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 Sep 2021 08:25:29 -0500
-Subject: [PATCH] Build Changes
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index f442236efe30d7d9e0c6a8dfb0f040540dc62753..bcdeb5a1c3c10d86d116dbf4257eb7b9d12f4426 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -22,8 +22,8 @@ repositories {
- }
- 
- dependencies {
--    implementation(project(":Paper-API"))
--    implementation(project(":Paper-MojangAPI"))
-+    implementation(project(":Slice-API")) // Slice
-+    implementation("io.papermc.paper:paper-mojangapi:1.17.1-R0.1-SNAPSHOT") // Slice
-     // Paper start
-     implementation("org.jline:jline-terminal-jansi:3.21.0")
-     implementation("net.minecrell:terminalconsoleappender:1.3.0")
-@@ -75,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,
-@@ -202,7 +202,7 @@ tasks.test {
- fun TaskContainer.registerRunTask(
-     name: String, block: JavaExec.() -> Unit
- ): TaskProvider<JavaExec> = register<JavaExec>(name) {
--    group = "paper"
-+    group = "paperweight"
-     standardInput = System.`in`
-     workingDir = rootProject.layout.projectDirectory.dir(
-         providers.gradleProperty("runWorkDir").forUseAtConfigurationTime().orElse("run")
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 5a4172faaf960d48939d6a485719041987df9242..402367f10b126c7d527e5a2b5319d331dce81857 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -1729,7 +1729,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @DontObfuscate
-     public String getServerModName() {
--        return "Paper"; // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-+        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 99a94898316b0601f55b333c15a9926eae24f8a2..f20dc9edfa15fd7705570830955d1b82b4fd59e3 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -251,7 +251,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

@@ -0,0 +1,144 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 a96f859a5d0c6ec692d4627a69f3c9ee49199dbc..7fe358dac8740ac6338a942f4189bca300d1f1be 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -425,6 +425,7 @@ public class ServerPlayerGameMode {
+                 this.level.captureDrops = new ArrayList<>();
+                 // CraftBukkit end
+                 BlockState iblockdata1 = block.playerWillDestroy(this.level, pos, iblockdata, this.player);
++                level.pendingPlayerBlockEvents.put(pos, new Level.PendingBlockEvent(pos, this.player)); // Paper
+                 boolean flag = this.level.removeBlock(pos, false);
+ 
+                 if (flag) {
+@@ -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
++                level.pendingPlayerBlockEvents.remove(pos); // Paper
+                 if (event.isDropItems()) {
+                     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 33e7d2884195677c4d6340d8b84c1dd85c636ec1..04f8269abe339610795237652edcd54ba31bc5fc 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -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
+ 
+             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 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,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
++    public static class PendingBlockEvent {
++
++        public final BlockPos block;
++        public final Player player;
++        public @Nullable BlockPos sourceBlock;
++
++        public PendingBlockEvent(BlockPos block, Player player) {
++            this(block, player, null);
++        }
++
++        public PendingBlockEvent(BlockPos block, Player player, @Nullable BlockPos sourceBlock) {
++            this.block = block;
++            this.player = player;
++            this.sourceBlock = sourceBlock;
++        }
++
++    }
++    public final Map<BlockPos, PendingBlockEvent> pendingPlayerBlockEvents = new HashMap<>();
++    // Paper end
++
++
+     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);
+             }
++            pendingPlayerBlockEvents.remove(blockposition); // Paper
+             // CraftBukkit end
+         }
+     }
+@@ -1246,6 +1269,17 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         if (iblockdata.isAir()) {
+             return false;
+         } else {
++            // Paper start
++            PendingBlockEvent blockEvent = pendingPlayerBlockEvents.get(pos);
++            if (blockEvent != null && blockEvent.sourceBlock != null) {
++                io.papermc.paper.event.block.BlockDestroyedByNeighborEvent event =
++                    new io.papermc.paper.event.block.BlockDestroyedByNeighborEvent(org.bukkit.craftbukkit.block.CraftBlock.at(this, pos),
++                        (org.bukkit.entity.Player) blockEvent.player.getBukkitEntity(),
++                        org.bukkit.craftbukkit.block.CraftBlock.at(this, blockEvent.sourceBlock));
++                event.callEvent();
++            }
++            // Paper end
++
+             FluidState fluid = this.getFluidState(pos);
+             // 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 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
+@@ -114,6 +114,15 @@ public class DoublePlantBlock extends BushBlock {
+             BlockPos blockposition1 = pos.below();
+             BlockState iblockdata1 = world.getBlockState(blockposition1);
+ 
++            Level.PendingBlockEvent blockEvent = world.pendingPlayerBlockEvents.remove(pos);
++            if (blockEvent != null) {
++                io.papermc.paper.event.block.BlockDestroyedByNeighborEvent event =
++                    new io.papermc.paper.event.block.BlockDestroyedByNeighborEvent(org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition1),
++                        (org.bukkit.entity.Player) blockEvent.player.getBukkitEntity(),
++                        org.bukkit.craftbukkit.block.CraftBlock.at(world, pos));
++                if (!event.callEvent()) return;
++            }
++
+             if (iblockdata1.is(state.getBlock()) && iblockdata1.getValue(DoublePlantBlock.HALF) == DoubleBlockHalf.LOWER) {
+                 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 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
+@@ -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;
++            BlockState blockState = world.getBlockState(pos); // Slice
+ 
+             for (int l = 0; l < k; ++l) {
+                 Direction enumdirection = aenumdirection[l];
+ 
+                 blockposition_mutableblockposition.setWithOffset(pos, enumdirection);
++                // Paper start - Propagate the PendingBlockEvent from the current blockPos to the next block
++                // if it will break (!canSurvive)
++                if (blockState.getBukkitMaterial() == org.bukkit.Material.AIR && !world.getBlockState(blockposition_mutableblockposition).canSurvive(world, blockposition_mutableblockposition)) {
++                    Level.PendingBlockEvent blockEvent = ((Level) world).pendingPlayerBlockEvents.get(pos);
++                    if (blockEvent != null) {
++                        BlockPos blockPosCopy = blockposition_mutableblockposition.immutable();
++                        ((Level) world).pendingPlayerBlockEvents.put(blockPosCopy, new Level.PendingBlockEvent(blockPosCopy, blockEvent.player, pos));
++                    }
++                }
++                // Paper end
+                 world.neighborShapeChanged(enumdirection.getOpposite(), blockposition_mutableblockposition, pos, this.asState(), flags, maxUpdateDepth);
+             }
+ 

patches/server/0002-Add-PlayerShieldDisableEvent.patch

@@ -1,53 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 Sep 2021 08:33:45 -0500
-Subject: [PATCH] Add PlayerShieldDisableEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 8a864238e154e2131834d013652746b7e7a78c97..806975b124bf91ae560dc3a0289f3a298373546d 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -1588,6 +1588,7 @@ public abstract class Mob extends LivingEntity {
-             float f = 0.25F + (float) EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
- 
-             if (this.random.nextFloat() < f) {
-+                if (!new io.papermc.paper.event.player.PlayerShieldDisableEvent((org.bukkit.entity.Player) player.getBukkitEntity(), getBukkitEntity()).callEvent()) return; // Slice
-                 player.getCooldowns().addCooldown(Items.SHIELD, 100);
-                 this.level.broadcastEntityEvent(player, (byte) 30);
-             }
-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 cea92f1dc663bf0648b2bd877d86ca380a517bc9..a1d1d8b5fbb5d7f8e980b4c116b8fec34f8878d5 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -936,7 +936,7 @@ public abstract class Player extends LivingEntity {
-     protected void blockUsingShield(LivingEntity attacker) {
-         super.blockUsingShield(attacker);
-         if (attacker.getMainHandItem().getItem() instanceof AxeItem) {
--            this.disableShield(true);
-+            this.disableShield(true, attacker); // Slice
-         }
- 
-     }
-@@ -1403,6 +1403,12 @@ public abstract class Player extends LivingEntity {
-     }
- 
-     public void disableShield(boolean sprinting) {
-+        // Slice start
-+        disableShield(sprinting, null);
-+    }
-+
-+    public void disableShield(boolean sprinting, @Nullable LivingEntity attacker) {
-+        // Slice end
-         float f = 0.25F + (float) EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
- 
-         if (sprinting) {
-@@ -1410,6 +1416,8 @@ public abstract class Player extends LivingEntity {
-         }
- 
-         if (this.random.nextFloat() < f) {
-+            org.bukkit.entity.Entity finalAttacker = attacker != null ? attacker.getBukkitEntity() : null; // Slice
-+            if (!new io.papermc.paper.event.player.PlayerShieldDisableEvent((org.bukkit.entity.Player) getBukkitEntity(), finalAttacker).callEvent()) return; // Slice
-             this.getCooldowns().addCooldown(Items.SHIELD, 100);
-             this.stopUsingItem();
-             this.level.broadcastEntityEvent(this, (byte) 30);

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: Wed, 29 Sep 2021 08:40:37 -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 f374d5d6fc3ac9187236d141931c3c57ddd57865..9ed8586a3e973ba8da340b82440be8f7369ef8ca 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
-@@ -552,7 +552,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 f374d5d6fc3ac9187236d141931c3c57ddd57865..9ed8586a3e973ba8da340b82440be8f7
          net.minecraft.world.item.ItemStack nms = CraftItemStack.asNMSCopy(item);
  
          // Modelled off EntityHuman#hasBlock
-@@ -563,6 +574,7 @@ public class CraftBlock implements Block {
+@@ -603,6 +614,7 @@ public class CraftBlock implements Block {
              return Collections.emptyList();
          }
      }

patches/server/0003-Multiple-Entries-with-Scoreboards.patch

@@ -1,188 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 21 Sep 2021 15:20:15 -0500
-Subject: [PATCH] Multiple Entries with Scoreboards
-
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-index 4c9660176e783999301565790b8cf6f47b0d02a2..3f1b093ae766c6e219ee233a75c64f0c522cc6c2 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-@@ -42,6 +42,12 @@ public class ClientboundSetPlayerTeamPacket implements Packet<ClientGamePacketLi
-         return new ClientboundSetPlayerTeamPacket(team.getName(), operation == ClientboundSetPlayerTeamPacket.Action.ADD ? 3 : 4, Optional.empty(), ImmutableList.of(playerName));
-     }
- 
-+    // Paper start
-+    public static ClientboundSetPlayerTeamPacket createMultiplePlayerPacket(PlayerTeam team, Collection<String> players, ClientboundSetPlayerTeamPacket.Action operation) {
-+        return new ClientboundSetPlayerTeamPacket(team.getName(), operation == ClientboundSetPlayerTeamPacket.Action.ADD ? 3 : 4, Optional.empty(), players);
-+    }
-+    // Paper end
-+
-     public ClientboundSetPlayerTeamPacket(FriendlyByteBuf buf) {
-         this.name = buf.readUtf(16);
-         this.method = buf.readByte();
-diff --git a/src/main/java/net/minecraft/server/ServerScoreboard.java b/src/main/java/net/minecraft/server/ServerScoreboard.java
-index 130a928f156961bae9ca184b3ca31004dbba1012..5d42967b1d9cbceb004566c0c503df21d1bb5c51 100644
---- a/src/main/java/net/minecraft/server/ServerScoreboard.java
-+++ b/src/main/java/net/minecraft/server/ServerScoreboard.java
-@@ -3,6 +3,7 @@ package net.minecraft.server;
- import com.google.common.collect.Lists;
- import com.google.common.collect.Sets;
- import java.util.Iterator;
-+import java.util.Collection; // Paper
- import java.util.List;
- import java.util.Objects;
- import java.util.Set;
-@@ -92,6 +93,19 @@ public class ServerScoreboard extends Scoreboard {
-         }
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean addPlayersToTeam(Collection<String> players, PlayerTeam team) {
-+        if (super.addPlayersToTeam(players, team)) {
-+            this.sendAll(ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(team, players, ClientboundSetPlayerTeamPacket.Action.ADD));
-+            this.setDirty();
-+            return true;
-+        } else {
-+            return false;
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     public void removePlayerFromTeam(String playerName, PlayerTeam team) {
-         super.removePlayerFromTeam(playerName, team);
-@@ -99,6 +113,19 @@ public class ServerScoreboard extends Scoreboard {
-         this.setDirty();
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean removePlayersFromTeam(Collection<String> players, PlayerTeam team) {
-+        if (super.removePlayersFromTeam(players, team)) {
-+            this.sendAll(ClientboundSetPlayerTeamPacket.createMultiplePlayerPacket(team, players, ClientboundSetPlayerTeamPacket.Action.REMOVE));
-+            this.setDirty();
-+            return true;
-+        } else {
-+            return false;
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     public void onObjectiveAdded(Objective objective) {
-         super.onObjectiveAdded(objective);
-diff --git a/src/main/java/net/minecraft/world/scores/Scoreboard.java b/src/main/java/net/minecraft/world/scores/Scoreboard.java
-index 3e75ea4d5a6c83ca570b29e3c1a5d51fb132379a..246bb45d73c3948fae081662995ada7cdb49822d 100644
---- a/src/main/java/net/minecraft/world/scores/Scoreboard.java
-+++ b/src/main/java/net/minecraft/world/scores/Scoreboard.java
-@@ -224,6 +224,28 @@ public class Scoreboard {
-         }
-     }
- 
-+    // Paper start
-+    public boolean addPlayersToTeam(Collection<String> players, PlayerTeam team) {
-+        boolean anyAdded = false;
-+        for (String playerName : players) {
-+            if (playerName.length() > 40) {
-+                net.minecraft.server.MinecraftServer.LOGGER.warn("The player name '" + playerName + "' is too long!");
-+            } else {
-+                if (this.getPlayersTeam(playerName) != null) {
-+                    this.removePlayerFromTeam(playerName);
-+                }
-+
-+                this.teamsByPlayer.put(playerName, team);
-+                if (team.getPlayers().add(playerName)) {
-+                    anyAdded = true;
-+                }
-+            }
-+        }
-+
-+        return anyAdded;
-+    }
-+    // Paper end
-+
-     public boolean removePlayerFromTeam(String playerName) {
-         PlayerTeam playerTeam = this.getPlayersTeam(playerName);
-         if (playerTeam != null) {
-@@ -243,6 +265,24 @@ public class Scoreboard {
-         }
-     }
- 
-+    // Paper start
-+    public boolean removePlayersFromTeam(Collection<String> players, PlayerTeam team) {
-+        boolean anyRemoved = false;
-+        for (String playerName : players) {
-+            if (this.getPlayersTeam(playerName) != team) {
-+                net.minecraft.server.MinecraftServer.LOGGER.warn("Player " + playerName + " is either on another team or not on any team. Cannot remove from team '" + team.getName() + "'.");
-+            } else {
-+                this.teamsByPlayer.remove(playerName);
-+                if (team.getPlayers().remove(playerName)) {
-+                    anyRemoved = true;
-+                }
-+            }
-+        }
-+
-+        return anyRemoved;
-+    }
-+    // Paper end
-+
-     public Collection<String> getTeamNames() {
-         return this.teamsByName.keySet();
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-index 2b87a652798cb632fe76bf20e9e7f8cb8bfb3b7b..f097e9fbdac1a572c12cc0299774455c75e373e9 100644
---- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftTeam.java
-@@ -1,6 +1,7 @@
- package org.bukkit.craftbukkit.scoreboard;
- 
- import com.google.common.collect.ImmutableSet;
-+import java.util.Collection; // Paper
- import java.util.Set;
- import net.minecraft.world.scores.PlayerTeam;
- import net.minecraft.world.scores.Team.Visibility;
-@@ -226,6 +227,16 @@ final class CraftTeam extends CraftScoreboardComponent implements Team {
-         scoreboard.board.addPlayerToTeam(entry, team);
-     }
- 
-+    // Paper start
-+    @Override
-+    public void addEntries(Collection<String> entries) throws IllegalStateException, IllegalArgumentException {
-+        Validate.notNull(entries, "Entries cannot be null");
-+        CraftScoreboard scoreboard = checkState();
-+
-+        scoreboard.board.addPlayersToTeam(entries, team);
-+    }
-+    // Paper end
-+
-     @Override
-     public boolean removePlayer(OfflinePlayer player) throws IllegalStateException, IllegalArgumentException {
-         Validate.notNull(player, "OfflinePlayer cannot be null");
-@@ -245,6 +256,25 @@ final class CraftTeam extends CraftScoreboardComponent implements Team {
-         return true;
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean removeEntries(Collection<String> entries) throws IllegalStateException, IllegalArgumentException {
-+        Validate.notNull(entries, "Entry cannot be null");
-+        CraftScoreboard scoreboard = this.checkState();
-+
-+        boolean anyRemoved = false;
-+        Collection<String> teamPlayers = this.team.getPlayers();
-+        for (String entry : entries) {
-+            if (teamPlayers.remove(entry)) {
-+                anyRemoved = true;
-+            }
-+        }
-+
-+        scoreboard.board.removePlayersFromTeam(entries, team);
-+        return anyRemoved;
-+    }
-+    // Paper end
-+
-     @Override
-     public boolean hasPlayer(OfflinePlayer player) throws IllegalArgumentException, IllegalStateException {
-         Validate.notNull(player, "OfflinePlayer cannot be null");

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

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Sun, 26 Sep 2021 16:36:29 -0500
+From: Cryptite <cryptite@gmail.com>
+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 1ef8eadd4e59f2e5d2bbd84f6f9bcf37b59db5bd..ea711757413e2580a5806e0063b3e4fa5d4eddbb 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
-@@ -110,7 +110,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/0004-Set-BlockData-without-light-update.patch

@@ -1,148 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Wed, 22 Sep 2021 09:41:27 -0500
-Subject: [PATCH] Set BlockData without light update
-
-
-diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-index 21d1e0c9c471e9e556b5bd70166a769b46105c7a..d46dc12001bd46596c3bb2e24144bbe4d2d3a5e1 100644
---- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-+++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
-@@ -241,7 +241,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);
-         }
-     }
- 
-@@ -298,7 +298,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) {
-         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 9cafd000b3533ed9fd35df2ec880f55e262084fb..8420d615867faa717266d1edfa5a469df1b1e43f 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -541,12 +541,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
-@@ -593,7 +593,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-             } else {
-                 BlockState iblockdata2 = this.getBlockState(pos);
- 
--                if ((flags & 128) == 0 && iblockdata2 != iblockdata1 && (iblockdata2.getLightBlock((BlockGetter) this, pos) != iblockdata1.getLightBlock((BlockGetter) this, pos) || iblockdata2.getLightEmission() != iblockdata1.getLightEmission() || iblockdata2.useShapeForLightOcclusion() || iblockdata1.useShapeForLightOcclusion())) {
-+                if (checkLight && (flags & 128) == 0 && iblockdata2 != iblockdata1 && (iblockdata2.getLightBlock((BlockGetter) this, pos) != iblockdata1.getLightBlock((BlockGetter) this, pos) || iblockdata2.getLightEmission() != iblockdata1.getLightEmission() || iblockdata2.useShapeForLightOcclusion() || iblockdata1.useShapeForLightOcclusion())) {
-                     this.getProfiler().push("queueCheckLight");
-                     this.getChunkSource().getLightEngine().checkBlock(pos);
-                     this.getProfiler().pop();
-@@ -740,7 +740,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-                 Block.dropResources(iblockdata, this, pos, tileentity, breakingEntity, ItemStack.EMPTY);
-             }
- 
--            boolean flag1 = this.setBlock(pos, fluid.createLegacyBlock(), 3, maxUpdateDepth);
-+            boolean flag1 = this.setBlock(pos, fluid.createLegacyBlock(), 3, maxUpdateDepth, true);
- 
-             if (flag1) {
-                 this.gameEvent(breakingEntity, GameEvent.BLOCK_DESTROY, pos);
-diff --git a/src/main/java/net/minecraft/world/level/LevelWriter.java b/src/main/java/net/minecraft/world/level/LevelWriter.java
-index b6825cd32033cac34c74af1f8c980ed7fb97a754..d2dfbfa0d58b94ce583992aa56f5b0e28d4b31f2 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 8c30e28b97ac7e8b54322c903e0b75ee8135620b..64cc26d146afba7c6ecb0d3052776837a41a5618 100644
---- a/src/main/java/net/minecraft/world/level/block/Block.java
-+++ b/src/main/java/net/minecraft/world/level/block/Block.java
-@@ -197,7 +197,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);
-             }
-         }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 6f01af8cc3f9ed4d2eaa3304990ca33f8692a453..f374d5d6fc3ac9187236d141931c3c57ddd57865 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -178,11 +178,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);
-     }
- 
-     public boolean setTypeAndData(final net.minecraft.world.level.block.state.BlockState blockData, final boolean applyPhysics) {
-+        return setTypeAndData(blockData, applyPhysics, true);
-+    }
-+
-+    public boolean setTypeAndData(final net.minecraft.world.level.block.state.BlockState blockData, final boolean applyPhysics, boolean checkLight) {
-         net.minecraft.world.level.block.state.BlockState old = this.getNMS();
-         // 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
-@@ -197,7 +206,7 @@ public class CraftBlock implements Block {
-         if (applyPhysics) {
-             return this.world.setBlock(position, blockData, 3);
-         } else {
--            boolean success = this.world.setBlock(position, blockData, 2 | 16 | 1024); // NOTIFY | NO_OBSERVER | NO_PLACE (custom)
-+            boolean success = this.world.setBlock(position, blockData, 2 | 16 | 1024, checkLight); // NOTIFY | NO_OBSERVER | NO_PLACE (custom)
-             if (success && this.world instanceof net.minecraft.world.level.Level) {
-                 this.world.getMinecraftWorld().sendBlockUpdated(
-                         position,
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-index 950d4381459d31d02acf55c4aef4f5e33367748b..0b09b06b3d9fe2cce5c6cbf70a4b84ff8edc2085 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
-@@ -231,7 +231,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;
-     }
- 

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

@@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 585e2b43a0326f0b81597fa1234d3c67c76af550..e256e5ff5c167c6cff5b9e985cdc80d5c9203708 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -231,6 +231,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     public boolean hasPhysicsEvent = true; // Paper - BlockPhysicsEvent
+     public boolean hasEntityMoveEvent; // Paper - Add EntityMoveEvent
+     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 57da11c0da7322e74810e7108e9c8000b0c36520..68e3dee346fe013f8e69900a0911583f851d2782 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1330,6 +1330,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         this.world.noSave = !value;
+     }
+ 
++    // Slice start
++    @Override
++    public boolean isInstance() {
++        return world.instance;
++    }
++
++    @Override
++    public void setInstance(boolean value) {
++        world.instance = value;
++    }
++    // Slice end
++
+     @Override
+     public void setDifficulty(Difficulty difficulty) {
+         this.getHandle().getServer().setDifficulty(this.getHandle(), net.minecraft.world.Difficulty.byId(difficulty.getValue()), true); // Paper - per level difficulty; don't skip other difficulty-changing logic

patches/server/0005-Don-t-send-equipment-updates-if-only-durability-chan.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Thu, 23 Sep 2021 08:56:42 -0500
-Subject: [PATCH] Don't send equipment updates if only durability changed
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index cbdff14b26f67b5040c13659f9d64d9ec4c7eaed..bd054a883ecb15260aec27c81ad79e774fca69a5 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -3007,7 +3007,7 @@ public abstract class LivingEntity extends Entity {
- 
-             ItemStack itemstack1 = this.getItemBySlot(enumitemslot);
- 
--            if (!ItemStack.matches(itemstack1, itemstack)) {
-+            if (!ItemStack.isSameIgnoreDurability(itemstack1, itemstack)) {
-                 // Paper start - PlayerArmorChangeEvent
-                 if (this instanceof ServerPlayer && enumitemslot.getType() == EquipmentSlot.Type.ARMOR) {
-                     final org.bukkit.inventory.ItemStack oldItem = CraftItemStack.asBukkitCopy(itemstack);

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

@@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Thu, 23 Sep 2021 09:08:06 -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 1891cfb8f7ebae5a95a55f706bb04f8206121d32..d24c22e0dd84344021a77d24926c2934e71d40ff 100644
---- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
-@@ -356,9 +356,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 7e45c97acce83a9fe8ada486e9fcdafe58769736..80e30b978455890506ef555773983dd4058185e3 100644
---- a/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/EnderChestBlock.java
-@@ -77,10 +77,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/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-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-Track-Player-throughout-entire-block-destroy.patch

@@ -1,139 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Thu, 23 Sep 2021 08:27:21 -0500
-Subject: [PATCH] Track Player throughout entire block destroy
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 12998d0e9ae0e148a155faa4468b0f78b8462cc9..b03eacbef3cf15b70ec012af0870975d3e8e8cba 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -441,6 +441,7 @@ public class ServerPlayerGameMode {
-                 org.bukkit.block.BlockState state = bblock.getState();
-                 level.captureDrops = new ArrayList<>();
-                 // CraftBukkit end
-+                level.pendingPlayerBlockEvents.put(pos, new Level.PendingBlockEvent(pos, this.player)); // Paper
-                 block.playerWillDestroy((Level) this.level, pos, iblockdata, (Player) this.player);
-                 boolean flag = this.level.removeBlock(pos, false);
- 
-@@ -465,6 +466,7 @@ public class ServerPlayerGameMode {
-                 // CraftBukkit start
-                 java.util.List<ItemEntity> itemsToDrop = level.captureDrops; // Paper - store current list
-                 level.captureDrops = null; // Paper - Remove this earlier so that we can actually drop stuff
-+                level.pendingPlayerBlockEvents.remove(pos); // Paper
-                 if (event.isDropItems()) {
-                     org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDropItemEvent(bblock, state, this.player, itemsToDrop); // Paper - use stored ref
-                 }
-diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
-index 7695a5ec88023720d873f81fc36f78ad60fb9589..71d02915581326f5546b2f916259a1ec00e85961 100644
---- a/src/main/java/net/minecraft/world/item/ItemStack.java
-+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -323,6 +323,7 @@ public final class ItemStack {
-                 }
-             }
-             Item item = this.getItem();
-+            if (entityhuman != null) world.pendingPlayerBlockEvents.put(blockposition, new Level.PendingBlockEvent(blockposition, entityhuman)); // Paper
-             InteractionResult enuminteractionresult = item.useOn(itemactioncontext);
-             CompoundTag newData = this.getTagClone();
-             int newCount = this.getCount();
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 8420d615867faa717266d1edfa5a469df1b1e43f..71fca6c915f90a771e6139b985ebc51c7923778c 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -176,6 +176,27 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     public final Map<Explosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
-     public java.util.ArrayDeque<net.minecraft.world.level.block.RedstoneTorchBlock.Toggle> redstoneUpdateInfos; // Paper - Move from Map in BlockRedstoneTorch to here
- 
-+    // Paper start - Holder class used to track what Player is responsible the last block event
-+    public static class PendingBlockEvent {
-+
-+        public final BlockPos block;
-+        public final Player player;
-+        public @Nullable BlockPos sourceBlock;
-+
-+        public PendingBlockEvent(BlockPos block, Player player) {
-+            this(block, player, null);
-+        }
-+
-+        public PendingBlockEvent(BlockPos block, Player player, @Nullable BlockPos sourceBlock) {
-+            this.block = block;
-+            this.player = player;
-+            this.sourceBlock = sourceBlock;
-+        }
-+
-+    }
-+    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) {
-@@ -695,6 +716,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-             if (!this.preventPoiUpdated) {
-                 this.onBlockStateChange(blockposition, iblockdata1, iblockdata2);
-             }
-+            pendingPlayerBlockEvents.remove(blockposition); // Paper
-             // CraftBukkit end
-         }
-     }
-@@ -800,8 +822,20 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     public void neighborChanged(BlockPos pos, Block sourceBlock, BlockPos neighborPos) {
-         if (!this.isClientSide) {
-             BlockState iblockdata = this.getBlockState(pos);
-+            org.bukkit.block.Block blockAt = world.getBlockAt(pos.getX(), pos.getY(), pos.getZ()); // Paper
- 
-             try {
-+                // Paper start - If this is a non-air block being set to an air block, get (remove, if exists)
-+                // our PendingBlockEvent
-+                if (blockAt.getType() != org.bukkit.Material.AIR && iblockdata.getMaterial() == net.minecraft.world.level.material.Material.AIR) {
-+                    PendingBlockEvent blockEvent = pendingPlayerBlockEvents.remove(pos);
-+                    if (blockEvent != null) {
-+                        //Would fire a future BlockDestroyedByNeighborEvent here, but must have this conditional block
-+                        //because it's important to remove from pendingPlayerBlockEvents
-+                    }
-+                }
-+                // Paper end
-+
-                 // CraftBukkit start
-                 CraftWorld world = ((ServerLevel) this).getWorld();
-                 if (world != null && ((ServerLevel)this).hasPhysicsEvent) { // Paper
-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 65a163d93a293e1e0a12a300d6335a700099cac2..b1b6072ffff0e1cc2e9e1a585ad882bc70697d92 100644
---- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-@@ -104,6 +104,12 @@ public class DoublePlantBlock extends BushBlock {
-             BlockPos blockposition1 = pos.below();
-             BlockState iblockdata1 = world.getBlockState(blockposition1);
- 
-+            Level.PendingBlockEvent blockEvent = world.pendingPlayerBlockEvents.remove(pos);
-+            if (blockEvent != null) {
-+                //Would fire a future BlockDestroyedByNeighborEvent here, but must have this conditional block
-+                //because it's important to remove from pendingPlayerBlockEvents
-+            }
-+
-             if (iblockdata1.is(state.getBlock()) && iblockdata1.getValue(DoublePlantBlock.HALF) == DoubleBlockHalf.LOWER) {
-                 BlockState iblockdata2 = iblockdata1.hasProperty(BlockStateProperties.WATERLOGGED) && (Boolean) iblockdata1.getValue(BlockStateProperties.WATERLOGGED) ? 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 83d813025efca5846538e36508a5d4fe38b02108..e1eed33f75c3118826ccd0c994325b327e20f83f 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
-@@ -890,6 +890,18 @@ public abstract class BlockBehaviour {
- 
-                 blockposition_mutableblockposition.setWithOffset((Vec3i) pos, enumdirection);
-                 BlockState iblockdata = world.getBlockState(blockposition_mutableblockposition);
-+
-+                // Paper start - Propagate the PendingBlockEvent from the current blockPos to the next block
-+                // if it will break (!canSurvive)
-+                if (this.getMaterial() == Material.AIR && !iblockdata.canSurvive(world, blockposition_mutableblockposition)) {
-+                    Level.PendingBlockEvent blockEvent = ((Level) world).pendingPlayerBlockEvents.get(pos);
-+                    if (blockEvent != null) {
-+                        BlockPos blockPosCopy = blockposition_mutableblockposition.immutable();
-+                        ((Level) world).pendingPlayerBlockEvents.put(blockPosCopy, new Level.PendingBlockEvent(blockPosCopy, blockEvent.player, pos));
-+                    }
-+                }
-+                // Paper end
-+
-                 BlockState iblockdata1 = iblockdata.updateShape(enumdirection.getOpposite(), this.asState(), world, blockposition_mutableblockposition, pos);
- 
-                 Block.updateOrDestroy(iblockdata, iblockdata1, world, blockposition_mutableblockposition, flags, maxUpdateDepth);

patches/server/0009-Add-BlockDestroyedByNeighborEvent.patch

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sun, 26 Sep 2021 09:00:50 -0500
-Subject: [PATCH] Add BlockDestroyedByNeighborEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 71fca6c915f90a771e6139b985ebc51c7923778c..96a7ae08649294062f856c67e49a793feb63ca37 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -738,6 +738,17 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-         if (iblockdata.isAir()) {
-             return false;
-         } else {
-+            // Paper start
-+            PendingBlockEvent blockEvent = pendingPlayerBlockEvents.get(pos);
-+            if (blockEvent != null && blockEvent.sourceBlock != null) {
-+                io.papermc.paper.event.block.BlockDestroyedByNeighborEvent event =
-+                    new io.papermc.paper.event.block.BlockDestroyedByNeighborEvent(org.bukkit.craftbukkit.block.CraftBlock.at(this, pos),
-+                        (org.bukkit.entity.Player) blockEvent.player.getBukkitEntity(),
-+                        org.bukkit.craftbukkit.block.CraftBlock.at(this, blockEvent.sourceBlock));
-+                event.callEvent();
-+            }
-+            // Paper end
-+
-             FluidState fluid = this.getFluidState(pos);
-             // Paper start - 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 b1b6072ffff0e1cc2e9e1a585ad882bc70697d92..f2eb493d99c2eb826d8b85adbc3dc6799c575f31 100644
---- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
-@@ -106,8 +106,11 @@ public class DoublePlantBlock extends BushBlock {
- 
-             Level.PendingBlockEvent blockEvent = world.pendingPlayerBlockEvents.remove(pos);
-             if (blockEvent != null) {
--                //Would fire a future BlockDestroyedByNeighborEvent here, but must have this conditional block
--                //because it's important to remove from pendingPlayerBlockEvents
-+                io.papermc.paper.event.block.BlockDestroyedByNeighborEvent event =
-+                    new io.papermc.paper.event.block.BlockDestroyedByNeighborEvent(org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition1),
-+                        (org.bukkit.entity.Player) blockEvent.player.getBukkitEntity(),
-+                        org.bukkit.craftbukkit.block.CraftBlock.at(world, pos));
-+                if (!event.callEvent()) return;
-             }
- 
-             if (iblockdata1.is(state.getBlock()) && iblockdata1.getValue(DoublePlantBlock.HALF) == DoubleBlockHalf.LOWER) {

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, 5 Oct 2021 09:05:10 -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 b3c99c1678c3ee159861c8aac38e765d664c4d1d..b6e1459db7f03801073d39ead5cd08fda8c9b4ba 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
-@@ -702,7 +702,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         return Math.max(Math.abs(k), Math.abs(l));
+@@ -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/0010-Don-t-send-fire-packets-if-player-has-FR.patch

@@ -1,17 +1,17 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Cryptite <cryptite@gmail.com>
-Date: Thu, 23 Sep 2021 09:29:09 -0500
-Subject: [PATCH] Don't send fire packets if player has Fire Resistance
+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 94857a736d2a16e8ade286c6f2ddf8bd798008eb..ea85fc39b77aece9c9544ec01348eafa233355d1 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
-@@ -760,7 +760,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
+@@ -949,7 +949,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
-         this.checkOutOfWorld();
-         if (!this.level.isClientSide) {
+         this.checkBelowWorld();
+         if (!this.level().isClientSide) {
 -            this.setSharedFlagOnFire(this.remainingFireTicks > 0);
 +            if (this instanceof net.minecraft.world.entity.LivingEntity livingEntity) {
 +                this.setSharedFlagOnFire(this.remainingFireTicks > 0 && !livingEntity.hasEffect(net.minecraft.world.effect.MobEffects.FIRE_RESISTANCE));

patches/server/0011-Allow-inventory-clicks-in-Spectator.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: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 b5d5dbc50a7b8c40739a15f164ffd08fdc534f9c..7644dfe30a51295ac3fa59384153c839fa781c01 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -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
+-            boolean cancelled = this.player.isSpectator(); // CraftBukkit - see below if
++            boolean cancelled = false; //Slice - allow spectator inv management this.player.isSpectator(); // CraftBukkit - see below if
+             if (false/*this.player.isSpectator()*/) { // CraftBukkit
+                 this.player.containerMenu.sendAllDataToRemote();
+             } else if (!this.player.containerMenu.stillValid(this.player)) {

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

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 880e5c52746e9e3a9a1f42ec6461be54e3ee136c..e8eeb1aaeec6d87af949e249d0ffd0856bfd71b1 100644
+--- a/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerConfigurationPacketListenerImpl.java
+@@ -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);
++            new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(this.gameProfile.getId(), this.gameProfile.getName(), ((java.net.InetSocketAddress)this.connection.address).getAddress(), com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent.ConnectionCloseReason.INVALID_PLAYER_DATA, false).callEvent(); // Slice
+         }
+ 
+     }

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/0013-Packet-obfuscation-and-reduction.patch

@@ -1,213 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Wed, 6 Oct 2021 11:03:01 -0500
-Subject: [PATCH] Packet obfuscation and reduction
-
-Minecraft is overzealous about packet updates for Entities. In Loka's case, we want to reduce as many unnecessary
-packet updates as possible. This patch is likely to be updated over and over in terms of reducing packet sends.
-
-In summary, this patch creates the concept of a "foreignValue" of a packet's data. We treat packets in two ways:
-1) The packet sent to the player itself (the normal way). This always has all of the values as usual.
-2) The packet data as seen by any other (foreign) players.
-
-This patch adds the ability to set a "foreignValue" for an entity value so as to obfuscate data received by other players.
-The current packets modified/obfuscated are the following:
-
-# Health - Foreign Players will only receive packets that say the player is "alive or dead (max health or 0 health).
-    # This reduces the amount of health packet updates as well which is great for players in combat.
-
-# Air Level - Foreign players will only ever see a player as having full oxygen
-    # Air level packets are sent PER-TICK, and as such a player with any change in air level will only spam themselves
-    # with packets instead of every single player within tracking distance
-
-# Score - Foreign players will only see a player's score as 0 and will not update due to gathering xp orbs, etc.
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java
-index 3e17f6131bf590d7c4a16b79c1c145cb4f565bc9..e1233fa58d068448d0accef7a7f6725fcb902848 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java
-@@ -22,6 +22,13 @@ public class ClientboundSetEntityDataPacket implements Packet<ClientGamePacketLi
- 
-     }
- 
-+    // Slice start
-+    public ClientboundSetEntityDataPacket(int id, List<SynchedEntityData.DataItem<?>> packedItems) {
-+        this.id = id;
-+        this.packedItems = packedItems;
-+    }
-+    // Slice end
-+
-     public ClientboundSetEntityDataPacket(FriendlyByteBuf buf) {
-         this.id = buf.readVarInt();
-         this.packedItems = SynchedEntityData.unpack(buf);
-diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
-index 4df12454001f0de5f358c88d876e34c35a736c42..72c74d2369a36b14f1103aa74b096f50e7990f4d 100644
---- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
-+++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
-@@ -136,6 +136,11 @@ public class SynchedEntityData {
-     }
- 
-     public <T> void set(EntityDataAccessor<T> key, T value) {
-+        //Slice start
-+        set(key, value, null);
-+    }
-+
-+    public <T> void set(EntityDataAccessor<T> key, T value, @Nullable T foreignValue) { // Slice end
-         SynchedEntityData.DataItem<T> datawatcher_item = this.getItem(key);
- 
-         if (ObjectUtils.notEqual(value, datawatcher_item.getValue())) {
-@@ -145,6 +150,11 @@ public class SynchedEntityData {
-             this.isDirty = true;
-         }
- 
-+        // Slice start
-+        if (foreignValue != null && ObjectUtils.notEqual(foreignValue, datawatcher_item.getForeignValue())) {
-+            datawatcher_item.setForeignValue(foreignValue);
-+        }
-+        // Slice end
-     }
- 
-     // CraftBukkit start - add method from above
-@@ -200,6 +210,28 @@ public class SynchedEntityData {
-         return list;
-     }
- 
-+    // Slice start
-+    @Nullable
-+    public List<SynchedEntityData.DataItem<?>> packForeignDirty(List<DataItem<?>> unpackedData) {
-+        List<SynchedEntityData.DataItem<?>> list = null;
-+
-+        for (DataItem<?> dataItem : unpackedData) {
-+            DataItem<?> item = itemsById.get(dataItem.accessor.getId());
-+            if (item.isDirty(true)) {
-+                item.setForeignDirty(false);
-+
-+                if (list == null) {
-+                    list = Lists.newArrayList();
-+                }
-+
-+                list.add(item.copy(true));
-+            }
-+        }
-+
-+        return list;
-+    }
-+    // Slice end
-+
-     @Nullable
-     public List<SynchedEntityData.DataItem<?>> getAll() {
-         List<SynchedEntityData.DataItem<?>> list = null;
-@@ -313,11 +345,14 @@ public class SynchedEntityData {
-         final EntityDataAccessor<T> accessor;
-         T value;
-         private boolean dirty;
-+        @Nullable T foreignValue = null; // Slice
-+        private boolean foreignDirty; // Slice
- 
-         public DataItem(EntityDataAccessor<T> data, T value) {
-             this.accessor = data;
-             this.value = value;
-             this.dirty = true;
-+            this.foreignDirty = true; // Slice
-         }
- 
-         public EntityDataAccessor<T> getAccessor() {
-@@ -343,5 +378,34 @@ public class SynchedEntityData {
-         public SynchedEntityData.DataItem<T> copy() {
-             return new SynchedEntityData.DataItem<>(this.accessor, this.accessor.getSerializer().copy(this.value));
-         }
-+
-+        // Slice start
-+        public void setForeignValue(T foreignValue) {
-+            this.foreignValue = foreignValue;
-+            this.foreignDirty = true;
-+        }
-+
-+        public @Nullable T getForeignValue() {
-+            return foreignValue;
-+        }
-+
-+        public boolean isDirty(boolean foreign) {
-+            if (foreign) {
-+                //There must be a foreign value in order for this to be dirty, otherwise we consider this a normal
-+                //value and check the normal dirty flag.
-+                return foreignValue == null || this.foreignDirty;
-+            }
-+
-+            return this.dirty;
-+        }
-+
-+        public void setForeignDirty(boolean dirty) {
-+            this.foreignDirty = dirty;
-+        }
-+
-+        public SynchedEntityData.DataItem<T> copy(boolean foreign) {
-+            return new SynchedEntityData.DataItem<>(this.accessor, this.accessor.getSerializer().copy((foreign && this.foreignValue != null ? this.foreignValue : this.value)));
-+        }
-+        // Slice end
-     }
- }
-diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 1c6bf5a3014beaf5f9c1c38aed4cf3225e50b8bb..6e9c5e210270647205499801b235849d20776156 100644
---- a/src/main/java/net/minecraft/server/level/ServerEntity.java
-+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -368,7 +368,19 @@ public class ServerEntity {
-         SynchedEntityData datawatcher = this.entity.getEntityData();
- 
-         if (datawatcher.isDirty()) {
--            this.broadcastAndSend(new ClientboundSetEntityDataPacket(this.entity.getId(), datawatcher, false));
-+            // Slice start
-+            ClientboundSetEntityDataPacket dataPacket = new ClientboundSetEntityDataPacket(this.entity.getId(), datawatcher, false);
-+            if (this.entity instanceof ServerPlayer serverPlayer) {
-+                serverPlayer.connection.send(dataPacket);
-+            }
-+
-+            //Get the packedData that the original packet has, and then determine if any of those are changed in
-+            //the foreign version. If null, nothing to notify foreign trackers about.
-+            List<SynchedEntityData.DataItem<?>> dirtyItems = datawatcher.packForeignDirty(dataPacket.getUnpackedData());
-+            if (dirtyItems != null) {
-+                this.broadcast(new ClientboundSetEntityDataPacket(this.entity.getId(), dirtyItems));
-+            }
-+            // Slice end
-         }
- 
-         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 78cb0786e741f8ef8611460dab64d0e2448fb6cf..587411322e75b08b7f6c2f18a22256ff9bf526ad 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -2953,7 +2953,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
-         if (event.isCancelled()) {
-             return;
-         }
--        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, event.getAmount());
-+        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, event.getAmount(), getMaxAirSupply()); // Slice
-         // CraftBukkit end
-     }
- 
-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 51fd9bca61888861b58966a69cd1b63c742c44ca..3ed6e5d0c50c259c3df2b0cf84e2fb7ccf64def3 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -633,7 +633,7 @@ public abstract class Player extends LivingEntity {
-     public void increaseScore(int score) {
-         int j = this.getScore();
- 
--        this.entityData.set(Player.DATA_SCORE_ID, j + score);
-+        this.entityData.set(Player.DATA_SCORE_ID, j + score, 0); // Slice
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 4ff4143f3a7cd89ef92f4b8882fa3e5addfe0f06..83495f9a7d92cd42c2f367891a0a04870a4a1577 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2004,7 +2004,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-                 this.sendHealthUpdate();
-             }
-         }
--        this.getHandle().getEntityData().set(LivingEntity.DATA_HEALTH_ID, (float) this.getScaledHealth());
-+        this.getHandle().getEntityData().set(LivingEntity.DATA_HEALTH_ID, (float) this.getScaledHealth(), isDead() ? 0f : 20f); // Slice
- 
-         this.getHandle().maxHealthCache = getMaxHealth();
-     }

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

@@ -0,0 +1,212 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 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
+@@ -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, 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();
++            slots.add(Pair.of(slot, entity.getOrCreateCachedEquipmentItem(tag, slot, pair.getSecond())));
++        }
++    }
++
+     private ClientboundSetEquipmentPacket(RegistryFriendlyByteBuf buf) {
+         this.entity = buf.readVarInt();
+         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 90eb4927fa51ce3df86aa7b6c71f49150a03e337..a6c3beb9d5ab87fca882e1761983ebe385011296 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -388,22 +388,7 @@ public class ServerEntity {
+         Entity entity = this.entity;
+ 
+         if (entity instanceof LivingEntity entityliving) {
+-            List<Pair<EquipmentSlot, ItemStack>> list = Lists.newArrayList();
+-            Iterator iterator = EquipmentSlot.VALUES.iterator();
+-
+-            while (iterator.hasNext()) {
+-                EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
+-                ItemStack itemstack = entityliving.getItemBySlot(enumitemslot);
+-
+-                if (!itemstack.isEmpty()) {
+-                    list.add(Pair.of(enumitemslot, itemstack.copy()));
+-                }
+-            }
+-
+-            if (!list.isEmpty()) {
+-                sender.accept(new ClientboundSetEquipmentPacket(this.entity.getId(), list, true)); // Paper - data sanitization
+-            }
+-            ((LivingEntity) this.entity).detectEquipmentUpdatesPublic(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
++            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 f36a075dbee2b96d01899e02460b1d8443e91749..0634626d4a0bda9ac58f1fd16265ca866ee9f5c3 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -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
+ 
++    // Slice start
++    private static final java.util.Map<String, com.google.common.cache.Cache<Integer, ItemStack>> equipmentPacketCache = new java.util.HashMap<>();
++    protected final java.util.Map<String, net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket> cachedEquipmentPacket = new java.util.HashMap<>();
++    // Slice end
++
+     @Override
+     public float getBukkitYaw() {
+         return this.getYHeadRot();
+@@ -3383,6 +3388,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         if (map != null) {
+             this.handleHandSwap(map);
+             if (!map.isEmpty()) {
++                cachedEquipmentPacket.clear(); // Slice - Must invalidate cached equipment map if we have changes
+                 this.handleEquipmentChanges(map);
+             }
+         }
+@@ -3507,7 +3513,25 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             }
+ 
+         });
+-        ((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());
++        if (entityTracker != null) {
++            ClientboundSetEquipmentPacket packet = new ClientboundSetEquipmentPacket(this.getId(), list);
++            for (net.minecraft.server.network.ServerPlayerConnection playerConnection : entityTracker.seenBy) {
++                ServerPlayer player = playerConnection.getPlayer();
++                org.bukkit.event.player.PlayerReceiveEquipmentEvent event = new org.bukkit.event.player.PlayerReceiveEquipmentEvent(player.getBukkitEntity(), getBukkitEntity());
++                level().getCraftServer().getPluginManager().callEvent(event);
++
++                String tag = event.getTag();
++                if (tag != null) {
++                    playerConnection.send(new ClientboundSetEquipmentPacket(this.getId(), list, this, false, tag));
++                } else {
++                    playerConnection.send(packet);
++                }
++            }
++        }
++        // Slice end
+     }
+ 
+     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) {
++        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)
++                        .build())
++                .asMap()
++                .computeIfAbsent(itemStack.hashCode(), i -> {
++                    String name = slot.name();
++
++                    //How neat is this.
++                    if (name.equals("MAINHAND")) {
++                        name = "HAND";
++                    } else if (name.equals("OFFHAND")) {
++                        name = "OFF_HAND";
++                    }
++
++                    org.bukkit.event.entity.EntityEquipmentItemLookup event = new org.bukkit.event.entity.EntityEquipmentItemLookup(getBukkitEntity(), tag, org.bukkit.inventory.EquipmentSlot.valueOf(name), CraftItemStack.asBukkitCopy(itemStack));
++                    this.level().getCraftServer().getPluginManager().callEvent(event);
++                    org.bukkit.inventory.ItemStack eventItem = event.getItemStack();
++                    return CraftItemStack.asNMSCopy(eventItem);
++                });
++    }
++    // Slice end
++
++    // Slice start
++    public void sendEquipment(java.util.function.Consumer<net.minecraft.network.protocol.Packet<net.minecraft.network.protocol.game.ClientGamePacketListener>> consumer, ServerPlayer p) {
++        org.bukkit.event.player.PlayerReceiveEquipmentEvent event = new org.bukkit.event.player.PlayerReceiveEquipmentEvent(p.getBukkitEntity(), getBukkitEntity());
++        level().getCraftServer().getPluginManager().callEvent(event);
++
++        boolean sendEquipment = !event.isCancelled();
++        String tag = event.getTag();
++        if (sendEquipment && this instanceof ServerPlayer player && tag != null) {
++        ClientboundSetEquipmentPacket equipmentPacket = player.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);
++                return;
++            }
++        }
++
++        if (sendEquipment) {
++            List<Pair<EquipmentSlot, ItemStack>> list = Lists.newArrayList();
++            Iterator iterator = EquipmentSlot.VALUES.iterator();
++
++            while (iterator.hasNext()) {
++                EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
++                ItemStack itemstack = getItemBySlot(enumitemslot);
++
++                if (!itemstack.isEmpty()) {
++                    ItemStack finalItemStack;
++                    if (tag != null) {
++                        finalItemStack = getOrCreateCachedEquipmentItem(tag, enumitemslot, itemstack);
++                    } else {
++                        finalItemStack = itemstack.copy();
++                    }
++
++                    list.add(Pair.of(enumitemslot, finalItemStack));
++                }
++            }
++
++            if (!list.isEmpty()) {
++                ClientboundSetEquipmentPacket equipmentPacket = new ClientboundSetEquipmentPacket(getId(), list, true);
++                if (tag != null) {
++                    cachedEquipmentPacket.put(tag, equipmentPacket);
++                }
++                consumer.accept(equipmentPacket);
++            }
++
++            detectEquipmentUpdatesPublic(); // CraftBukkit - SPIGOT-3789: sync again immediately after sending
++        }
++    }
++    // 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 d0c409f4efad289e3e325f44b500fc72589d89d4..baecf1c7bb459786bdbe6f7381ef148e0dad0ef5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1205,6 +1205,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     }
+     // Paper end - body yaw API
+ 
++    // Slice start
++    @Override
++    public void sendEquipment(Player p) {
++        if (entity instanceof net.minecraft.world.entity.LivingEntity livingEntity) {
++            net.minecraft.server.level.ServerPlayer serverPlayer = ((CraftPlayer) p).getHandle();
++            livingEntity.sendEquipment(packet -> serverPlayer.connection.send(packet), serverPlayer);
++        }
++    }
++    // Slice end
++
+     // Paper start - Expose canUseSlot
+     @Override
+     public boolean canUseEquipmentSlot(org.bukkit.inventory.EquipmentSlot slot) {

patches/server/0014-Smooth-World-Teleports.patch

@@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Sun, 10 Oct 2021 13:36:38 -0500
-Subject: [PATCH] Smooth World Teleports
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 11f46c1b8f4c8414e0667d1873542c17d6e01f2a..fda2fedb0a24800e2690bba13d44c1cbfc3fb867 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -263,6 +263,7 @@ public class ServerPlayer extends Player {
-     public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<ServerPlayer> cachedSingleHashSet; // Paper
-     public boolean needsChunkCenterUpdate; // Paper - no-tick view distance // Paper - public
-     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - there are a lot of changes to do if we change all methods leading to the event
-+    public boolean smoothWorldTeleport; // Slice
- 
-     public ServerPlayer(MinecraftServer server, ServerLevel world, GameProfile profile) {
-         super(world, world.getSharedSpawnPos(), world.getSharedSpawnAngle(), profile);
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index eaa005c1c9b4386bcdbe1d6eb28c3eca7635066c..86d00fdee17bce31a5caf370ede8a2dbc42e440b 100644
---- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -940,11 +940,11 @@ public abstract class PlayerList {
-         }
-         // CraftBukkit start
-         LevelData worlddata = worldserver1.getLevelData();
--        entityplayer1.connection.send(new ClientboundRespawnPacket(worldserver1.dimensionType(), worldserver1.dimension(), BiomeManager.obfuscateSeed(worldserver1.getSeed()), entityplayer1.gameMode.getGameModeForPlayer(), entityplayer1.gameMode.getPreviousGameModeForPlayer(), worldserver1.isDebug(), worldserver1.isFlat(), flag));
-+        if (!entityplayer.smoothWorldTeleport) entityplayer1.connection.send(new ClientboundRespawnPacket(worldserver1.dimensionType(), worldserver1.dimension(), BiomeManager.obfuscateSeed(worldserver1.getSeed()), entityplayer1.gameMode.getGameModeForPlayer(), entityplayer1.gameMode.getPreviousGameModeForPlayer(), worldserver1.isDebug(), worldserver1.isFlat(), flag));
-         entityplayer1.connection.send(new ClientboundSetChunkCacheRadiusPacket(worldserver1.getChunkSource().chunkMap.playerChunkManager.getLoadDistance())); // Spigot // Paper - no-tick view distance// Paper - replace old player chunk management
-         entityplayer1.setLevel(worldserver1);
-         entityplayer1.unsetRemoved();
--        entityplayer1.connection.teleport(new Location(worldserver1.getWorld(), entityplayer1.getX(), entityplayer1.getY(), entityplayer1.getZ(), entityplayer1.getYRot(), entityplayer1.getXRot()));
-+        if (!entityplayer.smoothWorldTeleport) entityplayer1.connection.teleport(new Location(worldserver1.getWorld(), entityplayer1.getX(), entityplayer1.getY(), entityplayer1.getZ(), entityplayer1.getYRot(), entityplayer1.getXRot()));
-         entityplayer1.setShiftKeyDown(false);
- 
-         // entityplayer1.connection.b(entityplayer1.locX(), entityplayer1.locY(), entityplayer1.locZ(), entityplayer1.getYRot(), entityplayer1.getXRot());

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/0015-World-Instance-Flag.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Mon, 18 Oct 2021 08:52:40 -0500
-Subject: [PATCH] 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 d40a367670ccea01978cabf7d45f3c1a690662fc..d9d7edebbdb65990ade0c8e3c0e8bddd80927c2e 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -200,6 +200,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     public final UUID uuid;
-     public boolean hasPhysicsEvent = true; // Paper
-     public boolean hasEntityMoveEvent = false; // Paper
-+    public boolean instance; // Slice
-     public static Throwable getAddToWorldStackTrace(Entity entity) {
-         return new Throwable(entity + " Added to world at " + new java.util.Date());
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 858e29ad77aee8a1b7797c2d82902abbfd662da2..135bb95bda500f24ceef664dc522dd02570822fe 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -1197,6 +1197,18 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         world.noSave = !value;
-     }
- 
-+    // Slice start
-+    @Override
-+    public boolean isInstance() {
-+        return world.instance;
-+    }
-+
-+    @Override
-+    public void setInstance(boolean value) {
-+        world.instance = value;
-+    }
-+    // Slice end
-+
-     @Override
-     public void setDifficulty(Difficulty difficulty) {
-         this.getHandle().serverLevelData.setDifficulty(net.minecraft.world.Difficulty.byId(difficulty.getValue()));

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

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 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
+@@ -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;
+@@ -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, world.getSeaLevel())) {
+             return false;
+         } else {

patches/server/0016-Block-Mob-Spawns-globally-by-EntityType.patch

@@ -1,94 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 29 Oct 2021 10:22:23 -0500
-Subject: [PATCH] Block Mob Spawns globally by EntityType
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 2509a170b8ddd812ad5be49e5345ec5a3c0cf2b8..6a0726ec0882a67d2cc6b652010e2b02a75b3833 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -665,4 +665,16 @@ public class PaperConfig {
-     private static void sendFullPosForHardCollidingEntities() {
-         sendFullPosForHardCollidingEntities = getBoolean("settings.send-full-pos-for-hard-colliding-entities", true);
-     }
-+
-+    // Slice start
-+    public static java.util.Set<net.minecraft.world.entity.EntityType<?>> globalBlockedMobSpawnTypes = new java.util.HashSet<>();
-+
-+    private static void globalBlockedMobSpawnTypes() {
-+        java.util.List<String> list = getList("settings.global-blocked-mobspawn-types", java.util.Collections.emptyList());
-+        for (String type : list) {
-+            java.util.Optional<net.minecraft.world.entity.EntityType<?>> entityType = net.minecraft.world.entity.EntityType.byString(type.toLowerCase());
-+            entityType.ifPresent(eType -> globalBlockedMobSpawnTypes.add(eType));
-+        }
-+    }
-+    // Slice end
- }
-diff --git a/src/main/java/net/minecraft/world/level/biome/MobSpawnSettings.java b/src/main/java/net/minecraft/world/level/biome/MobSpawnSettings.java
-index 86528ff031014e788d72a8bf7c1c9443512096bb..f66e6f750136fc3903acbcb7502e98e21e75fe5a 100644
---- a/src/main/java/net/minecraft/world/level/biome/MobSpawnSettings.java
-+++ b/src/main/java/net/minecraft/world/level/biome/MobSpawnSettings.java
-@@ -41,9 +41,10 @@ public class MobSpawnSettings {
-         }), Codec.BOOL.fieldOf("player_spawn_friendly").orElse(false).forGetter(MobSpawnSettings::playerSpawnFriendly)).apply(instance, MobSpawnSettings::new);
-     });
-     private final float creatureGenerationProbability;
--    private final Map<MobCategory, WeightedRandomList<MobSpawnSettings.SpawnerData>> spawners;
--    private final Map<EntityType<?>, MobSpawnSettings.MobSpawnCost> mobSpawnCosts;
-+    private Map<MobCategory, WeightedRandomList<MobSpawnSettings.SpawnerData>> spawners; // Slice
-+    private Map<EntityType<?>, MobSpawnSettings.MobSpawnCost> mobSpawnCosts; // Slice
-     private final boolean playerSpawnFriendly;
-+    private boolean stripped; // Slice
- 
-     MobSpawnSettings(float creatureSpawnProbability, Map<MobCategory, WeightedRandomList<MobSpawnSettings.SpawnerData>> spawners, Map<EntityType<?>, MobSpawnSettings.MobSpawnCost> spawnCosts, boolean playerSpawnFriendly) {
-         this.creatureGenerationProbability = creatureSpawnProbability;
-@@ -52,12 +53,49 @@ public class MobSpawnSettings {
-         this.playerSpawnFriendly = playerSpawnFriendly;
-     }
- 
-+    // Slice start
-+    // This very stupid thing is because Mob Spawning Biome data is statically registered before CraftServer
-+    // is even created. As a result, we need to lazily rebuild our spawning data here which is very cool and very
-+    // stupid. But it should only really happen once up front, so isn't the end of the world
-+    private void stripSpawnData() {
-+        if (com.destroystokyo.paper.PaperConfig.globalBlockedMobSpawnTypes.isEmpty()) {
-+            stripped = true;
-+            return;
-+        }
-+
-+        Map<EntityType<?>, MobSpawnSettings.MobSpawnCost> finalMobSpawnCosts = new java.util.HashMap<>();
-+        for (Entry<EntityType<?>, MobSpawnSettings.MobSpawnCost> entry : mobSpawnCosts.entrySet()) {
-+            if (!com.destroystokyo.paper.PaperConfig.globalBlockedMobSpawnTypes.contains(entry.getKey())) {
-+                finalMobSpawnCosts.put(entry.getKey(), entry.getValue());
-+            }
-+        }
-+        this.mobSpawnCosts = ImmutableMap.copyOf(finalMobSpawnCosts);
-+
-+        Map<MobCategory, WeightedRandomList<MobSpawnSettings.SpawnerData>> finalSpawners = new java.util.HashMap<>();
-+        for (Entry<MobCategory, WeightedRandomList<SpawnerData>> entry : spawners.entrySet()) {
-+            List<SpawnerData> finalSpawnerData = new java.util.ArrayList<>();
-+            for (SpawnerData spawnerData : entry.getValue().unwrap()) {
-+                if (!com.destroystokyo.paper.PaperConfig.globalBlockedMobSpawnTypes.contains(spawnerData.type)) {
-+                    finalSpawnerData.add(spawnerData);
-+                }
-+            }
-+
-+            finalSpawners.put(entry.getKey(), finalSpawnerData.isEmpty() ? EMPTY_MOB_LIST : WeightedRandomList.create(finalSpawnerData));
-+        }
-+
-+        this.spawners = ImmutableMap.copyOf(finalSpawners);
-+        stripped = true;
-+    }
-+    // Slice end
-+
-     public WeightedRandomList<MobSpawnSettings.SpawnerData> getMobs(MobCategory spawnGroup) {
-+        if (!stripped) stripSpawnData(); // Slice
-         return this.spawners.getOrDefault(spawnGroup, EMPTY_MOB_LIST);
-     }
- 
-     @Nullable
-     public MobSpawnSettings.MobSpawnCost getMobSpawnCost(EntityType<?> entityType) {
-+        if (!stripped) stripSpawnData(); // Slice
-         return this.mobSpawnCosts.get(entityType);
-     }
- 

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-Very-far-tracking-range.patch

@@ -1,58 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Fri, 29 Oct 2021 17:06:43 -0500
-Subject: [PATCH] Very far tracking range
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 9f32296ca4afaa7f2c0dd920a4c994af7a815ec3..2b2fb92cbfeed75276f054e6f04e21b37d28b49b 100644
---- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -1994,8 +1994,15 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         // Paper end
-         if (!(entity instanceof EnderDragonPart)) {
-             EntityType<?> entitytypes = entity.getType();
--            int i = entitytypes.clientTrackingRange() * 16;
--            i = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, i); // Spigot
-+            // Slice
-+            int i;
-+            if (entity.visibleFromVeryFar) {
-+                i = 128;
-+            } else {
-+                i = entitytypes.clientTrackingRange() * 16;
-+                i = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, i); // Spigot
-+            }
-+            // Slice end
- 
-             if (i != 0) {
-                 int j = entitytypes.updateInterval();
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 7c3cd4d613489e5ad68a15f59b076668cbc82c5e..b9f85c52ee8af7349b3600a7a45f37c593ed761d 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -339,6 +339,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
-     public void inactiveTick() { }
-     // Spigot end
- 
-+    public boolean visibleFromVeryFar; // Slice
-+
-     public float getBukkitYaw() {
-         return this.yRot;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 986f045a2e6a040c6e2aab7420c8cb2d4ac3a726..eb18db47313ebefb4e66a92f072931186245e968 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -1067,6 +1067,12 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         this.getHandle().setSilent(flag);
-     }
- 
-+    // Slice start
-+    public void setVisibleFromVeryFar(boolean flag) {
-+        this.getHandle().visibleFromVeryFar = flag;
-+    }
-+    // Slice end
-+
-     @Override
-     public boolean hasGravity() {
-         return !this.getHandle().isNoGravity();

patches/server/0018-Add-jackson.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 16 Nov 2024 09:14:26 -0600
+Subject: [PATCH] Add jackson
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 63aa7a91dad0903383405c2cccf894d23a2ede54..fcc93b891c04d8b340b29a8b96e939df9b58839a 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -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")
++    implementation("com.fasterxml.jackson.core:jackson-databind:2.13.0")
++    implementation("com.fasterxml.jackson.core:jackson-annotations:2.13.0")
++    // Slice end
++
+     // 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

patches/server/0018-PlayerTrackEntityEvent.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Cryptite <cryptite@gmail.com>
-Date: Tue, 30 Nov 2021 12:04:50 -0600
-Subject: [PATCH] PlayerTrackEntityEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 6e9c5e210270647205499801b235849d20776156..bae3f9447d9dbb6cc48fe4878ac2d57c4d28b9d7 100644
---- a/src/main/java/net/minecraft/server/level/ServerEntity.java
-+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -362,6 +362,7 @@ public class ServerEntity {
-             }
-         }
- 
-+        this.entity.level.getCraftServer().getPluginManager().callEvent(new org.bukkit.event.player.PlayerTrackEntityEvent(entityplayer.getBukkitEntity().getPlayer(), this.entity.getBukkitEntity())); // Slice
-     }
- 
-     private void sendDirtyEntityData() {

patches/server/0019-Add-BlockDestroyedByNeighborEvent.patch

@@ -1,121 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tom <cryptite@gmail.com>
-Date: Tue, 7 Dec 2021 07:59:41 -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 b03eacbef3cf15b70ec012af0870975d3e8e8cba..d792f9ad494f01d6ca78704a9fadf445e0d4e65e 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -606,6 +606,8 @@ public class ServerPlayerGameMode {
-                     enuminteractionresult1 = stack.placeItem(itemactioncontext, hand);
-                 }
- 
-+                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 9f3355dbbbab1ab88cf2b7034130c2888e38d7a7..ec43aa3661bc891a17670aec54d3f009c29b463b 100644
---- a/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-+++ b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
-@@ -201,7 +201,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();
- 
-@@ -227,7 +232,7 @@ public class ServerStatsCounter extends StatsCounter {
- 
-         jsonobject1.add("stats", jsonobject);
-         jsonobject1.addProperty("DataVersion", SharedConstants.getCurrentVersion().getWorldVersion());
--        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 35c39aed9583275ef25d32c783715798b52bdb63..258813e65b521dccb19f4f3248588a7106a1e24b 100644
---- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
-+++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
-@@ -33,6 +33,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());
-             File file = File.createTempFile(player.getStringUUID() + "-", ".dat", this.playerDir);
-@@ -52,32 +53,40 @@ 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);
--            }
--            // Spigot Start
--            if ( usingWrongFile )
--            {
--                file.renameTo( new File( file.getPath() + ".offline-read" ) );
-+                if (file.exists() && file.isFile()) {
-+                    nbttagcompound = NbtIo.readCompressed(file);
-+                }
-+                // 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) {

patches/server/0019-Add-ObjectId.patch

@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+Date: Sat, 16 Nov 2024 09:22:24 -0600
+Subject: [PATCH] Add ObjectId
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index fcc93b891c04d8b340b29a8b96e939df9b58839a..4893e10810583c12f6b34ec63d96bc8477264415 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -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-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 9bb19124498370c5b5ecaff10f523ee6e391b767..77cc9ae3f5d71454c3b75c44cf53bcfbc5f3eb84 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -223,7 +223,17 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             // Paper start - Folia schedulers
+             synchronized (this) {
+                 if (this.bukkitEntity == null) {
+-                    return this.bukkitEntity = CraftEntity.getEntity(this.level.getCraftServer(), this);
++                    this.bukkitEntity = CraftEntity.getEntity(this.level.getCraftServer(), this);
++
++                    // Slice start - resolve ObjectId
++                    if (this.bukkitEntity instanceof org.bukkit.craftbukkit.entity.CraftHumanEntity craftHumanEntity) {
++                        io.papermc.paper.event.player.PlayerResolveObjectIdEvent event = new io.papermc.paper.event.player.PlayerResolveObjectIdEvent((org.bukkit.entity.Player) bukkitEntity);
++                        event.callEvent();
++                        craftHumanEntity.setObjectId(event.getObjectId());
++                    }
++                    // Slice end
++
++                    return this.bukkitEntity;
+                 }
+             }
+             // 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 e345cdbfab44a0f5da80d738798dbb4424b7ab5c..ba1280382f2b95ea2cb412d3a15789affc65bb12 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -73,6 +73,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+     protected final PermissibleBase perm = new PermissibleBase(this);
+     private boolean op;
+     private GameMode mode;
++    private org.bson.types.ObjectId objectId;
+ 
+     public CraftHumanEntity(final CraftServer server, final Player entity) {
+         super(server, entity);
+@@ -81,6 +82,18 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         this.enderChest = new CraftInventory(entity.getEnderChestInventory());
+     }
+ 
++    // Slice start
++    @Override
++    public org.bson.types.ObjectId getObjectId() {
++        return objectId;
++    }
++
++    @Override
++    public void setObjectId(org.bson.types.ObjectId objectId) {
++        this.objectId = objectId;
++    }
++    // Slice end
++
+     @Override
+     public PlayerInventory getInventory() {
+         return this.inventory;

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

@@ -0,0 +1,185 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 0f99733660f91280e4c6262cf75b3c9cae86f65a..8845497071ca3be0e439b454f1f2d14f0f74e842 100644
+--- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
++++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -63,15 +63,29 @@ public class SynchedEntityData {
+     }
+ 
+     public <T> void set(EntityDataAccessor<T> key, T value, boolean force) {
++        // Slice start
++        this.set(key, value, force, null);
++    }
++
++    public <T> void set(EntityDataAccessor<T> key, T value, @Nullable T foreignValue) {
++        this.set(key, value, false, foreignValue);
++    }
++
++    public <T> void set(EntityDataAccessor<T> key, T value, boolean force, @Nullable T foreignValue) { // Slice end
+         SynchedEntityData.DataItem<T> datawatcher_item = this.getItem(key);
+ 
++        // Slice start
++        if (foreignValue != null && ObjectUtils.notEqual(foreignValue, datawatcher_item.getForeignValue())) {
++            datawatcher_item.setForeignValue(foreignValue);
++        }
++        // Slice end
++
+         if (force || ObjectUtils.notEqual(value, datawatcher_item.getValue())) {
+             datawatcher_item.setValue(value);
+             this.entity.onSyncedDataUpdated(key);
+             datawatcher_item.setDirty(true);
+             this.isDirty = true;
+         }
+-
+     }
+ 
+     // CraftBukkit start - add method from above
+@@ -108,6 +122,26 @@ public class SynchedEntityData {
+         }
+     }
+ 
++    // Slice start
++    @Nullable
++    public List<SynchedEntityData.DataValue<?>> packForeignDirty() {
++        List<SynchedEntityData.DataValue<?>> list = null;
++
++        for (DataItem<?> dataItem : this.itemsById) {
++            if (dataItem.isDirty(true)) {
++                dataItem.setForeignDirty(false);
++                if (list == null) {
++                    list = new ArrayList();
++                }
++
++                list.add(dataItem.foreignValue != null ? dataItem.foreignValue() : dataItem.value());
++            }
++        }
++
++        return list;
++    }
++    // Slice end
++
+     @Nullable
+     public List<SynchedEntityData.DataValue<?>> getNonDefaultValues() {
+         List<SynchedEntityData.DataValue<?>> list = null;
+@@ -171,11 +205,14 @@ public class SynchedEntityData {
+         T value;
+         private final T initialValue;
+         private boolean dirty;
++        private @Nullable T foreignValue = null; // Slice
++        private boolean foreignDirty; // Slice
+ 
+         public DataItem(EntityDataAccessor<T> data, T value) {
+             this.accessor = data;
+             this.initialValue = value;
+             this.value = value;
++            this.foreignDirty = true; //Slice
+         }
+ 
+         public EntityDataAccessor<T> getAccessor() {
+@@ -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);
++        }
++
++        public void setForeignValue(T foreignValue) {
++            this.foreignValue = foreignValue;
++            this.foreignDirty = true;
++        }
++
++        public @Nullable T getForeignValue() {
++            return foreignValue;
++        }
++
++        public boolean isDirty(boolean foreign) {
++            if (foreign) {
++                //There must be a foreign value in order for this to be dirty, otherwise we consider this a normal
++                //value and check the normal dirty flag.
++                return foreignValue == null || this.foreignDirty;
++            }
++
++            return this.dirty;
++        }
++
++        public void setForeignDirty(boolean dirty) {
++            this.foreignDirty = dirty;
++        }
++        // Slice end
+     }
+ 
+     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 a6c3beb9d5ab87fca882e1761983ebe385011296..112a8c0840ded4156782a6bab7550d4696b02c6f 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -434,7 +434,20 @@ public class ServerEntity {
+ 
+         if (list != null) {
+             this.trackedDataValues = datawatcher.getNonDefaultValues();
+-            this.broadcastAndSend(new ClientboundSetEntityDataPacket(this.entity.getId(), list));
++//            this.broadcastAndSend(new ClientboundSetEntityDataPacket(this.entity.getId(), list));
++            // Slice start
++            ClientboundSetEntityDataPacket dataPacket = new ClientboundSetEntityDataPacket(this.entity.getId(), list);
++            if (this.entity instanceof ServerPlayer serverPlayer) {
++                serverPlayer.connection.send(dataPacket);
++            }
++
++            //Get the packedData that the original packet has, and then determine if any of those are changed in
++            //the foreign version. If null, nothing to notify foreign trackers about.
++            List<SynchedEntityData.DataValue<?>> dirtyItems = datawatcher.packForeignDirty();
++            if (dirtyItems != null) {
++                this.broadcast.accept(new ClientboundSetEntityDataPacket(this.entity.getId(), dirtyItems));
++            }
++            // Slice end
+         }
+ 
+         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 77cc9ae3f5d71454c3b75c44cf53bcfbc5f3eb84..a46df2ccbae85cdbdb7a19825a89c1797337d270 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3670,7 +3670,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             this.entityData.markDirty(Entity.DATA_AIR_SUPPLY_ID);
+             return;
+         }
+-        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, event.getAmount());
++        this.entityData.set(Entity.DATA_AIR_SUPPLY_ID, event.getAmount(), getMaxAirSupply()); // Slice
+         // CraftBukkit end
+     }
+ 
+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 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
+@@ -676,7 +676,7 @@ public abstract class Player extends LivingEntity {
+     public void increaseScore(int score) {
+         int j = this.getScore();
+ 
+-        this.entityData.set(Player.DATA_SCORE_ID, j + score);
++        this.entityData.set(Player.DATA_SCORE_ID, j + score, 0); // Slice
+     }
+ 
+     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 973726a3429498b19bf36915b2e84ff29a203704..b4d72cbcbb9caa10e07fc07278d85fdc87f40102 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2864,7 +2864,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+                 this.sendHealthUpdate();
+             }
+         }
+-        this.getHandle().getEntityData().set(net.minecraft.world.entity.LivingEntity.DATA_HEALTH_ID, (float) this.getScaledHealth());
++        this.getHandle().getEntityData().set(net.minecraft.world.entity.LivingEntity.DATA_HEALTH_ID, (float) this.getScaledHealth(), isDead() ? 0f : 20f); // Slice
+ 
+         this.getHandle().maxHealthCache = this.getMaxHealth();
+     }

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

@@ -0,0 +1,162 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <cryptite@gmail.com>
+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 2c1781a45828ef8018e976a445984197f0df1445..46f060f33fcbc6a4568a7fcfba29e83a4d192578 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1414,7 +1414,7 @@ public abstract class PlayerList {
+                 }
+             }
+ 
+-            serverstatisticmanager = new ServerStatsCounter(this.server, file1);
++            serverstatisticmanager = new ServerStatsCounter(this.server, file1, uuid); // Slice
+             // this.stats.put(uuid, serverstatisticmanager); // CraftBukkit
+         }
+ 
+diff --git a/src/main/java/net/minecraft/stats/ServerStatsCounter.java b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+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 {
+     private final File file;
+     private final Set<Stat<?>> dirty = Sets.newHashSet();
+ 
+-    public ServerStatsCounter(MinecraftServer server, File file) {
++    public ServerStatsCounter(MinecraftServer server, File file, java.util.UUID uuid) { // Slice
+         this.server = server;
+         this.file = file;
+-        if (file.isFile()) {
++        // 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 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) {
+@@ -101,77 +107,59 @@ public class ServerStatsCounter extends StatsCounter {
+         try {
+             JsonReader jsonreader = new JsonReader(new StringReader(json));
+ 
+-            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)) {
+-                            break label48;
+-                        }
+-
+-                        CompoundTag nbttagcompound1 = nbttagcompound.getCompound("stats");
+-                        Iterator iterator = nbttagcompound1.getAllKeys().iterator();
+-
+-                        while (true) {
+-                            if (!iterator.hasNext()) {
+-                                break label48;
+-                            }
+-
+-                            String s1 = (String) iterator.next();
+-
+-                            if (nbttagcompound1.contains(s1, 10)) {
+-                                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();
+-
+-                                        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);
+-                                            });
+-                                        } 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.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);
+ 
+-                    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;
+             }
+ 
+             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");
++
++        for (String s1 : nbttagcompound1.getAllKeys()) {
++            if (nbttagcompound1.contains(s1, 10)) {
++                Util.ifElse(BuiltInRegistries.STAT_TYPE.getOptional(ResourceLocation.parse(s1)), (statisticwrapper) -> {
++                    CompoundTag nbttagcompound2 = nbttagcompound1.getCompound(s1);
++                    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));
++                        } 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));
++            }
++        }
+     }
++    // Slice end
+ 
+     private <T> Optional<Stat<T>> getStat(StatType<T> type, String id) {
+         // CraftBukkit - decompile error start

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/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/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-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/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-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() {

settings.gradle.kts

@@ -1,10 +1,59 @@
+import java.util.Locale
+
         pluginManagement {
             repositories {
                 gradlePluginPortal()
-        maven("https://papermc.io/repo/repository/maven-public/")
+                maven("https://repo.papermc.io/repository/maven-public/")
             }
         }
 
-rootProject.name = "Slice"
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
 
-include("Slice-API", "Slice-Server")
+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"
+
+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()
+        )
+    }
+}