diff --git a/patches/api/0001-Pufferfish-API-Changes.patch b/patches/api/0001-Pufferfish-API-Changes.patch new file mode 100644 index 000000000..87b48c811 --- /dev/null +++ b/patches/api/0001-Pufferfish-API-Changes.patch @@ -0,0 +1,527 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Kevin Raneri +Date: Tue, 9 Nov 2021 14:01:56 -0500 +Subject: [PATCH] Pufferfish API Changes + +Pufferfish +Copyright (C) 2022 Pufferfish Studios LLC + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . + +diff --git a/build.gradle.kts b/build.gradle.kts +index 4b2330bac734cd07f8798ceeb6d9c67bd3f3521d..1efb8043c5bd734643a91f29a338dd8256579f3d 100644 +--- a/build.gradle.kts ++++ b/build.gradle.kts +@@ -44,6 +44,7 @@ dependencies { + apiAndDocs("net.kyori:adventure-text-logger-slf4j") + api("org.apache.logging.log4j:log4j-api:2.17.1") + api("org.slf4j:slf4j-api:1.8.0-beta4") ++ api("io.sentry:sentry:5.4.0") // Pufferfish + + implementation("org.ow2.asm:asm:9.4") + implementation("org.ow2.asm:asm-commons:9.4") +@@ -87,6 +88,13 @@ val generateApiVersioningFile by tasks.registering { + } + } + ++// Pufferfish Start ++tasks.withType { ++ val compilerArgs = options.compilerArgs ++ compilerArgs.add("--add-modules=jdk.incubator.vector") ++} ++// Pufferfish End ++ + tasks.jar { + from(generateApiVersioningFile.map { it.outputs.files.singleFile }) { + into("META-INF/maven/${project.group}/${project.name}") +diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java +new file mode 100644 +index 0000000000000000000000000000000000000000..10310fdd53de28efb8a8250f6d3b0c8eb08fb68a +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java +@@ -0,0 +1,161 @@ ++package gg.pufferfish.pufferfish.sentry; ++ ++import com.google.gson.Gson; ++import java.lang.reflect.Field; ++import java.lang.reflect.Modifier; ++import java.util.Map; ++import java.util.TreeMap; ++import org.apache.logging.log4j.ThreadContext; ++import org.bukkit.command.Command; ++import org.bukkit.command.CommandSender; ++import org.bukkit.entity.Player; ++import org.bukkit.event.Event; ++import org.bukkit.event.player.PlayerEvent; ++import org.bukkit.plugin.Plugin; ++import org.bukkit.plugin.RegisteredListener; ++import org.jetbrains.annotations.Nullable; ++ ++public class SentryContext { ++ ++ private static final Gson GSON = new Gson(); ++ ++ public static void setPluginContext(@Nullable Plugin plugin) { ++ if (plugin != null) { ++ ThreadContext.put("pufferfishsentry_pluginname", plugin.getName()); ++ ThreadContext.put("pufferfishsentry_pluginversion", plugin.getDescription().getVersion()); ++ } ++ } ++ ++ public static void removePluginContext() { ++ ThreadContext.remove("pufferfishsentry_pluginname"); ++ ThreadContext.remove("pufferfishsentry_pluginversion"); ++ } ++ ++ public static void setSenderContext(@Nullable CommandSender sender) { ++ if (sender != null) { ++ ThreadContext.put("pufferfishsentry_playername", sender.getName()); ++ if (sender instanceof Player player) { ++ ThreadContext.put("pufferfishsentry_playerid", player.getUniqueId().toString()); ++ } ++ } ++ } ++ ++ public static void removeSenderContext() { ++ ThreadContext.remove("pufferfishsentry_playername"); ++ ThreadContext.remove("pufferfishsentry_playerid"); ++ } ++ ++ public static void setEventContext(Event event, RegisteredListener registration) { ++ setPluginContext(registration.getPlugin()); ++ ++ try { ++ // Find the player that was involved with this event ++ Player player = null; ++ if (event instanceof PlayerEvent) { ++ player = ((PlayerEvent) event).getPlayer(); ++ } else { ++ Class eventClass = event.getClass(); ++ ++ Field playerField = null; ++ ++ for (Field field : eventClass.getDeclaredFields()) { ++ if (field.getType().equals(Player.class)) { ++ playerField = field; ++ break; ++ } ++ } ++ ++ if (playerField != null) { ++ playerField.setAccessible(true); ++ player = (Player) playerField.get(event); ++ } ++ } ++ ++ if (player != null) { ++ setSenderContext(player); ++ } ++ } catch (Exception e) {} // We can't really safely log exceptions. ++ ++ ThreadContext.put("pufferfishsentry_eventdata", GSON.toJson(serializeFields(event))); ++ } ++ ++ public static void removeEventContext() { ++ removePluginContext(); ++ removeSenderContext(); ++ ThreadContext.remove("pufferfishsentry_eventdata"); ++ } ++ ++ private static Map serializeFields(Object object) { ++ Map fields = new TreeMap<>(); ++ fields.put("_class", object.getClass().getName()); ++ for (Field declaredField : object.getClass().getDeclaredFields()) { ++ try { ++ if (Modifier.isStatic(declaredField.getModifiers())) { ++ continue; ++ } ++ ++ String fieldName = declaredField.getName(); ++ if (fieldName.equals("handlers")) { ++ continue; ++ } ++ declaredField.setAccessible(true); ++ Object value = declaredField.get(object); ++ if (value != null) { ++ fields.put(fieldName, value.toString()); ++ } else { ++ fields.put(fieldName, ""); ++ } ++ } catch (Exception e) {} // We can't really safely log exceptions. ++ } ++ return fields; ++ } ++ ++ public static class State { ++ ++ private Plugin plugin; ++ private Command command; ++ private String commandLine; ++ private Event event; ++ private RegisteredListener registeredListener; ++ ++ public Plugin getPlugin() { ++ return plugin; ++ } ++ ++ public void setPlugin(Plugin plugin) { ++ this.plugin = plugin; ++ } ++ ++ public Command getCommand() { ++ return command; ++ } ++ ++ public void setCommand(Command command) { ++ this.command = command; ++ } ++ ++ public String getCommandLine() { ++ return commandLine; ++ } ++ ++ public void setCommandLine(String commandLine) { ++ this.commandLine = commandLine; ++ } ++ ++ public Event getEvent() { ++ return event; ++ } ++ ++ public void setEvent(Event event) { ++ this.event = event; ++ } ++ ++ public RegisteredListener getRegisteredListener() { ++ return registeredListener; ++ } ++ ++ public void setRegisteredListener(RegisteredListener registeredListener) { ++ this.registeredListener = registeredListener; ++ } ++ } ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java +new file mode 100644 +index 0000000000000000000000000000000000000000..ab5fea0b03224bf249352ce340e94704ff713345 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java +@@ -0,0 +1,40 @@ ++package gg.pufferfish.pufferfish.simd; ++ ++import java.util.logging.Level; ++import java.util.logging.Logger; ++import jdk.incubator.vector.FloatVector; ++import jdk.incubator.vector.IntVector; ++import jdk.incubator.vector.VectorSpecies; ++ ++/** ++ * Basically, java is annoying and we have to push this out to its own class. ++ */ ++@Deprecated ++public class SIMDChecker { ++ ++ @Deprecated ++ public static boolean canEnable(Logger logger) { ++ try { ++ if (SIMDDetection.getJavaVersion() != 17 && SIMDDetection.getJavaVersion() != 18 && SIMDDetection.getJavaVersion() != 19) { ++ return false; ++ } else { ++ SIMDDetection.testRun = true; ++ ++ VectorSpecies ISPEC = IntVector.SPECIES_PREFERRED; ++ VectorSpecies FSPEC = FloatVector.SPECIES_PREFERRED; ++ ++ logger.log(Level.INFO, "Max SIMD vector size on this system is " + ISPEC.vectorBitSize() + " bits (int)"); ++ logger.log(Level.INFO, "Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)"); ++ ++ if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) { ++ logger.log(Level.WARNING, "SIMD is not properly supported on this system!"); ++ return false; ++ } ++ ++ return true; ++ } ++ } catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it. ++ return false; ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java +new file mode 100644 +index 0000000000000000000000000000000000000000..a84889d3e9cfc4d7ab5f867820a6484c6070711b +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java +@@ -0,0 +1,35 @@ ++package gg.pufferfish.pufferfish.simd; ++ ++import java.util.logging.Logger; ++ ++@Deprecated ++public class SIMDDetection { ++ ++ public static boolean isEnabled = false; ++ public static boolean versionLimited = false; ++ public static boolean testRun = false; ++ ++ @Deprecated ++ public static boolean canEnable(Logger logger) { ++ try { ++ return SIMDChecker.canEnable(logger); ++ } catch (NoClassDefFoundError | Exception ignored) { ++ return false; ++ } ++ } ++ ++ @Deprecated ++ public static int getJavaVersion() { ++ // https://stackoverflow.com/a/2591122 ++ String version = System.getProperty("java.version"); ++ if(version.startsWith("1.")) { ++ version = version.substring(2, 3); ++ } else { ++ int dot = version.indexOf("."); ++ if(dot != -1) { version = version.substring(0, dot); } ++ } ++ version = version.split("-")[0]; // Azul is stupid ++ return Integer.parseInt(version); ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java +new file mode 100644 +index 0000000000000000000000000000000000000000..ae2464920c9412ac90b819a540ee58be0741465f +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java +@@ -0,0 +1,83 @@ ++package gg.pufferfish.pufferfish.simd; ++ ++import java.awt.Color; ++import jdk.incubator.vector.FloatVector; ++import jdk.incubator.vector.IntVector; ++import jdk.incubator.vector.VectorMask; ++import jdk.incubator.vector.VectorSpecies; ++import org.bukkit.map.MapPalette; ++ ++@Deprecated ++public class VectorMapPalette { ++ ++ private static final VectorSpecies I_SPEC = IntVector.SPECIES_PREFERRED; ++ private static final VectorSpecies F_SPEC = FloatVector.SPECIES_PREFERRED; ++ ++ @Deprecated ++ public static void matchColorVectorized(int[] in, byte[] out) { ++ int speciesLength = I_SPEC.length(); ++ int i; ++ for (i = 0; i < in.length - speciesLength; i += speciesLength) { ++ float[] redsArr = new float[speciesLength]; ++ float[] bluesArr = new float[speciesLength]; ++ float[] greensArr = new float[speciesLength]; ++ int[] alphasArr = new int[speciesLength]; ++ ++ for (int j = 0; j < speciesLength; j++) { ++ alphasArr[j] = (in[i + j] >> 24) & 0xFF; ++ redsArr[j] = (in[i + j] >> 16) & 0xFF; ++ greensArr[j] = (in[i + j] >> 8) & 0xFF; ++ bluesArr[j] = (in[i + j] >> 0) & 0xFF; ++ } ++ ++ IntVector alphas = IntVector.fromArray(I_SPEC, alphasArr, 0); ++ FloatVector reds = FloatVector.fromArray(F_SPEC, redsArr, 0); ++ FloatVector greens = FloatVector.fromArray(F_SPEC, greensArr, 0); ++ FloatVector blues = FloatVector.fromArray(F_SPEC, bluesArr, 0); ++ IntVector resultIndex = IntVector.zero(I_SPEC); ++ VectorMask modificationMask = VectorMask.fromLong(I_SPEC, 0xffffffff); ++ ++ modificationMask = modificationMask.and(alphas.lt(128).not()); ++ FloatVector bestDistances = FloatVector.broadcast(F_SPEC, Float.MAX_VALUE); ++ ++ for (int c = 4; c < MapPalette.colors.length; c++) { ++ // We're using 32-bit floats here because it's 2x faster and nobody will know the difference. ++ // For correctness, the original algorithm uses 64-bit floats instead. Completely unnecessary. ++ FloatVector compReds = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getRed()); ++ FloatVector compGreens = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getGreen()); ++ FloatVector compBlues = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getBlue()); ++ ++ FloatVector rMean = reds.add(compReds).div(2.0f); ++ FloatVector rDiff = reds.sub(compReds); ++ FloatVector gDiff = greens.sub(compGreens); ++ FloatVector bDiff = blues.sub(compBlues); ++ ++ FloatVector weightR = rMean.div(256.0f).add(2); ++ FloatVector weightG = FloatVector.broadcast(F_SPEC, 4.0f); ++ FloatVector weightB = FloatVector.broadcast(F_SPEC, 255.0f).sub(rMean).div(256.0f).add(2.0f); ++ ++ FloatVector distance = weightR.mul(rDiff).mul(rDiff).add(weightG.mul(gDiff).mul(gDiff)).add(weightB.mul(bDiff).mul(bDiff)); ++ ++ // Now we compare to the best distance we've found. ++ // This mask contains a "1" if better, and a "0" otherwise. ++ VectorMask bestDistanceMask = distance.lt(bestDistances); ++ bestDistances = bestDistances.blend(distance, bestDistanceMask); // Update the best distances ++ ++ // Update the result array ++ // We also AND with the modification mask because we don't want to interfere if the alpha value isn't large enough. ++ resultIndex = resultIndex.blend(c, bestDistanceMask.cast(I_SPEC).and(modificationMask)); // Update the results ++ } ++ ++ for (int j = 0; j < speciesLength; j++) { ++ int index = resultIndex.lane(j); ++ out[i + j] = (byte) (index < 128 ? index : -129 + (index - 127)); ++ } ++ } ++ ++ // For the final ones, fall back to the regular method ++ for (; i < in.length; i++) { ++ out[i] = MapPalette.matchColor(new Color(in[i], true)); ++ } ++ } ++ ++} +diff --git a/src/main/java/org/bukkit/map/MapPalette.java b/src/main/java/org/bukkit/map/MapPalette.java +index 3a9aaca2e76411a9c27f9f5e0f22d060d5a66d06..9584e245144b561b4f6745b2f26a4f69a6f92891 100644 +--- a/src/main/java/org/bukkit/map/MapPalette.java ++++ b/src/main/java/org/bukkit/map/MapPalette.java +@@ -1,6 +1,7 @@ + package org.bukkit.map; + + import com.google.common.base.Preconditions; ++import gg.pufferfish.pufferfish.simd.SIMDDetection; // Pufferfish + import java.awt.Color; + import java.awt.Graphics2D; + import java.awt.Image; +@@ -40,7 +41,7 @@ public final class MapPalette { + } + + @NotNull +- static final Color[] colors = { ++ public static final Color[] colors = { // Pufferfish - public access + c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0), + c(89, 125, 39), c(109, 153, 48), c(127, 178, 56), c(67, 94, 29), + c(174, 164, 115), c(213, 201, 140), c(247, 233, 163), c(130, 123, 86), +@@ -211,9 +212,15 @@ public final class MapPalette { + temp.getRGB(0, 0, temp.getWidth(), temp.getHeight(), pixels, 0, temp.getWidth()); + + byte[] result = new byte[temp.getWidth() * temp.getHeight()]; ++ // Pufferfish start ++ if (!SIMDDetection.isEnabled) { + for (int i = 0; i < pixels.length; i++) { + result[i] = matchColor(new Color(pixels[i], true)); + } ++ } else { ++ gg.pufferfish.pufferfish.simd.VectorMapPalette.matchColorVectorized(pixels, result); ++ } ++ // Pufferfish end + return result; + } + +diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java +index fc2dae69165776d08274e34a69962cc70445f411..899d67fa782fac639fe7fb096e05c551d75bd647 100644 +--- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java ++++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java +@@ -584,7 +584,9 @@ public final class SimplePluginManager implements PluginManager { + + // Paper start + private void handlePluginException(String msg, Throwable ex, Plugin plugin) { ++ gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish + server.getLogger().log(Level.SEVERE, msg, ex); ++ gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish + callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerPluginEnableDisableException(msg, ex, plugin))); + } + // Paper end +@@ -654,9 +656,11 @@ public final class SimplePluginManager implements PluginManager { + )); + } + } catch (Throwable ex) { ++ gg.pufferfish.pufferfish.sentry.SentryContext.setEventContext(event, registration); // Pufferfish + // Paper start - error reporting + String msg = "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(); + server.getLogger().log(Level.SEVERE, msg, ex); ++ gg.pufferfish.pufferfish.sentry.SentryContext.removeEventContext(); // Pufferfish + if (!(event instanceof com.destroystokyo.paper.event.server.ServerExceptionEvent)) { // We don't want to cause an endless event loop + callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerEventException(msg, ex, registration.getPlugin(), registration.getListener(), event))); + } +diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java +index eaefbb00e9993d54906cc8cf35cf753c0d6c7707..301e82369603f3dd6e6c1bd380da4bacacd7ef6c 100644 +--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java ++++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java +@@ -336,7 +336,13 @@ public final class JavaPluginLoader implements PluginLoader { + try { + jPlugin.setEnabled(true); + } catch (Throwable ex) { ++ gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish + server.getLogger().log(Level.SEVERE, "Error occurred while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); ++ gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish ++ // Paper start - Disable plugins that fail to load ++ this.server.getPluginManager().disablePlugin(jPlugin); ++ return; ++ // Paper end + } + + // Perhaps abort here, rather than continue going, but as it stands, +@@ -361,7 +367,9 @@ public final class JavaPluginLoader implements PluginLoader { + try { + jPlugin.setEnabled(false); + } catch (Throwable ex) { ++ gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish + server.getLogger().log(Level.SEVERE, "Error occurred while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); ++ gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish + } + + if (cloader instanceof PluginClassLoader) { +diff --git a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java +index 13da387d3b59bc67c0d73e3fbd3a4034b1281527..7572a0bf6614b02be3cbccc7b86e52ee1b8df621 100644 +--- a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java ++++ b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java +@@ -48,6 +48,8 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm + private io.papermc.paper.plugin.provider.classloader.PluginClassLoaderGroup classLoaderGroup; // Paper + public io.papermc.paper.plugin.provider.entrypoint.DependencyContext dependencyContext; // Paper + ++ private boolean closed = false; // Pufferfish ++ + static { + ClassLoader.registerAsParallelCapable(); + } +@@ -183,6 +185,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm + throw new ClassNotFoundException(name); + } + ++ public boolean _airplane_hasClass(@NotNull String name) { return this.classes.containsKey(name); } // Pufferfish + @Override + protected Class findClass(String name) throws ClassNotFoundException { + if (name.startsWith("org.bukkit.") || name.startsWith("net.minecraft.")) { +@@ -190,7 +193,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm + } + Class result = classes.get(name); + +- if (result == null) { ++ if (result == null && !this.closed) { // Pufferfish + String path = name.replace('.', '/').concat(".class"); + JarEntry entry = jar.getJarEntry(path); + +@@ -237,6 +240,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm + this.setClass(name, result); // Paper + } + ++ if (result == null) throw new ClassNotFoundException(name); // Pufferfish + return result; + } + +@@ -251,6 +255,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm + // Paper end + super.close(); + } finally { ++ this.closed = true; // Pufferfish + jar.close(); + } + } diff --git a/patches/removed/api/0002-Fix-pufferfish-issues.patch b/patches/api/0002-Fix-pufferfish-issues.patch similarity index 90% rename from patches/removed/api/0002-Fix-pufferfish-issues.patch rename to patches/api/0002-Fix-pufferfish-issues.patch index 593233a54..08bd8a159 100644 --- a/patches/removed/api/0002-Fix-pufferfish-issues.patch +++ b/patches/api/0002-Fix-pufferfish-issues.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix pufferfish issues diff --git a/src/test/java/org/bukkit/AnnotationTest.java b/src/test/java/org/bukkit/AnnotationTest.java -index 2cb81e6d253d70388da15c9d07b630277d486c70..fa7229ae5e00e36b0dc8b4cf15d3c99892cc3291 100644 +index 06e96e5c98f1a7a68c8b4b5e527314c1aa774e38..49bba9a7a02b9cf3a552583315eff2b7dbe060c0 100644 --- a/src/test/java/org/bukkit/AnnotationTest.java +++ b/src/test/java/org/bukkit/AnnotationTest.java @@ -47,6 +47,10 @@ public class AnnotationTest { diff --git a/patches/api/0002-Purpur-config-files.patch b/patches/api/0003-Purpur-config-files.patch similarity index 100% rename from patches/api/0002-Purpur-config-files.patch rename to patches/api/0003-Purpur-config-files.patch diff --git a/patches/api/0001-Build-System-Changes.patch b/patches/api/0004-Build-System-Changes.patch similarity index 85% rename from patches/api/0001-Build-System-Changes.patch rename to patches/api/0004-Build-System-Changes.patch index 5792549d2..0d51d84f0 100644 --- a/patches/api/0001-Build-System-Changes.patch +++ b/patches/api/0004-Build-System-Changes.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Build System Changes diff --git a/build.gradle.kts b/build.gradle.kts -index 7d6239855a84502de4eb3328b0dcf12ac671dce4..fc107bffc4efe56816d42c7f78d04897fe253729 100644 +index 1efb8043c5bd734643a91f29a338dd8256579f3d..031607787e57e4076f7be6203b95d449292da136 100644 --- a/build.gradle.kts +++ b/build.gradle.kts -@@ -99,6 +99,8 @@ tasks.jar { +@@ -107,6 +107,8 @@ tasks.jar { } tasks.withType { diff --git a/patches/api/0003-Purpur-client-support.patch b/patches/api/0005-Purpur-client-support.patch similarity index 100% rename from patches/api/0003-Purpur-client-support.patch rename to patches/api/0005-Purpur-client-support.patch diff --git a/patches/api/0004-Default-permissions.patch b/patches/api/0006-Default-permissions.patch similarity index 100% rename from patches/api/0004-Default-permissions.patch rename to patches/api/0006-Default-permissions.patch diff --git a/patches/api/0005-Ridables.patch b/patches/api/0007-Ridables.patch similarity index 100% rename from patches/api/0005-Ridables.patch rename to patches/api/0007-Ridables.patch diff --git a/patches/api/0006-Allow-inventory-resizing.patch b/patches/api/0008-Allow-inventory-resizing.patch similarity index 89% rename from patches/api/0006-Allow-inventory-resizing.patch rename to patches/api/0008-Allow-inventory-resizing.patch index f4ae288d5..43e3c9122 100644 --- a/patches/api/0006-Allow-inventory-resizing.patch +++ b/patches/api/0008-Allow-inventory-resizing.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Allow inventory resizing diff --git a/src/main/java/org/bukkit/event/inventory/InventoryType.java b/src/main/java/org/bukkit/event/inventory/InventoryType.java -index b821fa535b23fe5af5884e536b1708460076ee40..a794beed383ec2beaa565eab372fb7e401c0379b 100644 +index daddb12947e61ee69c100b422f6d07d49f76d724..27a182c18db825836b3d3d3c87503bfc5ae0957e 100644 --- a/src/main/java/org/bukkit/event/inventory/InventoryType.java +++ b/src/main/java/org/bukkit/event/inventory/InventoryType.java @@ -152,7 +152,7 @@ public enum InventoryType { diff --git a/patches/api/0007-Llama-API.patch b/patches/api/0009-Llama-API.patch similarity index 100% rename from patches/api/0007-Llama-API.patch rename to patches/api/0009-Llama-API.patch diff --git a/patches/api/0008-AFK-API.patch b/patches/api/0010-AFK-API.patch similarity index 100% rename from patches/api/0008-AFK-API.patch rename to patches/api/0010-AFK-API.patch diff --git a/patches/api/0009-Bring-back-server-name.patch b/patches/api/0011-Bring-back-server-name.patch similarity index 100% rename from patches/api/0009-Bring-back-server-name.patch rename to patches/api/0011-Bring-back-server-name.patch diff --git a/patches/api/0010-ExecuteCommandEvent.patch b/patches/api/0012-ExecuteCommandEvent.patch similarity index 100% rename from patches/api/0010-ExecuteCommandEvent.patch rename to patches/api/0012-ExecuteCommandEvent.patch diff --git a/patches/api/0011-LivingEntity-safeFallDistance.patch b/patches/api/0013-LivingEntity-safeFallDistance.patch similarity index 100% rename from patches/api/0011-LivingEntity-safeFallDistance.patch rename to patches/api/0013-LivingEntity-safeFallDistance.patch diff --git a/patches/api/0012-Lagging-threshold.patch b/patches/api/0014-Lagging-threshold.patch similarity index 100% rename from patches/api/0012-Lagging-threshold.patch rename to patches/api/0014-Lagging-threshold.patch diff --git a/patches/api/0013-PlayerSetSpawnerTypeWithEggEvent.patch b/patches/api/0015-PlayerSetSpawnerTypeWithEggEvent.patch similarity index 100% rename from patches/api/0013-PlayerSetSpawnerTypeWithEggEvent.patch rename to patches/api/0015-PlayerSetSpawnerTypeWithEggEvent.patch diff --git a/patches/api/0014-Player-invulnerabilities.patch b/patches/api/0016-Player-invulnerabilities.patch similarity index 100% rename from patches/api/0014-Player-invulnerabilities.patch rename to patches/api/0016-Player-invulnerabilities.patch diff --git a/patches/api/0015-Anvil-API.patch b/patches/api/0017-Anvil-API.patch similarity index 100% rename from patches/api/0015-Anvil-API.patch rename to patches/api/0017-Anvil-API.patch diff --git a/patches/api/0016-ItemStack-convenience-methods.patch b/patches/api/0018-ItemStack-convenience-methods.patch similarity index 100% rename from patches/api/0016-ItemStack-convenience-methods.patch rename to patches/api/0018-ItemStack-convenience-methods.patch diff --git a/patches/api/0017-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch b/patches/api/0019-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch similarity index 100% rename from patches/api/0017-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch rename to patches/api/0019-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch diff --git a/patches/api/0018-ChatColor-conveniences.patch b/patches/api/0020-ChatColor-conveniences.patch similarity index 100% rename from patches/api/0018-ChatColor-conveniences.patch rename to patches/api/0020-ChatColor-conveniences.patch diff --git a/patches/api/0019-LivingEntity-broadcastItemBreak.patch b/patches/api/0021-LivingEntity-broadcastItemBreak.patch similarity index 100% rename from patches/api/0019-LivingEntity-broadcastItemBreak.patch rename to patches/api/0021-LivingEntity-broadcastItemBreak.patch diff --git a/patches/api/0020-Item-entity-immunities.patch b/patches/api/0022-Item-entity-immunities.patch similarity index 100% rename from patches/api/0020-Item-entity-immunities.patch rename to patches/api/0022-Item-entity-immunities.patch diff --git a/patches/api/0021-Add-option-to-disable-zombie-aggressiveness-towards-.patch b/patches/api/0023-Add-option-to-disable-zombie-aggressiveness-towards-.patch similarity index 100% rename from patches/api/0021-Add-option-to-disable-zombie-aggressiveness-towards-.patch rename to patches/api/0023-Add-option-to-disable-zombie-aggressiveness-towards-.patch diff --git a/patches/api/0022-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch b/patches/api/0024-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch similarity index 100% rename from patches/api/0022-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch rename to patches/api/0024-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch diff --git a/patches/api/0023-Rabid-Wolf-API.patch b/patches/api/0025-Rabid-Wolf-API.patch similarity index 100% rename from patches/api/0023-Rabid-Wolf-API.patch rename to patches/api/0025-Rabid-Wolf-API.patch diff --git a/patches/api/0024-PlayerBookTooLargeEvent.patch b/patches/api/0026-PlayerBookTooLargeEvent.patch similarity index 100% rename from patches/api/0024-PlayerBookTooLargeEvent.patch rename to patches/api/0026-PlayerBookTooLargeEvent.patch diff --git a/patches/api/0025-Full-netherite-armor-grants-fire-resistance.patch b/patches/api/0027-Full-netherite-armor-grants-fire-resistance.patch similarity index 100% rename from patches/api/0025-Full-netherite-armor-grants-fire-resistance.patch rename to patches/api/0027-Full-netherite-armor-grants-fire-resistance.patch diff --git a/patches/api/0026-Add-EntityTeleportHinderedEvent.patch b/patches/api/0028-Add-EntityTeleportHinderedEvent.patch similarity index 100% rename from patches/api/0026-Add-EntityTeleportHinderedEvent.patch rename to patches/api/0028-Add-EntityTeleportHinderedEvent.patch diff --git a/patches/api/0027-Add-enchantment-target-for-bows-and-crossbows.patch b/patches/api/0029-Add-enchantment-target-for-bows-and-crossbows.patch similarity index 100% rename from patches/api/0027-Add-enchantment-target-for-bows-and-crossbows.patch rename to patches/api/0029-Add-enchantment-target-for-bows-and-crossbows.patch diff --git a/patches/api/0028-Iron-golem-poppy-calms-anger.patch b/patches/api/0030-Iron-golem-poppy-calms-anger.patch similarity index 100% rename from patches/api/0028-Iron-golem-poppy-calms-anger.patch rename to patches/api/0030-Iron-golem-poppy-calms-anger.patch diff --git a/patches/api/0029-API-for-any-mob-to-burn-daylight.patch b/patches/api/0031-API-for-any-mob-to-burn-daylight.patch similarity index 100% rename from patches/api/0029-API-for-any-mob-to-burn-daylight.patch rename to patches/api/0031-API-for-any-mob-to-burn-daylight.patch diff --git a/patches/api/0030-Add-back-player-spawned-endermite-API.patch b/patches/api/0032-Add-back-player-spawned-endermite-API.patch similarity index 100% rename from patches/api/0030-Add-back-player-spawned-endermite-API.patch rename to patches/api/0032-Add-back-player-spawned-endermite-API.patch diff --git a/patches/api/0031-Fix-default-permission-system.patch b/patches/api/0033-Fix-default-permission-system.patch similarity index 100% rename from patches/api/0031-Fix-default-permission-system.patch rename to patches/api/0033-Fix-default-permission-system.patch diff --git a/patches/api/0032-Summoner-API.patch b/patches/api/0034-Summoner-API.patch similarity index 100% rename from patches/api/0032-Summoner-API.patch rename to patches/api/0034-Summoner-API.patch diff --git a/patches/api/0033-Clean-up-version-command-output.patch b/patches/api/0035-Clean-up-version-command-output.patch similarity index 100% rename from patches/api/0033-Clean-up-version-command-output.patch rename to patches/api/0035-Clean-up-version-command-output.patch diff --git a/patches/api/0034-Extended-OfflinePlayer-API.patch b/patches/api/0036-Extended-OfflinePlayer-API.patch similarity index 100% rename from patches/api/0034-Extended-OfflinePlayer-API.patch rename to patches/api/0036-Extended-OfflinePlayer-API.patch diff --git a/patches/api/0035-Added-the-ability-to-add-combustible-items.patch b/patches/api/0037-Added-the-ability-to-add-combustible-items.patch similarity index 100% rename from patches/api/0035-Added-the-ability-to-add-combustible-items.patch rename to patches/api/0037-Added-the-ability-to-add-combustible-items.patch diff --git a/patches/api/0036-Potion-NamespacedKey.patch b/patches/api/0038-Potion-NamespacedKey.patch similarity index 100% rename from patches/api/0036-Potion-NamespacedKey.patch rename to patches/api/0038-Potion-NamespacedKey.patch diff --git a/patches/api/0037-Grindstone-API.patch b/patches/api/0039-Grindstone-API.patch similarity index 100% rename from patches/api/0037-Grindstone-API.patch rename to patches/api/0039-Grindstone-API.patch diff --git a/patches/api/0038-Shears-can-have-looting-enchantment.patch b/patches/api/0040-Shears-can-have-looting-enchantment.patch similarity index 100% rename from patches/api/0038-Shears-can-have-looting-enchantment.patch rename to patches/api/0040-Shears-can-have-looting-enchantment.patch diff --git a/patches/api/0039-Lobotomize-stuck-villagers.patch b/patches/api/0041-Lobotomize-stuck-villagers.patch similarity index 100% rename from patches/api/0039-Lobotomize-stuck-villagers.patch rename to patches/api/0041-Lobotomize-stuck-villagers.patch diff --git a/patches/api/0040-Add-local-difficulty-api.patch b/patches/api/0042-Add-local-difficulty-api.patch similarity index 100% rename from patches/api/0040-Add-local-difficulty-api.patch rename to patches/api/0042-Add-local-difficulty-api.patch diff --git a/patches/api/0041-Remove-Timings.patch b/patches/api/0043-Remove-Timings.patch similarity index 100% rename from patches/api/0041-Remove-Timings.patch rename to patches/api/0043-Remove-Timings.patch diff --git a/patches/api/0042-Add-Bee-API.patch b/patches/api/0044-Add-Bee-API.patch similarity index 100% rename from patches/api/0042-Add-Bee-API.patch rename to patches/api/0044-Add-Bee-API.patch diff --git a/patches/api/0043-Debug-Marker-API.patch b/patches/api/0045-Debug-Marker-API.patch similarity index 100% rename from patches/api/0043-Debug-Marker-API.patch rename to patches/api/0045-Debug-Marker-API.patch diff --git a/patches/api/0044-Add-death-screen-API.patch b/patches/api/0046-Add-death-screen-API.patch similarity index 100% rename from patches/api/0044-Add-death-screen-API.patch rename to patches/api/0046-Add-death-screen-API.patch diff --git a/patches/api/0045-Add-item-packet-serialize-event.patch b/patches/api/0047-Add-item-packet-serialize-event.patch similarity index 100% rename from patches/api/0045-Add-item-packet-serialize-event.patch rename to patches/api/0047-Add-item-packet-serialize-event.patch diff --git a/patches/api/0046-Language-API.patch b/patches/api/0048-Language-API.patch similarity index 100% rename from patches/api/0046-Language-API.patch rename to patches/api/0048-Language-API.patch diff --git a/patches/api/0047-Add-log-suppression-for-LibraryLoader.patch b/patches/api/0049-Add-log-suppression-for-LibraryLoader.patch similarity index 96% rename from patches/api/0047-Add-log-suppression-for-LibraryLoader.patch rename to patches/api/0049-Add-log-suppression-for-LibraryLoader.patch index 4948f9b89..95e4cd2ac 100644 --- a/patches/api/0047-Add-log-suppression-for-LibraryLoader.patch +++ b/patches/api/0049-Add-log-suppression-for-LibraryLoader.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add log suppression for LibraryLoader diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java -index eaefbb00e9993d54906cc8cf35cf753c0d6c7707..f1e58639213be0c43cd2ff090b625e7d0a67e8be 100644 +index 301e82369603f3dd6e6c1bd380da4bacacd7ef6c..0c6ca7588fb3d6b6497ddf032fe75e5c6c9719e5 100644 --- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java +++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java @@ -55,6 +55,7 @@ public final class JavaPluginLoader implements PluginLoader { diff --git a/patches/api/0048-Fire-Immunity-API.patch b/patches/api/0050-Fire-Immunity-API.patch similarity index 100% rename from patches/api/0048-Fire-Immunity-API.patch rename to patches/api/0050-Fire-Immunity-API.patch diff --git a/patches/api/0049-Added-goat-ram-event.patch b/patches/api/0051-Added-goat-ram-event.patch similarity index 100% rename from patches/api/0049-Added-goat-ram-event.patch rename to patches/api/0051-Added-goat-ram-event.patch diff --git a/patches/api/0050-Add-PreExplodeEvents.patch b/patches/api/0052-Add-PreExplodeEvents.patch similarity index 100% rename from patches/api/0050-Add-PreExplodeEvents.patch rename to patches/api/0052-Add-PreExplodeEvents.patch diff --git a/patches/server/0001-Pufferfish-Server-Changes.patch b/patches/server/0001-Pufferfish-Server-Changes.patch new file mode 100644 index 000000000..1954abbc3 --- /dev/null +++ b/patches/server/0001-Pufferfish-Server-Changes.patch @@ -0,0 +1,3585 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Kevin Raneri +Date: Wed, 3 Feb 2021 23:02:38 -0600 +Subject: [PATCH] Pufferfish Server Changes + +Pufferfish +Copyright (C) 2022 Pufferfish Studios LLC + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . + +diff --git a/build.gradle.kts b/build.gradle.kts +index a0c5592530d2a59bfde87d1e9eb3752e7d4694da..a3da1d0c043ad4f8786ba6c4e25077e14efec364 100644 +--- a/build.gradle.kts ++++ b/build.gradle.kts +@@ -7,8 +7,12 @@ plugins { + } + + dependencies { +- implementation(project(":paper-api")) +- implementation(project(":paper-mojangapi")) ++ implementation(project(":pufferfish-api")) // Pufferfish // Paper ++ // Pufferfish start ++ implementation("io.papermc.paper:paper-mojangapi:1.19.2-R0.1-SNAPSHOT") { ++ exclude("io.papermc.paper", "paper-api") ++ } ++ // Pufferfish end + // Paper start + implementation("org.jline:jline-terminal-jansi:3.21.0") + implementation("net.minecrell:terminalconsoleappender:1.3.0") +@@ -43,6 +47,13 @@ dependencies { + runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.9.10") + runtimeOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.9.10") + ++ // Pufferfish start ++ implementation("org.yaml:snakeyaml:1.32") ++ implementation ("me.carleslc.Simple-YAML:Simple-Yaml:1.8.4") { ++ exclude(group="org.yaml", module="snakeyaml") ++ } ++ // Pufferfish end ++ + testImplementation("io.github.classgraph:classgraph:4.8.47") // Paper - mob goal test + testImplementation("junit:junit:4.13.2") + testImplementation("org.hamcrest:hamcrest-library:1.3") +@@ -51,6 +62,14 @@ dependencies { + } + + val craftbukkitPackageVersion = "1_20_R1" // Paper ++ ++// Pufferfish Start ++tasks.withType { ++ val compilerArgs = options.compilerArgs ++ compilerArgs.add("--add-modules=jdk.incubator.vector") ++} ++// Pufferfish End ++ + tasks.jar { + archiveClassifier.set("dev") + +@@ -63,7 +82,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-Pufferfish-$implementationVersion", // Pufferfish + "Implementation-Vendor" to date, // Paper + "Specification-Title" to "Bukkit", + "Specification-Version" to project.version, +diff --git a/src/main/java/co/aikar/timings/TimingsExport.java b/src/main/java/co/aikar/timings/TimingsExport.java +index a2f71a6d1a9e98133dff6cd0f625da9435a8af14..ff940e43ca35094bbcae6c7d471d3c4aeb7c1727 100644 +--- a/src/main/java/co/aikar/timings/TimingsExport.java ++++ b/src/main/java/co/aikar/timings/TimingsExport.java +@@ -242,7 +242,8 @@ public class TimingsExport extends Thread { + parent.put("config", createObject( + pair("spigot", mapAsJSON(Bukkit.spigot().getSpigotConfig(), null)), + pair("bukkit", mapAsJSON(Bukkit.spigot().getBukkitConfig(), null)), +- pair("paper", mapAsJSON(Bukkit.spigot().getPaperConfig(), null)) ++ pair("paper", mapAsJSON(Bukkit.spigot().getPaperConfig(), null)), // Pufferfish ++ pair("pufferfish", mapAsJSON(gg.pufferfish.pufferfish.PufferfishConfig.getConfigCopy(), null)) // Pufferfish + )); + + new TimingsExport(listeners, parent, history).start(); +diff --git a/src/main/java/com/destroystokyo/paper/Metrics.java b/src/main/java/com/destroystokyo/paper/Metrics.java +index 4b002e8b75d117b726b0de274a76d3596fce015b..692c962193cf9fcc6801fc93f3220bdc673d527b 100644 +--- a/src/main/java/com/destroystokyo/paper/Metrics.java ++++ b/src/main/java/com/destroystokyo/paper/Metrics.java +@@ -593,7 +593,7 @@ public class Metrics { + boolean logFailedRequests = config.getBoolean("logFailedRequests", false); + // Only start Metrics, if it's enabled in the config + if (config.getBoolean("enabled", true)) { +- Metrics metrics = new Metrics("Paper", serverUUID, logFailedRequests, Bukkit.getLogger()); ++ Metrics metrics = new Metrics("Pufferfish", serverUUID, logFailedRequests, Bukkit.getLogger()); // Pufferfish + + metrics.addCustomChart(new Metrics.SimplePie("minecraft_version", () -> { + String minecraftVersion = Bukkit.getVersion(); +@@ -607,11 +607,11 @@ public class Metrics { + final String implVersion = org.bukkit.craftbukkit.Main.class.getPackage().getImplementationVersion(); + if (implVersion != null) { + final String buildOrHash = implVersion.substring(implVersion.lastIndexOf('-') + 1); +- paperVersion = "git-Paper-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); ++ paperVersion = "git-Pufferfish-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); // Pufferfish + } else { + paperVersion = "unknown"; + } +- metrics.addCustomChart(new Metrics.SimplePie("paper_version", () -> paperVersion)); ++ metrics.addCustomChart(new Metrics.SimplePie("pufferfish_version", () -> paperVersion)); // Pufferfish + + metrics.addCustomChart(new Metrics.DrilldownPie("java_version", () -> { + Map> map = new HashMap<>(); +diff --git a/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java b/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java +index 41b9405d6759d865e0d14dd4f95163e9690e967d..091b1ae822e1c0517e59572e7a9bda11e998c0ee 100644 +--- a/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java ++++ b/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java +@@ -26,7 +26,7 @@ public abstract class AreaMap { + + // we use linked for better iteration. + // map of: coordinate to set of objects in coordinate +- protected final Long2ObjectOpenHashMap> areaMap = new Long2ObjectOpenHashMap<>(1024, 0.7f); ++ protected Long2ObjectOpenHashMap> areaMap = new Long2ObjectOpenHashMap<>(1024, 0.7f); // Pufferfish - not actually final + protected final PooledLinkedHashSets pooledHashSets; + + protected final ChangeCallback addCallback; +@@ -160,7 +160,8 @@ public abstract class AreaMap { + protected abstract PooledLinkedHashSets.PooledObjectLinkedOpenHashSet getEmptySetFor(final E object); + + // expensive op, only for debug +- protected void validate(final E object, final int viewDistance) { ++ protected void validate0(final E object, final int viewDistance) { // Pufferfish - rename this thing just in case it gets used I'd rather a compile time error. ++ if (true) throw new UnsupportedOperationException(); // Pufferfish - not going to put in the effort to fix this if it doesn't ever get used. + int entiesGot = 0; + int expectedEntries = (2 * viewDistance + 1); + expectedEntries *= expectedEntries; +diff --git a/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java b/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java +index 46954db7ecd35ac4018fdf476df7c8020d7ce6c8..1ad890a244bdf6df48a8db68cb43450e08c788a6 100644 +--- a/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java ++++ b/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java +@@ -5,7 +5,7 @@ import net.minecraft.server.level.ServerPlayer; + /** + * @author Spottedleaf + */ +-public final class PlayerAreaMap extends AreaMap { ++public class PlayerAreaMap extends AreaMap { // Pufferfish - not actually final + + public PlayerAreaMap() { + super(); +diff --git a/src/main/java/gg/airplane/structs/FluidDirectionCache.java b/src/main/java/gg/airplane/structs/FluidDirectionCache.java +new file mode 100644 +index 0000000000000000000000000000000000000000..aa8467b9dda1f7707e41f50ac7b3e9d7343723ec +--- /dev/null ++++ b/src/main/java/gg/airplane/structs/FluidDirectionCache.java +@@ -0,0 +1,136 @@ ++package gg.airplane.structs; ++ ++import it.unimi.dsi.fastutil.HashCommon; ++ ++/** ++ * This is a replacement for the cache used in FluidTypeFlowing. ++ * The requirements for the previous cache were: ++ * - Store 200 entries ++ * - Look for the flag in the cache ++ * - If it exists, move to front of cache ++ * - If it doesn't exist, remove last entry in cache and insert in front ++ * ++ * This class accomplishes something similar, however has a few different ++ * requirements put into place to make this more optimize: ++ * ++ * - maxDistance is the most amount of entries to be checked, instead ++ * of having to check the entire list. ++ * - In combination with that, entries are all tracked by age and how ++ * frequently they're used. This enables us to remove old entries, ++ * without constantly shifting any around. ++ * ++ * Usage of the previous map would have to reset the head every single usage, ++ * shifting the entire map. Here, nothing happens except an increment when ++ * the cache is hit, and when it needs to replace an old element only a single ++ * element is modified. ++ */ ++public class FluidDirectionCache { ++ ++ private static class FluidDirectionEntry { ++ private final T data; ++ private final boolean flag; ++ private int uses = 0; ++ private int age = 0; ++ ++ private FluidDirectionEntry(T data, boolean flag) { ++ this.data = data; ++ this.flag = flag; ++ } ++ ++ public int getValue() { ++ return this.uses - (this.age >> 1); // age isn't as important as uses ++ } ++ ++ public void incrementUses() { ++ this.uses = this.uses + 1 & Integer.MAX_VALUE; ++ } ++ ++ public void incrementAge() { ++ this.age = this.age + 1 & Integer.MAX_VALUE; ++ } ++ } ++ ++ private final FluidDirectionEntry[] entries; ++ private final int mask; ++ private final int maxDistance; // the most amount of entries to check for a value ++ ++ public FluidDirectionCache(int size) { ++ int arraySize = HashCommon.nextPowerOfTwo(size); ++ this.entries = new FluidDirectionEntry[arraySize]; ++ this.mask = arraySize - 1; ++ this.maxDistance = Math.min(arraySize, 4); ++ } ++ ++ public Boolean getValue(T data) { ++ FluidDirectionEntry curr; ++ int pos; ++ ++ if ((curr = this.entries[pos = HashCommon.mix(data.hashCode()) & this.mask]) == null) { ++ return null; ++ } else if (data.equals(curr.data)) { ++ curr.incrementUses(); ++ return curr.flag; ++ } ++ ++ int checked = 1; // start at 1 because we already checked the first spot above ++ ++ while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) { ++ if (data.equals(curr.data)) { ++ curr.incrementUses(); ++ return curr.flag; ++ } else if (++checked >= this.maxDistance) { ++ break; ++ } ++ } ++ ++ return null; ++ } ++ ++ public void putValue(T data, boolean flag) { ++ FluidDirectionEntry curr; ++ int pos; ++ ++ if ((curr = this.entries[pos = HashCommon.mix(data.hashCode()) & this.mask]) == null) { ++ this.entries[pos] = new FluidDirectionEntry<>(data, flag); // add ++ return; ++ } else if (data.equals(curr.data)) { ++ curr.incrementUses(); ++ return; ++ } ++ ++ int checked = 1; // start at 1 because we already checked the first spot above ++ ++ while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) { ++ if (data.equals(curr.data)) { ++ curr.incrementUses(); ++ return; ++ } else if (++checked >= this.maxDistance) { ++ this.forceAdd(data, flag); ++ return; ++ } ++ } ++ ++ this.entries[pos] = new FluidDirectionEntry<>(data, flag); // add ++ } ++ ++ private void forceAdd(T data, boolean flag) { ++ int expectedPos = HashCommon.mix(data.hashCode()) & this.mask; ++ ++ int toRemovePos = expectedPos; ++ FluidDirectionEntry entryToRemove = this.entries[toRemovePos]; ++ ++ for (int i = expectedPos + 1; i < expectedPos + this.maxDistance; i++) { ++ int pos = i & this.mask; ++ FluidDirectionEntry entry = this.entries[pos]; ++ if (entry.getValue() < entryToRemove.getValue()) { ++ toRemovePos = pos; ++ entryToRemove = entry; ++ } ++ ++ entry.incrementAge(); // use this as a mechanism to age the other entries ++ } ++ ++ // remove the least used/oldest entry ++ this.entries[toRemovePos] = new FluidDirectionEntry(data, flag); ++ } ++} +diff --git a/src/main/java/gg/airplane/structs/ItemListWithBitset.java b/src/main/java/gg/airplane/structs/ItemListWithBitset.java +new file mode 100644 +index 0000000000000000000000000000000000000000..1b7a4ee47f4445d7f2ac91d3a73ae113edbdddb2 +--- /dev/null ++++ b/src/main/java/gg/airplane/structs/ItemListWithBitset.java +@@ -0,0 +1,114 @@ ++package gg.airplane.structs; ++ ++import net.minecraft.core.NonNullList; ++import net.minecraft.world.item.ItemStack; ++import org.apache.commons.lang.Validate; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++ ++import java.util.AbstractList; ++import java.util.Arrays; ++import java.util.List; ++ ++public class ItemListWithBitset extends AbstractList { ++ public static ItemListWithBitset fromList(List list) { ++ if (list instanceof ItemListWithBitset ours) { ++ return ours; ++ } ++ return new ItemListWithBitset(list); ++ } ++ ++ private static ItemStack[] createArray(int size) { ++ ItemStack[] array = new ItemStack[size]; ++ Arrays.fill(array, ItemStack.EMPTY); ++ return array; ++ } ++ ++ private final ItemStack[] items; ++ ++ private long bitSet = 0; ++ private final long allBits; ++ ++ private static class OurNonNullList extends NonNullList { ++ protected OurNonNullList(List delegate) { ++ super(delegate, ItemStack.EMPTY); ++ } ++ } ++ ++ public final NonNullList nonNullList = new OurNonNullList(this); ++ ++ private ItemListWithBitset(List list) { ++ this(list.size()); ++ ++ for (int i = 0; i < list.size(); i++) { ++ this.set(i, list.get(i)); ++ } ++ } ++ ++ public ItemListWithBitset(int size) { ++ Validate.isTrue(size < Long.BYTES * 8, "size is too large"); ++ ++ this.items = createArray(size); ++ this.allBits = ((1L << size) - 1); ++ } ++ ++ public boolean isCompletelyEmpty() { ++ return this.bitSet == 0; ++ } ++ ++ public boolean hasFullStacks() { ++ return (this.bitSet & this.allBits) == allBits; ++ } ++ ++ @Override ++ public ItemStack set(int index, @NotNull ItemStack itemStack) { ++ ItemStack existing = this.items[index]; ++ ++ this.items[index] = itemStack; ++ ++ if (itemStack == ItemStack.EMPTY) { ++ this.bitSet &= ~(1L << index); ++ } else { ++ this.bitSet |= 1L << index; ++ } ++ ++ return existing; ++ } ++ ++ @NotNull ++ @Override ++ public ItemStack get(int var0) { ++ return this.items[var0]; ++ } ++ ++ @Override ++ public int size() { ++ return this.items.length; ++ } ++ ++ @Override ++ public void clear() { ++ Arrays.fill(this.items, ItemStack.EMPTY); ++ } ++ ++ // these are unsupported for block inventories which have a static size ++ @Override ++ public void add(int var0, ItemStack var1) { ++ throw new UnsupportedOperationException(); ++ } ++ ++ @Override ++ public ItemStack remove(int var0) { ++ throw new UnsupportedOperationException(); ++ } ++ ++ @Override ++ public String toString() { ++ return "ItemListWithBitset{" + ++ "items=" + Arrays.toString(items) + ++ ", bitSet=" + Long.toString(bitSet, 2) + ++ ", allBits=" + Long.toString(allBits, 2) + ++ ", size=" + this.items.length + ++ '}'; ++ } ++} +diff --git a/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java b/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java +new file mode 100644 +index 0000000000000000000000000000000000000000..a7f297ebb569f7c1f205e967ca485be70013a714 +--- /dev/null ++++ b/src/main/java/gg/airplane/structs/Long2FloatAgingCache.java +@@ -0,0 +1,119 @@ ++package gg.airplane.structs; ++ ++import it.unimi.dsi.fastutil.HashCommon; ++ ++/** ++ * A replacement for the cache used in Biome. ++ */ ++public class Long2FloatAgingCache { ++ ++ private static class AgingEntry { ++ private long data; ++ private float value; ++ private int uses = 0; ++ private int age = 0; ++ ++ private AgingEntry(long data, float value) { ++ this.data = data; ++ this.value = value; ++ } ++ ++ public void replace(long data, float flag) { ++ this.data = data; ++ this.value = flag; ++ } ++ ++ public int getValue() { ++ return this.uses - (this.age >> 1); // age isn't as important as uses ++ } ++ ++ public void incrementUses() { ++ this.uses = this.uses + 1 & Integer.MAX_VALUE; ++ } ++ ++ public void incrementAge() { ++ this.age = this.age + 1 & Integer.MAX_VALUE; ++ } ++ } ++ ++ private final AgingEntry[] entries; ++ private final int mask; ++ private final int maxDistance; // the most amount of entries to check for a value ++ ++ public Long2FloatAgingCache(int size) { ++ int arraySize = HashCommon.nextPowerOfTwo(size); ++ this.entries = new AgingEntry[arraySize]; ++ this.mask = arraySize - 1; ++ this.maxDistance = Math.min(arraySize, 4); ++ } ++ ++ public float getValue(long data) { ++ AgingEntry curr; ++ int pos; ++ ++ if ((curr = this.entries[pos = HashCommon.mix(HashCommon.long2int(data)) & this.mask]) == null) { ++ return Float.NaN; ++ } else if (data == curr.data) { ++ curr.incrementUses(); ++ return curr.value; ++ } ++ ++ int checked = 1; // start at 1 because we already checked the first spot above ++ ++ while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) { ++ if (data == curr.data) { ++ curr.incrementUses(); ++ return curr.value; ++ } else if (++checked >= this.maxDistance) { ++ break; ++ } ++ } ++ ++ return Float.NaN; ++ } ++ ++ public void putValue(long data, float value) { ++ AgingEntry curr; ++ int pos; ++ ++ if ((curr = this.entries[pos = HashCommon.mix(HashCommon.long2int(data)) & this.mask]) == null) { ++ this.entries[pos] = new AgingEntry(data, value); // add ++ return; ++ } else if (data == curr.data) { ++ curr.incrementUses(); ++ return; ++ } ++ ++ int checked = 1; // start at 1 because we already checked the first spot above ++ ++ while ((curr = this.entries[pos = (pos + 1) & this.mask]) != null) { ++ if (data == curr.data) { ++ curr.incrementUses(); ++ return; ++ } else if (++checked >= this.maxDistance) { ++ this.forceAdd(data, value); ++ return; ++ } ++ } ++ ++ this.entries[pos] = new AgingEntry(data, value); // add ++ } ++ ++ private void forceAdd(long data, float value) { ++ int expectedPos = HashCommon.mix(HashCommon.long2int(data)) & this.mask; ++ AgingEntry entryToRemove = this.entries[expectedPos]; ++ ++ for (int i = expectedPos + 1; i < expectedPos + this.maxDistance; i++) { ++ int pos = i & this.mask; ++ AgingEntry entry = this.entries[pos]; ++ if (entry.getValue() < entryToRemove.getValue()) { ++ entryToRemove = entry; ++ } ++ ++ entry.incrementAge(); // use this as a mechanism to age the other entries ++ } ++ ++ // remove the least used/oldest entry ++ entryToRemove.replace(data, value); ++ } ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishCommand.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishCommand.java +new file mode 100644 +index 0000000000000000000000000000000000000000..020368da69b9a492155f6de6297f74732f4ab6ea +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishCommand.java +@@ -0,0 +1,68 @@ ++package gg.pufferfish.pufferfish; ++ ++import java.io.IOException; ++import java.util.Collections; ++import java.util.List; ++import java.util.stream.Collectors; ++import java.util.stream.Stream; ++import net.kyori.adventure.text.Component; ++import net.kyori.adventure.text.format.NamedTextColor; ++import net.md_5.bungee.api.ChatColor; ++import net.minecraft.server.MinecraftServer; ++import org.bukkit.Bukkit; ++import org.bukkit.Location; ++import org.bukkit.command.Command; ++import org.bukkit.command.CommandSender; ++ ++public class PufferfishCommand extends Command { ++ ++ public PufferfishCommand() { ++ super("pufferfish"); ++ this.description = "Pufferfish related commands"; ++ this.usageMessage = "/pufferfish [reload | version]"; ++ this.setPermission("bukkit.command.pufferfish"); ++ } ++ ++ public static void init() { ++ MinecraftServer.getServer().server.getCommandMap().register("pufferfish", "Pufferfish", new PufferfishCommand()); ++ } ++ ++ @Override ++ public List tabComplete(CommandSender sender, String alias, String[] args, Location location) throws IllegalArgumentException { ++ if (args.length == 1) { ++ return Stream.of("reload", "version") ++ .filter(arg -> arg.startsWith(args[0].toLowerCase())) ++ .collect(Collectors.toList()); ++ } ++ return Collections.emptyList(); ++ } ++ ++ @Override ++ public boolean execute(CommandSender sender, String commandLabel, String[] args) { ++ if (!testPermission(sender)) return true; ++ String prefix = ChatColor.of("#12fff6") + "" + ChatColor.BOLD + "Pufferfish ยป " + ChatColor.of("#e8f9f9"); ++ ++ if (args.length != 1) { ++ sender.sendMessage(prefix + "Usage: " + usageMessage); ++ args = new String[]{"version"}; ++ } ++ ++ if (args[0].equalsIgnoreCase("reload")) { ++ MinecraftServer console = MinecraftServer.getServer(); ++ try { ++ PufferfishConfig.load(); ++ } catch (IOException e) { ++ sender.sendMessage(Component.text("Failed to reload.", NamedTextColor.RED)); ++ e.printStackTrace(); ++ return true; ++ } ++ console.server.reloadCount++; ++ ++ Command.broadcastCommandMessage(sender, prefix + "Pufferfish configuration has been reloaded."); ++ } else if (args[0].equalsIgnoreCase("version")) { ++ Command.broadcastCommandMessage(sender, prefix + "This server is running " + Bukkit.getName() + " version " + Bukkit.getVersion() + " (Implementing API version " + Bukkit.getBukkitVersion() + ")"); ++ } ++ ++ return true; ++ } ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java +new file mode 100644 +index 0000000000000000000000000000000000000000..0dd3374468e05f7a312ba5856b9cf8a4787dfa59 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java +@@ -0,0 +1,293 @@ ++package gg.pufferfish.pufferfish; ++ ++import gg.pufferfish.pufferfish.simd.SIMDDetection; ++import java.io.File; ++import java.io.IOException; ++import java.util.Collections; ++import net.minecraft.core.registries.BuiltInRegistries; ++import java.util.Locale; ++import java.util.Map; ++import net.minecraft.server.MinecraftServer; ++import net.minecraft.tags.TagKey; ++import org.apache.logging.log4j.Level; ++import org.bukkit.configuration.ConfigurationSection; ++import net.minecraft.world.entity.EntityType; ++import java.lang.reflect.Method; ++import java.lang.reflect.Modifier; ++import java.util.List; ++import net.minecraft.server.MinecraftServer; ++import org.apache.logging.log4j.Level; ++import org.bukkit.configuration.ConfigurationSection; ++import org.bukkit.configuration.MemoryConfiguration; ++import org.jetbrains.annotations.Nullable; ++import org.simpleyaml.configuration.comments.CommentType; ++import org.simpleyaml.configuration.file.YamlFile; ++import org.simpleyaml.exceptions.InvalidConfigurationException; ++ ++public class PufferfishConfig { ++ ++ private static final YamlFile config = new YamlFile(); ++ private static int updates = 0; ++ ++ private static ConfigurationSection convertToBukkit(org.simpleyaml.configuration.ConfigurationSection section) { ++ ConfigurationSection newSection = new MemoryConfiguration(); ++ for (String key : section.getKeys(false)) { ++ if (section.isConfigurationSection(key)) { ++ newSection.set(key, convertToBukkit(section.getConfigurationSection(key))); ++ } else { ++ newSection.set(key, section.get(key)); ++ } ++ } ++ return newSection; ++ } ++ ++ public static ConfigurationSection getConfigCopy() { ++ return convertToBukkit(config); ++ } ++ ++ public static int getUpdates() { ++ return updates; ++ } ++ ++ public static void load() throws IOException { ++ File configFile = new File("pufferfish.yml"); ++ ++ if (configFile.exists()) { ++ try { ++ config.load(configFile); ++ } catch (InvalidConfigurationException e) { ++ throw new IOException(e); ++ } ++ } ++ ++ getString("info.version", "1.0"); ++ setComment("info", ++ "Pufferfish Configuration", ++ "Check out Pufferfish Host for maximum performance server hosting: https://pufferfish.host", ++ "Join our Discord for support: https://discord.gg/reZw4vQV9H", ++ "Download new builds at https://ci.pufferfish.host/job/Pufferfish"); ++ ++ for (Method method : PufferfishConfig.class.getDeclaredMethods()) { ++ if (Modifier.isStatic(method.getModifiers()) && Modifier.isPrivate(method.getModifiers()) && method.getParameterCount() == 0 && ++ method.getReturnType() == Void.TYPE && !method.getName().startsWith("lambda")) { ++ method.setAccessible(true); ++ try { ++ method.invoke(null); ++ } catch (Throwable t) { ++ MinecraftServer.LOGGER.warn("Failed to load configuration option from " + method.getName(), t); ++ } ++ } ++ } ++ ++ updates++; ++ ++ config.save(configFile); ++ ++ // Attempt to detect vectorization ++ try { ++ SIMDDetection.isEnabled = SIMDDetection.canEnable(PufferfishLogger.LOGGER); ++ SIMDDetection.versionLimited = SIMDDetection.getJavaVersion() != 17 && SIMDDetection.getJavaVersion() != 18 && SIMDDetection.getJavaVersion() != 19; ++ } catch (NoClassDefFoundError | Exception ignored) { ++ ignored.printStackTrace(); ++ } ++ ++ if (SIMDDetection.isEnabled) { ++ PufferfishLogger.LOGGER.info("SIMD operations detected as functional. Will replace some operations with faster versions."); ++ } else if (SIMDDetection.versionLimited) { ++ PufferfishLogger.LOGGER.warning("Will not enable SIMD! These optimizations are only safely supported on Java 17, Java 18, and Java 19."); ++ } else { ++ PufferfishLogger.LOGGER.warning("SIMD operations are available for your server, but are not configured!"); ++ PufferfishLogger.LOGGER.warning("To enable additional optimizations, add \"--add-modules=jdk.incubator.vector\" to your startup flags, BEFORE the \"-jar\"."); ++ PufferfishLogger.LOGGER.warning("If you have already added this flag, then SIMD operations are not supported on your JVM or CPU."); ++ PufferfishLogger.LOGGER.warning("Debug: Java: " + System.getProperty("java.version") + ", test run: " + SIMDDetection.testRun); ++ } ++ } ++ ++ private static void setComment(String key, String... comment) { ++ if (config.contains(key)) { ++ config.setComment(key, String.join("\n", comment), CommentType.BLOCK); ++ } ++ } ++ ++ private static void ensureDefault(String key, Object defaultValue, String... comment) { ++ if (!config.contains(key)) { ++ config.set(key, defaultValue); ++ config.setComment(key, String.join("\n", comment), CommentType.BLOCK); ++ } ++ } ++ ++ private static boolean getBoolean(String key, boolean defaultValue, String... comment) { ++ return getBoolean(key, null, defaultValue, comment); ++ } ++ ++ private static boolean getBoolean(String key, @Nullable String oldKey, boolean defaultValue, String... comment) { ++ ensureDefault(key, defaultValue, comment); ++ return config.getBoolean(key, defaultValue); ++ } ++ ++ private static int getInt(String key, int defaultValue, String... comment) { ++ return getInt(key, null, defaultValue, comment); ++ } ++ ++ private static int getInt(String key, @Nullable String oldKey, int defaultValue, String... comment) { ++ ensureDefault(key, defaultValue, comment); ++ return config.getInt(key, defaultValue); ++ } ++ ++ private static double getDouble(String key, double defaultValue, String... comment) { ++ return getDouble(key, null, defaultValue, comment); ++ } ++ ++ private static double getDouble(String key, @Nullable String oldKey, double defaultValue, String... comment) { ++ ensureDefault(key, defaultValue, comment); ++ return config.getDouble(key, defaultValue); ++ } ++ ++ private static String getString(String key, String defaultValue, String... comment) { ++ return getOldString(key, null, defaultValue, comment); ++ } ++ ++ private static String getOldString(String key, @Nullable String oldKey, String defaultValue, String... comment) { ++ ensureDefault(key, defaultValue, comment); ++ return config.getString(key, defaultValue); ++ } ++ ++ private static List getStringList(String key, List defaultValue, String... comment) { ++ return getStringList(key, null, defaultValue, comment); ++ } ++ ++ private static List getStringList(String key, @Nullable String oldKey, List defaultValue, String... comment) { ++ ensureDefault(key, defaultValue, comment); ++ return config.getStringList(key); ++ } ++ ++ public static String sentryDsn; ++ private static void sentry() { ++ String sentryEnvironment = System.getenv("SENTRY_DSN"); ++ String sentryConfig = getString("sentry-dsn", "", "Sentry DSN for improved error logging, leave blank to disable", "Obtain from https://sentry.io/"); ++ ++ sentryDsn = sentryEnvironment == null ? sentryConfig : sentryEnvironment; ++ if (sentryDsn != null && !sentryDsn.isBlank()) { ++ gg.pufferfish.pufferfish.sentry.SentryManager.init(); ++ } ++ } ++ ++ public static boolean enableBooks; ++ private static void books() { ++ enableBooks = getBoolean("enable-books", true, ++ "Whether or not books should be writeable.", ++ "Servers that anticipate being a target for duping may want to consider", ++ "disabling this option.", ++ "This can be overridden per-player with the permission pufferfish.usebooks"); ++ } ++ ++ public static boolean enableSuffocationOptimization; ++ private static void suffocationOptimization() { ++ enableSuffocationOptimization = getBoolean("enable-suffocation-optimization", true, ++ "Optimizes the suffocation check by selectively skipping", ++ "the check in a way that still appears vanilla. This should", ++ "be left enabled on most servers, but is provided as a", ++ "configuration option if the vanilla deviation is undesirable."); ++ } ++ ++ public static boolean enableAsyncMobSpawning; ++ public static boolean asyncMobSpawningInitialized; ++ private static void asyncMobSpawning() { ++ boolean temp = getBoolean("enable-async-mob-spawning", true, ++ "Whether or not asynchronous mob spawning should be enabled.", ++ "On servers with many entities, this can improve performance by up to 15%. You must have", ++ "paper's per-player-mob-spawns setting set to true for this to work.", ++ "One quick note - this does not actually spawn mobs async (that would be very unsafe).", ++ "This just offloads some expensive calculations that are required for mob spawning."); ++ ++ // This prevents us from changing the value during a reload. ++ if (!asyncMobSpawningInitialized) { ++ asyncMobSpawningInitialized = true; ++ enableAsyncMobSpawning = temp; ++ } ++ } ++ ++ public static int maxProjectileLoadsPerTick; ++ public static int maxProjectileLoadsPerProjectile; ++ private static void projectileLoading() { ++ maxProjectileLoadsPerTick = getInt("projectile.max-loads-per-tick", 10, "Controls how many chunks are allowed", "to be sync loaded by projectiles in a tick."); ++ maxProjectileLoadsPerProjectile = getInt("projectile.max-loads-per-projectile", 10, "Controls how many chunks a projectile", "can load in its lifetime before it gets", "automatically removed."); ++ ++ setComment("projectile", "Optimizes projectile settings"); ++ } ++ ++ ++ public static boolean dearEnabled; ++ public static int startDistance; ++ public static int startDistanceSquared; ++ public static int maximumActivationPrio; ++ public static int activationDistanceMod; ++ ++ private static void dynamicActivationOfBrains() throws IOException { ++ dearEnabled = getBoolean("dab.enabled", "activation-range.enabled", true); ++ startDistance = getInt("dab.start-distance", "activation-range.start-distance", 12, ++ "This value determines how far away an entity has to be", ++ "from the player to start being effected by DEAR."); ++ startDistanceSquared = startDistance * startDistance; ++ maximumActivationPrio = getInt("dab.max-tick-freq", "activation-range.max-tick-freq", 20, ++ "This value defines how often in ticks, the furthest entity", ++ "will get their pathfinders and behaviors ticked. 20 = 1s"); ++ activationDistanceMod = getInt("dab.activation-dist-mod", "activation-range.activation-dist-mod", 8, ++ "This value defines how much distance modifies an entity's", ++ "tick frequency. freq = (distanceToPlayer^2) / (2^value)", ++ "If you want further away entities to tick less often, use 7.", ++ "If you want further away entities to tick more often, try 9."); ++ ++ for (EntityType entityType : BuiltInRegistries.ENTITY_TYPE) { ++ entityType.dabEnabled = true; // reset all, before setting the ones to true ++ } ++ getStringList("dab.blacklisted-entities", "activation-range.blacklisted-entities", Collections.emptyList(), "A list of entities to ignore for activation") ++ .forEach(name -> EntityType.byString(name).ifPresentOrElse(entityType -> { ++ entityType.dabEnabled = false; ++ }, () -> MinecraftServer.LOGGER.warn("Unknown entity \"" + name + "\""))); ++ ++ setComment("dab", "Optimizes entity brains when", "they're far away from the player"); ++ } ++ ++ public static Map projectileTimeouts; ++ private static void projectileTimeouts() { ++ // Set some defaults ++ getInt("entity_timeouts.SNOWBALL", -1); ++ getInt("entity_timeouts.LLAMA_SPIT", -1); ++ setComment("entity_timeouts", ++ "These values define a entity's maximum lifespan. If an", ++ "entity is in this list and it has survived for longer than", ++ "that number of ticks, then it will be removed. Setting a value to", ++ "-1 disables this feature."); ++ ++ for (EntityType entityType : BuiltInRegistries.ENTITY_TYPE) { ++ String type = EntityType.getKey(entityType).getPath().toUpperCase(Locale.ROOT); ++ entityType.ttl = config.getInt("entity_timeouts." + type, -1); ++ } ++ } ++ ++ public static boolean throttleInactiveGoalSelectorTick; ++ private static void inactiveGoalSelectorThrottle() { ++ throttleInactiveGoalSelectorTick = getBoolean("inactive-goal-selector-throttle", "inactive-goal-selector-disable", true, ++ "Throttles the AI goal selector in entity inactive ticks.", ++ "This can improve performance by a few percent, but has minor gameplay implications."); ++ } ++ ++ public static boolean allowEndCrystalRespawn; ++ private static void allowEndCrystalRespawn() { ++ allowEndCrystalRespawn = getBoolean("allow-end-crystal-respawn", true, ++ "Allows end crystals to respawn the ender dragon.", ++ "On servers that expect end crystal fights in the end dimension, disabling this", ++ "will prevent the server from performing an expensive search to attempt respawning", ++ "the ender dragon whenever a player places an end crystal."); ++ } ++ ++ public static boolean disableMethodProfiler; ++ public static boolean disableOutOfOrderChat; ++ private static void miscSettings() { ++ disableMethodProfiler = getBoolean("misc.disable-method-profiler", true); ++ disableOutOfOrderChat = getBoolean("misc.disable-out-of-order-chat", false); ++ setComment("misc", "Settings for things that don't belong elsewhere"); ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishLogger.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishLogger.java +new file mode 100644 +index 0000000000000000000000000000000000000000..53f2df00c6809618a9ee3d2ea72e85e8052fbcf1 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishLogger.java +@@ -0,0 +1,16 @@ ++package gg.pufferfish.pufferfish; ++ ++import java.util.logging.Level; ++import java.util.logging.Logger; ++import org.bukkit.Bukkit; ++ ++public class PufferfishLogger extends Logger { ++ public static final PufferfishLogger LOGGER = new PufferfishLogger(); ++ ++ private PufferfishLogger() { ++ super("Pufferfish", null); ++ ++ setParent(Bukkit.getLogger()); ++ setLevel(Level.ALL); ++ } ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishVersionFetcher.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishVersionFetcher.java +new file mode 100644 +index 0000000000000000000000000000000000000000..893d8c0946ef71a0561221dd76bffff0dc940d56 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishVersionFetcher.java +@@ -0,0 +1,136 @@ ++package gg.pufferfish.pufferfish; ++ ++import static net.kyori.adventure.text.Component.text; ++import static net.kyori.adventure.text.format.NamedTextColor.GREEN; ++import static net.kyori.adventure.text.format.NamedTextColor.RED; ++ ++import com.destroystokyo.paper.VersionHistoryManager; ++import com.destroystokyo.paper.util.VersionFetcher; ++import com.google.gson.Gson; ++import com.google.gson.JsonObject; ++import java.io.IOException; ++import java.net.URI; ++import java.net.http.HttpClient; ++import java.net.http.HttpRequest; ++import java.net.http.HttpResponse; ++import java.nio.charset.StandardCharsets; ++import java.util.concurrent.TimeUnit; ++import java.util.logging.Level; ++import java.util.logging.Logger; ++import net.kyori.adventure.text.Component; ++import net.kyori.adventure.text.JoinConfiguration; ++import net.kyori.adventure.text.format.NamedTextColor; ++import net.kyori.adventure.text.format.TextDecoration; ++import org.bukkit.craftbukkit.CraftServer; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++ ++public class PufferfishVersionFetcher implements VersionFetcher { ++ ++ private static final Logger LOGGER = Logger.getLogger("PufferfishVersionFetcher"); ++ private static final HttpClient client = HttpClient.newHttpClient(); ++ ++ private static final URI JENKINS_URI = URI.create("https://ci.pufferfish.host/job/Pufferfish-1.20/lastSuccessfulBuild/buildNumber"); ++ private static final String GITHUB_FORMAT = "https://api.github.com/repos/pufferfish-gg/Pufferfish/compare/ver/1.20...%s"; ++ ++ private static final HttpResponse.BodyHandler JSON_OBJECT_BODY_HANDLER = responseInfo -> HttpResponse.BodySubscribers ++ .mapping( ++ HttpResponse.BodySubscribers.ofString(StandardCharsets.UTF_8), ++ string -> new Gson().fromJson(string, JsonObject.class) ++ ); ++ ++ @Override ++ public long getCacheTime() { ++ return TimeUnit.MINUTES.toMillis(30); ++ } ++ ++ @Override ++ public @NotNull Component getVersionMessage(final @NotNull String serverVersion) { ++ final String[] parts = CraftServer.class.getPackage().getImplementationVersion().split("-"); ++ @NotNull Component component; ++ ++ if (parts.length != 3) { ++ component = text("Unknown server version.", RED); ++ } else { ++ final String versionString = parts[2]; ++ ++ try { ++ component = this.fetchJenkinsVersion(Integer.parseInt(versionString)); ++ } catch (NumberFormatException e) { ++ component = this.fetchGithubVersion(versionString.substring(1, versionString.length() - 1)); ++ } ++ } ++ ++ final @Nullable Component history = this.getHistory(); ++ return history != null ? Component ++ .join(JoinConfiguration.noSeparators(), component, Component.newline(), this.getHistory()) : component; ++ } ++ ++ private @NotNull Component fetchJenkinsVersion(final int versionNumber) { ++ final HttpRequest request = HttpRequest.newBuilder(JENKINS_URI).build(); ++ try { ++ final HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); ++ if (response.statusCode() != 200) { ++ return text("Received invalid status code (" + response.statusCode() + ") from server.", RED); ++ } ++ ++ int latestVersionNumber; ++ try { ++ latestVersionNumber = Integer.parseInt(response.body()); ++ } catch (NumberFormatException e) { ++ LOGGER.log(Level.WARNING, "Received invalid response from Jenkins \"" + response.body() + "\"."); ++ return text("Received invalid response from server.", RED); ++ } ++ ++ final int versionDiff = latestVersionNumber - versionNumber; ++ return this.getResponseMessage(versionDiff); ++ } catch (IOException | InterruptedException e) { ++ LOGGER.log(Level.WARNING, "Failed to look up version from Jenkins", e); ++ return text("Failed to retrieve version from server.", RED); ++ } ++ } ++ ++ // Based off code contributed by Techcable in Paper/GH-65 ++ private @NotNull Component fetchGithubVersion(final @NotNull String hash) { ++ final URI uri = URI.create(String.format(GITHUB_FORMAT, hash)); ++ final HttpRequest request = HttpRequest.newBuilder(uri).build(); ++ try { ++ final HttpResponse response = client.send(request, JSON_OBJECT_BODY_HANDLER); ++ if (response.statusCode() != 200) { ++ return text("Received invalid status code (" + response.statusCode() + ") from server.", RED); ++ } ++ ++ final JsonObject obj = response.body(); ++ final int versionDiff = obj.get("behind_by").getAsInt(); ++ ++ return this.getResponseMessage(versionDiff); ++ } catch (IOException | InterruptedException e) { ++ LOGGER.log(Level.WARNING, "Failed to look up version from GitHub", e); ++ return text("Failed to retrieve version from server.", RED); ++ } ++ } ++ ++ private @NotNull Component getResponseMessage(final int versionDiff) { ++ return switch (Math.max(-1, Math.min(1, versionDiff))) { ++ case -1 -> text("You are running an unsupported version of Pufferfish.", RED); ++ case 0 -> text("You are on the latest version!", GREEN); ++ default -> text("You are running " + versionDiff + " version" + (versionDiff == 1 ? "" : "s") + " beyond. " + ++ "Please update your server when possible to maintain stability, security, and receive the latest optimizations.", ++ RED); ++ }; ++ } ++ ++ private @Nullable Component getHistory() { ++ final VersionHistoryManager.VersionData data = VersionHistoryManager.INSTANCE.getVersionData(); ++ if (data == null) { ++ return null; ++ } ++ ++ final String oldVersion = data.getOldVersion(); ++ if (oldVersion == null) { ++ return null; ++ } ++ ++ return Component.text("Previous version: " + oldVersion, NamedTextColor.GRAY, TextDecoration.ITALIC); ++ } ++} +\ No newline at end of file +diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java +new file mode 100644 +index 0000000000000000000000000000000000000000..731ef11c7a025ae95ed8a757b530d834733d0621 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java +@@ -0,0 +1,135 @@ ++package gg.pufferfish.pufferfish.sentry; ++ ++import com.google.common.reflect.TypeToken; ++import com.google.gson.Gson; ++import io.sentry.Breadcrumb; ++import io.sentry.Sentry; ++import io.sentry.SentryEvent; ++import io.sentry.SentryLevel; ++import io.sentry.protocol.Message; ++import io.sentry.protocol.User; ++import java.util.Map; ++import org.apache.logging.log4j.Level; ++import org.apache.logging.log4j.LogManager; ++import org.apache.logging.log4j.Marker; ++import org.apache.logging.log4j.core.LogEvent; ++import org.apache.logging.log4j.core.Logger; ++import org.apache.logging.log4j.core.appender.AbstractAppender; ++import org.apache.logging.log4j.core.filter.AbstractFilter; ++ ++public class PufferfishSentryAppender extends AbstractAppender { ++ ++ private static final org.apache.logging.log4j.Logger logger = LogManager.getLogger(PufferfishSentryAppender.class); ++ private static final Gson GSON = new Gson(); ++ ++ public PufferfishSentryAppender() { ++ super("PufferfishSentryAdapter", new SentryFilter(), null); ++ } ++ ++ @Override ++ public void append(LogEvent logEvent) { ++ if (logEvent.getThrown() != null && logEvent.getLevel().isMoreSpecificThan(Level.WARN)) { ++ try { ++ logException(logEvent); ++ } catch (Exception e) { ++ logger.warn("Failed to log event with sentry", e); ++ } ++ } else { ++ try { ++ logBreadcrumb(logEvent); ++ } catch (Exception e) { ++ logger.warn("Failed to log event with sentry", e); ++ } ++ } ++ } ++ ++ private void logException(LogEvent e) { ++ SentryEvent event = new SentryEvent(e.getThrown()); ++ ++ Message sentryMessage = new Message(); ++ sentryMessage.setMessage(e.getMessage().getFormattedMessage()); ++ ++ event.setThrowable(e.getThrown()); ++ event.setLevel(getLevel(e.getLevel())); ++ event.setLogger(e.getLoggerName()); ++ event.setTransaction(e.getLoggerName()); ++ event.setExtra("thread_name", e.getThreadName()); ++ ++ boolean hasContext = e.getContextData() != null; ++ ++ if (hasContext && e.getContextData().containsKey("pufferfishsentry_playerid")) { ++ User user = new User(); ++ user.setId(e.getContextData().getValue("pufferfishsentry_playerid")); ++ user.setUsername(e.getContextData().getValue("pufferfishsentry_playername")); ++ event.setUser(user); ++ } ++ ++ if (hasContext && e.getContextData().containsKey("pufferfishsentry_pluginname")) { ++ event.setExtra("plugin.name", e.getContextData().getValue("pufferfishsentry_pluginname")); ++ event.setExtra("plugin.version", e.getContextData().getValue("pufferfishsentry_pluginversion")); ++ event.setTransaction(e.getContextData().getValue("pufferfishsentry_pluginname")); ++ } ++ ++ if (hasContext && e.getContextData().containsKey("pufferfishsentry_eventdata")) { ++ Map eventFields = GSON.fromJson((String) e.getContextData().getValue("pufferfishsentry_eventdata"), new TypeToken>() {}.getType()); ++ if (eventFields != null) { ++ event.setExtra("event", eventFields); ++ } ++ } ++ ++ Sentry.captureEvent(event); ++ } ++ ++ private void logBreadcrumb(LogEvent e) { ++ Breadcrumb breadcrumb = new Breadcrumb(); ++ ++ breadcrumb.setLevel(getLevel(e.getLevel())); ++ breadcrumb.setCategory(e.getLoggerName()); ++ breadcrumb.setType(e.getLoggerName()); ++ breadcrumb.setMessage(e.getMessage().getFormattedMessage()); ++ ++ Sentry.addBreadcrumb(breadcrumb); ++ } ++ ++ private SentryLevel getLevel(Level level) { ++ switch (level.getStandardLevel()) { ++ case TRACE: ++ case DEBUG: ++ return SentryLevel.DEBUG; ++ case WARN: ++ return SentryLevel.WARNING; ++ case ERROR: ++ return SentryLevel.ERROR; ++ case FATAL: ++ return SentryLevel.FATAL; ++ case INFO: ++ default: ++ return SentryLevel.INFO; ++ } ++ } ++ ++ private static class SentryFilter extends AbstractFilter { ++ ++ @Override ++ public Result filter(Logger logger, org.apache.logging.log4j.Level level, Marker marker, String msg, ++ Object... params) { ++ return this.filter(logger.getName()); ++ } ++ ++ @Override ++ public Result filter(Logger logger, org.apache.logging.log4j.Level level, Marker marker, Object msg, Throwable t) { ++ return this.filter(logger.getName()); ++ } ++ ++ @Override ++ public Result filter(LogEvent event) { ++ return this.filter(event == null ? null : event.getLoggerName()); ++ } ++ ++ private Result filter(String loggerName) { ++ return loggerName != null && loggerName.startsWith("gg.castaway.pufferfish.sentry") ? Result.DENY ++ : Result.NEUTRAL; ++ } ++ ++ } ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java +new file mode 100644 +index 0000000000000000000000000000000000000000..1b29210ad0bbb4ada150f23357f0c80d331c996d +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java +@@ -0,0 +1,40 @@ ++package gg.pufferfish.pufferfish.sentry; ++ ++import gg.pufferfish.pufferfish.PufferfishConfig; ++import io.sentry.Sentry; ++import org.apache.logging.log4j.LogManager; ++import org.apache.logging.log4j.Logger; ++ ++public class SentryManager { ++ ++ private static final Logger logger = LogManager.getLogger(SentryManager.class); ++ ++ private SentryManager() { ++ ++ } ++ ++ private static boolean initialized = false; ++ ++ public static synchronized void init() { ++ if (initialized) { ++ return; ++ } ++ try { ++ initialized = true; ++ ++ Sentry.init(options -> { ++ options.setDsn(PufferfishConfig.sentryDsn); ++ options.setMaxBreadcrumbs(100); ++ }); ++ ++ PufferfishSentryAppender appender = new PufferfishSentryAppender(); ++ appender.start(); ++ ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).addAppender(appender); ++ logger.info("Sentry logging started!"); ++ } catch (Exception e) { ++ logger.warn("Failed to initialize sentry!", e); ++ initialized = false; ++ } ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/util/AsyncExecutor.java b/src/main/java/gg/pufferfish/pufferfish/util/AsyncExecutor.java +new file mode 100644 +index 0000000000000000000000000000000000000000..8e5323d5d9af25c8a85c4b34a6be76cfc54384cf +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/util/AsyncExecutor.java +@@ -0,0 +1,73 @@ ++package gg.pufferfish.pufferfish.util; ++ ++import com.google.common.collect.Queues; ++import gg.pufferfish.pufferfish.PufferfishLogger; ++import java.util.Queue; ++import java.util.concurrent.locks.Condition; ++import java.util.concurrent.locks.Lock; ++import java.util.concurrent.locks.ReentrantLock; ++import java.util.logging.Level; ++ ++public class AsyncExecutor implements Runnable { ++ ++ private final Queue jobs = Queues.newArrayDeque(); ++ private final Lock mutex = new ReentrantLock(); ++ private final Condition cond = mutex.newCondition(); ++ private final Thread thread; ++ private volatile boolean killswitch = false; ++ ++ public AsyncExecutor(String threadName) { ++ this.thread = new Thread(this, threadName); ++ } ++ ++ public void start() { ++ thread.start(); ++ } ++ ++ public void kill() { ++ killswitch = true; ++ cond.signalAll(); ++ } ++ ++ public void submit(Runnable runnable) { ++ mutex.lock(); ++ try { ++ jobs.offer(runnable); ++ cond.signalAll(); ++ } finally { ++ mutex.unlock(); ++ } ++ } ++ ++ @Override ++ public void run() { ++ while (!killswitch) { ++ try { ++ Runnable runnable = takeRunnable(); ++ if (runnable != null) { ++ runnable.run(); ++ } ++ } catch (InterruptedException e) { ++ Thread.currentThread().interrupt(); ++ } catch (Exception e) { ++ PufferfishLogger.LOGGER.log(Level.SEVERE, e, () -> "Failed to execute async job for thread " + thread.getName()); ++ } ++ } ++ } ++ ++ private Runnable takeRunnable() throws InterruptedException { ++ mutex.lock(); ++ try { ++ while (jobs.isEmpty() && !killswitch) { ++ cond.await(); ++ } ++ ++ if (jobs.isEmpty()) return null; // We've set killswitch ++ ++ return jobs.remove(); ++ } finally { ++ mutex.unlock(); ++ } ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java b/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java +new file mode 100644 +index 0000000000000000000000000000000000000000..fdcb62d12164024a5f354d60cc863821a18d1b2a +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java +@@ -0,0 +1,31 @@ ++package gg.pufferfish.pufferfish.util; ++ ++import com.destroystokyo.paper.util.misc.PlayerAreaMap; ++import com.destroystokyo.paper.util.misc.PooledLinkedHashSets; ++import java.util.concurrent.ConcurrentHashMap; ++import net.minecraft.server.level.ServerPlayer; ++ ++public final class AsyncPlayerAreaMap extends PlayerAreaMap { ++ ++ public AsyncPlayerAreaMap() { ++ super(); ++ this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f)); ++ } ++ ++ public AsyncPlayerAreaMap(final PooledLinkedHashSets pooledHashSets) { ++ super(pooledHashSets); ++ this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f)); ++ } ++ ++ public AsyncPlayerAreaMap(final PooledLinkedHashSets pooledHashSets, final ChangeCallback addCallback, ++ final ChangeCallback removeCallback) { ++ this(pooledHashSets, addCallback, removeCallback, null); ++ } ++ ++ public AsyncPlayerAreaMap(final PooledLinkedHashSets pooledHashSets, final ChangeCallback addCallback, ++ final ChangeCallback removeCallback, final ChangeSourceCallback changeSourceCallback) { ++ super(pooledHashSets, addCallback, removeCallback, changeSourceCallback); ++ this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f)); ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/util/IterableWrapper.java b/src/main/java/gg/pufferfish/pufferfish/util/IterableWrapper.java +new file mode 100644 +index 0000000000000000000000000000000000000000..c1929840254a3e6d721816f4a20415bea1742580 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/util/IterableWrapper.java +@@ -0,0 +1,20 @@ ++package gg.pufferfish.pufferfish.util; ++ ++import java.util.Iterator; ++import org.jetbrains.annotations.NotNull; ++ ++public class IterableWrapper implements Iterable { ++ ++ private final Iterator iterator; ++ ++ public IterableWrapper(Iterator iterator) { ++ this.iterator = iterator; ++ } ++ ++ @NotNull ++ @Override ++ public Iterator iterator() { ++ return iterator; ++ } ++ ++} +diff --git a/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java b/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java +new file mode 100644 +index 0000000000000000000000000000000000000000..facd55463d44cb7e3d2ca6892982f5497b8dded1 +--- /dev/null ++++ b/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java +@@ -0,0 +1,40 @@ ++package gg.pufferfish.pufferfish.util; ++ ++import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap; ++import java.util.Map; ++import org.jetbrains.annotations.Nullable; ++ ++public class Long2ObjectOpenHashMapWrapper extends Long2ObjectOpenHashMap { ++ ++ private final Map backingMap; ++ ++ public Long2ObjectOpenHashMapWrapper(Map map) { ++ backingMap = map; ++ } ++ ++ @Override ++ public V put(Long key, V value) { ++ return backingMap.put(key, value); ++ } ++ ++ @Override ++ public V get(Object key) { ++ return backingMap.get(key); ++ } ++ ++ @Override ++ public V remove(Object key) { ++ return backingMap.remove(key); ++ } ++ ++ @Nullable ++ @Override ++ public V putIfAbsent(Long key, V value) { ++ return backingMap.putIfAbsent(key, value); ++ } ++ ++ @Override ++ public int size() { ++ return backingMap.size(); ++ } ++} +diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java +index 2d11a67bdc82088abf0b3ca134f352f155c8eb1f..8bd24c8eef3169a765d42a676903446011a15be8 100644 +--- a/src/main/java/io/papermc/paper/util/MCUtil.java ++++ b/src/main/java/io/papermc/paper/util/MCUtil.java +@@ -210,7 +210,7 @@ public final class MCUtil { + } + + public static long getCoordinateKey(final Entity entity) { +- return ((long)(MCUtil.fastFloor(entity.getZ()) >> 4) << 32) | ((MCUtil.fastFloor(entity.getX()) >> 4) & 0xFFFFFFFFL); ++ return ((long)(entity.blockPosition.getZ() >> 4) << 32) | ((entity.blockPosition.getX() >> 4) & 0xFFFFFFFFL); // Pufferfish - eliminate double->long cast in hotpath + } + + public static long getCoordinateKey(final ChunkPos pair) { +diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java +index 80cf4852e4010eeeadaf920ab927a40df0179b40..55d5e325006d5a948b98451b1e455bb8bb869cbb 100644 +--- a/src/main/java/net/minecraft/server/MinecraftServer.java ++++ b/src/main/java/net/minecraft/server/MinecraftServer.java +@@ -311,6 +311,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop S spin(Function serverFactory) { + AtomicReference atomicreference = new AtomicReference(); +@@ -1679,7 +1681,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop // Spigot - Spigot > // CraftBukkit - cb > vanilla! ++ return "Pufferfish"; // Pufferfish - Pufferfish > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla! + } + + public SystemReport fillSystemReport(SystemReport details) { +@@ -2258,6 +2260,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop passengers = parent.getPassengers(); ++ ++ for (int i = 0, size = passengers.size(); i < size; i++) { ++ Entity entity = passengers.get(i); ++ int range = entity.getType().clientTrackingRange() * 16; ++ range = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, range); // Paper ++ ++ if (range > highest) { // Paper - we need the lowest range thanks to the fact that our tracker doesn't account for passenger logic // Tuinity - not anymore! ++ highest = range; ++ } ++ ++ highest = getHighestRange(entity, highest); ++ } ++ ++ return highest; ++ } ++ + private int getEffectiveRange() { + int i = this.range; ++ // Pufferfish start - remove iterators and streams ++ /* + Iterator iterator = this.entity.getIndirectPassengers().iterator(); + + while (iterator.hasNext()) { +@@ -1569,6 +1589,9 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + i = j; + } + } ++ */ ++ i = getHighestRange(this.entity, i); ++ // Pufferfish end + + return this.scaledRange(i); + } +diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +index 488a253e218409b5f0b4a872cee0928578fa7582..6e3b2863f04419ee6914ac3fd4f12a4fe78d16b7 100644 +--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java ++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +@@ -76,6 +76,9 @@ public class ServerChunkCache extends ChunkSource { + final it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap loadedChunkMap = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(8192, 0.5f); + + private final LevelChunk[] lastLoadedChunks = new LevelChunk[4 * 4]; ++ ++ public boolean firstRunSpawnCounts = true; // Pufferfish ++ public final java.util.concurrent.atomic.AtomicBoolean _pufferfish_spawnCountsReady = new java.util.concurrent.atomic.AtomicBoolean(false); // Pufferfish - optimize countmobs + + private static int getChunkCacheKey(int x, int z) { + return x & 3 | ((z & 3) << 2); +@@ -553,6 +556,7 @@ public class ServerChunkCache extends ChunkSource { + ProfilerFiller gameprofilerfiller = this.level.getProfiler(); + + gameprofilerfiller.push("pollingChunks"); ++ this.level.resetIceAndSnowTick(); // Pufferfish - reset ice & snow tick random + int k = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING); + boolean flag1 = level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && worlddata.getGameTime() % level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit + +@@ -562,18 +566,25 @@ public class ServerChunkCache extends ChunkSource { + // Paper start - per player mob spawning + NaturalSpawner.SpawnState spawnercreature_d; // moved down + if ((this.spawnFriendlies || this.spawnEnemies) && this.chunkMap.playerMobDistanceMap != null) { // don't count mobs when animals and monsters are disabled +- // re-set mob counts +- for (ServerPlayer player : this.level.players) { +- Arrays.fill(player.mobCounts, 0); ++ // Pufferfish start - moved down when async processing ++ if (!gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncMobSpawning) { ++ // re-set mob counts ++ for (ServerPlayer player : this.level.players) { ++ Arrays.fill(player.mobCounts, 0); ++ } ++ lastSpawnState = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, null, true); + } +- spawnercreature_d = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, null, true); ++ // Pufferfish end + } else { +- spawnercreature_d = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, this.chunkMap.playerMobDistanceMap == null ? new LocalMobCapCalculator(this.chunkMap) : null, false); ++ // Pufferfish start - this is only implemented for per-player mob spawning so this makes everything work if this setting is disabled. ++ lastSpawnState = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, this.chunkMap.playerMobDistanceMap == null ? new LocalMobCapCalculator(this.chunkMap) : null, false); ++ _pufferfish_spawnCountsReady.set(true); ++ // Pufferfish end + } + // Paper end + this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings + +- this.lastSpawnState = spawnercreature_d; ++ //this.lastSpawnState = spawnercreature_d; // Pufferfish - this is managed asynchronously + gameprofilerfiller.popPush("filteringLoadedChunks"); + // Paper - moved down + this.level.timings.chunkTicks.startTiming(); // Paper +@@ -612,8 +623,8 @@ public class ServerChunkCache extends ChunkSource { + + if ((true || this.level.isNaturalSpawningAllowed(chunkcoordintpair)) && this.chunkMap.anyPlayerCloseEnoughForSpawning(holder, chunkcoordintpair, false)) { // Paper - optimise anyPlayerCloseEnoughForSpawning // Paper - the chunk is known ticking + chunk1.incrementInhabitedTime(j); +- if (flag2 && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair) && this.chunkMap.anyPlayerCloseEnoughForSpawning(holder, chunkcoordintpair, true)) { // Spigot // Paper - optimise anyPlayerCloseEnoughForSpawning & optimise chunk tick iteration +- NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1); ++ if (flag2 && (!gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncMobSpawning || _pufferfish_spawnCountsReady.get()) && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair) && this.chunkMap.anyPlayerCloseEnoughForSpawning(holder, chunkcoordintpair, true)) { // Spigot // Paper - optimise anyPlayerCloseEnoughForSpawning & optimise chunk tick iteration ++ NaturalSpawner.spawnForChunk(this.level, chunk1, lastSpawnState, this.spawnFriendlies, this.spawnEnemies, flag1); // Pufferfish + } + + if (true || this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) { // Paper - the chunk is known ticking +@@ -675,6 +686,30 @@ public class ServerChunkCache extends ChunkSource { + } + // Paper end - controlled flush for entity tracker packets + } ++ ++ // Pufferfish start - optimize mob spawning ++ if (gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncMobSpawning) { ++ for (ServerPlayer player : this.level.players) { ++ Arrays.fill(player.mobCounts, 0); ++ } ++ if (firstRunSpawnCounts) { ++ firstRunSpawnCounts = false; ++ _pufferfish_spawnCountsReady.set(true); ++ } ++ if (chunkMap.playerMobDistanceMap != null && _pufferfish_spawnCountsReady.getAndSet(false)) { ++ net.minecraft.server.MinecraftServer.getServer().mobSpawnExecutor.submit(() -> { ++ int mapped = distanceManager.getNaturalSpawnChunkCount(); ++ io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.Iterator objectiterator = ++ level.entityTickList.entities.iterator(io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.ITERATOR_FLAG_SEE_ADDITIONS); ++ gg.pufferfish.pufferfish.util.IterableWrapper wrappedIterator = ++ new gg.pufferfish.pufferfish.util.IterableWrapper<>(objectiterator); ++ lastSpawnState = NaturalSpawner.createState(mapped, wrappedIterator, this::getFullChunk, null, true); ++ objectiterator.finishedIterating(); ++ _pufferfish_spawnCountsReady.set(true); ++ }); ++ } ++ } ++ // Pufferfish end + } + + private void getFullChunk(long pos, Consumer chunkConsumer) { +diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java +index 6670e657e08e130f7e0368f418379fd1ece00cdf..e921b6db8905a8676a45e36564d877075afb081f 100644 +--- a/src/main/java/net/minecraft/server/level/ServerEntity.java ++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java +@@ -180,7 +180,8 @@ public class ServerEntity { + long i1 = this.positionCodec.encodeZ(vec3d); + boolean flag6 = k < -32768L || k > 32767L || l < -32768L || l > 32767L || i1 < -32768L || i1 > 32767L; + +- if (!flag6 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.onGround()&& !(io.papermc.paper.configuration.GlobalConfiguration.get().collisions.sendFullPosForHardCollidingEntities && this.entity.hardCollides())) { // Paper - send full pos for hard colliding entities to prevent collision problems due to desync ++ if (!flag6 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.onGround() && !(io.papermc.paper.configuration.GlobalConfiguration.get().collisions.sendFullPosForHardCollidingEntities && this.entity.hardCollides())) { // Paper - send full pos for hard colliding entities to prevent collision problems due to desync ++ if (flag2 || flag3 || this.entity instanceof AbstractArrow) { // Pufferfish + if ((!flag2 || !flag3) && !(this.entity instanceof AbstractArrow)) { + if (flag2) { + packet1 = new ClientboundMoveEntityPacket.Pos(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), this.entity.onGround()); +@@ -194,6 +195,7 @@ public class ServerEntity { + flag4 = true; + flag5 = true; + } ++ } // Pufferfish + } else { + this.wasOnGround = this.entity.onGround(); + this.teleportDelay = 0; +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index 18aac3da3c88f33b1a71a5920a8daa27e9723913..eac31c3fcc9161711328588ac852fcae1116d8ef 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -850,6 +850,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + org.spigotmc.ActivationRange.activateEntities(this); // Spigot + timings.entityTick.startTiming(); // Spigot + this.entityTickList.forEach((entity) -> { ++ entity.activatedPriorityReset = false; // Pufferfish - DAB + if (!entity.isRemoved()) { + if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed + entity.discard(); +@@ -869,7 +870,20 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + + gameprofilerfiller.push("tick"); +- this.guardEntityTick(this::tickNonPassenger, entity); ++ // Pufferfish start - copied from this.guardEntityTick ++ try { ++ this.tickNonPassenger(entity); // Pufferfish - changed ++ MinecraftServer.getServer().executeMidTickTasks(); // Tuinity - execute chunk tasks mid tick ++ } catch (Throwable throwable) { ++ if (throwable instanceof ThreadDeath) throw throwable; // Paper ++ // Paper start - Prevent tile entity and entity crashes ++ final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level().getWorld().getName(), entity.getX(), entity.getY(), entity.getZ()); ++ MinecraftServer.LOGGER.error(msg, throwable); ++ getCraftServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerInternalException(msg, throwable))); ++ entity.discard(); ++ // Paper end ++ } ++ // Pufferfish end + gameprofilerfiller.pop(); + } + } +@@ -934,9 +948,11 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + // Paper start - optimise random block ticking + private final BlockPos.MutableBlockPos chunkTickMutablePosition = new BlockPos.MutableBlockPos(); +- private final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(this.random.nextLong()); ++ // private final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(); // Pufferfish - moved to super + // Paper end + ++ private int currentIceAndSnowTick = 0; protected void resetIceAndSnowTick() { this.currentIceAndSnowTick = this.randomTickRandom.nextInt(16); } // Pufferfish ++ + public void tickChunk(LevelChunk chunk, int randomTickSpeed) { + ChunkPos chunkcoordintpair = chunk.getPos(); + boolean flag = this.isRaining(); +@@ -947,7 +963,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + gameprofilerfiller.push("thunder"); + final BlockPos.MutableBlockPos blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change + +- if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder ++ if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && /*this.random.nextInt(this.spigotConfig.thunderChance) == 0 &&*/ chunk.shouldDoLightning(this.random)) { // Spigot // Paper - disable thunder // Pufferfish - replace random with shouldDoLightning + blockposition.set(this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15))); // Paper + if (this.isRainingAt(blockposition)) { + DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition); +@@ -978,7 +994,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + int l; + int i1; + +- if (!this.paperConfig().environment.disableIceAndSnow && this.random.nextInt(16) == 0) { // Paper - Disable ice and snow ++ if (!this.paperConfig().environment.disableIceAndSnow && (this.currentIceAndSnowTick++ & 15) == 0) { // Paper - Disable ice and snow // Paper - optimise random ticking // Pufferfish - optimize further random ticking + // Paper start - optimise chunk ticking + this.getRandomBlockPosition(j, 0, k, 15, blockposition); + int normalY = chunk.getHeight(Heightmap.Types.MOTION_BLOCKING, blockposition.getX() & 15, blockposition.getZ() & 15) + 1; +diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +index d9c2d06ae24dcf80a497e75f4c7f63d401b77f9b..29dbd3a902c2d620b9da191d0bcd9f6e9108034a 100644 +--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java ++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +@@ -1219,6 +1219,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic + + @Override + public void handleEditBook(ServerboundEditBookPacket packet) { ++ if (!gg.pufferfish.pufferfish.PufferfishConfig.enableBooks && !this.player.getBukkitEntity().hasPermission("pufferfish.usebooks")) return; // Pufferfish + // Paper start + if (!this.cserver.isPrimaryThread()) { + List pageList = packet.getPages(); +@@ -2364,6 +2365,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic + } + + private boolean updateChatOrder(Instant timestamp) { ++ if (gg.pufferfish.pufferfish.PufferfishConfig.disableOutOfOrderChat) return true; + Instant instant1; + + do { +diff --git a/src/main/java/net/minecraft/world/CompoundContainer.java b/src/main/java/net/minecraft/world/CompoundContainer.java +index 241fec02e6869c638d3a160819b32173a081467b..6a8f9e8f5bf108674c47018def28906e2d0a729c 100644 +--- a/src/main/java/net/minecraft/world/CompoundContainer.java ++++ b/src/main/java/net/minecraft/world/CompoundContainer.java +@@ -1,5 +1,6 @@ + package net.minecraft.world; + ++import net.minecraft.core.Direction; // Pufferfish + import net.minecraft.world.entity.player.Player; + import net.minecraft.world.item.ItemStack; + +@@ -64,6 +65,23 @@ public class CompoundContainer implements Container { + this.container2 = second; + } + ++ // Pufferfish start ++ @Override ++ public boolean hasEmptySlot(Direction enumdirection) { ++ return this.container1.hasEmptySlot(null) || this.container2.hasEmptySlot(null); ++ } ++ ++ @Override ++ public boolean isCompletelyFull(Direction enumdirection) { ++ return this.container1.isCompletelyFull(null) && this.container2.isCompletelyFull(null); ++ } ++ ++ @Override ++ public boolean isCompletelyEmpty(Direction enumdirection) { ++ return this.container1.isCompletelyEmpty(null) && this.container2.isCompletelyEmpty(null); ++ } ++ // Pufferfish end ++ + @Override + public int getContainerSize() { + return this.container1.getContainerSize() + this.container2.getContainerSize(); +diff --git a/src/main/java/net/minecraft/world/Container.java b/src/main/java/net/minecraft/world/Container.java +index 04b1531572e8fff1e46fe1c94e7fc863841e0f66..47ddc42f2b63d9d3fae5ae6ea93d418352d76c94 100644 +--- a/src/main/java/net/minecraft/world/Container.java ++++ b/src/main/java/net/minecraft/world/Container.java +@@ -3,6 +3,8 @@ package net.minecraft.world; + import java.util.Set; + import java.util.function.Predicate; + import net.minecraft.core.BlockPos; ++ ++import net.minecraft.core.Direction; // Pufferfish + import net.minecraft.world.entity.player.Player; + import net.minecraft.world.item.Item; + import net.minecraft.world.item.ItemStack; +@@ -13,6 +15,63 @@ import org.bukkit.craftbukkit.entity.CraftHumanEntity; + // CraftBukkit end + + public interface Container extends Clearable { ++ // Pufferfish start - allow the inventory to override and optimize these frequent calls ++ default boolean hasEmptySlot(@org.jetbrains.annotations.Nullable Direction enumdirection) { // there is a slot with 0 items in it ++ if (this instanceof WorldlyContainer worldlyContainer) { ++ for (int i : worldlyContainer.getSlotsForFace(enumdirection)) { ++ if (this.getItem(i).isEmpty()) { ++ return true; ++ } ++ } ++ } else { ++ int size = this.getContainerSize(); ++ for (int i = 0; i < size; i++) { ++ if (this.getItem(i).isEmpty()) { ++ return true; ++ } ++ } ++ } ++ return false; ++ } ++ ++ default boolean isCompletelyFull(@org.jetbrains.annotations.Nullable Direction enumdirection) { // every stack is maxed ++ if (this instanceof WorldlyContainer worldlyContainer) { ++ for (int i : worldlyContainer.getSlotsForFace(enumdirection)) { ++ ItemStack itemStack = this.getItem(i); ++ if (itemStack.getCount() < itemStack.getMaxStackSize()) { ++ return false; ++ } ++ } ++ } else { ++ int size = this.getContainerSize(); ++ for (int i = 0; i < size; i++) { ++ ItemStack itemStack = this.getItem(i); ++ if (itemStack.getCount() < itemStack.getMaxStackSize()) { ++ return false; ++ } ++ } ++ } ++ return true; ++ } ++ ++ default boolean isCompletelyEmpty(@org.jetbrains.annotations.Nullable Direction enumdirection) { ++ if (this instanceof WorldlyContainer worldlyContainer) { ++ for (int i : worldlyContainer.getSlotsForFace(enumdirection)) { ++ if (!this.getItem(i).isEmpty()) { ++ return false; ++ } ++ } ++ } else { ++ int size = this.getContainerSize(); ++ for (int i = 0; i < size; i++) { ++ if (!this.getItem(i).isEmpty()) { ++ return false; ++ } ++ } ++ } ++ return true; ++ } ++ // Pufferfish end + + int LARGE_MAX_STACK_SIZE = 64; + int DEFAULT_DISTANCE_LIMIT = 8; +diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java +index b38c4cbcf0405d82c7b6e018e80a3174e460c1a4..53fec4d15ac3d21e5f82c76133ee8dc449d1e67a 100644 +--- a/src/main/java/net/minecraft/world/entity/Entity.java ++++ b/src/main/java/net/minecraft/world/entity/Entity.java +@@ -294,7 +294,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + public double yo; + public double zo; + private Vec3 position; +- private BlockPos blockPosition; ++ public BlockPos blockPosition; // Pufferfish - private->public + private ChunkPos chunkPosition; + private Vec3 deltaMovement; + private float yRot; +@@ -421,6 +421,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + return this.originWorld; + } + // Paper end ++ // Pufferfish start ++ public boolean activatedPriorityReset = false; // DAB ++ public int activatedPriority = gg.pufferfish.pufferfish.PufferfishConfig.maximumActivationPrio; // golf score ++ public final BlockPos.MutableBlockPos cachedBlockPos = new BlockPos.MutableBlockPos(); // used where needed ++ // Pufferfish end ++ + public float getBukkitYaw() { + return this.yRot; + } +@@ -495,17 +501,36 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + this.isLegacyTrackingEntity = isLegacyTrackingEntity; + } + ++ private org.spigotmc.TrackingRange.TrackingRangeType getFurthestEntity(Entity entity, net.minecraft.server.level.ChunkMap chunkMap, org.spigotmc.TrackingRange.TrackingRangeType type, int range) { ++ List passengers = entity.getPassengers(); ++ for (int i = 0, size = passengers.size(); i < size; i++) { ++ Entity passenger = passengers.get(i); ++ org.spigotmc.TrackingRange.TrackingRangeType passengerType = passenger.trackingRangeType; ++ int passengerRange = chunkMap.getEntityTrackerRange(passengerType.ordinal()); ++ if (passengerRange > range) { ++ type = passengerType; ++ range = passengerRange; ++ } ++ ++ type = this.getFurthestEntity(passenger, chunkMap, type, range); ++ } ++ ++ return type; ++ } ++ + public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet getPlayersInTrackRange() { + // determine highest range of passengers + if (this.passengers.isEmpty()) { + return ((ServerLevel)this.level).getChunkSource().chunkMap.playerEntityTrackerTrackMaps[this.trackingRangeType.ordinal()] + .getObjectsInRange(MCUtil.getCoordinateKey(this)); + } +- Iterable passengers = this.getIndirectPassengers(); ++ //Iterable passengers = this.getIndirectPassengers(); // Pufferfish + net.minecraft.server.level.ChunkMap chunkMap = ((ServerLevel)this.level).getChunkSource().chunkMap; + org.spigotmc.TrackingRange.TrackingRangeType type = this.trackingRangeType; + int range = chunkMap.getEntityTrackerRange(type.ordinal()); + ++ // Pufferfish start - use getFurthestEntity to skip getIndirectPassengers ++ /* + for (Entity passenger : passengers) { + org.spigotmc.TrackingRange.TrackingRangeType passengerType = passenger.trackingRangeType; + int passengerRange = chunkMap.getEntityTrackerRange(passengerType.ordinal()); +@@ -514,6 +539,9 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + range = passengerRange; + } + } ++ */ ++ type = this.getFurthestEntity(this, chunkMap, type, range); ++ // Pufferfish end + + return chunkMap.playerEntityTrackerTrackMaps[type.ordinal()].getObjectsInRange(MCUtil.getCoordinateKey(this)); + } +@@ -797,6 +825,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + // CraftBukkit end + + public void baseTick() { ++ // Pufferfish start - entity TTL ++ if (type != EntityType.PLAYER && type.ttl >= 0 && this.tickCount >= type.ttl) { ++ remove(RemovalReason.DISCARDED); ++ return; ++ } ++ // Pufferfish end - entity TTL + this.level().getProfiler().push("entityBaseTick"); + if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking + this.feetBlockState = null; +@@ -4293,16 +4327,18 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + + public boolean updateFluidHeightAndDoFluidPushing(TagKey tag, double speed) { +- if (this.touchingUnloadedChunk()) { ++ if (false && this.touchingUnloadedChunk()) { // Pufferfish - cost of a lookup here is the same cost as below, so skip + return false; + } else { + AABB axisalignedbb = this.getBoundingBox().deflate(0.001D); +- int i = Mth.floor(axisalignedbb.minX); +- int j = Mth.ceil(axisalignedbb.maxX); +- int k = Mth.floor(axisalignedbb.minY); +- int l = Mth.ceil(axisalignedbb.maxY); +- int i1 = Mth.floor(axisalignedbb.minZ); +- int j1 = Mth.ceil(axisalignedbb.maxZ); ++ // Pufferfish start - rename ++ int minBlockX = Mth.floor(axisalignedbb.minX); ++ int maxBlockX = Mth.ceil(axisalignedbb.maxX); ++ int minBlockY = Mth.floor(axisalignedbb.minY); ++ int maxBlockY = Mth.ceil(axisalignedbb.maxY); ++ int minBlockZ = Mth.floor(axisalignedbb.minZ); ++ int maxBlockZ = Mth.ceil(axisalignedbb.maxZ); ++ // Pufferfish end + double d1 = 0.0D; + boolean flag = this.isPushedByFluid(); + boolean flag1 = false; +@@ -4310,14 +4346,61 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + int k1 = 0; + BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos(); + +- for (int l1 = i; l1 < j; ++l1) { +- for (int i2 = k; i2 < l; ++i2) { +- for (int j2 = i1; j2 < j1; ++j2) { +- blockposition_mutableblockposition.set(l1, i2, j2); +- FluidState fluid = this.level().getFluidState(blockposition_mutableblockposition); ++ // Pufferfish start - based off CollisionUtil.getCollisionsForBlocksOrWorldBorder ++ final int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this.level()); ++ final int maxSection = io.papermc.paper.util.WorldUtil.getMaxSection(this.level()); ++ final int minBlock = minSection << 4; ++ final int maxBlock = (maxSection << 4) | 15; ++ ++ // special cases: ++ if (minBlockY > maxBlock || maxBlockY < minBlock) { ++ // no point in checking ++ return false; ++ } ++ ++ int minYIterate = Math.max(minBlock, minBlockY); ++ int maxYIterate = Math.min(maxBlock, maxBlockY); ++ ++ int minChunkX = minBlockX >> 4; ++ int maxChunkX = maxBlockX >> 4; ++ ++ int minChunkZ = minBlockZ >> 4; ++ int maxChunkZ = maxBlockZ >> 4; ++ ++ for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) { ++ int minZ = currChunkZ == minChunkZ ? minBlockZ & 15 : 0; // coordinate in chunk ++ int maxZ = currChunkZ == maxChunkZ ? maxBlockZ & 15 : 16; // coordinate in chunk ++ ++ for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) { ++ int minX = currChunkX == minChunkX ? minBlockX & 15 : 0; // coordinate in chunk ++ int maxX = currChunkX == maxChunkX ? maxBlockX & 15 : 16; // coordinate in chunk ++ ++ net.minecraft.world.level.chunk.ChunkAccess chunk = this.level().getChunkIfLoadedImmediately(currChunkX, currChunkZ); ++ if (chunk == null) { ++ return false; // if we're touching an unloaded chunk then it's false ++ } ++ ++ net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunk.getSections(); ++ ++ for (int currY = minYIterate; currY < maxYIterate; ++currY) { ++ net.minecraft.world.level.chunk.LevelChunkSection section = sections[(currY >> 4) - minSection]; ++ ++ if (section == null || section.hasOnlyAir() || section.fluidStateCount == 0) { // if no fluids, nothing in this section ++ // empty ++ // skip to next section ++ currY = (currY & ~(15)) + 15; // increment by 15: iterator loop increments by the extra one ++ continue; ++ } ++ ++ net.minecraft.world.level.chunk.PalettedContainer blocks = section.states; ++ ++ for (int currZ = minZ; currZ < maxZ; ++currZ) { ++ for (int currX = minX; currX < maxX; ++currX) { ++ FluidState fluid = blocks.get(currX & 15, currY & 15, currZ & 15).getFluidState(); + + if (fluid.is(tag)) { +- double d2 = (double) ((float) i2 + fluid.getHeight(this.level(), blockposition_mutableblockposition)); ++ blockposition_mutableblockposition.set((currChunkX << 4) + currX, currY, (currChunkZ << 4) + currZ); ++ double d2 = (double) ((float) currY + fluid.getHeight(this.level(), blockposition_mutableblockposition)); + + if (d2 >= axisalignedbb.minY) { + flag1 = true; +@@ -4339,9 +4422,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + // CraftBukkit end + } + } ++ } ++ } + } + } + } ++ // Pufferfish end + + if (vec3d.length() > 0.0D) { + if (k1 > 0) { +diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java +index 9afc81ccb237c3655d64cdbe8a0db9a4d7791043..aa5cec6d56d7a8e80861aa4c9b4a74ca3e64be8c 100644 +--- a/src/main/java/net/minecraft/world/entity/EntityType.java ++++ b/src/main/java/net/minecraft/world/entity/EntityType.java +@@ -300,6 +300,8 @@ public class EntityType implements FeatureElement, EntityTypeT + private final boolean canSpawnFarFromPlayer; + private final int clientTrackingRange; + private final int updateInterval; ++ public boolean dabEnabled = false; // Pufferfish ++ public int ttl = -1; // Pufferfish + @Nullable + private String descriptionId; + @Nullable +diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java +index a189461330a4d427a7450d504ef13de3605497e3..eccd61f5401ecb2ef0b460337a3284d1844bd85f 100644 +--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java ++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java +@@ -143,7 +143,6 @@ import org.bukkit.event.entity.EntityTeleportEvent; + import org.bukkit.event.player.PlayerItemConsumeEvent; + // CraftBukkit end + +-import co.aikar.timings.MinecraftTimings; // Paper + + public abstract class LivingEntity extends Entity implements Attackable { + +@@ -415,7 +414,7 @@ public abstract class LivingEntity extends Entity implements Attackable { + boolean flag = this instanceof net.minecraft.world.entity.player.Player; + + if (!this.level().isClientSide) { +- if (this.isInWall()) { ++ if ((!gg.pufferfish.pufferfish.PufferfishConfig.enableSuffocationOptimization || (tickCount % 10 == 0 && couldPossiblyBeHurt(1.0F))) && this.isInWall()) { // Pufferfish - optimize suffocation + this.hurt(this.damageSources().inWall(), 1.0F); + } else if (flag && !this.level().getWorldBorder().isWithinBounds(this.getBoundingBox())) { + double d0 = this.level().getWorldBorder().getDistanceToBorder(this) + this.level().getWorldBorder().getDamageSafeZone(); +@@ -1370,6 +1369,15 @@ public abstract class LivingEntity extends Entity implements Attackable { + return this.getHealth() <= 0.0F; + } + ++ // Pufferfish start - optimize suffocation ++ public boolean couldPossiblyBeHurt(float amount) { ++ if ((float) this.invulnerableTime > (float) this.invulnerableDuration / 2.0F && amount <= this.lastHurt) { ++ return false; ++ } ++ return true; ++ } ++ // Pufferfish end ++ + @Override + public boolean hurt(DamageSource source, float amount) { + if (this.isInvulnerableTo(source)) { +@@ -1975,6 +1983,20 @@ public abstract class LivingEntity extends Entity implements Attackable { + return this.lastClimbablePos; + } + ++ ++ // Pufferfish start ++ private boolean cachedOnClimable = false; ++ private BlockPos lastClimbingPosition = null; ++ ++ public boolean onClimableCached() { ++ if (!this.blockPosition().equals(this.lastClimbingPosition)) { ++ this.cachedOnClimable = this.onClimbable(); ++ this.lastClimbingPosition = this.blockPosition(); ++ } ++ return this.cachedOnClimable; ++ } ++ // Pufferfish end ++ + public boolean onClimbable() { + if (this.isSpectator()) { + return false; +@@ -3661,7 +3683,10 @@ public abstract class LivingEntity extends Entity implements Attackable { + Vec3 vec3d1 = new Vec3(entity.getX(), entity.getEyeY(), entity.getZ()); + + // Paper - diff on change - used in CraftLivingEntity#hasLineOfSight(Location) and CraftWorld#lineOfSightExists +- return vec3d1.distanceToSqr(vec3d) > 128D * 128D ? false : this.level().clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS; ++ // Pufferfish start ++ //return vec3d1.distanceToSqr(vec3d) > 128D * 128D ? false : this.level().clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, this)).getType() == HitResult.Type.MISS; ++ return vec3d1.distanceToSqr(vec3d) > 128D * 128D ? false : this.level().rayTraceDirect(vec3d, vec3d1, net.minecraft.world.phys.shapes.CollisionContext.of(this)) == net.minecraft.world.phys.BlockHitResult.Type.MISS; ++ // Pufferfish end + } + } + +diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java +index e2a25c29ec74147b3e66aa0b3deb85a8f6ee53a5..f6eb032897c6d5d16ab5c8c287e49e189c24571c 100644 +--- a/src/main/java/net/minecraft/world/entity/Mob.java ++++ b/src/main/java/net/minecraft/world/entity/Mob.java +@@ -218,14 +218,16 @@ public abstract class Mob extends LivingEntity implements Targeting { + return this.lookControl; + } + ++ int _pufferfish_inactiveTickDisableCounter = 0; // Pufferfish - throttle inactive goal selector ticking + // Paper start + @Override + public void inactiveTick() { + super.inactiveTick(); +- if (this.goalSelector.inactiveTick()) { ++ boolean isThrottled = gg.pufferfish.pufferfish.PufferfishConfig.throttleInactiveGoalSelectorTick && _pufferfish_inactiveTickDisableCounter++ % 20 != 0; // Pufferfish - throttle inactive goal selector ticking ++ if (this.goalSelector.inactiveTick(this.activatedPriority, true) && !isThrottled) { // Pufferfish - pass activated priroity // Pufferfish - throttle inactive goal selector ticking + this.goalSelector.tick(); + } +- if (this.targetSelector.inactiveTick()) { ++ if (this.targetSelector.inactiveTick(this.activatedPriority, true)) { // Pufferfish - pass activated priority + this.targetSelector.tick(); + } + } +@@ -910,16 +912,20 @@ public abstract class Mob extends LivingEntity implements Targeting { + + if (i % 2 != 0 && this.tickCount > 1) { + this.level().getProfiler().push("targetSelector"); ++ if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.targetSelector.tickRunningGoals(false); + this.level().getProfiler().pop(); + this.level().getProfiler().push("goalSelector"); ++ if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.goalSelector.tickRunningGoals(false); + this.level().getProfiler().pop(); + } else { + this.level().getProfiler().push("targetSelector"); ++ if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.targetSelector.tick(); + this.level().getProfiler().pop(); + this.level().getProfiler().push("goalSelector"); ++ if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.goalSelector.tick(); + this.level().getProfiler().pop(); + } +diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java +index dd1102d5291ef6f18e82400a6d8a0a376cc071e9..e283eb57c25f7de222f9d09dca851169f5f6e488 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java ++++ b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java +@@ -23,9 +23,11 @@ public class AttributeMap { + private final Map attributes = Maps.newHashMap(); + private final Set dirtyAttributes = Sets.newHashSet(); + private final AttributeSupplier supplier; ++ private final java.util.function.Function createInstance; // Pufferfish + + public AttributeMap(AttributeSupplier defaultAttributes) { + this.supplier = defaultAttributes; ++ this.createInstance = attribute -> this.supplier.createInstance(this::onAttributeModified, attribute); // Pufferfish + } + + private void onAttributeModified(AttributeInstance instance) { +@@ -45,11 +47,10 @@ public class AttributeMap { + }).collect(Collectors.toList()); + } + ++ + @Nullable + public AttributeInstance getInstance(Attribute attribute) { +- return this.attributes.computeIfAbsent(attribute, (attributex) -> { +- return this.supplier.createInstance(this::onAttributeModified, attributex); +- }); ++ return this.attributes.computeIfAbsent(attribute, this.createInstance); // Pufferfish - cache lambda, as for some reason java allocates it anyways + } + + @Nullable +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java +index d4c91e0a0c64fcb7f1145de3f30134cb1f1f8ee6..fe502445a77afe7e3807afae48d7bf03f370e290 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java +@@ -47,6 +47,7 @@ public class AcquirePoi { + return false; + } else { + mutableLong.setValue(time + 20L + (long)world.getRandom().nextInt(20)); ++ if (entity.getNavigation().isStuck()) mutableLong.add(200); // Pufferfish - wait an additional 10s to check again if they're stuck + PoiManager poiManager = world.getPoiManager(); + long2ObjectMap.long2ObjectEntrySet().removeIf((entry) -> { + return !entry.getValue().isStillValid(time); +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerPanicTrigger.java b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerPanicTrigger.java +index 646d9a121d908a2fc3e4e302484dd5cd1bfc6804..e546ecdccde352502e26a8668eaaafe048d6e282 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerPanicTrigger.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerPanicTrigger.java +@@ -37,7 +37,11 @@ public class VillagerPanicTrigger extends Behavior { + + @Override + protected void tick(ServerLevel world, Villager entity, long time) { +- if (time % 100L == 0L) { ++ // Pufferfish start ++ if (entity.nextGolemPanic < 0) entity.nextGolemPanic = time + 100; ++ if (--entity.nextGolemPanic < time) { ++ entity.nextGolemPanic = -1; ++ // Pufferfish end + entity.spawnGolemIfNeeded(world, time, 3); + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java +index b738ee2d3801fadfd09313f05ae24593e56b0ec6..1635818fc4b1788c0d397085239df6dd75b210ab 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java ++++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java +@@ -53,9 +53,12 @@ public class GoalSelector { + } + + // Paper start +- public boolean inactiveTick() { ++ public boolean inactiveTick(int tickRate, boolean inactive) { // Pufferfish start ++ if (inactive && !gg.pufferfish.pufferfish.PufferfishConfig.dearEnabled) tickRate = 4; // reset to Paper's ++ tickRate = Math.min(tickRate, this.newGoalRate); + this.curRate++; +- return this.curRate % this.newGoalRate == 0; ++ return this.curRate % tickRate == 0; ++ // Pufferfish end + } + public boolean hasTasks() { + for (WrappedGoal task : this.availableGoals) { +diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java +index 34f319ad09276c6f68dde449c79351de0d7d86f5..a719af0b512d9ef243d0d54f3b744b1b1a5f2772 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java ++++ b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java +@@ -119,6 +119,7 @@ public abstract class MoveToBlockGoal extends Goal { + for(int m = 0; m <= l; m = m > 0 ? -m : 1 - m) { + for(int n = m < l && m > -l ? l : 0; n <= l; n = n > 0 ? -n : 1 - n) { + mutableBlockPos.setWithOffset(blockPos, m, k - 1, n); ++ if (!this.mob.level().hasChunkAt(mutableBlockPos)) continue; // Pufferfish - if this block isn't loaded, continue + if (this.mob.isWithinRestriction(mutableBlockPos) && this.isValidTarget(this.mob.level(), mutableBlockPos)) { + this.blockPos = mutableBlockPos; + setTargetPosition(mutableBlockPos.immutable()); // Paper +diff --git a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java +index 58422f00c7d64dbd1cf6d7211c9838875cbe7778..d25307ae8bbdf10ae067ec70fc2cb957b852a0eb 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java ++++ b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java +@@ -75,9 +75,18 @@ public class TargetingConditions { + } + + if (this.range > 0.0D) { +- double d = this.testInvisible ? targetEntity.getVisibilityPercent(baseEntity) : 1.0D; +- double e = Math.max((this.useFollowRange ? this.getFollowRange(baseEntity) : this.range) * d, 2.0D); // Paper ++ // Pufferfish start - check range before getting visibility ++ // d = invisibility percent, e = follow range adjusted for invisibility, f = distance + double f = baseEntity.distanceToSqr(targetEntity.getX(), targetEntity.getY(), targetEntity.getZ()); ++ double followRangeRaw = this.useFollowRange ? this.getFollowRange(baseEntity) : this.range; ++ ++ if (f > followRangeRaw * followRangeRaw) { // the actual follow range will always be this value or smaller, so if the distance is larger then it never will return true after getting invis ++ return false; ++ } ++ ++ double d = this.testInvisible ? targetEntity.getVisibilityPercent(baseEntity) : 1.0D; ++ double e = Math.max((followRangeRaw) * d, 2.0D); // Paper ++ // Pufferfish end + if (f > e * e) { + return false; + } +diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java +index 940cd932e74bc2e6754186731d7aa6f10d56eb68..92a9770fabc6a8175245fef92753c52bc18d16ac 100644 +--- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java ++++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java +@@ -251,13 +251,22 @@ public class Bat extends AmbientCreature { + } + } + ++ // Pufferfish start - only check for spooky season once an hour ++ private static boolean isSpookySeason = false; ++ private static final int ONE_HOUR = 20 * 60 * 60; ++ private static int lastSpookyCheck = -ONE_HOUR; + private static boolean isHalloween() { ++ if (net.minecraft.server.MinecraftServer.currentTick - lastSpookyCheck > ONE_HOUR) { + LocalDate localdate = LocalDate.now(); + int i = localdate.get(ChronoField.DAY_OF_MONTH); + int j = localdate.get(ChronoField.MONTH_OF_YEAR); + +- return j == 10 && i >= 20 || j == 11 && i <= 3; ++ isSpookySeason = j == 10 && i >= 20 || j == 11 && i <= 3; ++ lastSpookyCheck = net.minecraft.server.MinecraftServer.currentTick; ++ } ++ return isSpookySeason; + } ++ // Pufferfish end + + @Override + protected float getStandingEyeHeight(Pose pose, EntityDimensions dimensions) { +diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +index 339c70f101d026a100a801e66cf514b3329a89d2..1a0eee3b766a5ce5623c32ed9c023a0f80db1d1a 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java ++++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +@@ -222,9 +222,11 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS + return 0.4F; + } + ++ private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("allayBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel) this.level(), this); + this.level().getProfiler().pop(); + this.level().getProfiler().push("allayActivityUpdate"); +diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +index 2682a49cd3948e0f80e2d7e58abcd3e6d8f7ac4e..42e22a4b9cb6841de04862cc81454da3232aa65a 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java ++++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +@@ -285,9 +285,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder { + return true; + } + ++ private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("frogBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel)this.level(), this); + this.level().getProfiler().pop(); + this.level().getProfiler().push("frogActivityUpdate"); +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +index 4aeab90e778629c355189dfe79c39c4b21f5f5ac..6ed4ac06c76b8d0d6e8db778cade15dbd1e3e5f5 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +@@ -77,9 +77,11 @@ public class Tadpole extends AbstractFish { + return SoundEvents.TADPOLE_FLOP; + } + ++ private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("tadpoleBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel) this.level(), this); + this.level().getProfiler().pop(); + this.level().getProfiler().push("tadpoleActivityUpdate"); +diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +index 528e7ba29dcd38726b2c1bbc1d8ac208c64ba9df..2c7193e967b4cb5a7c98a760286a2c3791152359 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java ++++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +@@ -188,9 +188,11 @@ public class Goat extends Animal { + return (Brain) super.getBrain(); // CraftBukkit - decompile error + } + ++ private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("goatBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel) this.level(), this); + this.level().getProfiler().pop(); + this.level().getProfiler().push("goatActivityUpdate"); +diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java +index 3d41dbe0285f8fec8adae1e93010cf464df9b08c..63f8f2dfc2afddcf3c4960d60e65cb8e29507223 100644 +--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java ++++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java +@@ -269,10 +269,16 @@ public class ItemEntity extends Entity implements TraceableEntity { + if (entityitem.isMergable()) { + // Paper Start - Fix items merging through walls + if (this.level().paperConfig().fixes.fixItemsMergingThroughWalls) { ++ // Pufferfish start - skip the allocations ++ /* + net.minecraft.world.level.ClipContext rayTrace = new net.minecraft.world.level.ClipContext(this.position(), entityitem.position(), + net.minecraft.world.level.ClipContext.Block.COLLIDER, net.minecraft.world.level.ClipContext.Fluid.NONE, this); + net.minecraft.world.phys.BlockHitResult rayTraceResult = this.level().clip(rayTrace); + if (rayTraceResult.getType() == net.minecraft.world.phys.HitResult.Type.BLOCK) continue; ++ */ ++ if (level().rayTraceDirect(this.position(), entityitem.position(), net.minecraft.world.phys.shapes.CollisionContext.of(this)) == ++ net.minecraft.world.phys.HitResult.Type.BLOCK) continue; ++ // Pufferfish end + } + // Paper End + this.tryToMerge(entityitem); +diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +index 5519ccf558c09f32e19b35f4b403fc9ed966ed65..54a9529ea92889d57e348307a35097f715a13501 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java ++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +@@ -322,11 +322,17 @@ public class EnderMan extends Monster implements NeutralMob { + private boolean teleport(double x, double y, double z) { + BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos(x, y, z); + +- while (blockposition_mutableblockposition.getY() > this.level().getMinBuildHeight() && !this.level().getBlockState(blockposition_mutableblockposition).blocksMotion()) { ++ // Pufferfish start - single chunk lookup ++ net.minecraft.world.level.chunk.LevelChunk chunk = this.level().getChunkIfLoaded(blockposition_mutableblockposition); ++ if (chunk == null) { ++ return false; ++ } ++ // Pufferfish end ++ while (blockposition_mutableblockposition.getY() > this.level().getMinBuildHeight() && !chunk.getBlockState(blockposition_mutableblockposition).blocksMotion()) { // Pufferfish + blockposition_mutableblockposition.move(Direction.DOWN); + } + +- BlockState iblockdata = this.level().getBlockState(blockposition_mutableblockposition); ++ BlockState iblockdata = chunk.getBlockState(blockposition_mutableblockposition); // Pufferfish + boolean flag = iblockdata.blocksMotion(); + boolean flag1 = iblockdata.getFluidState().is(FluidTags.WATER); + +diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +index e8f6c34ea789136d63c0aa88aec90203ef6282b5..d6d61b91096d28eea1e5af69ea1c07890820ee7f 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +@@ -126,9 +126,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { + return (Brain) super.getBrain(); // Paper - decompile fix + } + ++ private int behaviorTick; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("hoglinBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel)this.level(), this); + this.level().getProfiler().pop(); + HoglinAi.updateActivity(this); +diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +index 27d9145693a772cd1b5d171da303c934101f3be8..e235cc9d1b3ce59ab662ef3cf3ce0267ca78536d 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +@@ -305,9 +305,11 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento + return !this.cannotHunt; + } + ++ private int behaviorTick; // Pufferfish + @Override + protected void customServerAiStep() { + this.level().getProfiler().push("piglinBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel) this.level(), this); + this.level().getProfiler().pop(); + PiglinAi.updateActivity(this); +diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +index 97b763431bc5015448ee7a26a340635a932c950b..71db8bd6885377d55cfc571fccc21df6d8a57b54 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java ++++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +@@ -271,11 +271,13 @@ public class Warden extends Monster implements VibrationSystem { + + } + ++ private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { + ServerLevel worldserver = (ServerLevel) this.level(); + + worldserver.getProfiler().push("wardenBrain"); ++ if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick(worldserver, this); + this.level().getProfiler().pop(); + super.customServerAiStep(); +diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java +index e30d5ae3e2900f43d7cafde71b8196f26e872841..c4ddf2661bca728d504918171295e10e307b18b4 100644 +--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java ++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java +@@ -141,6 +141,8 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + return holder.is(PoiTypes.MEETING); + }); + ++ public long nextGolemPanic = -1; // Pufferfish ++ + public Villager(EntityType entityType, Level world) { + this(entityType, world, VillagerType.PLAINS); + } +@@ -244,6 +246,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + } + // Spigot End + ++ private int behaviorTick = 0; // Pufferfish + @Override + @Deprecated // Paper + protected void customServerAiStep() { +@@ -253,7 +256,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + protected void customServerAiStep(final boolean inactive) { + // Paper end + this.level().getProfiler().push("villagerBrain"); +- if (!inactive) this.getBrain().tick((ServerLevel) this.level(), this); // Paper ++ // Pufferfish start ++ if (!inactive && this.behaviorTick++ % this.activatedPriority == 0) { ++ this.getBrain().tick((ServerLevel) this.level(), this); // Paper ++ } ++ // Pufferfish end + this.level().getProfiler().pop(); + if (this.assignProfessionWhenSpawned) { + this.assignProfessionWhenSpawned = false; +diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java +index 395cecc385e4126a7534ac9aeb15cf323efab03e..089166d9e6121df3069b2b71d6b556ae37520a26 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Inventory.java ++++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java +@@ -681,6 +681,8 @@ public class Inventory implements Container, Nameable { + } + + public boolean contains(ItemStack stack) { ++ // Pufferfish start - don't allocate iterators ++ /* + Iterator iterator = this.compartments.iterator(); + + while (iterator.hasNext()) { +@@ -695,6 +697,18 @@ public class Inventory implements Container, Nameable { + } + } + } ++ */ ++ for (int i = 0; i < this.compartments.size(); i++) { ++ List list = this.compartments.get(i); ++ for (int j = 0; j < list.size(); j++) { ++ ItemStack itemstack1 = list.get(j); ++ ++ if (!itemstack1.isEmpty() && ItemStack.isSameItemSameTags(itemstack1, stack)) { ++ return true; ++ } ++ } ++ } ++ // Pufferfish end + + return false; + } +diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java +index 1b7cf6d06bdf36f146656727511a461f2520762e..459aee61b519a40d9136546c0d9356562f5757c8 100644 +--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java ++++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java +@@ -44,6 +44,36 @@ public abstract class Projectile extends Entity implements TraceableEntity { + super(type, world); + } + ++ // Pufferfish start ++ private static int loadedThisTick = 0; ++ private static int loadedTick; ++ ++ private int loadedLifetime = 0; ++ @Override ++ public void setPos(double x, double y, double z) { ++ int currentTick = net.minecraft.server.MinecraftServer.currentTick; ++ if (loadedTick != currentTick) { ++ loadedTick = currentTick; ++ loadedThisTick = 0; ++ } ++ int previousX = Mth.floor(this.getX()) >> 4, previousZ = Mth.floor(this.getZ()) >> 4; ++ int newX = Mth.floor(x) >> 4, newZ = Mth.floor(z) >> 4; ++ if (previousX != newX || previousZ != newZ) { ++ boolean isLoaded = ((net.minecraft.server.level.ServerChunkCache) this.level().getChunkSource()).getChunkAtIfLoadedMainThread(newX, newZ) != null; ++ if (!isLoaded) { ++ if (Projectile.loadedThisTick > gg.pufferfish.pufferfish.PufferfishConfig.maxProjectileLoadsPerTick) { ++ if (++this.loadedLifetime > gg.pufferfish.pufferfish.PufferfishConfig.maxProjectileLoadsPerProjectile) { ++ this.discard(); ++ } ++ return; ++ } ++ Projectile.loadedThisTick++; ++ } ++ } ++ super.setPos(x, y, z); ++ } ++ // Pufferfish end ++ + public void setOwner(@Nullable Entity entity) { + if (entity != null) { + this.ownerUUID = entity.getUUID(); +diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java +index 272095d7a09ab41227d741172735f66fd2798ce1..47692d6db44b58bb724c87128279bd0d3e62a398 100644 +--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java ++++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java +@@ -27,7 +27,10 @@ import org.bukkit.inventory.InventoryHolder; + + public abstract class AbstractMinecartContainer extends AbstractMinecart implements ContainerEntity { + ++ // Pufferfish start + private NonNullList itemStacks; ++ private gg.airplane.structs.ItemListWithBitset itemStacksOptimized; ++ // Pufferfish end + @Nullable + public ResourceLocation lootTable; + public long lootTableSeed; +@@ -89,12 +92,18 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme + + protected AbstractMinecartContainer(EntityType type, Level world) { + super(type, world); +- this.itemStacks = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY); // CraftBukkit - SPIGOT-3513 ++ // Pufferfish start ++ this.itemStacksOptimized = new gg.airplane.structs.ItemListWithBitset(this.getContainerSize()); // CraftBukkit - SPIGOT-3513 ++ this.itemStacks = this.itemStacksOptimized.nonNullList; ++ // Pufferfish end + } + + protected AbstractMinecartContainer(EntityType type, double x, double y, double z, Level world) { + super(type, world, x, y, z); +- this.itemStacks = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY); // CraftBukkit - SPIGOT-3513 ++ // Pufferfish start ++ this.itemStacksOptimized = new gg.airplane.structs.ItemListWithBitset(this.getContainerSize()); // CraftBukkit - SPIGOT-3513 ++ this.itemStacks = this.itemStacksOptimized.nonNullList; ++ // Pufferfish end + } + + @Override +@@ -156,6 +165,10 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme + protected void readAdditionalSaveData(CompoundTag nbt) { + super.readAdditionalSaveData(nbt); + this.lootableData.loadNbt(nbt); // Paper ++ // Pufferfish start ++ this.itemStacksOptimized = new gg.airplane.structs.ItemListWithBitset(this.getContainerSize()); ++ this.itemStacks = this.itemStacksOptimized.nonNullList; ++ // Pufferfish end + this.readChestVehicleSaveData(nbt); + } + +diff --git a/src/main/java/net/minecraft/world/item/EndCrystalItem.java b/src/main/java/net/minecraft/world/item/EndCrystalItem.java +index ca1edc083847b47bb450b291723aca778a5912dc..dc695c518beed770e787d61bcda7e1cd28bc43eb 100644 +--- a/src/main/java/net/minecraft/world/item/EndCrystalItem.java ++++ b/src/main/java/net/minecraft/world/item/EndCrystalItem.java +@@ -55,7 +55,7 @@ public class EndCrystalItem extends Item { + world.gameEvent((Entity) context.getPlayer(), GameEvent.ENTITY_PLACE, blockposition1); + EndDragonFight enderdragonbattle = ((ServerLevel) world).getDragonFight(); + +- if (enderdragonbattle != null) { ++ if (enderdragonbattle != null && gg.pufferfish.pufferfish.PufferfishConfig.allowEndCrystalRespawn) { // Pufferfish + enderdragonbattle.tryRespawn(); + } + } +diff --git a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java +index 7f174bb89bf4d700a5ae1b65d8abd4f5b1e7b5ed..e16bde81442e2bedeb2a5b1b77b008c418f05b1c 100644 +--- a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java ++++ b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java +@@ -27,8 +27,13 @@ public class ShapelessRecipe implements CraftingRecipe { + final CraftingBookCategory category; + final ItemStack result; + final NonNullList ingredients; ++ private final boolean isBukkit; // Pufferfish + ++ // Pufferfish start + public ShapelessRecipe(ResourceLocation id, String group, CraftingBookCategory category, ItemStack output, NonNullList input) { ++ this(id, group, category, output, input, false); ++ } ++ public ShapelessRecipe(ResourceLocation id, String group, CraftingBookCategory category, ItemStack output, NonNullList input, boolean isBukkit) { this.isBukkit = isBukkit; // Pufferfish end + this.id = id; + this.group = group; + this.category = category; +@@ -82,6 +87,28 @@ public class ShapelessRecipe implements CraftingRecipe { + } + + public boolean matches(CraftingContainer inventory, Level world) { ++ // Pufferfish start ++ if (!this.isBukkit) { ++ java.util.List ingredients = com.google.common.collect.Lists.newArrayList(this.ingredients.toArray(new Ingredient[0])); ++ ++ inventory: for (int index = 0; index < inventory.getContainerSize(); index++) { ++ ItemStack itemStack = inventory.getItem(index); ++ ++ if (!itemStack.isEmpty()) { ++ for (int i = 0; i < ingredients.size(); i++) { ++ if (ingredients.get(i).test(itemStack)) { ++ ingredients.remove(i); ++ continue inventory; ++ } ++ } ++ return false; ++ } ++ } ++ ++ return ingredients.isEmpty(); ++ } ++ // Pufferfish end ++ + StackedContents autorecipestackmanager = new StackedContents(); + int i = 0; + +diff --git a/src/main/java/net/minecraft/world/level/BlockGetter.java b/src/main/java/net/minecraft/world/level/BlockGetter.java +index 0e8746759752b692668886370181aa5db1fd0bb0..58e5ce2afabf480f5dfd9adf43f8fc12666861c6 100644 +--- a/src/main/java/net/minecraft/world/level/BlockGetter.java ++++ b/src/main/java/net/minecraft/world/level/BlockGetter.java +@@ -68,6 +68,16 @@ public interface BlockGetter extends LevelHeightAccessor { + }); + } + ++ // Pufferfish start - broken down variant of below rayTraceBlock, used by World#rayTraceDirect ++ default net.minecraft.world.phys.BlockHitResult.Type rayTraceBlockDirect(Vec3 vec3d, Vec3 vec3d1, BlockPos blockposition, BlockState iblockdata, net.minecraft.world.phys.shapes.CollisionContext voxelshapecoll) { ++ if (iblockdata.isAir()) return null; // Tuinity - optimise air cases ++ VoxelShape voxelshape = ClipContext.Block.COLLIDER.get(iblockdata, this, blockposition, voxelshapecoll); ++ net.minecraft.world.phys.BlockHitResult movingobjectpositionblock = this.clipWithInteractionOverride(vec3d, vec3d1, blockposition, voxelshape, iblockdata); ++ ++ return movingobjectpositionblock == null ? null : movingobjectpositionblock.getType(); ++ } ++ // Pufferfish end ++ + // CraftBukkit start - moved block handling into separate method for use by Block#rayTrace + default BlockHitResult clip(ClipContext raytrace1, BlockPos blockposition) { + // Paper start - Prevent raytrace from loading chunks +diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java +index 147d802d9207e358fdb2d1c7806fc2f634dcfd98..30d8ec75203adc677e5fb91d9538baf52a0684ad 100644 +--- a/src/main/java/net/minecraft/world/level/Level.java ++++ b/src/main/java/net/minecraft/world/level/Level.java +@@ -273,6 +273,17 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + + public abstract ResourceKey getTypeKey(); + ++ protected final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom(java.util.concurrent.ThreadLocalRandom.current().nextLong()); public net.minecraft.util.RandomSource getThreadUnsafeRandom() { return this.randomTickRandom; } // Pufferfish - move thread unsafe random initialization // Pufferfish - getter ++ ++ // Pufferfish start - ensure these get inlined ++ private final int minBuildHeight, minSection, height, maxBuildHeight, maxSection; ++ @Override public final int getMaxBuildHeight() { return this.maxBuildHeight; } ++ @Override public final int getMinSection() { return this.minSection; } ++ @Override public final int getMaxSection() { return this.maxSection; } ++ @Override public final int getMinBuildHeight() { return this.minBuildHeight; } ++ @Override public final int getHeight() { return this.height; } ++ // Pufferfish end ++ + protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, RegistryAccess iregistrycustom, Holder holder, Supplier supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor + this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot + this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper +@@ -295,6 +306,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + }); + final DimensionType dimensionmanager = (DimensionType) holder.value(); + ++ // Pufferfish start ++ this.minBuildHeight = dimensionmanager.minY(); ++ this.minSection = SectionPos.blockToSectionCoord(this.minBuildHeight); ++ this.height = dimensionmanager.height(); ++ this.maxBuildHeight = this.minBuildHeight + this.height; ++ this.maxSection = SectionPos.blockToSectionCoord(this.maxBuildHeight - 1) + 1; ++ // Pufferfish end + this.dimension = resourcekey; + this.isClientSide = flag; + if (dimensionmanager.coordinateScale() != 1.0D) { +@@ -412,6 +430,91 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + return null; + } + ++ // Pufferfish start - broken down method of raytracing for EntityLiving#hasLineOfSight, replaces IBlockAccess#rayTrace(RayTrace) ++ public net.minecraft.world.phys.BlockHitResult.Type rayTraceDirect(net.minecraft.world.phys.Vec3 vec3d, net.minecraft.world.phys.Vec3 vec3d1, net.minecraft.world.phys.shapes.CollisionContext voxelshapecoll) { ++ // most of this code comes from IBlockAccess#a(RayTrace, BiFunction, Function), but removes the needless functions ++ if (vec3d.equals(vec3d1)) { ++ return net.minecraft.world.phys.BlockHitResult.Type.MISS; ++ } ++ ++ double endX = Mth.lerp(-1.0E-7D, vec3d1.x, vec3d.x); ++ double endY = Mth.lerp(-1.0E-7D, vec3d1.y, vec3d.y); ++ double endZ = Mth.lerp(-1.0E-7D, vec3d1.z, vec3d.z); ++ ++ double startX = Mth.lerp(-1.0E-7D, vec3d.x, vec3d1.x); ++ double startY = Mth.lerp(-1.0E-7D, vec3d.y, vec3d1.y); ++ double startZ = Mth.lerp(-1.0E-7D, vec3d.z, vec3d1.z); ++ ++ int currentX = Mth.floor(startX); ++ int currentY = Mth.floor(startY); ++ int currentZ = Mth.floor(startZ); ++ ++ BlockPos.MutableBlockPos currentBlock = new BlockPos.MutableBlockPos(currentX, currentY, currentZ); ++ ++ LevelChunk chunk = this.getChunkIfLoaded(currentBlock); ++ if (chunk == null) { ++ return net.minecraft.world.phys.BlockHitResult.Type.MISS; ++ } ++ ++ net.minecraft.world.phys.BlockHitResult.Type initialCheck = this.rayTraceBlockDirect(vec3d, vec3d1, currentBlock, chunk.getBlockState(currentBlock), voxelshapecoll); ++ ++ if (initialCheck != null) { ++ return initialCheck; ++ } ++ ++ double diffX = endX - startX; ++ double diffY = endY - startY; ++ double diffZ = endZ - startZ; ++ ++ int xDirection = Mth.sign(diffX); ++ int yDirection = Mth.sign(diffY); ++ int zDirection = Mth.sign(diffZ); ++ ++ double normalizedX = xDirection == 0 ? Double.MAX_VALUE : (double) xDirection / diffX; ++ double normalizedY = yDirection == 0 ? Double.MAX_VALUE : (double) yDirection / diffY; ++ double normalizedZ = zDirection == 0 ? Double.MAX_VALUE : (double) zDirection / diffZ; ++ ++ double normalizedXDirection = normalizedX * (xDirection > 0 ? 1.0D - Mth.frac(startX) : Mth.frac(startX)); ++ double normalizedYDirection = normalizedY * (yDirection > 0 ? 1.0D - Mth.frac(startY) : Mth.frac(startY)); ++ double normalizedZDirection = normalizedZ * (zDirection > 0 ? 1.0D - Mth.frac(startZ) : Mth.frac(startZ)); ++ ++ net.minecraft.world.phys.BlockHitResult.Type result; ++ ++ do { ++ if (normalizedXDirection > 1.0D && normalizedYDirection > 1.0D && normalizedZDirection > 1.0D) { ++ return net.minecraft.world.phys.BlockHitResult.Type.MISS; ++ } ++ ++ if (normalizedXDirection < normalizedYDirection) { ++ if (normalizedXDirection < normalizedZDirection) { ++ currentX += xDirection; ++ normalizedXDirection += normalizedX; ++ } else { ++ currentZ += zDirection; ++ normalizedZDirection += normalizedZ; ++ } ++ } else if (normalizedYDirection < normalizedZDirection) { ++ currentY += yDirection; ++ normalizedYDirection += normalizedY; ++ } else { ++ currentZ += zDirection; ++ normalizedZDirection += normalizedZ; ++ } ++ ++ currentBlock.set(currentX, currentY, currentZ); ++ if (chunk.getPos().x != currentBlock.getX() >> 4 || chunk.getPos().z != currentBlock.getZ() >> 4) { ++ chunk = this.getChunkIfLoaded(currentBlock); ++ if (chunk == null) { ++ return net.minecraft.world.phys.BlockHitResult.Type.MISS; ++ } ++ } ++ result = this.rayTraceBlockDirect(vec3d, vec3d1, currentBlock, chunk.getBlockState(currentBlock), voxelshapecoll); ++ } while (result == null); ++ ++ return result; ++ } ++ // Pufferfish end ++ + public boolean isInWorldBounds(BlockPos pos) { + return pos.isInsideBuildHeightAndWorldBoundsHorizontal(this); // Paper - use better/optimized check + } +@@ -918,13 +1021,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + try { + tickConsumer.accept(entity); + MinecraftServer.getServer().executeMidTickTasks(); // Paper - execute chunk tasks mid tick +- } catch (Throwable throwable) { ++ } catch (Throwable throwable) { // Pufferfish - diff on change ServerLevel.tick + if (throwable instanceof ThreadDeath) throw throwable; // Paper + // Paper start - Prevent tile entity and entity crashes + final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level().getWorld().getName(), entity.getX(), entity.getY(), entity.getZ()); + MinecraftServer.LOGGER.error(msg, throwable); + getCraftServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable))); +- entity.discard(); ++ entity.discard(); // Pufferfish - diff on change ServerLevel.tick + // Paper end + } + } +@@ -1379,6 +1482,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + } + + public ProfilerFiller getProfiler() { ++ if (gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish + return (ProfilerFiller) this.profiler.get(); + } + +diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +index 089dd93d4cd4c1f72e63c4944b3b82c1e2ba732d..5d19ef5231752c6cccc73b9adfb67e53e87baf7a 100644 +--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java ++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +@@ -417,12 +417,12 @@ public final class NaturalSpawner { + } + } + +- private static BlockPos getRandomPosWithin(Level world, LevelChunk chunk) { ++ private static BlockPos getRandomPosWithin(ServerLevel world, LevelChunk chunk) { // Pufferfish - accept serverlevel + ChunkPos chunkcoordintpair = chunk.getPos(); +- int i = chunkcoordintpair.getMinBlockX() + world.random.nextInt(16); +- int j = chunkcoordintpair.getMinBlockZ() + world.random.nextInt(16); ++ int i = chunkcoordintpair.getMinBlockX() + world.getThreadUnsafeRandom().nextInt(16); // Pufferfish - use thread unsafe random ++ int j = chunkcoordintpair.getMinBlockZ() + world.getThreadUnsafeRandom().nextInt(16); // Pufferfish + int k = chunk.getHeight(Heightmap.Types.WORLD_SURFACE, i, j) + 1; +- int l = Mth.randomBetweenInclusive(world.random, world.getMinBuildHeight(), k); ++ int l = Mth.randomBetweenInclusive(world.getThreadUnsafeRandom(), world.getMinBuildHeight(), k); // Pufferfish + + return new BlockPos(i, l, j); + } +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 65012a12e1430956ef55ced56773e6354ac26444..ed439b7e94646141c93a7dd3704d1cdeb5c27e16 100644 +--- a/src/main/java/net/minecraft/world/level/biome/Biome.java ++++ b/src/main/java/net/minecraft/world/level/biome/Biome.java +@@ -66,14 +66,20 @@ public final class Biome { + private final BiomeGenerationSettings generationSettings; + private final MobSpawnSettings mobSettings; + private final BiomeSpecialEffects specialEffects; +- private final ThreadLocal temperatureCache = ThreadLocal.withInitial(() -> { ++ // Pufferfish start - use our cache ++ private final ThreadLocal temperatureCache = ThreadLocal.withInitial(() -> { + return Util.make(() -> { ++ /* + Long2FloatLinkedOpenHashMap long2FloatLinkedOpenHashMap = new Long2FloatLinkedOpenHashMap(1024, 0.25F) { + protected void rehash(int i) { + } + }; + long2FloatLinkedOpenHashMap.defaultReturnValue(Float.NaN); + return long2FloatLinkedOpenHashMap; ++ ++ */ ++ return new gg.airplane.structs.Long2FloatAgingCache(TEMPERATURE_CACHE_SIZE); ++ // Pufferfish end + }); + }); + +@@ -118,17 +124,15 @@ public final class Biome { + @Deprecated + public float getTemperature(BlockPos blockPos) { + long l = blockPos.asLong(); +- Long2FloatLinkedOpenHashMap long2FloatLinkedOpenHashMap = this.temperatureCache.get(); +- float f = long2FloatLinkedOpenHashMap.get(l); ++ // Pufferfish start ++ gg.airplane.structs.Long2FloatAgingCache cache = this.temperatureCache.get(); ++ float f = cache.getValue(l); + if (!Float.isNaN(f)) { + return f; + } else { + float g = this.getHeightAdjustedTemperature(blockPos); +- if (long2FloatLinkedOpenHashMap.size() == 1024) { +- long2FloatLinkedOpenHashMap.removeFirstFloat(); +- } +- +- long2FloatLinkedOpenHashMap.put(l, g); ++ cache.putValue(l, g); ++ // Pufferfish end + return g; + } + } +diff --git a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java +index a71414397bd45ee7bcacfeef0041d80dfa25f114..d66806565770cb03a21794f99e5c4b0f3040b26a 100644 +--- a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java ++++ b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java +@@ -31,7 +31,10 @@ import org.bukkit.entity.HumanEntity; + public class ChestBlockEntity extends RandomizableContainerBlockEntity implements LidBlockEntity { + + private static final int EVENT_SET_OPEN_COUNT = 1; ++ // Pufferfish start + private NonNullList items; ++ private gg.airplane.structs.ItemListWithBitset optimizedItems; ++ // Pufferfish end + public final ContainerOpenersCounter openersCounter; + private final ChestLidController chestLidController; + +@@ -65,9 +68,13 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement + } + // CraftBukkit end + ++ private final boolean isNative = getClass().equals(ChestBlockEntity.class); // Pufferfish + protected ChestBlockEntity(BlockEntityType type, BlockPos pos, BlockState state) { + super(type, pos, state); +- this.items = NonNullList.withSize(27, ItemStack.EMPTY); ++ // Pufferfish start ++ this.optimizedItems = new gg.airplane.structs.ItemListWithBitset(27); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + this.openersCounter = new ContainerOpenersCounter() { + @Override + protected void onOpen(Level world, BlockPos pos, BlockState state) { +@@ -98,6 +105,23 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement + this.chestLidController = new ChestLidController(); + } + ++ // Pufferfish start ++ @Override ++ public boolean hasEmptySlot(Direction enumdirection) { ++ return isNative ? !this.optimizedItems.hasFullStacks() : super.hasEmptySlot(enumdirection); ++ } ++ ++ @Override ++ public boolean isCompletelyFull(Direction enumdirection) { ++ return isNative ? this.optimizedItems.hasFullStacks() && super.isCompletelyFull(enumdirection) : super.isCompletelyFull(enumdirection); ++ } ++ ++ @Override ++ public boolean isCompletelyEmpty(Direction enumdirection) { ++ return isNative && this.optimizedItems.isCompletelyEmpty() || super.isCompletelyEmpty(enumdirection); ++ } ++ // Pufferfish end ++ + public ChestBlockEntity(BlockPos pos, BlockState state) { + this(BlockEntityType.CHEST, pos, state); + } +@@ -115,7 +139,10 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement + @Override + public void load(CompoundTag nbt) { + super.load(nbt); +- this.items = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY); ++ // Pufferfish start ++ this.optimizedItems = new gg.airplane.structs.ItemListWithBitset(this.getContainerSize()); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + if (!this.tryLoadLootTable(nbt)) { + ContainerHelper.loadAllItems(nbt, this.items); + } +@@ -187,7 +214,10 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement + + @Override + protected void setItems(NonNullList list) { +- this.items = list; ++ // Pufferfish start ++ this.optimizedItems = gg.airplane.structs.ItemListWithBitset.fromList(list); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + } + + @Override +diff --git a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java +index a8a26a0a37a08b6bbeb5a1fde417d6f448d3c79f..87164ca253447188cfc76073f7c73949cb0b3e03 100644 +--- a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java ++++ b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java +@@ -47,7 +47,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + + public static final int MOVE_ITEM_SPEED = 8; + public static final int HOPPER_CONTAINER_SIZE = 5; ++ // Pufferfish start + private NonNullList items; ++ private gg.airplane.structs.ItemListWithBitset optimizedItems; // Pufferfish ++ // Pufferfish end + private int cooldownTime; + private long tickedGameTime; + +@@ -83,14 +86,37 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + + public HopperBlockEntity(BlockPos pos, BlockState state) { + super(BlockEntityType.HOPPER, pos, state); +- this.items = NonNullList.withSize(5, ItemStack.EMPTY); ++ // Pufferfish start ++ this.optimizedItems = new gg.airplane.structs.ItemListWithBitset(5); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + this.cooldownTime = -1; + } + ++ // Pufferfish start ++ @Override ++ public boolean hasEmptySlot(Direction enumdirection) { ++ return !this.optimizedItems.hasFullStacks(); ++ } ++ ++ @Override ++ public boolean isCompletelyFull(Direction enumdirection) { ++ return this.optimizedItems.hasFullStacks() && super.isCompletelyFull(enumdirection); ++ } ++ ++ @Override ++ public boolean isCompletelyEmpty(Direction enumdirection) { ++ return this.optimizedItems.isCompletelyEmpty() || super.isCompletelyEmpty(enumdirection); ++ } ++ // Pufferfish end ++ + @Override + public void load(CompoundTag nbt) { + super.load(nbt); +- this.items = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY); ++ // Pufferfish start ++ this.optimizedItems = new gg.airplane.structs.ItemListWithBitset(this.getContainerSize()); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + if (!this.tryLoadLootTable(nbt)) { + ContainerHelper.loadAllItems(nbt, this.items); + } +@@ -162,7 +188,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + flag = HopperBlockEntity.ejectItems(world, pos, state, (Container) blockEntity, blockEntity); // CraftBukkit + } + +- if (!blockEntity.inventoryFull()) { ++ if (!blockEntity.optimizedItems.hasFullStacks() || !blockEntity.inventoryFull()) { // Pufferfish - use bitset first + flag |= booleansupplier.getAsBoolean(); + } + +@@ -451,11 +477,18 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + } + + private static boolean isFullContainer(Container inventory, Direction direction) { +- return allMatch(inventory, direction, STACK_SIZE_TEST); // Paper - no streams ++ // Pufferfish start - use bitsets ++ //return allMatch(inventory, direction, STACK_SIZE_TEST); // Paper - no streams ++ return inventory.isCompletelyFull(direction); ++ // Pufferfish end + } + + private static boolean isEmptyContainer(Container inv, Direction facing) { +- return allMatch(inv, facing, IS_EMPTY_TEST); ++ // Paper start ++ // Pufferfish start - use bitsets ++ //return allMatch(inv, facing, IS_EMPTY_TEST); ++ return inv.isCompletelyEmpty(facing); ++ // Pufferfish end + } + + public static boolean suckInItems(Level world, Hopper hopper) { +@@ -636,7 +669,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + + if (HopperBlockEntity.canPlaceItemInContainer(to, stack, slot, side)) { + boolean flag = false; +- boolean flag1 = to.isEmpty(); ++ boolean flag1 = to.isCompletelyEmpty(side); // Pufferfish + + if (itemstack1.isEmpty()) { + // Spigot start - SPIGOT-6693, InventorySubcontainer#setItem +@@ -831,7 +864,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen + + @Override + protected void setItems(NonNullList list) { +- this.items = list; ++ // Pufferfish start ++ this.optimizedItems = gg.airplane.structs.ItemListWithBitset.fromList(list); ++ this.items = this.optimizedItems.nonNullList; ++ // Pufferfish end + } + + public static void entityInside(Level world, BlockPos pos, BlockState state, Entity entity, HopperBlockEntity blockEntity) { +diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java +index 081691f9710ff1115e4308f79ed49fbc38941193..765ee7f78532a363813286ef7db2a7e48605cb06 100644 +--- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java ++++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java +@@ -96,12 +96,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc + public boolean isEmpty() { + this.unpackLootTable((Player)null); + // Paper start +- for (final ItemStack itemStack : this.getItems()) { +- if (!itemStack.isEmpty()) { +- return false; +- } +- } +- return true; ++ return this.isCompletelyEmpty(null); // Pufferfish - use super + // Paper end + } + +diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +index 4ff0d2fc9fd76e92e64abd69f2c9e299aa08ac32..3eeb1f0eac76efe9b7c24f6d5787018c7842d07a 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +@@ -85,6 +85,18 @@ public class LevelChunk extends ChunkAccess { + private final LevelChunkTicks blockTicks; + private final LevelChunkTicks fluidTicks; + ++ // Pufferfish start - instead of using a random every time the chunk is ticked, define when lightning strikes preemptively ++ private int lightningTick; ++ // shouldDoLightning compiles down to 29 bytes, which with the default of 35 byte inlining should guarantee an inline ++ public final boolean shouldDoLightning(net.minecraft.util.RandomSource random) { ++ if (this.lightningTick-- <= 0) { ++ this.lightningTick = random.nextInt(this.level.spigotConfig.thunderChance) << 1; ++ return true; ++ } ++ return false; ++ } ++ // Pufferfish end ++ + public LevelChunk(Level world, ChunkPos pos) { + this(world, pos, UpgradeData.EMPTY, new LevelChunkTicks<>(), new LevelChunkTicks<>(), 0L, (LevelChunkSection[]) null, (LevelChunk.PostLoadProcessor) null, (BlendingData) null); + } +@@ -112,6 +124,8 @@ public class LevelChunk extends ChunkAccess { + this.postLoad = entityLoader; + this.blockTicks = blockTickScheduler; + this.fluidTicks = fluidTickScheduler; ++ ++ this.lightningTick = this.level.getThreadUnsafeRandom().nextInt(100000) << 1; // Pufferfish - initialize lightning tick + } + + // CraftBukkit start +diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java +index d4477b0dda6a1ef7bd8323c0d11b636bd071d18e..5d3dd6a61366ae2c185b62bc9198440ef6227927 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java +@@ -25,6 +25,7 @@ public class LevelChunkSection { + public final PalettedContainer states; + // CraftBukkit start - read/write + private PalettedContainer> biomes; ++ public short fluidStateCount; // Pufferfish + public final com.destroystokyo.paper.util.maplist.IBlockDataList tickingList = new com.destroystokyo.paper.util.maplist.IBlockDataList(); // Paper + + public LevelChunkSection(PalettedContainer datapaletteblock, PalettedContainer> palettedcontainerro) { +@@ -190,6 +191,7 @@ public class LevelChunkSection { + + if (!fluid.isEmpty()) { + --this.tickingFluidCount; ++ --this.fluidStateCount; // Pufferfish + } + + if (!state.isAir()) { +@@ -204,6 +206,7 @@ public class LevelChunkSection { + + if (!fluid1.isEmpty()) { + ++this.tickingFluidCount; ++ ++this.fluidStateCount; // Pufferfish + } + + this.updateKnownBlockInfo(x | (z << 4) | (y << 8), iblockdata1, state); // Paper +@@ -249,6 +252,7 @@ public class LevelChunkSection { + if (fluid.isRandomlyTicking()) { + this.tickingFluidCount = (short) (this.tickingFluidCount + 1); + } ++ this.fluidStateCount++; // Pufferfish + } + + }); +diff --git a/src/main/java/net/minecraft/world/level/entity/EntityTickList.java b/src/main/java/net/minecraft/world/level/entity/EntityTickList.java +index 4cdfc433df67afcd455422e9baf56f167dd712ae..57fcf3910f45ce371ac2e237b277b1034caaac4e 100644 +--- a/src/main/java/net/minecraft/world/level/entity/EntityTickList.java ++++ b/src/main/java/net/minecraft/world/level/entity/EntityTickList.java +@@ -8,7 +8,7 @@ import javax.annotation.Nullable; + import net.minecraft.world.entity.Entity; + + public class EntityTickList { +- private final io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet entities = new io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet<>(true); // Paper - rewrite this, always keep this updated - why would we EVER tick an entity that's not ticking? ++ public final io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet entities = new io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet<>(true); // Paper - rewrite this, always keep this updated - why would we EVER tick an entity that's not ticking? // Pufferfish - private->public + + private void ensureActiveIsNotIterated() { + // Paper - replace with better logic, do not delay removals +diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java +index 5502ad143fd2575f1346334b5b4fe7846628f54e..7d56693102ee558fe784e3a9b9fdcff4b7ad57b9 100644 +--- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java ++++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java +@@ -44,6 +44,8 @@ public abstract class FlowingFluid extends Fluid { + public static final BooleanProperty FALLING = BlockStateProperties.FALLING; + public static final IntegerProperty LEVEL = BlockStateProperties.LEVEL_FLOWING; + private static final int CACHE_SIZE = 200; ++ // Pufferfish start - use our own cache ++ /* + private static final ThreadLocal> OCCLUSION_CACHE = ThreadLocal.withInitial(() -> { + Object2ByteLinkedOpenHashMap object2bytelinkedopenhashmap = new Object2ByteLinkedOpenHashMap(200) { + protected void rehash(int i) {} +@@ -52,6 +54,14 @@ public abstract class FlowingFluid extends Fluid { + object2bytelinkedopenhashmap.defaultReturnValue((byte) 127); + return object2bytelinkedopenhashmap; + }); ++ */ ++ ++ private static final ThreadLocal> localFluidDirectionCache = ThreadLocal.withInitial(() -> { ++ // Pufferfish todo - mess with this number for performance ++ // with 2048 it seems very infrequent on a small world that it has to remove old entries ++ return new gg.airplane.structs.FluidDirectionCache<>(2048); ++ }); ++ // Pufferfish end + private final Map shapes = Maps.newIdentityHashMap(); + + public FlowingFluid() {} +@@ -240,6 +250,8 @@ public abstract class FlowingFluid extends Fluid { + } + + private boolean canPassThroughWall(Direction face, BlockGetter world, BlockPos pos, BlockState state, BlockPos fromPos, BlockState fromState) { ++ // Pufferfish start - modify to use our cache ++ /* + Object2ByteLinkedOpenHashMap object2bytelinkedopenhashmap; + + if (!state.getBlock().hasDynamicShape() && !fromState.getBlock().hasDynamicShape()) { +@@ -247,9 +259,16 @@ public abstract class FlowingFluid extends Fluid { + } else { + object2bytelinkedopenhashmap = null; + } ++ */ ++ gg.airplane.structs.FluidDirectionCache cache = null; ++ ++ if (!state.getBlock().hasDynamicShape() && !fromState.getBlock().hasDynamicShape()) { ++ cache = localFluidDirectionCache.get(); ++ } + + Block.BlockStatePairKey block_a; + ++ /* + if (object2bytelinkedopenhashmap != null) { + block_a = new Block.BlockStatePairKey(state, fromState, face); + byte b0 = object2bytelinkedopenhashmap.getAndMoveToFirst(block_a); +@@ -260,11 +279,22 @@ public abstract class FlowingFluid extends Fluid { + } else { + block_a = null; + } ++ */ ++ if (cache != null) { ++ block_a = new Block.BlockStatePairKey(state, fromState, face); ++ Boolean flag = cache.getValue(block_a); ++ if (flag != null) { ++ return flag; ++ } ++ } else { ++ block_a = null; ++ } + + VoxelShape voxelshape = state.getCollisionShape(world, pos); + VoxelShape voxelshape1 = fromState.getCollisionShape(world, fromPos); + boolean flag = !Shapes.mergedFaceOccludes(voxelshape, voxelshape1, face); + ++ /* + if (object2bytelinkedopenhashmap != null) { + if (object2bytelinkedopenhashmap.size() == 200) { + object2bytelinkedopenhashmap.removeLastByte(); +@@ -272,6 +302,11 @@ public abstract class FlowingFluid extends Fluid { + + object2bytelinkedopenhashmap.putAndMoveToFirst(block_a, (byte) (flag ? 1 : 0)); + } ++ */ ++ if (cache != null) { ++ cache.putValue(block_a, flag); ++ } ++ // Pufferfish end + + return flag; + } +diff --git a/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java b/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java +index e43d07ccdd36f0c9f5b8e9c74cf0d87e17eec66a..8e441f7c2b2d911a0c0111aaa231fc6adae08730 100644 +--- a/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java ++++ b/src/main/java/net/minecraft/world/level/storage/loot/LootParams.java +@@ -21,8 +21,10 @@ public class LootParams { + + public LootParams(ServerLevel world, Map, Object> parameters, Map dynamicDrops, float luck) { + this.level = world; +- this.params = parameters; +- this.dynamicDrops = dynamicDrops; ++ // Pufferfish start - use unmodifiable maps instead of immutable ones to skip the copy ++ this.params = java.util.Collections.unmodifiableMap(parameters); ++ this.dynamicDrops = java.util.Collections.unmodifiableMap(dynamicDrops); ++ // Pufferfish end + this.luck = luck; + } + +diff --git a/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java b/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java +index ebe65474a4a05ff1637d7f37ebcfe690af59def5..42142c512b12e5b269c19f1e821c50e7496a5f25 100644 +--- a/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java ++++ b/src/main/java/net/minecraft/world/phys/shapes/EntityCollisionContext.java +@@ -19,47 +19,66 @@ public class EntityCollisionContext implements CollisionContext { + return defaultValue; + } + }; +- private final boolean descending; +- private final double entityBottom; +- private final ItemStack heldItem; +- private final Predicate canStandOnFluid; ++ // Pufferfish start - remove these and pray no plugin uses them ++ // private final boolean descending; ++ // private final double entityBottom; ++ // private final ItemStack heldItem; ++ // private final Predicate canStandOnFluid; ++ // Pufferfish end + @Nullable + private final Entity entity; + + protected EntityCollisionContext(boolean descending, double minY, ItemStack heldItem, Predicate walkOnFluidPredicate, @Nullable Entity entity) { +- this.descending = descending; +- this.entityBottom = minY; +- this.heldItem = heldItem; +- this.canStandOnFluid = walkOnFluidPredicate; ++ // Pufferfish start - remove these ++ // this.descending = descending; ++ // this.entityBottom = minY; ++ // this.heldItem = heldItem; ++ // this.canStandOnFluid = walkOnFluidPredicate; ++ // Pufferfish end + this.entity = entity; + } + + /** @deprecated */ + @Deprecated + protected EntityCollisionContext(Entity entity) { +- this(entity.isDescending(), entity.getY(), entity instanceof LivingEntity ? ((LivingEntity)entity).getMainHandItem() : ItemStack.EMPTY, entity instanceof LivingEntity ? ((LivingEntity)entity)::canStandOnFluid : (fluidState) -> { +- return false; +- }, entity); ++ // Pufferfish start - remove this ++ // this(entity.isDescending(), entity.getY(), entity instanceof LivingEntity ? ((LivingEntity)entity).getMainHandItem() : ItemStack.EMPTY, entity instanceof LivingEntity ? ((LivingEntity)entity)::canStandOnFluid : (fluidState) -> { ++ // return false; ++ // }, entity); ++ // Pufferfish end ++ this.entity = entity; + } + + @Override + public boolean isHoldingItem(Item item) { +- return this.heldItem.is(item); ++ // Pufferfish start ++ Entity entity = this.entity; ++ if (entity instanceof LivingEntity livingEntity) { ++ return livingEntity.getMainHandItem().is(item); ++ } ++ return ItemStack.EMPTY.is(item); ++ // Pufferfish end + } + + @Override + public boolean canStandOnFluid(FluidState stateAbove, FluidState state) { +- return this.canStandOnFluid.test(state) && !stateAbove.getType().isSame(state.getType()); ++ // Pufferfish start ++ Entity entity = this.entity; ++ if (entity instanceof LivingEntity livingEntity) { ++ return livingEntity.canStandOnFluid(state) && !stateAbove.getType().isSame(state.getType()); ++ } ++ return false; ++ // Pufferfish end + } + + @Override + public boolean isDescending() { +- return this.descending; ++ return this.entity != null && this.entity.isDescending(); // Pufferfish + } + + @Override + public boolean isAbove(VoxelShape shape, BlockPos pos, boolean defaultValue) { +- return this.entityBottom > (double)pos.getY() + shape.max(Direction.Axis.Y) - (double)1.0E-5F; ++ return (this.entity == null ? -Double.MAX_VALUE : entity.getY()) > (double)pos.getY() + shape.max(Direction.Axis.Y) - (double)1.0E-5F; // Pufferfish + } + + @Nullable +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +index 9f8c5ceb8485b14a84f2a7b2ffc8192be5c6bdfd..ac0684aebef870246e94f623f7a16066f8a3a418 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +@@ -261,7 +261,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 = "Pufferfish"; // Paper // Pufferfish + private final String serverVersion; + private final String bukkitVersion = Versioning.getBukkitVersion(); + private final Logger logger = Logger.getLogger("Minecraft"); +@@ -1062,6 +1062,11 @@ public final class CraftServer implements Server { + plugin.getPluginMeta().getDisplayName(), + "This plugin is not properly shutting down its async tasks when it is being shut down. This task may throw errors during the final shutdown logs and might not complete before process dies." + )); ++ getLogger().log(Level.SEVERE, String.format("%s Stacktrace", worker.getThread().getName())); ++ StackTraceElement[] stackTrace = worker.getThread().getStackTrace(); ++ for (StackTraceElement element : stackTrace) { ++ getLogger().log(Level.SEVERE, " " + element.toString()); ++ } + } + } + // Paper end +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java +index f7ea77dd82d978ad307f99c743efacfb34478b3d..009ab06182359862b8f543030ec4fe4e2572c93c 100644 +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java +@@ -44,6 +44,6 @@ public class CraftShapelessRecipe extends ShapelessRecipe implements CraftRecipe + data.set(i, toNMS(ingred.get(i), true)); + } + +- MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.ShapelessRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), this.getGroup(), CraftRecipe.getCategory(this.getCategory()), CraftItemStack.asNMSCopy(this.getResult()), data)); ++ MinecraftServer.getServer().getRecipeManager().addRecipe(new net.minecraft.world.item.crafting.ShapelessRecipe(CraftNamespacedKey.toMinecraft(this.getKey()), this.getGroup(), CraftRecipe.getCategory(this.getCategory()), CraftItemStack.asNMSCopy(this.getResult()), data, true)); + } + } +diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +index 83cef5ec27c31f133a23cd27349f722799c786ea..1adf1ab6af94b561dc8cbbd3e5746e0bb2a11d41 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +@@ -470,7 +470,7 @@ public final class CraftMagicNumbers implements UnsafeValues { + + @Override + public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() { +- return new com.destroystokyo.paper.PaperVersionFetcher(); ++ return new gg.pufferfish.pufferfish.PufferfishVersionFetcher(); // Pufferfish + } + + @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..80553face9c70c2a3d897681e7761df85b22d464 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/gg.pufferfish.pufferfish/pufferfish-api/pom.properties"); // Pufferfish + Properties properties = new Properties(); + + if (stream != null) { +diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java +index eda7f0bb42f7269676d5d2193e1155912ede9920..68557964e27fa1e5ba218178f9bcc0b28e3a78d9 100644 +--- a/src/main/java/org/spigotmc/ActivationRange.java ++++ b/src/main/java/org/spigotmc/ActivationRange.java +@@ -38,6 +38,10 @@ import co.aikar.timings.MinecraftTimings; + import net.minecraft.world.entity.schedule.Activity; + import net.minecraft.world.level.Level; + import net.minecraft.world.phys.AABB; ++// Pufferfish start ++import net.minecraft.world.phys.Vec3; ++import java.util.List; ++// Pufferfish end + + public class ActivationRange + { +@@ -217,6 +221,25 @@ public class ActivationRange + for (int i = 0; i < entities.size(); i++) { + Entity entity = entities.get(i); + ActivationRange.activateEntity(entity); ++ ++ // Pufferfish start ++ if (gg.pufferfish.pufferfish.PufferfishConfig.dearEnabled && entity.getType().dabEnabled) { ++ if (!entity.activatedPriorityReset) { ++ entity.activatedPriorityReset = true; ++ entity.activatedPriority = gg.pufferfish.pufferfish.PufferfishConfig.maximumActivationPrio; ++ } ++ Vec3 playerVec = player.position(); ++ Vec3 entityVec = entity.position(); ++ double diffX = playerVec.x - entityVec.x, diffY = playerVec.y - entityVec.y, diffZ = playerVec.z - entityVec.z; ++ int squaredDistance = (int) (diffX * diffX + diffY * diffY + diffZ * diffZ); ++ entity.activatedPriority = squaredDistance > gg.pufferfish.pufferfish.PufferfishConfig.startDistanceSquared ? ++ Math.max(1, Math.min(squaredDistance >> gg.pufferfish.pufferfish.PufferfishConfig.activationDistanceMod, entity.activatedPriority)) : ++ 1; ++ } else { ++ entity.activatedPriority = 1; ++ } ++ // Pufferfish end ++ + } + // Paper end + } +@@ -233,12 +256,12 @@ public class ActivationRange + if ( MinecraftServer.currentTick > entity.activatedTick ) + { + if ( entity.defaultActivationState ) +- { ++ { // Pufferfish - diff on change + entity.activatedTick = MinecraftServer.currentTick; + return; + } + if ( entity.activationType.boundingBox.intersects( entity.getBoundingBox() ) ) +- { ++ { // Pufferfish - diff on change + entity.activatedTick = MinecraftServer.currentTick; + } + } +@@ -292,7 +315,7 @@ public class ActivationRange + if ( entity instanceof LivingEntity ) + { + LivingEntity living = (LivingEntity) entity; +- if ( living.onClimbable() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 ) // Paper ++ if ( living.onClimableCached() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 ) // Paper // Pufferfish - use cached + { + return 1; // Paper + } diff --git a/patches/removed/server/0002-Fix-pufferfish-issues.patch b/patches/server/0002-Fix-pufferfish-issues.patch similarity index 90% rename from patches/removed/server/0002-Fix-pufferfish-issues.patch rename to patches/server/0002-Fix-pufferfish-issues.patch index 224cfcaf8..b72835a19 100644 --- a/patches/removed/server/0002-Fix-pufferfish-issues.patch +++ b/patches/server/0002-Fix-pufferfish-issues.patch @@ -27,10 +27,10 @@ index 0dd3374468e05f7a312ba5856b9cf8a4787dfa59..960c0555a001fe63de78d77d5ea47d08 "This can improve performance by a few percent, but has minor gameplay implications."); } diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 3ee5c3c17d450dce54e051dc53c9df44d9b3dc1b..de2d7bdd7c6f38f4d9c943162846c816bc814bd4 100644 +index eac31c3fcc9161711328588ac852fcae1116d8ef..dbb59969cf55eda997588f4c3ef7dc899ea619bb 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -807,7 +807,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -948,7 +948,7 @@ public class ServerLevel extends Level implements WorldGenLevel { } // Paper start - optimise random block ticking private final BlockPos.MutableBlockPos chunkTickMutablePosition = new BlockPos.MutableBlockPos(); @@ -40,10 +40,10 @@ index 3ee5c3c17d450dce54e051dc53c9df44d9b3dc1b..de2d7bdd7c6f38f4d9c943162846c816 private int currentIceAndSnowTick = 0; protected void resetIceAndSnowTick() { this.currentIceAndSnowTick = this.randomTickRandom.nextInt(16); } // Pufferfish diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 6aec1983a0236d6aa0507a2b3ad1c08b3330f0fc..66cc44d9f14b01f6c8e53b0f990866ac897c1c81 100644 +index 30d8ec75203adc677e5fb91d9538baf52a0684ad..5eca99fbd23ff0d35607bd185b011d6f9a30d0f0 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -274,7 +274,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -273,7 +273,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { public abstract ResourceKey getTypeKey(); @@ -53,10 +53,10 @@ index 6aec1983a0236d6aa0507a2b3ad1c08b3330f0fc..66cc44d9f14b01f6c8e53b0f990866ac // Pufferfish start - ensure these get inlined private final int minBuildHeight, minSection, height, maxBuildHeight, maxSection; diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -index 13594b96cc8f451723c3598ef302ccee8e01bcac..96394bc930a8dab04cd7f5b6e0e9d457b11f58e3 100644 +index 3eeb1f0eac76efe9b7c24f6d5787018c7842d07a..dbb0593a6feb60216379bde6720ca16f3ca827ae 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -@@ -129,7 +129,7 @@ public class LevelChunk extends ChunkAccess { +@@ -125,7 +125,7 @@ public class LevelChunk extends ChunkAccess { this.blockTicks = blockTickScheduler; this.fluidTicks = fluidTickScheduler; diff --git a/patches/server/0001-Rebrand.patch b/patches/server/0003-Rebrand.patch similarity index 96% rename from patches/server/0001-Rebrand.patch rename to patches/server/0003-Rebrand.patch index ddb65cbfb..b014d5108 100644 --- a/patches/server/0001-Rebrand.patch +++ b/patches/server/0003-Rebrand.patch @@ -5,25 +5,27 @@ Subject: [PATCH] Rebrand diff --git a/build.gradle.kts b/build.gradle.kts -index a0c5592530d2a59bfde87d1e9eb3752e7d4694da..af58d80d3c031dc00f8ac0e17b6a862b17eab97d 100644 +index a3da1d0c043ad4f8786ba6c4e25077e14efec364..3030116af88d66c376e794b55a4716381fc7552b 100644 --- a/build.gradle.kts +++ b/build.gradle.kts -@@ -7,8 +7,12 @@ plugins { +@@ -7,12 +7,12 @@ plugins { } dependencies { -- implementation(project(":paper-api")) -- implementation(project(":paper-mojangapi")) +- implementation(project(":pufferfish-api")) // Pufferfish // Paper +- // Pufferfish start +- implementation("io.papermc.paper:paper-mojangapi:1.19.2-R0.1-SNAPSHOT") { + // Purpur start -+ implementation(project(":purpur-api")) // Pufferfish ++ implementation(project(":purpur-api")) + implementation("io.papermc.paper:paper-mojangapi:${project.version}") { -+ exclude("io.papermc.paper", "paper-api") -+ } + exclude("io.papermc.paper", "paper-api") + } +- // Pufferfish end + // Purpur end // Paper start implementation("org.jline:jline-terminal-jansi:3.21.0") implementation("net.minecrell:terminalconsoleappender:1.3.0") -@@ -39,6 +43,10 @@ dependencies { +@@ -43,6 +43,10 @@ dependencies { } // Paper end @@ -34,16 +36,16 @@ index a0c5592530d2a59bfde87d1e9eb3752e7d4694da..af58d80d3c031dc00f8ac0e17b6a862b runtimeOnly("org.apache.maven:maven-resolver-provider:3.9.2") runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.9.10") runtimeOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.9.10") -@@ -63,7 +71,7 @@ tasks.jar { +@@ -82,7 +86,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-Pufferfish-$implementationVersion", // Pufferfish + "Implementation-Version" to "git-Purpur-$implementationVersion", // Pufferfish // Purpur "Implementation-Vendor" to date, // Paper "Specification-Title" to "Bukkit", "Specification-Version" to project.version, -@@ -135,7 +143,7 @@ fun TaskContainer.registerRunTask( +@@ -154,7 +158,7 @@ fun TaskContainer.registerRunTask( name: String, block: JavaExec.() -> Unit ): TaskProvider = register(name) { @@ -175,10 +177,19 @@ index abe37c7c3c6f5ab73afd738ec78f06d7e4d2ed96..b5b6657e52e4f7a630229bd3ba433438 stringbuilder.append(CrashReport.getErrorComment()); stringbuilder.append("\n\n"); diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 80cf4852e4010eeeadaf920ab927a40df0179b40..b5bf78380b6d3b93c5d4a0b94f4df6803a213f17 100644 +index 55d5e325006d5a948b98451b1e455bb8bb869cbb..73951d1456584d6e0938b3dec5a10eb79ad75e19 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -921,7 +921,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop S spin(Function serverFactory) { +@@ -923,7 +923,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop // Spigot - Spigot > // CraftBukkit - cb > vanilla! +- return "Pufferfish"; // Pufferfish - Pufferfish > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla! + return "Purpur"; // Purpur - Purpur > // Pufferfish - Pufferfish > // 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 9f8c5ceb8485b14a84f2a7b2ffc8192be5c6bdfd..5bc5270dd4e601ea29b4ac6588ab39ca410ae4cd 100644 +index ac0684aebef870246e94f623f7a16066f8a3a418..c34d64a17638a1164a149595478d08d8349caabb 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -261,7 +261,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 = "Pufferfish"; // Paper // Pufferfish + private final String serverName = "Purpur"; // Paper // Pufferfish // Purpur private final String serverVersion; private final String bukkitVersion = Versioning.getBukkitVersion(); @@ -263,27 +274,27 @@ index d7ce4971d9271dbeff4adb9d852e4e7bdf60bf03..5a47a8785bc2e251d041f80a79295c43 // (async tasks must live with race-conditions if they attempt to cancel between these few lines of code) } diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -index 83cef5ec27c31f133a23cd27349f722799c786ea..b0dedc0883475fc2ecb9b3a22c43eb5d3b312dbe 100644 +index 1adf1ab6af94b561dc8cbbd3e5746e0bb2a11d41..0aee1fadaeb948fd90d8e61ac57dbe7f810529ff 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java @@ -470,7 +470,7 @@ public final class CraftMagicNumbers implements UnsafeValues { @Override public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() { -- return new com.destroystokyo.paper.PaperVersionFetcher(); -+ return new com.destroystokyo.paper.PaperVersionFetcher(); // Purpur +- return new gg.pufferfish.pufferfish.PufferfishVersionFetcher(); // Pufferfish ++ return new com.destroystokyo.paper.PaperVersionFetcher(); // Pufferfish // Purpur } @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..99597258e8e88cd9e2c901c4ac3ff7faeeabee2b 100644 +index 80553face9c70c2a3d897681e7761df85b22d464..99597258e8e88cd9e2c901c4ac3ff7faeeabee2b 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/gg.pufferfish.pufferfish/pufferfish-api/pom.properties"); // Pufferfish + InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/org.purpurmc.purpur/purpur-api/pom.properties"); // Pufferfish // Purpur Properties properties = new Properties(); diff --git a/patches/server/0002-Purpur-config-files.patch b/patches/server/0004-Purpur-config-files.patch similarity index 96% rename from patches/server/0002-Purpur-config-files.patch rename to patches/server/0004-Purpur-config-files.patch index 8fef50627..7abbc6c59 100644 --- a/patches/server/0002-Purpur-config-files.patch +++ b/patches/server/0004-Purpur-config-files.patch @@ -5,14 +5,14 @@ Subject: [PATCH] Purpur config files diff --git a/src/main/java/com/destroystokyo/paper/Metrics.java b/src/main/java/com/destroystokyo/paper/Metrics.java -index 4b002e8b75d117b726b0de274a76d3596fce015b..8cde30544e14f8fc2dac32966ae3c21f8cf3a551 100644 +index 692c962193cf9fcc6801fc93f3220bdc673d527b..8cde30544e14f8fc2dac32966ae3c21f8cf3a551 100644 --- a/src/main/java/com/destroystokyo/paper/Metrics.java +++ b/src/main/java/com/destroystokyo/paper/Metrics.java @@ -593,7 +593,7 @@ public class Metrics { boolean logFailedRequests = config.getBoolean("logFailedRequests", false); // Only start Metrics, if it's enabled in the config if (config.getBoolean("enabled", true)) { -- Metrics metrics = new Metrics("Paper", serverUUID, logFailedRequests, Bukkit.getLogger()); +- Metrics metrics = new Metrics("Pufferfish", serverUUID, logFailedRequests, Bukkit.getLogger()); // Pufferfish + Metrics metrics = new Metrics("Purpur", serverUUID, logFailedRequests, Bukkit.getLogger()); // Pufferfish // Purpur metrics.addCustomChart(new Metrics.SimplePie("minecraft_version", () -> { @@ -26,11 +26,11 @@ index 4b002e8b75d117b726b0de274a76d3596fce015b..8cde30544e14f8fc2dac32966ae3c21f - final String implVersion = org.bukkit.craftbukkit.Main.class.getPackage().getImplementationVersion(); - if (implVersion != null) { - final String buildOrHash = implVersion.substring(implVersion.lastIndexOf('-') + 1); -- paperVersion = "git-Paper-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); +- paperVersion = "git-Pufferfish-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); // Pufferfish - } else { - paperVersion = "unknown"; - } -- metrics.addCustomChart(new Metrics.SimplePie("paper_version", () -> paperVersion)); +- metrics.addCustomChart(new Metrics.SimplePie("pufferfish_version", () -> paperVersion)); // Pufferfish + metrics.addCustomChart(new Metrics.SimplePie("online_mode", () -> Bukkit.getOnlineMode() ? "online" : (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() ? "bungee" : "offline"))); // Purpur + metrics.addCustomChart(new Metrics.SimplePie("purpur_version", () -> (org.bukkit.craftbukkit.Main.class.getPackage().getImplementationVersion() != null) ? org.bukkit.craftbukkit.Main.class.getPackage().getImplementationVersion() : "unknown")); // Purpur @@ -72,7 +72,7 @@ index 22884a2b148b9a5af8655bb754ebe73618218a83..4d9a796422ab595acc8b0158cf9dcd5b boolean flag1 = this.source.acceptsSuccess() && !this.silent; boolean flag2 = broadcastToOps && this.source.shouldInformAdmins() && !this.silent; diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java -index 9f422cbeaa52b3e6a0a27af4f8ad4ddb7808483f..44d76c80e67bc0d5ab28e26bfcf64e2534e627a5 100644 +index 28af96ce4f9f1a83316b6fd9e1625c71b5874c3f..cf7c7b3cd4081e1be059647dca237ffd72c374df 100644 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java @@ -218,6 +218,15 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface @@ -92,7 +92,7 @@ index 9f422cbeaa52b3e6a0a27af4f8ad4ddb7808483f..44d76c80e67bc0d5ab28e26bfcf64e25 io.papermc.paper.brigadier.PaperBrigadierProviderImpl.INSTANCE.getClass(); // init PaperBrigadierProvider // Paper end diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 147d802d9207e358fdb2d1c7806fc2f634dcfd98..13176ad151b53047993938838b3763f85ae1aeff 100644 +index 5eca99fbd23ff0d35607bd185b011d6f9a30d0f0..6a9f5e3f8c72363b91b23729df5e98784d66ba8b 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java @@ -176,6 +176,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { @@ -103,7 +103,7 @@ index 147d802d9207e358fdb2d1c7806fc2f634dcfd98..13176ad151b53047993938838b3763f8 public final co.aikar.timings.WorldTimingsHandler timings; // Paper public static BlockPos lastPhysicsProblem; // Spigot private org.spigotmc.TickLimiter entityLimiter; -@@ -276,6 +277,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -287,6 +288,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, RegistryAccess iregistrycustom, Holder holder, Supplier supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper @@ -112,7 +112,7 @@ index 147d802d9207e358fdb2d1c7806fc2f634dcfd98..13176ad151b53047993938838b3763f8 this.world = new CraftWorld((ServerLevel) this, gen, biomeProvider, env); diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 5bc5270dd4e601ea29b4ac6588ab39ca410ae4cd..4a00ab2a4b1d445c43d633c50c7ff66aa4034d60 100644 +index c34d64a17638a1164a149595478d08d8349caabb..a487bdaa357e42cb00778505f3cf2283f5602b26 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -979,6 +979,7 @@ public final class CraftServer implements Server { @@ -139,7 +139,7 @@ index 5bc5270dd4e601ea29b4ac6588ab39ca410ae4cd..4a00ab2a4b1d445c43d633c50c7ff66a this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*"); this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions"); -@@ -2776,6 +2779,18 @@ public final class CraftServer implements Server { +@@ -2781,6 +2784,18 @@ public final class CraftServer implements Server { return CraftServer.this.console.paperConfigurations.createLegacyObject(CraftServer.this.console); } diff --git a/patches/server/0003-Purpur-client-support.patch b/patches/server/0005-Purpur-client-support.patch similarity index 94% rename from patches/server/0003-Purpur-client-support.patch rename to patches/server/0005-Purpur-client-support.patch index a43a2620c..4ee78d53f 100644 --- a/patches/server/0003-Purpur-client-support.patch +++ b/patches/server/0005-Purpur-client-support.patch @@ -17,10 +17,10 @@ index 9d46536f80b5b3e6641fd377c02166a431edfd77..16b742fdaf5524b22cedb4d5ba047559 private final java.util.concurrent.atomic.AtomicReference viewDistances = new java.util.concurrent.atomic.AtomicReference<>(new io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances(-1, -1, -1)); public io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader; diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index d9c2d06ae24dcf80a497e75f4c7f63d401b77f9b..ec3b1437d4bc8c21c596c53b665e3d8cb20f7f0e 100644 +index 29dbd3a902c2d620b9da191d0bcd9f6e9108034a..3b19ee96281e47591473e50b0b961334a422f58a 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -3505,6 +3505,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -3507,6 +3507,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic private static final ResourceLocation CUSTOM_UNREGISTER = new ResourceLocation("unregister"); private static final ResourceLocation MINECRAFT_BRAND = new ResourceLocation("brand"); // Paper - Brand support @@ -28,7 +28,7 @@ index d9c2d06ae24dcf80a497e75f4c7f63d401b77f9b..ec3b1437d4bc8c21c596c53b665e3d8c @Override public void handleCustomPayload(ServerboundCustomPayloadPacket packet) { -@@ -3529,6 +3530,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -3531,6 +3532,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic ServerGamePacketListenerImpl.LOGGER.error("Couldn\'t unregister custom payload", ex); this.disconnect("Invalid payload UNREGISTER!", org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PAYLOAD); // Paper - kick event cause } diff --git a/patches/server/0004-Fix-decompile-errors.patch b/patches/server/0006-Fix-decompile-errors.patch similarity index 100% rename from patches/server/0004-Fix-decompile-errors.patch rename to patches/server/0006-Fix-decompile-errors.patch diff --git a/patches/server/0005-Component-related-conveniences.patch b/patches/server/0007-Component-related-conveniences.patch similarity index 92% rename from patches/server/0005-Component-related-conveniences.patch rename to patches/server/0007-Component-related-conveniences.patch index 9596a9e86..080801005 100644 --- a/patches/server/0005-Component-related-conveniences.patch +++ b/patches/server/0007-Component-related-conveniences.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Component related conveniences diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index a808c7bb143dc8c5f60bf8eacdb6e45f73da69fb..15539499b5a0f16ad2d44c39c5b824876fdf0951 100644 +index 16b742fdaf5524b22cedb4d5ba047559e3ac8371..41698264b3155f20f7a7d473a43aa2dab7ca61bb 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -1774,6 +1774,26 @@ public class ServerPlayer extends Player { @@ -36,7 +36,7 @@ index a808c7bb143dc8c5f60bf8eacdb6e45f73da69fb..15539499b5a0f16ad2d44c39c5b82487 public void displayClientMessage(Component message, boolean overlay) { this.sendSystemMessage(message, overlay); diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 683b5d78f9e3dc34e40c54683f64be32317797ac..01a550086f21672c7e2e51e304bf8fcffd6451f0 100644 +index 8547e7ff2f1f5b7701fb0f3c3010c14601a5f83e..c5cfc95df8cc8c1768457bc640d447148d0f6644 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -1036,6 +1036,20 @@ public abstract class PlayerList { @@ -81,10 +81,10 @@ index 25a5a3b949a0eb632611355e74ccd4865be108ca..14fcfd7c1d3a62833978e163f4e0d6f9 return this.type().msgId(); } diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 92202262eff01ae3bbeff0e6ebdcf26ad613c169..ac795034342cabd85ccb62faf0adb10ee4ac1c00 100644 +index 53fec4d15ac3d21e5f82c76133ee8dc449d1e67a..9021cf92fcb4d338e70d5b2e3bb6c93df755e0a9 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -4011,6 +4011,20 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -4045,6 +4045,20 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return SlotAccess.NULL; } diff --git a/patches/server/0006-Ridables.patch b/patches/server/0008-Ridables.patch similarity index 98% rename from patches/server/0006-Ridables.patch rename to patches/server/0008-Ridables.patch index 2370e062a..5c7e2a822 100644 --- a/patches/server/0006-Ridables.patch +++ b/patches/server/0008-Ridables.patch @@ -22,10 +22,10 @@ index 83cab746d1d6fe25c043c8aee28c39412b90c127..ec6b58dae525c81bbb1c0e2d96fbded6 super(x, y, z); } diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index b5bf78380b6d3b93c5d4a0b94f4df6803a213f17..3d2af8732f60b29619e3701acca9429c6d5a32f8 100644 +index 73951d1456584d6e0938b3dec5a10eb79ad75e19..a4cc0f1ab0fc138c22b9472ce8d3d6ad7561a7df 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1524,6 +1524,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0; // Paper net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = worldserver.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper worldserver.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper @@ -34,7 +34,7 @@ index b5bf78380b6d3b93c5d4a0b94f4df6803a213f17..3d2af8732f60b29619e3701acca9429c this.profiler.push(() -> { return worldserver + " " + worldserver.dimension().location(); diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 18aac3da3c88f33b1a71a5920a8daa27e9723913..a6acc178949f45c18009b5da2b8998cbcab2289b 100644 +index dbb59969cf55eda997588f4c3ef7dc899ea619bb..4c3b5a26a6b04afff3a707929ced3c62b5256a67 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -223,6 +223,7 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -66,10 +66,10 @@ index 41698264b3155f20f7a7d473a43aa2dab7ca61bb..77c38ea427dac0176941f8bc26ebe540 public void doTick() { diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index ec3b1437d4bc8c21c596c53b665e3d8cb20f7f0e..c7b9acaee1c14fde6d557c1068bf4544a282da24 100644 +index 3b19ee96281e47591473e50b0b961334a422f58a..304b825da36f883b887118a20975f49347f76940 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2808,6 +2808,8 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2810,6 +2810,8 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic ServerGamePacketListenerImpl.this.cserver.getPluginManager().callEvent(event); @@ -79,7 +79,7 @@ index ec3b1437d4bc8c21c596c53b665e3d8cb20f7f0e..c7b9acaee1c14fde6d557c1068bf4544 if ((entity instanceof Bucketable && entity instanceof LivingEntity && origItem != null && origItem.asItem() == Items.WATER_BUCKET) && (event.isCancelled() || ServerGamePacketListenerImpl.this.player.getInventory().getSelected() == null || ServerGamePacketListenerImpl.this.player.getInventory().getSelected().getItem() != origItem)) { entity.getEntityData().resendPossiblyDesyncedEntity(player); // Paper - The entire mob gets deleted, so resend it. diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 6bd894fa4617d5132a735d90fed89fcd36d330fc..c07db4a711fd15a461f13226a54929cf5991b7b8 100644 +index 9021cf92fcb4d338e70d5b2e3bb6c93df755e0a9..50762602899893b20b38a6fa5cc516a5575af880 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -364,7 +364,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { @@ -91,7 +91,7 @@ index 6bd894fa4617d5132a735d90fed89fcd36d330fc..c07db4a711fd15a461f13226a54929cf private float eyeHeight; public boolean isInPowderSnow; public boolean wasInPowderSnow; -@@ -2910,6 +2910,13 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -2944,6 +2944,13 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.passengers = ImmutableList.copyOf(list); } @@ -105,7 +105,7 @@ index 6bd894fa4617d5132a735d90fed89fcd36d330fc..c07db4a711fd15a461f13226a54929cf this.gameEvent(GameEvent.ENTITY_MOUNT, entity); } return true; // CraftBukkit -@@ -2951,6 +2958,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -2985,6 +2992,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return false; } // Spigot end @@ -120,7 +120,7 @@ index 6bd894fa4617d5132a735d90fed89fcd36d330fc..c07db4a711fd15a461f13226a54929cf if (this.passengers.size() == 1 && this.passengers.get(0) == entity) { this.passengers = ImmutableList.of(); } else { -@@ -4790,4 +4805,45 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -4876,4 +4891,45 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return ((net.minecraft.server.level.ServerChunkCache) level.getChunkSource()).isPositionTicking(this); } // Paper end @@ -191,10 +191,10 @@ index 759713f7c646aaf1a918c87a2834a1d405385dad..c6a06e07f0b4bb29b5f4c70dfa53ff6d protected ParticleOptions getInkParticle() { return ParticleTypes.GLOW_SQUID_INK; diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f8d2d2786 100644 +index eccd61f5401ecb2ef0b460337a3284d1844bd85f..559d0efb855175806a2c2ce3a0e5139a96bfec79 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -220,9 +220,9 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -219,9 +219,9 @@ public abstract class LivingEntity extends Entity implements Attackable { protected int deathScore; public float lastHurt; public boolean jumping; @@ -207,7 +207,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f protected int lerpSteps; protected double lerpX; protected double lerpY; -@@ -288,7 +288,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -287,7 +287,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.effectsDirty = true; this.useItem = ItemStack.EMPTY; this.lastClimbablePos = Optional.empty(); @@ -216,7 +216,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f this.craftAttributes = new CraftAttributeMap(this.attributes); // CraftBukkit // CraftBukkit - setHealth(getMaxHealth()) inlined and simplified to skip the instanceof check for EntityPlayer, as getBukkitEntity() is not initialized in constructor this.entityData.set(LivingEntity.DATA_HEALTH_ID, (float) this.getAttribute(Attributes.MAX_HEALTH).getValue()); -@@ -339,6 +339,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -338,6 +338,7 @@ public abstract class LivingEntity extends Entity implements Attackable { public static AttributeSupplier.Builder createLivingAttributes() { return AttributeSupplier.builder().add(Attributes.MAX_HEALTH).add(Attributes.KNOCKBACK_RESISTANCE).add(Attributes.MOVEMENT_SPEED).add(Attributes.ARMOR).add(Attributes.ARMOR_TOUGHNESS); } @@ -224,7 +224,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f @Override protected void checkFallDamage(double heightDifference, boolean onGround, BlockState state, BlockPos landedPosition) { -@@ -2674,7 +2675,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2696,7 +2697,7 @@ public abstract class LivingEntity extends Entity implements Attackable { } protected long lastJumpTime = 0L; // Paper @@ -233,7 +233,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f Vec3 vec3d = this.getDeltaMovement(); // Paper start long time = System.nanoTime(); -@@ -3446,8 +3447,10 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3468,8 +3469,10 @@ public abstract class LivingEntity extends Entity implements Attackable { this.pushEntities(); this.level().getProfiler().pop(); // Paper start @@ -246,7 +246,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f Location from = new Location(this.level().getWorld(), this.xo, this.yo, this.zo, this.yRotO, this.xRotO); Location to = new Location (this.level().getWorld(), this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot()); io.papermc.paper.event.entity.EntityMoveEvent event = new io.papermc.paper.event.entity.EntityMoveEvent(this.getBukkitLivingEntity(), from, to.clone()); -@@ -3457,6 +3460,21 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3479,6 +3482,21 @@ public abstract class LivingEntity extends Entity implements Attackable { this.absMoveTo(event.getTo().getX(), event.getTo().getY(), event.getTo().getZ(), event.getTo().getYaw(), event.getTo().getPitch()); } } @@ -269,7 +269,7 @@ index a189461330a4d427a7450d504ef13de3605497e3..dcf0a29c8736d9bc48e15f6cff84c45f // Paper end if (!this.level().isClientSide && this.isSensitiveToWater() && this.isInWaterRainOrBubble()) { diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index e2a25c29ec74147b3e66aa0b3deb85a8f6ee53a5..d2ae293a23f8d02b3a2f0a60e4389497be77b60d 100644 +index f6eb032897c6d5d16ab5c8c287e49e189c24571c..1f4c41521c9d6fd781f96c7d9552c8e55bbf347b 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -145,8 +145,8 @@ public abstract class Mob extends LivingEntity implements Targeting { @@ -283,7 +283,7 @@ index e2a25c29ec74147b3e66aa0b3deb85a8f6ee53a5..d2ae293a23f8d02b3a2f0a60e4389497 this.jumpControl = new JumpControl(this); this.bodyRotationControl = this.createBodyControl(); this.navigation = this.createNavigation(world); -@@ -1375,7 +1375,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1381,7 +1381,7 @@ public abstract class Mob extends LivingEntity implements Targeting { protected void onOffspringSpawnedFromEgg(Player player, Mob child) {} protected InteractionResult mobInteract(Player player, InteractionHand hand) { @@ -292,7 +292,7 @@ index e2a25c29ec74147b3e66aa0b3deb85a8f6ee53a5..d2ae293a23f8d02b3a2f0a60e4389497 } public boolean isWithinRestriction() { -@@ -1753,4 +1753,56 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1759,4 +1759,56 @@ public abstract class Mob extends LivingEntity implements Targeting { return itemmonsteregg == null ? null : new ItemStack(itemmonsteregg); } @@ -350,13 +350,13 @@ index e2a25c29ec74147b3e66aa0b3deb85a8f6ee53a5..d2ae293a23f8d02b3a2f0a60e4389497 + // Purpur end } diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java -index dd1102d5291ef6f18e82400a6d8a0a376cc071e9..9932a801be1bde1c57697396c097fb47a6b26ede 100644 +index e283eb57c25f7de222f9d09dca851169f5f6e488..210a0bee1227e4671909dd553ab22027cfc868fb 100644 --- a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java +++ b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java -@@ -23,13 +23,20 @@ public class AttributeMap { - private final Map attributes = Maps.newHashMap(); +@@ -24,14 +24,21 @@ public class AttributeMap { private final Set dirtyAttributes = Sets.newHashSet(); private final AttributeSupplier supplier; + private final java.util.function.Function createInstance; // Pufferfish + private final net.minecraft.world.entity.LivingEntity entity; // Purpur public AttributeMap(AttributeSupplier defaultAttributes) { @@ -367,6 +367,7 @@ index dd1102d5291ef6f18e82400a6d8a0a376cc071e9..9932a801be1bde1c57697396c097fb47 + this.entity = entity; + // Purpur end this.supplier = defaultAttributes; + this.createInstance = attribute -> this.supplier.createInstance(this::onAttributeModified, attribute); // Pufferfish } private void onAttributeModified(AttributeInstance instance) { @@ -375,7 +376,7 @@ index dd1102d5291ef6f18e82400a6d8a0a376cc071e9..9932a801be1bde1c57697396c097fb47 this.dirtyAttributes.add(instance); } -@@ -41,7 +48,7 @@ public class AttributeMap { +@@ -43,7 +50,7 @@ public class AttributeMap { public Collection getSyncableAttributes() { return this.attributes.values().stream().filter((attribute) -> { @@ -526,7 +527,7 @@ index 7df56705a4a0de2dc4ff7ab133fc26612c219162..384bed4505b6cabb1ae151cd2c4eb5e5 --this.lookAtCooldown; this.getYRotD().ifPresent((yaw) -> { diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java -index 940cd932e74bc2e6754186731d7aa6f10d56eb68..2ac0c8a7335450c192352da9c34151a70a2645dd 100644 +index 92a9770fabc6a8175245fef92753c52bc18d16ac..fc240adb941cfa7db37916516b63cbfdb83f737d 100644 --- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java +++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java @@ -18,6 +18,7 @@ import net.minecraft.world.entity.EntityDimensions; @@ -2141,7 +2142,7 @@ index 27c4dd3605373f08078048fe923a8f6f4d3ccf3b..cb2b8c7cbbe882ae0ca876edaa66bea1 this.targetSelector.addGoal(2, new OwnerHurtTargetGoal(this)); this.targetSelector.addGoal(3, (new HurtByTargetGoal(this, new Class[0])).setAlertOthers()); diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java -index 339c70f101d026a100a801e66cf514b3329a89d2..9588f9adad23aa6f2240d1ddb2f92aa82e8e740b 100644 +index 1a0eee3b766a5ce5623c32ed9c023a0f80db1d1a..801dde462d5ff785691157520270f6f20e1bd1b2 100644 --- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java @@ -101,10 +101,23 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS @@ -2199,7 +2200,7 @@ index 339c70f101d026a100a801e66cf514b3329a89d2..9588f9adad23aa6f2240d1ddb2f92aa8 protected Brain.Provider brainProvider() { return Brain.provider(Allay.MEMORY_TYPES, Allay.SENSOR_TYPES); diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -index 2682a49cd3948e0f80e2d7e58abcd3e6d8f7ac4e..ede5469f26f530beacfc655581e213d39276c7d9 100644 +index 42e22a4b9cb6841de04862cc81454da3232aa65a..943bd1f270e7e355840dd3b07151c0e5ba9492e4 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java @@ -98,6 +98,23 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder getModelRotationValues() { return this.modelRotationValues; -@@ -519,14 +536,22 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder { @@ -2350,7 +2351,7 @@ index 203691417e208b9e023e5f8c3b76993db2747ba8..d4100aab149913a3146ce00f20baf15e @Override protected Brain.Provider brainProvider() { return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); -@@ -345,7 +394,7 @@ public class Frog extends Animal implements VariantHolder { +@@ -347,7 +396,7 @@ public class Frog extends Animal implements VariantHolder { return world.getBlockState(pos.below()).is(BlockTags.FROGS_SPAWNABLE_ON) && isBrightEnoughToSpawn(world, pos); } @@ -2360,7 +2361,7 @@ index 203691417e208b9e023e5f8c3b76993db2747ba8..d4100aab149913a3146ce00f20baf15e super(entity); } diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java -index 4aeab90e778629c355189dfe79c39c4b21f5f5ac..955e112f52898ffde28e1b49b6e91d3e33e057b5 100644 +index 6ed4ac06c76b8d0d6e8db778cade15dbd1e3e5f5..05545b399d068e5c88f4fcd2729e616222fe1e3a 100644 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java @@ -45,13 +45,50 @@ public class Tadpole extends AbstractFish { @@ -2416,7 +2417,7 @@ index 4aeab90e778629c355189dfe79c39c4b21f5f5ac..955e112f52898ffde28e1b49b6e91d3e protected PathNavigation createNavigation(Level world) { return new WaterBoundPathNavigation(this, world); diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index 528e7ba29dcd38726b2c1bbc1d8ac208c64ba9df..98f9489623a755778bec2f8977b57882ad2f0b4f 100644 +index 2c7193e967b4cb5a7c98a760286a2c3791152359..1d9e2c93fa08d6f2f16b81021477294a6de3ce04 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -89,6 +89,23 @@ public class Goat extends Animal { @@ -2443,11 +2444,12 @@ index 528e7ba29dcd38726b2c1bbc1d8ac208c64ba9df..98f9489623a755778bec2f8977b57882 @Override protected Brain.Provider brainProvider() { return Brain.provider(Goat.MEMORY_TYPES, Goat.SENSOR_TYPES); -@@ -191,6 +208,7 @@ public class Goat extends Animal { +@@ -192,7 +209,7 @@ public class Goat extends Animal { @Override protected void customServerAiStep() { this.level().getProfiler().push("goatBrain"); -+ //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch +- if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish ++ if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch this.getBrain().tick((ServerLevel) this.level(), this); this.level().getProfiler().pop(); this.level().getProfiler().push("goatActivityUpdate"); @@ -3429,7 +3431,7 @@ index 8f481e11815d7162dd62a2b850b3d2af6d904519..16486ece9fc415d875ff94d9b806b0b5 return Guardian.createAttributes().add(Attributes.MOVEMENT_SPEED, 0.30000001192092896D).add(Attributes.ATTACK_DAMAGE, 8.0D).add(Attributes.MAX_HEALTH, 80.0D); } diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index 5519ccf558c09f32e19b35f4b403fc9ed966ed65..f05c8b8201e3ccc853080b1afd2eecf17ee4a8a2 100644 +index 54a9529ea92889d57e348307a35097f715a13501..c3cfa392b92b9bc7944fd28782b3b74cf15702bb 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java @@ -92,9 +92,27 @@ public class EnderMan extends Monster implements NeutralMob { @@ -3477,7 +3479,7 @@ index 5519ccf558c09f32e19b35f4b403fc9ed966ed65..f05c8b8201e3ccc853080b1afd2eecf1 float f = this.getLightLevelDependentMagicValue(); if (f > 0.5F && this.level().canSeeSky(this.blockPosition()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.RUNAWAY)) { // Paper -@@ -398,6 +417,7 @@ public class EnderMan extends Monster implements NeutralMob { +@@ -404,6 +423,7 @@ public class EnderMan extends Monster implements NeutralMob { public boolean hurt(DamageSource source, float amount) { if (this.isInvulnerableTo(source)) { return false; @@ -4820,7 +4822,7 @@ index aff140cfb2bbdce8b512080cf394c84c5c4ff807..fe9bdc4006b916748e55a976b6c86210 public void setPersistentAngerTarget(@Nullable UUID angryAt) { this.persistentAngerTarget = angryAt; diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -index e8f6c34ea789136d63c0aa88aec90203ef6282b5..e071796123ff391ea81ed765c2014e58b20cdc25 100644 +index d6d61b91096d28eea1e5af69ea1c07890820ee7f..8ba7896a823d60065c1e293d0fcdb2d3ac76da77 100644 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java @@ -67,6 +67,23 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { @@ -4847,16 +4849,17 @@ index e8f6c34ea789136d63c0aa88aec90203ef6282b5..e071796123ff391ea81ed765c2014e58 @Override public boolean canBeLeashed(Player player) { return !this.isLeashed(); -@@ -129,6 +146,7 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { +@@ -130,7 +147,7 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { @Override protected void customServerAiStep() { this.level().getProfiler().push("hoglinBrain"); -+ //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch +- if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish ++ if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider this.getBrain().tick((ServerLevel)this.level(), this); this.level().getProfiler().pop(); HoglinAi.updateActivity(this); diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -index 27d9145693a772cd1b5d171da303c934101f3be8..bc01cad31c977dc45f8d252ca742c409da7f1c30 100644 +index e235cc9d1b3ce59ab662ef3cf3ce0267ca78536d..c54f70f608093511f9ef1e7e904d9497a4710bdd 100644 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java @@ -96,6 +96,23 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento @@ -4883,11 +4886,12 @@ index 27d9145693a772cd1b5d171da303c934101f3be8..bc01cad31c977dc45f8d252ca742c409 @Override public void addAdditionalSaveData(CompoundTag nbt) { super.addAdditionalSaveData(nbt); -@@ -308,6 +325,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento +@@ -309,7 +326,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento @Override protected void customServerAiStep() { this.level().getProfiler().push("piglinBrain"); -+ //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch +- if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish ++ if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider this.getBrain().tick((ServerLevel) this.level(), this); this.level().getProfiler().pop(); PiglinAi.updateActivity(this); @@ -4928,7 +4932,7 @@ index e1be4a77fae0b9120781f460079269b85c993930..2d842c0dfce1c7e7229bd42b2a92c024 this.level().getProfiler().pop(); PiglinBruteAi.updateActivity(this); diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java -index 97b763431bc5015448ee7a26a340635a932c950b..9f5e44d3d44a7ca546c410a40c9397a4e3b27b79 100644 +index 71db8bd6885377d55cfc571fccc21df6d8a57b54..0aa6874022d4ee8e38f2d85c45a2a4201c2a83fe 100644 --- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java @@ -121,8 +121,32 @@ public class Warden extends Monster implements VibrationSystem { @@ -4964,7 +4968,7 @@ index 97b763431bc5015448ee7a26a340635a932c950b..9f5e44d3d44a7ca546c410a40c9397a4 @Override public Packet getAddEntityPacket() { return new ClientboundAddEntityPacket(this, this.hasPose(Pose.EMERGING) ? 1 : 0); -@@ -394,19 +418,16 @@ public class Warden extends Monster implements VibrationSystem { +@@ -396,19 +420,16 @@ public class Warden extends Monster implements VibrationSystem { @Contract("null->false") public boolean canTargetEntity(@Nullable Entity entity) { @@ -4988,10 +4992,10 @@ index 97b763431bc5015448ee7a26a340635a932c950b..9f5e44d3d44a7ca546c410a40c9397a4 public static void applyDarknessAround(ServerLevel world, Vec3 pos, @Nullable Entity entity, int range) { diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index e30d5ae3e2900f43d7cafde71b8196f26e872841..b1cde791f4994bb0b4ddc063d3c31d16a10b62a5 100644 +index c4ddf2661bca728d504918171295e10e307b18b4..7b58329067d8debeb34abe801d150038a362ffed 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -154,6 +154,28 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -156,6 +156,28 @@ public class Villager extends AbstractVillager implements ReputationEventHandler this.setVillagerData(this.getVillagerData().setType(type).setProfession(VillagerProfession.NONE)); } @@ -5020,15 +5024,16 @@ index e30d5ae3e2900f43d7cafde71b8196f26e872841..b1cde791f4994bb0b4ddc063d3c31d16 @Override public Brain getBrain() { return (Brain) super.getBrain(); // CraftBukkit - decompile error -@@ -254,6 +276,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -257,7 +279,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler // Paper end this.level().getProfiler().push("villagerBrain"); - if (!inactive) this.getBrain().tick((ServerLevel) this.level(), this); // Paper -+ // if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch - this.level().getProfiler().pop(); - if (this.assignProfessionWhenSpawned) { - this.assignProfessionWhenSpawned = false; -@@ -310,7 +333,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + // Pufferfish start +- if (!inactive && this.behaviorTick++ % this.activatedPriority == 0) { ++ if (!inactive && (getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) { // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel) this.level(), this); // Paper + } + // Pufferfish end +@@ -317,7 +339,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler if (!itemstack.is(Items.VILLAGER_SPAWN_EGG) && this.isAlive() && !this.isTrading() && !this.isSleeping()) { if (this.isBaby()) { this.setUnhappy(); @@ -5037,7 +5042,7 @@ index e30d5ae3e2900f43d7cafde71b8196f26e872841..b1cde791f4994bb0b4ddc063d3c31d16 } else { boolean flag = this.getOffers().isEmpty(); -@@ -323,8 +346,9 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -330,8 +352,9 @@ public class Villager extends AbstractVillager implements ReputationEventHandler } if (flag) { diff --git a/patches/server/0007-Configurable-entity-base-attributes.patch b/patches/server/0009-Configurable-entity-base-attributes.patch similarity index 99% rename from patches/server/0007-Configurable-entity-base-attributes.patch rename to patches/server/0009-Configurable-entity-base-attributes.patch index be8a3bc63..05b0fe12e 100644 --- a/patches/server/0007-Configurable-entity-base-attributes.patch +++ b/patches/server/0009-Configurable-entity-base-attributes.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Configurable entity base attributes diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index f5de46130df5b6057e8b3b8a46843428f600b9f1..a45f705caf08adf4ed1efbe237c592b5d557793f 100644 +index 50762602899893b20b38a6fa5cc516a5575af880..b853bda52a2705200c6efde165632b36fc85fe4e 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -156,7 +156,7 @@ import org.bukkit.plugin.PluginManager; @@ -34,10 +34,10 @@ index c6a06e07f0b4bb29b5f4c70dfa53ff6db2e4e6ea..730958dab7f074930cdccb88a89aa26e protected ParticleOptions getInkParticle() { return ParticleTypes.GLOW_SQUID_INK; diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 57317c6b848c598155928aa3ade9957201155787..03499f6142a77f75150fe3421cbff628598c6a3b 100644 +index 559d0efb855175806a2c2ce3a0e5139a96bfec79..2516544b2e346a4384020776d4cb07e4aa5d0d3c 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -289,6 +289,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -288,6 +288,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.useItem = ItemStack.EMPTY; this.lastClimbablePos = Optional.empty(); this.attributes = new AttributeMap(DefaultAttributes.getSupplier(type), this); // Purpur @@ -45,7 +45,7 @@ index 57317c6b848c598155928aa3ade9957201155787..03499f6142a77f75150fe3421cbff628 this.craftAttributes = new CraftAttributeMap(this.attributes); // CraftBukkit // CraftBukkit - setHealth(getMaxHealth()) inlined and simplified to skip the instanceof check for EntityPlayer, as getBukkitEntity() is not initialized in constructor this.entityData.set(LivingEntity.DATA_HEALTH_ID, (float) this.getAttribute(Attributes.MAX_HEALTH).getValue()); -@@ -304,6 +305,8 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -303,6 +304,8 @@ public abstract class LivingEntity extends Entity implements Attackable { this.brain = this.makeBrain(new Dynamic(dynamicopsnbt, (Tag) dynamicopsnbt.createMap((Map) ImmutableMap.of(dynamicopsnbt.createString("memories"), (Tag) dynamicopsnbt.emptyMap())))); } @@ -55,7 +55,7 @@ index 57317c6b848c598155928aa3ade9957201155787..03499f6142a77f75150fe3421cbff628 return this.brain; } diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java -index 2ac0c8a7335450c192352da9c34151a70a2645dd..45297abb703c82f13cc206896758458afcfb3b51 100644 +index fc240adb941cfa7db37916516b63cbfdb83f737d..42ab8b3828f66e84cf0d89169fe28867f387be6b 100644 --- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java +++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java @@ -278,6 +278,18 @@ public class Bat extends AmbientCreature { @@ -459,7 +459,7 @@ index cb2b8c7cbbe882ae0ca876edaa66bea1d5cd141d..c9ad084ce93eb618261221c7e19450c0 protected void registerGoals() { this.goalSelector.addGoal(1, new FloatGoal(this)); diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -index ede5469f26f530beacfc655581e213d39276c7d9..3b70849dca92ee4b0427396de6440f1c29fd724a 100644 +index 943bd1f270e7e355840dd3b07151c0e5ba9492e4..203aa1a885ab5d1770ac93f5346af27a9a47dbe8 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java @@ -115,6 +115,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder org.spigotmc.SpigotConfig.movedWronglyThreshold && !this.player.isSleeping() && !this.player.gameMode.isCreative() && this.player.gameMode.getGameModeForPlayer() != GameType.SPECTATOR) { // Spigot flag2 = true; // Paper - diff on change, this should be moved wrongly @@ -134,7 +134,7 @@ index c7b9acaee1c14fde6d557c1068bf4544a282da24..38f4baddd932c4af10e656c10f201ab1 } // Paper start - optimise out extra getCubes -@@ -1600,6 +1622,8 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1601,6 +1623,8 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic this.lastYaw = to.getYaw(); this.lastPitch = to.getPitch(); @@ -178,7 +178,7 @@ index 3ff999734d14e2b6e7828e117f5ee32a60c26bc1..cfa9607241c3e69777ffc317206996c2 private EntitySelector() {} // Paper start diff --git a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java -index 58422f00c7d64dbd1cf6d7211c9838875cbe7778..db988d263b470e597d6df362da43d76005444572 100644 +index d25307ae8bbdf10ae067ec70fc2cb957b852a0eb..54bdb81785b617e13e67530752395f2a0c6d703a 100644 --- a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java +++ b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java @@ -64,6 +64,10 @@ public class TargetingConditions { @@ -318,10 +318,10 @@ index 049658a2c939255003a8b32a18b67bb153243b23..2596204f9b1d0b9fd54ac71f7cecc169 public boolean untamedTamablesAreRidable = true; public boolean useNightVisionWhenRiding = false; diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java -index eda7f0bb42f7269676d5d2193e1155912ede9920..2eb33bd133009447154c7f018e9300d509f20725 100644 +index 68557964e27fa1e5ba218178f9bcc0b28e3a78d9..12adaba78ec30e463963f99c0d78e844756143a1 100644 --- a/src/main/java/org/spigotmc/ActivationRange.java +++ b/src/main/java/org/spigotmc/ActivationRange.java -@@ -199,6 +199,7 @@ public class ActivationRange +@@ -203,6 +203,7 @@ public class ActivationRange continue; } diff --git a/patches/server/0011-Bring-back-server-name.patch b/patches/server/0013-Bring-back-server-name.patch similarity index 91% rename from patches/server/0011-Bring-back-server-name.patch rename to patches/server/0013-Bring-back-server-name.patch index 06ac90d74..d5032833b 100644 --- a/patches/server/0011-Bring-back-server-name.patch +++ b/patches/server/0013-Bring-back-server-name.patch @@ -17,10 +17,10 @@ index 818289e831e3dad29345c43265e2efd7689bc500..1ea3012995c738c67b31e997c138f824 public final boolean spawnNpcs = this.get("spawn-npcs", true); public final boolean pvp = this.get("pvp", true); diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 4a00ab2a4b1d445c43d633c50c7ff66aa4034d60..90def71180c29c8a5226da5199d42ce2ab37269c 100644 +index a487bdaa357e42cb00778505f3cf2283f5602b26..9f8300313465bef8f356961dde9d9cee870561c2 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -@@ -3004,4 +3004,11 @@ public final class CraftServer implements Server { +@@ -3009,4 +3009,11 @@ public final class CraftServer implements Server { } // Paper end diff --git a/patches/server/0012-Configurable-server-mod-name.patch b/patches/server/0014-Configurable-server-mod-name.patch similarity index 92% rename from patches/server/0012-Configurable-server-mod-name.patch rename to patches/server/0014-Configurable-server-mod-name.patch index ea03529a1..ca9656028 100644 --- a/patches/server/0012-Configurable-server-mod-name.patch +++ b/patches/server/0014-Configurable-server-mod-name.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Configurable server mod name diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 3d2af8732f60b29619e3701acca9429c6d5a32f8..39ab22e836a1e0d7ecb39389387466e889869bae 100644 +index a4cc0f1ab0fc138c22b9472ce8d3d6ad7561a7df..bd474cebc35219c62fd667799e5467eea60c08da 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1680,7 +1680,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop drops = new ArrayList(); public final org.bukkit.craftbukkit.attribute.CraftAttributeMap craftAttributes; -@@ -355,7 +356,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -354,7 +355,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.tryAddSoulSpeed(); } @@ -25,7 +25,7 @@ index 483c659362497eef75bd390e9e38152302fb42d7..584a15e2dc7a1ff2396084ff833c8022 double d1 = this.getX(); double d2 = this.getY(); double d3 = this.getZ(); -@@ -370,7 +371,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -369,7 +370,7 @@ public abstract class LivingEntity extends Entity implements Attackable { d3 = (double) landedPosition.getZ() + 0.5D + d5 / d6 * 0.5D; } @@ -34,7 +34,7 @@ index 483c659362497eef75bd390e9e38152302fb42d7..584a15e2dc7a1ff2396084ff833c8022 double d7 = Math.min((double) (0.2F + f / 15.0F), 2.5D); int i = (int) (150.0D * d7); -@@ -2042,7 +2043,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2064,7 +2065,7 @@ public abstract class LivingEntity extends Entity implements Attackable { MobEffectInstance mobeffect = this.getEffect(MobEffects.JUMP); float f2 = mobeffect == null ? 0.0F : (float) (mobeffect.getAmplifier() + 1); diff --git a/patches/server/0014-Lagging-threshold.patch b/patches/server/0016-Lagging-threshold.patch similarity index 88% rename from patches/server/0014-Lagging-threshold.patch rename to patches/server/0016-Lagging-threshold.patch index a1a0e3a69..65c580cf9 100644 --- a/patches/server/0014-Lagging-threshold.patch +++ b/patches/server/0016-Lagging-threshold.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Lagging threshold diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 39ab22e836a1e0d7ecb39389387466e889869bae..837338fb19e5506f01da687e603860b5eb3860f5 100644 +index bd474cebc35219c62fd667799e5467eea60c08da..9abd0167f644194367fab679f878c0288758d898 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -307,6 +307,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop implements FeatureElement, EntityTypeT +@@ -315,6 +315,16 @@ public class EntityType implements FeatureElement, EntityTypeT return (EntityType) Registry.register(BuiltInRegistries.ENTITY_TYPE, id, (EntityType) type.build(id)); // CraftBukkit - decompile error } @@ -25,7 +25,7 @@ index 1eae10b9ddb10e6de941c03d54b57c815105feba..b7e3efcca0b544440f8799a3be27e928 public static ResourceLocation getKey(EntityType type) { return BuiltInRegistries.ENTITY_TYPE.getKey(type); } -@@ -528,6 +538,16 @@ public class EntityType implements FeatureElement, EntityTypeT +@@ -530,6 +540,16 @@ public class EntityType implements FeatureElement, EntityTypeT return this.category; } diff --git a/patches/server/0016-Player-invulnerabilities.patch b/patches/server/0018-Player-invulnerabilities.patch similarity index 98% rename from patches/server/0016-Player-invulnerabilities.patch rename to patches/server/0018-Player-invulnerabilities.patch index cc5df16b8..cf1a05bac 100644 --- a/patches/server/0016-Player-invulnerabilities.patch +++ b/patches/server/0018-Player-invulnerabilities.patch @@ -82,10 +82,10 @@ index e528d3bb75b892e1674e4c282b91a28128a387a7..6838e85030667776c6b0534d0e92c9fb public Scoreboard getScoreboard() { return this.getBukkitEntity().getScoreboard().getHandle(); diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 38f4baddd932c4af10e656c10f201ab1c3c67fa3..d39ff2adeee86a1d67c653655860797fea68e662 100644 +index 8aed172bc6d719e39415eca1961f1d0fdedc495f..fc04f3f0de1851e1d6e981f9116d35cdf1cba0e7 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2092,12 +2092,21 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2093,12 +2093,21 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @Override public void handleResourcePackResponse(ServerboundResourcePackPacket packet) { PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); diff --git a/patches/server/0017-Anvil-API.patch b/patches/server/0019-Anvil-API.patch similarity index 100% rename from patches/server/0017-Anvil-API.patch rename to patches/server/0019-Anvil-API.patch diff --git a/patches/server/0018-Alternative-Keepalive-Handling.patch b/patches/server/0020-Alternative-Keepalive-Handling.patch similarity index 96% rename from patches/server/0018-Alternative-Keepalive-Handling.patch rename to patches/server/0020-Alternative-Keepalive-Handling.patch index 8b65a54a7..ef8fbc27d 100644 --- a/patches/server/0018-Alternative-Keepalive-Handling.patch +++ b/patches/server/0020-Alternative-Keepalive-Handling.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Alternative Keepalive Handling diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index d39ff2adeee86a1d67c653655860797fea68e662..19cc555da0a7fbdf9fbaa81151d22a843d4f2025 100644 +index fc04f3f0de1851e1d6e981f9116d35cdf1cba0e7..72b693f78a28a08a9b802bbef83be2496ed06589 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java @@ -263,6 +263,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @@ -38,7 +38,7 @@ index d39ff2adeee86a1d67c653655860797fea68e662..19cc555da0a7fbdf9fbaa81151d22a84 if (this.keepAlivePending) { if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getScoreboardName()); // more info -@@ -3490,6 +3506,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -3492,6 +3508,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @Override public void handleKeepAlive(ServerboundKeepAlivePacket packet) { diff --git a/patches/server/0019-Silk-touch-spawners.patch b/patches/server/0021-Silk-touch-spawners.patch similarity index 99% rename from patches/server/0019-Silk-touch-spawners.patch rename to patches/server/0021-Silk-touch-spawners.patch index 33e7312a7..c293832bc 100644 --- a/patches/server/0019-Silk-touch-spawners.patch +++ b/patches/server/0021-Silk-touch-spawners.patch @@ -89,7 +89,7 @@ index 936d844a5a246138c9f9ae4ae6e318242b8f1420..d58dc4aa02fe371deaf879df8692dbe9 int i = 15 + worldserver.random.nextInt(15) + worldserver.random.nextInt(15); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 9c2a8b9c56e1dbd79573740d8c16ba8e01c43f4b..1d33fed2bd6702ea68ebd0b6bebb642151fd2e52 100644 +index b577fde66a4c4e1d7d83732649b1fcd136a838cb..22d561b588b0d1c5b67d8d2144f397a5c674da58 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -114,6 +114,38 @@ public class PurpurWorldConfig { diff --git a/patches/server/0020-Add-turtle-egg-block-options.patch b/patches/server/0022-Add-turtle-egg-block-options.patch similarity index 96% rename from patches/server/0020-Add-turtle-egg-block-options.patch rename to patches/server/0022-Add-turtle-egg-block-options.patch index 09c23814a..7d94babe8 100644 --- a/patches/server/0020-Add-turtle-egg-block-options.patch +++ b/patches/server/0022-Add-turtle-egg-block-options.patch @@ -36,7 +36,7 @@ index 6c1a0e6f961e46a1a89850746a71e97b32514adf..1942649e868fc985a488034c411a6721 } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 67468fde7d4a670bb5b85ef07648cb7ffec6fc74..cd259a48b86fa257fc0ec748e667ba17e26e98a5 100644 +index 22d561b588b0d1c5b67d8d2144f397a5c674da58..a48daeb4f143083161af2545ab690324004ef2d5 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -146,6 +146,15 @@ public class PurpurWorldConfig { diff --git a/patches/server/0021-Logger-settings-suppressing-pointless-logs.patch b/patches/server/0023-Logger-settings-suppressing-pointless-logs.patch similarity index 98% rename from patches/server/0021-Logger-settings-suppressing-pointless-logs.patch rename to patches/server/0023-Logger-settings-suppressing-pointless-logs.patch index a24f60046..de40b9614 100644 --- a/patches/server/0021-Logger-settings-suppressing-pointless-logs.patch +++ b/patches/server/0023-Logger-settings-suppressing-pointless-logs.patch @@ -41,7 +41,7 @@ index ea29e07a105f3ba6a878bdccf36e7eaf66280280..d5dce6c8d85938d61a57a78f82381d26 } else { handler.accept((Recipe) optional.get()); diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java -index 110503062b3043cffa082a1cda6b8d57152869aa..3e7e06bd5e9e4ed45c9e3452eb04e946fac817d8 100644 +index 2677e21d8239bf0361a3bc5c9a50c328e54d70f6..544a79d5da661aff19e2019f7b83a3a49350bb68 100644 --- a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java +++ b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java @@ -256,6 +256,7 @@ public final class CraftLegacy { diff --git a/patches/server/0022-Disable-outdated-build-check.patch b/patches/server/0024-Disable-outdated-build-check.patch similarity index 100% rename from patches/server/0022-Disable-outdated-build-check.patch rename to patches/server/0024-Disable-outdated-build-check.patch diff --git a/patches/server/0023-Giants-AI-settings.patch b/patches/server/0025-Giants-AI-settings.patch similarity index 100% rename from patches/server/0023-Giants-AI-settings.patch rename to patches/server/0025-Giants-AI-settings.patch diff --git a/patches/server/0024-Zombie-horse-naturally-spawn.patch b/patches/server/0026-Zombie-horse-naturally-spawn.patch similarity index 95% rename from patches/server/0024-Zombie-horse-naturally-spawn.patch rename to patches/server/0026-Zombie-horse-naturally-spawn.patch index b431bdd2c..e3efaa6dc 100644 --- a/patches/server/0024-Zombie-horse-naturally-spawn.patch +++ b/patches/server/0026-Zombie-horse-naturally-spawn.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Zombie horse naturally spawn diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index a6acc178949f45c18009b5da2b8998cbcab2289b..2cd6b08ef5d8a67175c86d33e938c088dd053a82 100644 +index 4c3b5a26a6b04afff3a707929ced3c62b5256a67..11f92c1011a1accaf485e5785d2e9ebc8440406c 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -955,10 +955,18 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -971,10 +971,18 @@ public class ServerLevel extends Level implements WorldGenLevel { boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * this.paperConfig().entities.spawning.skeletonHorseThunderSpawnChance.or(0.01D) && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper if (flag1) { diff --git a/patches/server/0025-Charged-creeper-naturally-spawn.patch b/patches/server/0027-Charged-creeper-naturally-spawn.patch similarity index 100% rename from patches/server/0025-Charged-creeper-naturally-spawn.patch rename to patches/server/0027-Charged-creeper-naturally-spawn.patch diff --git a/patches/server/0026-Rabbit-naturally-spawn-toast-and-killer.patch b/patches/server/0028-Rabbit-naturally-spawn-toast-and-killer.patch similarity index 100% rename from patches/server/0026-Rabbit-naturally-spawn-toast-and-killer.patch rename to patches/server/0028-Rabbit-naturally-spawn-toast-and-killer.patch diff --git a/patches/server/0027-Fix-outdated-server-showing-in-ping-before-server-fu.patch b/patches/server/0029-Fix-outdated-server-showing-in-ping-before-server-fu.patch similarity index 100% rename from patches/server/0027-Fix-outdated-server-showing-in-ping-before-server-fu.patch rename to patches/server/0029-Fix-outdated-server-showing-in-ping-before-server-fu.patch diff --git a/patches/server/0028-Tulips-change-fox-type.patch b/patches/server/0030-Tulips-change-fox-type.patch similarity index 100% rename from patches/server/0028-Tulips-change-fox-type.patch rename to patches/server/0030-Tulips-change-fox-type.patch diff --git a/patches/server/0029-Breedable-Polar-Bears.patch b/patches/server/0031-Breedable-Polar-Bears.patch similarity index 100% rename from patches/server/0029-Breedable-Polar-Bears.patch rename to patches/server/0031-Breedable-Polar-Bears.patch diff --git a/patches/server/0030-Chickens-can-retaliate.patch b/patches/server/0032-Chickens-can-retaliate.patch similarity index 100% rename from patches/server/0030-Chickens-can-retaliate.patch rename to patches/server/0032-Chickens-can-retaliate.patch diff --git a/patches/server/0031-Add-option-to-set-armorstand-step-height.patch b/patches/server/0033-Add-option-to-set-armorstand-step-height.patch similarity index 92% rename from patches/server/0031-Add-option-to-set-armorstand-step-height.patch rename to patches/server/0033-Add-option-to-set-armorstand-step-height.patch index 1f1e27160..5b4e272c7 100644 --- a/patches/server/0031-Add-option-to-set-armorstand-step-height.patch +++ b/patches/server/0033-Add-option-to-set-armorstand-step-height.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add option to set armorstand step height diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index a45f705caf08adf4ed1efbe237c592b5d557793f..c8fea6ecc4507615d60f080be5707b16211c32f3 100644 +index b853bda52a2705200c6efde165632b36fc85fe4e..c760a55ac0743f09ac5ee7cda51c0c2be0ca4fe3 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -322,7 +322,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { @@ -30,7 +30,7 @@ index 8a8b9e8983be1acad66ad875c901be5bbdeabb1f..09912c11bad7dc639b8afe8b0041a5fb if (!this.canTick) { if (this.noTickPoseDirty) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7d0d29f9934fc4b7a4227cecd223f145e3502c83..2ad780f84f5717f9f171540939b543820c4867ee 100644 +index 8d764e136fa4ea6f9d3efb555f4e299df8831a4e..1ea0b241a819527e48ad3050bb0f6c57013a891b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -92,6 +92,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0032-Cat-spawning-options.patch b/patches/server/0034-Cat-spawning-options.patch similarity index 100% rename from patches/server/0032-Cat-spawning-options.patch rename to patches/server/0034-Cat-spawning-options.patch diff --git a/patches/server/0033-Cows-eat-mushrooms.patch b/patches/server/0035-Cows-eat-mushrooms.patch similarity index 100% rename from patches/server/0033-Cows-eat-mushrooms.patch rename to patches/server/0035-Cows-eat-mushrooms.patch diff --git a/patches/server/0034-Fix-cow-rotation-when-shearing-mooshroom.patch b/patches/server/0036-Fix-cow-rotation-when-shearing-mooshroom.patch similarity index 93% rename from patches/server/0034-Fix-cow-rotation-when-shearing-mooshroom.patch rename to patches/server/0036-Fix-cow-rotation-when-shearing-mooshroom.patch index 55ccb3d54..d0a54e840 100644 --- a/patches/server/0034-Fix-cow-rotation-when-shearing-mooshroom.patch +++ b/patches/server/0036-Fix-cow-rotation-when-shearing-mooshroom.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix cow rotation when shearing mooshroom diff --git a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java -index 2eac9d3c1069f79c3fcbfb87518b5d5d1e17c6dd..3e798a9d94963dc39ec4a81265fa659b6cfe5db8 100644 +index 780a11339d2492dd607e3ef91867ffbb9062e2cd..b27c0f21354a78025f9d1664c560fb8799bced91 100644 --- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java +++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java @@ -202,7 +202,13 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder entityType = entity.getType(); final int saveLimit = level.paperConfig().chunks.entityPerChunkSaveLimit.getOrDefault(entityType, -1); diff --git a/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java b/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java -index b436fd92e2db17f6a2ee4118a7a51e324b567b46..fe14721ac16e702850a778b7481e306ed4bdfd74 100644 +index af057c1d7fd74f3dd806c5ce7f8b0ad06cab7b8e..ce614ae6b1fa0b31c1ee8dacb69134bb20c949f4 100644 --- a/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java +++ b/src/main/java/org/purpurmc/purpur/entity/DolphinSpit.java @@ -35,6 +35,13 @@ public class DolphinSpit extends LlamaSpit { diff --git a/patches/server/0055-Dispenser-curse-of-binding-protection.patch b/patches/server/0057-Dispenser-curse-of-binding-protection.patch similarity index 92% rename from patches/server/0055-Dispenser-curse-of-binding-protection.patch rename to patches/server/0057-Dispenser-curse-of-binding-protection.patch index 38ab9cd49..5af4d4f4c 100644 --- a/patches/server/0055-Dispenser-curse-of-binding-protection.patch +++ b/patches/server/0057-Dispenser-curse-of-binding-protection.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Dispenser curse of binding protection diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index c68952d8f565ca14855fb43d9f8ea40bab27764f..1b18532360b9508a08ea46b48331acad3e37c049 100644 +index 5241abca7ef49c0891c28e1be6fafb791b8ea347..ef8d0f594c727f355a8209f36da924ae45017ce5 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -65,6 +65,7 @@ import net.minecraft.world.item.ProjectileWeaponItem; @@ -16,7 +16,7 @@ index c68952d8f565ca14855fb43d9f8ea40bab27764f..1b18532360b9508a08ea46b48331acad import net.minecraft.world.level.GameRules; import net.minecraft.world.level.ItemLike; import net.minecraft.world.level.Level; -@@ -1160,6 +1161,12 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1166,6 +1167,12 @@ public abstract class Mob extends LivingEntity implements Targeting { } @@ -43,7 +43,7 @@ index d7a0cbde8f8c99276307502674c71463fbe7e89c..3500c56cb85d8c76b2acd77976d374ea // CraftBukkit start Level world = pointer.getLevel(); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 5b41745fdc55441d1b8ac89571d690ef506462bd..4f46aa379b18f526c9826722b8d5fbf44cbf17d3 100644 +index af4dce5c4708e0540819af2388e9a38b2710b041..3b58033a22343b671c7da9dd88453bf936d24e1c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -230,6 +230,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0056-Add-option-for-boats-to-eject-players-on-land.patch b/patches/server/0058-Add-option-for-boats-to-eject-players-on-land.patch similarity index 95% rename from patches/server/0056-Add-option-for-boats-to-eject-players-on-land.patch rename to patches/server/0058-Add-option-for-boats-to-eject-players-on-land.patch index 091036001..b31e194bf 100644 --- a/patches/server/0056-Add-option-for-boats-to-eject-players-on-land.patch +++ b/patches/server/0058-Add-option-for-boats-to-eject-players-on-land.patch @@ -17,7 +17,7 @@ index 35aeba4e8430e6419caa9db4a0b931a994228618..cb8443c9bc902741dfe6746baca91292 } else { return Boat.Status.IN_AIR; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 47d0a78f47e80db7aaeacbeac6df177bd3b1fb42..0427450b37f89d6eaf90a80be1d4c8db37475b3b 100644 +index 3b58033a22343b671c7da9dd88453bf936d24e1c..b3c6739cc7a47ad965482cb488ba75e649856aeb 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -97,12 +97,14 @@ public class PurpurWorldConfig { diff --git a/patches/server/0057-Mending-mends-most-damages-equipment-first.patch b/patches/server/0059-Mending-mends-most-damages-equipment-first.patch similarity index 96% rename from patches/server/0057-Mending-mends-most-damages-equipment-first.patch rename to patches/server/0059-Mending-mends-most-damages-equipment-first.patch index 5403a3ece..377621c28 100644 --- a/patches/server/0057-Mending-mends-most-damages-equipment-first.patch +++ b/patches/server/0059-Mending-mends-most-damages-equipment-first.patch @@ -18,7 +18,7 @@ index eca634792d2a7cc649675e3394e84dbaf1453905..2bd576849403bc2cfae298c221061619 if (entry != null) { ItemStack itemstack = (ItemStack) entry.getValue(); diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java -index b367ec1feaccbd67e9e28c0d0515e163f37135fe..7de8d028ff8a6099b207e444d8173e5fc09d4ed2 100644 +index adb7220be617d6d9f2cdd7fbe4fa2dd24cc7d142..7db5657885b76885d48d0f231a4aad7b77724868 100644 --- a/src/main/java/net/minecraft/world/item/ItemStack.java +++ b/src/main/java/net/minecraft/world/item/ItemStack.java @@ -578,6 +578,16 @@ public final class ItemStack { @@ -73,7 +73,7 @@ index ecf640b00007a386290f8dfe9935a8aa610079fd..2048899f8e4c8211e8dde0d11148d647 public static Map.Entry getRandomItemWith(Enchantment enchantment, LivingEntity entity) { return getRandomItemWith(enchantment, entity, (stack) -> { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a91d8e9ca70b2fb89765c1b09d62583fbcd1e61e..ce713dc6a05be884cea7141859f1c31a30adf24d 100644 +index b3c6739cc7a47ad965482cb488ba75e649856aeb..9e7b3a8be6ce2c3540c7b775ae9d85ed0cccad00 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -97,6 +97,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0058-Add-5-second-tps-average-in-tps.patch b/patches/server/0060-Add-5-second-tps-average-in-tps.patch similarity index 94% rename from patches/server/0058-Add-5-second-tps-average-in-tps.patch rename to patches/server/0060-Add-5-second-tps-average-in-tps.patch index 4e03513d2..eca94ca37 100644 --- a/patches/server/0058-Add-5-second-tps-average-in-tps.patch +++ b/patches/server/0060-Add-5-second-tps-average-in-tps.patch @@ -27,7 +27,7 @@ index fa56cd09102a89692b42f1d14257990508c5c720..f9251183df72ddc56662fd3f02acf216 setListData(vector); } diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 517a817050f9c2be21866811f44e87b04eb2eacd..2da0bb6f710562d9abd181c110b85e970285d446 100644 +index 82cd8c65268838f0bad3b15a8a228fb5b9a30b07..e187ca5cfb1a99ca3e8c25f9a89d4b12b66ab5cd 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -303,7 +303,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop> consumer, Set trackedPlayers) { this.trackedPlayers = trackedPlayers; diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java -index 3d41dbe0285f8fec8adae1e93010cf464df9b08c..9ff579c8f293491364e9de4b1e85cfb43c92a249 100644 +index 63f8f2dfc2afddcf3c4960d60e65cb8e29507223..7bda44003604b8a0ae8dd571c7f3e79eb42a4822 100644 --- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java +++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java @@ -55,6 +55,12 @@ public class ItemEntity extends Entity implements TraceableEntity { @@ -34,7 +34,7 @@ index 3d41dbe0285f8fec8adae1e93010cf464df9b08c..9ff579c8f293491364e9de4b1e85cfb4 public ItemEntity(EntityType type, Level world) { super(type, world); -@@ -347,6 +353,15 @@ public class ItemEntity extends Entity implements TraceableEntity { +@@ -353,6 +359,15 @@ public class ItemEntity extends Entity implements TraceableEntity { return false; } else if (!this.getItem().getItem().canBeHurtBy(source)) { return false; @@ -50,7 +50,7 @@ index 3d41dbe0285f8fec8adae1e93010cf464df9b08c..9ff579c8f293491364e9de4b1e85cfb4 } else if (this.level().isClientSide) { return true; } else { -@@ -545,6 +560,12 @@ public class ItemEntity extends Entity implements TraceableEntity { +@@ -551,6 +566,12 @@ public class ItemEntity extends Entity implements TraceableEntity { this.getEntityData().set(ItemEntity.DATA_ITEM, stack); this.getEntityData().markDirty(ItemEntity.DATA_ITEM); // CraftBukkit - SPIGOT-4591, must mark dirty this.despawnRate = this.level().paperConfig().entities.spawning.altItemDespawnRate.enabled ? this.level().paperConfig().entities.spawning.altItemDespawnRate.items.getOrDefault(stack.getItem(), this.level().spigotConfig.itemDespawnRate) : this.level().spigotConfig.itemDespawnRate; // Paper @@ -115,7 +115,7 @@ index a925b5c490e7129b27370aa57b5fad1cf05530c6..09001578b88658c44d0661d340a0ee0f + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d7cc6c9f15fdc29bbd1666d9a07904eea8a3d723..ee354de33f436dde6a234c05787a9de28966d7cf 100644 +index 31629257826aa600fe6e5bf17e89002a71bbc1b3..31af922dd6cf4af8d555b74189ac83fe248479ac 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -127,6 +127,49 @@ public class PurpurWorldConfig { diff --git a/patches/server/0061-Add-ping-command.patch b/patches/server/0063-Add-ping-command.patch similarity index 100% rename from patches/server/0061-Add-ping-command.patch rename to patches/server/0063-Add-ping-command.patch diff --git a/patches/server/0062-Add-demo-command.patch b/patches/server/0064-Add-demo-command.patch similarity index 100% rename from patches/server/0062-Add-demo-command.patch rename to patches/server/0064-Add-demo-command.patch diff --git a/patches/server/0063-Add-credits-command.patch b/patches/server/0065-Add-credits-command.patch similarity index 100% rename from patches/server/0063-Add-credits-command.patch rename to patches/server/0065-Add-credits-command.patch diff --git a/patches/server/0064-Configurable-jockey-options.patch b/patches/server/0066-Configurable-jockey-options.patch similarity index 100% rename from patches/server/0064-Configurable-jockey-options.patch rename to patches/server/0066-Configurable-jockey-options.patch diff --git a/patches/server/0065-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch b/patches/server/0067-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch similarity index 100% rename from patches/server/0065-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch rename to patches/server/0067-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch diff --git a/patches/server/0066-Add-phantom-spawning-options.patch b/patches/server/0068-Add-phantom-spawning-options.patch similarity index 100% rename from patches/server/0066-Add-phantom-spawning-options.patch rename to patches/server/0068-Add-phantom-spawning-options.patch diff --git a/patches/server/0067-Implement-bed-explosion-options.patch b/patches/server/0069-Implement-bed-explosion-options.patch similarity index 97% rename from patches/server/0067-Implement-bed-explosion-options.patch rename to patches/server/0069-Implement-bed-explosion-options.patch index 59996386a..3b001095d 100644 --- a/patches/server/0067-Implement-bed-explosion-options.patch +++ b/patches/server/0069-Implement-bed-explosion-options.patch @@ -27,7 +27,7 @@ index d40500f9a807cab0b2fb6fa9032f33f4fb74c895..e8405a57fb88e63b63baaf00645c4176 } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a6a71ea8dda8a1c42f3e32f9fccb9dc5366d9295..2ff268a9bf92c151e7b0e5f0b075eb9fc72035a7 100644 +index b1434e34e94b9cad2cc8f37ab4663cd6e3f30408..7b87d42167b54ade951befd855359a2a99d5a702 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -290,6 +290,27 @@ public class PurpurWorldConfig { diff --git a/patches/server/0068-Implement-respawn-anchor-explosion-options.patch b/patches/server/0070-Implement-respawn-anchor-explosion-options.patch similarity index 97% rename from patches/server/0068-Implement-respawn-anchor-explosion-options.patch rename to patches/server/0070-Implement-respawn-anchor-explosion-options.patch index b8aa24368..e9a71687d 100644 --- a/patches/server/0068-Implement-respawn-anchor-explosion-options.patch +++ b/patches/server/0070-Implement-respawn-anchor-explosion-options.patch @@ -18,7 +18,7 @@ index 2ed78cf83c0ae66a6ddba1ff307da89a24b0d0a8..ae17d6a54fad0bd2d71d306f418b5ced public static boolean canSetSpawn(Level world) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2ff268a9bf92c151e7b0e5f0b075eb9fc72035a7..70576507db0a84b209729cdd2efa595bd0450042 100644 +index 7b87d42167b54ade951befd855359a2a99d5a702..c69147c1bc8e96c43a9496fd8c4fb4139682afd5 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -330,6 +330,27 @@ public class PurpurWorldConfig { diff --git a/patches/server/0069-Add-allow-water-in-end-world-option.patch b/patches/server/0071-Add-allow-water-in-end-world-option.patch similarity index 96% rename from patches/server/0069-Add-allow-water-in-end-world-option.patch rename to patches/server/0071-Add-allow-water-in-end-world-option.patch index 2874e584f..05b9b4a8b 100644 --- a/patches/server/0069-Add-allow-water-in-end-world-option.patch +++ b/patches/server/0071-Add-allow-water-in-end-world-option.patch @@ -27,10 +27,10 @@ index 578c3db52dda4c169b5ea615a4ce4a79f15a4cad..0bd98b802f246a3f6061f716d470a479 return true; diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 13176ad151b53047993938838b3763f85ae1aeff..6e3d1122a2b7cdb91115bb8ed6c1578fa02ab58b 100644 +index 6a9f5e3f8c72363b91b23729df5e98784d66ba8b..6b661982b217ae120d72ede3e19e82fbd3ebb69e 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -1471,4 +1471,14 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1575,4 +1575,14 @@ public abstract class Level implements LevelAccessor, AutoCloseable { return null; } // Paper end diff --git a/patches/server/0070-Allow-color-codes-in-books.patch b/patches/server/0072-Allow-color-codes-in-books.patch similarity index 92% rename from patches/server/0070-Allow-color-codes-in-books.patch rename to patches/server/0072-Allow-color-codes-in-books.patch index ba3a338d8..ec070891b 100644 --- a/patches/server/0070-Allow-color-codes-in-books.patch +++ b/patches/server/0072-Allow-color-codes-in-books.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Allow color codes in books diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 19186118731d0a57359b09c726aa009495d2113d..0e616bc3a09fcab0d5d3b6243c2e1d39223a2de1 100644 +index 72b693f78a28a08a9b802bbef83be2496ed06589..7b60c2b4563a44c20196951e4ebeb92a0c74b79d 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -1344,13 +1344,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1345,13 +1345,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic itemstack1.setTag(nbttagcompound.copy()); } @@ -28,7 +28,7 @@ index 19186118731d0a57359b09c726aa009495d2113d..0e616bc3a09fcab0d5d3b6243c2e1d39 this.updateBookPages(pages, (s) -> { return Component.Serializer.toJson(Component.literal(s)); -@@ -1362,10 +1365,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1363,10 +1366,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic private void updateBookPages(List list, UnaryOperator unaryoperator, ItemStack itemstack, int slot, ItemStack handItem) { // CraftBukkit ListTag nbttaglist = new ListTag(); @@ -44,7 +44,7 @@ index 19186118731d0a57359b09c726aa009495d2113d..0e616bc3a09fcab0d5d3b6243c2e1d39 Objects.requireNonNull(nbttaglist); stream.forEach(nbttaglist::add); -@@ -1375,11 +1381,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1376,11 +1382,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic for (int j = list.size(); i < j; ++i) { FilteredText filteredtext = (FilteredText) list.get(i); @@ -58,7 +58,7 @@ index 19186118731d0a57359b09c726aa009495d2113d..0e616bc3a09fcab0d5d3b6243c2e1d39 } } -@@ -1392,6 +1398,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1393,6 +1399,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic this.player.getInventory().setItem(slot, CraftEventFactory.handleEditBookEvent(player, slot, handItem, itemstack)); // CraftBukkit // Paper - Don't ignore result (see other callsite for handleEditBookEvent) } diff --git a/patches/server/0071-Entity-lifespan.patch b/patches/server/0073-Entity-lifespan.patch similarity index 89% rename from patches/server/0071-Entity-lifespan.patch rename to patches/server/0073-Entity-lifespan.patch index f9cd3d978..f1e5ca076 100644 --- a/patches/server/0071-Entity-lifespan.patch +++ b/patches/server/0073-Entity-lifespan.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Entity lifespan diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 4475c9fb628cdd7175899370ba144d27f4148757..a4d3f1cbb5d832281d12ce7c27506c6eb037d38c 100644 +index 7b60c2b4563a44c20196951e4ebeb92a0c74b79d..f106638020d94499601ac21d5c958ada3ddc3ea8 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2860,6 +2860,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2862,6 +2862,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic AABB axisalignedbb = entity.getBoundingBox(); if (axisalignedbb.distanceToSqr(this.player.getEyePosition()) < ServerGamePacketListenerImpl.MAX_INTERACTION_DISTANCE) { @@ -17,7 +17,7 @@ index 4475c9fb628cdd7175899370ba144d27f4148757..a4d3f1cbb5d832281d12ce7c27506c6e private void performInteraction(InteractionHand enumhand, ServerGamePacketListenerImpl.EntityInteraction playerconnection_a, PlayerInteractEntityEvent event) { // CraftBukkit ItemStack itemstack = ServerGamePacketListenerImpl.this.player.getItemInHand(enumhand); diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44fe8549d0d 100644 +index ef8d0f594c727f355a8209f36da924ae45017ce5..64a682ea339809adfb8304a7f14d4a596e5332be 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -133,6 +133,7 @@ public abstract class Mob extends LivingEntity implements Targeting { @@ -28,7 +28,7 @@ index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44f public boolean aware = true; // CraftBukkit protected Mob(EntityType type, Level world) { -@@ -321,6 +322,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -323,6 +324,7 @@ public abstract class Mob extends LivingEntity implements Targeting { entityliving = null; } } @@ -36,7 +36,7 @@ index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44f this.target = entityliving; return true; // CraftBukkit end -@@ -368,8 +370,28 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -370,8 +372,28 @@ public abstract class Mob extends LivingEntity implements Targeting { } this.level().getProfiler().pop(); @@ -65,7 +65,7 @@ index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44f @Override protected void playHurtSound(DamageSource source) { this.resetAmbientSoundTime(); -@@ -559,6 +581,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -561,6 +583,7 @@ public abstract class Mob extends LivingEntity implements Targeting { } nbt.putBoolean("Bukkit.Aware", this.aware); // CraftBukkit @@ -73,7 +73,7 @@ index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44f } @Override -@@ -629,6 +652,11 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -631,6 +654,11 @@ public abstract class Mob extends LivingEntity implements Targeting { this.aware = nbt.getBoolean("Bukkit.Aware"); } // CraftBukkit end @@ -85,7 +85,7 @@ index ef290c4f243e07a15a489ddd7461b4f182cb2345..9f68247ffc31b67e1eb66d3b6449c44f } @Override -@@ -1688,6 +1716,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1694,6 +1722,7 @@ public abstract class Mob extends LivingEntity implements Targeting { this.setLastHurtMob(target); } diff --git a/patches/server/0072-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch b/patches/server/0074-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch similarity index 91% rename from patches/server/0072-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch rename to patches/server/0074-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch index e01d7ec07..4a59e53fa 100644 --- a/patches/server/0072-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch +++ b/patches/server/0074-Add-option-to-teleport-to-spawn-if-outside-world-bor.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add option to teleport to spawn if outside world border diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index c28a819ea5bb93914dda4b94be42506e9492f9f2..14d5af88fb39af6bc6a8461972de3a96ad4f0de8 100644 +index fa7c220057be4d233752d9022a934d03e5f3df59..421aaf1fd85da9807bfe1b193bc13c5f3de2f474 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -2758,4 +2758,26 @@ public class ServerPlayer extends Player { @@ -36,10 +36,10 @@ index c28a819ea5bb93914dda4b94be42506e9492f9f2..14d5af88fb39af6bc6a8461972de3a96 + // Purpur end } diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 851bffca44dce8680a34bd5e862c1c0794806021..20b3b2deae7b72cc16f5e47ad73fab4d9779d047 100644 +index 9075fb0c8807157063d3f0435784a1382a75701a..6d636e45063a1fd6ab2f7560eacfca2655d55e93 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -429,6 +429,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -428,6 +428,7 @@ public abstract class LivingEntity extends Entity implements Attackable { double d1 = this.level().getWorldBorder().getDamagePerBlock(); if (d1 > 0.0D) { @@ -48,7 +48,7 @@ index 851bffca44dce8680a34bd5e862c1c0794806021..20b3b2deae7b72cc16f5e47ad73fab4d } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index af6cae292b86b7bfca06f869f22f1b4d40fdd81b..7a6c463c91ec2de4dc118299bd3e7b3eabcd62ee 100644 +index 96203a380bbb4dc9aaffb6867ca1395d96795f43..b585b7dfed1036c2bb250df4a6e265bdad9d5ec1 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -246,6 +246,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0073-Squid-EAR-immunity.patch b/patches/server/0075-Squid-EAR-immunity.patch similarity index 94% rename from patches/server/0073-Squid-EAR-immunity.patch rename to patches/server/0075-Squid-EAR-immunity.patch index 8e0cafcda..131599478 100644 --- a/patches/server/0073-Squid-EAR-immunity.patch +++ b/patches/server/0075-Squid-EAR-immunity.patch @@ -25,7 +25,7 @@ index b585b7dfed1036c2bb250df4a6e265bdad9d5ec1..72433b3f850ba3a5958ea77061d61bb7 public boolean spiderRidable = false; diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java -index cd2ec0b11f74e2b17f74ebb83f4e8b183f5b890e..17f99670d7e3dfb4a2863722eedc60dcfd73729d 100644 +index 12adaba78ec30e463963f99c0d78e844756143a1..79d027e517ce08443d86b877a55df24cc20d102b 100644 --- a/src/main/java/org/spigotmc/ActivationRange.java +++ b/src/main/java/org/spigotmc/ActivationRange.java @@ -15,6 +15,7 @@ import net.minecraft.world.entity.ambient.AmbientCreature; @@ -36,7 +36,7 @@ index cd2ec0b11f74e2b17f74ebb83f4e8b183f5b890e..17f99670d7e3dfb4a2863722eedc60dc import net.minecraft.world.entity.animal.WaterAnimal; import net.minecraft.world.entity.animal.horse.Llama; import net.minecraft.world.entity.boss.EnderDragonPart; -@@ -374,6 +375,7 @@ public class ActivationRange +@@ -397,6 +398,7 @@ public class ActivationRange */ public static boolean checkIfActive(Entity entity) { diff --git a/patches/server/0074-Phantoms-burn-in-light.patch b/patches/server/0076-Phantoms-burn-in-light.patch similarity index 100% rename from patches/server/0074-Phantoms-burn-in-light.patch rename to patches/server/0076-Phantoms-burn-in-light.patch diff --git a/patches/server/0075-Configurable-villager-breeding.patch b/patches/server/0077-Configurable-villager-breeding.patch similarity index 93% rename from patches/server/0075-Configurable-villager-breeding.patch rename to patches/server/0077-Configurable-villager-breeding.patch index f59d714e6..2b47ac602 100644 --- a/patches/server/0075-Configurable-villager-breeding.patch +++ b/patches/server/0077-Configurable-villager-breeding.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Configurable villager breeding diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 813b9708d218589afaaa2d0578affcc78f0c075f..52a84f354cc51b3ca875756514588b2e6309fc25 100644 +index 50925ab7d719ae3323d7456df03a3d2ab3481bfd..7d13a5308161d4093023b732bed7d06152f54737 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -779,7 +779,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -785,7 +785,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler @Override public boolean canBreed() { diff --git a/patches/server/0076-Redstone-deactivates-spawners.patch b/patches/server/0078-Redstone-deactivates-spawners.patch similarity index 89% rename from patches/server/0076-Redstone-deactivates-spawners.patch rename to patches/server/0078-Redstone-deactivates-spawners.patch index 89b51113d..f2e441616 100644 --- a/patches/server/0076-Redstone-deactivates-spawners.patch +++ b/patches/server/0078-Redstone-deactivates-spawners.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Redstone deactivates spawners diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java -index 8fdbc603486ff8a902b6327bc2acfb86a806626e..cb9acec46677048bd8ffbb0e3f2f0378350bf8b7 100644 +index 633500aefd515df5dadda3802b94079f75a03fa0..64d911bee1607880514061c75116d8672df8bb8f 100644 --- a/src/main/java/net/minecraft/world/level/BaseSpawner.java +++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java @@ -55,6 +55,7 @@ public abstract class BaseSpawner { @@ -17,7 +17,7 @@ index 8fdbc603486ff8a902b6327bc2acfb86a806626e..cb9acec46677048bd8ffbb0e3f2f0378 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 769cc5910468fddab1fbe8751e9dc4d30d4647f0..12db36e5496fba216863679a49ec1757ea26a349 100644 +index bca57328c6385017862d8b2efbd5bafa58bdf648..00d4878896e209b0077999aa5b0e2aec55380d3f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -358,6 +358,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0077-Totems-work-in-inventory.patch b/patches/server/0079-Totems-work-in-inventory.patch similarity index 91% rename from patches/server/0077-Totems-work-in-inventory.patch rename to patches/server/0079-Totems-work-in-inventory.patch index 0e9e80422..60c989366 100644 --- a/patches/server/0077-Totems-work-in-inventory.patch +++ b/patches/server/0079-Totems-work-in-inventory.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Totems work in inventory diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 20b3b2deae7b72cc16f5e47ad73fab4d9779d047..27df4e881e850a73947651ce7ad98df5159f4c1c 100644 +index 6d636e45063a1fd6ab2f7560eacfca2655d55e93..acd9c48a247b13be2d06e5fd6ada033f6084341d 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -1592,6 +1592,18 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -1600,6 +1600,18 @@ public abstract class LivingEntity extends Entity implements Attackable { } } @@ -28,7 +28,7 @@ index 20b3b2deae7b72cc16f5e47ad73fab4d9779d047..27df4e881e850a73947651ce7ad98df5 EntityResurrectEvent event = new EntityResurrectEvent((org.bukkit.entity.LivingEntity) this.getBukkitEntity(), handSlot); event.setCancelled(itemstack == null); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 12db36e5496fba216863679a49ec1757ea26a349..d30c6b98d394576c8eab5c298b9c731e6bd70cfa 100644 +index 00d4878896e209b0077999aa5b0e2aec55380d3f..fcb73074a54db31cf8b5c17e8806b80666ae22c6 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -247,6 +247,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0078-Add-vindicator-johnny-spawn-chance.patch b/patches/server/0080-Add-vindicator-johnny-spawn-chance.patch similarity index 100% rename from patches/server/0078-Add-vindicator-johnny-spawn-chance.patch rename to patches/server/0080-Add-vindicator-johnny-spawn-chance.patch diff --git a/patches/server/0079-Add-option-to-disable-certain-block-updates.patch b/patches/server/0081-Add-option-to-disable-certain-block-updates.patch similarity index 100% rename from patches/server/0079-Add-option-to-disable-certain-block-updates.patch rename to patches/server/0081-Add-option-to-disable-certain-block-updates.patch diff --git a/patches/server/0080-Dispensers-place-anvils-option.patch b/patches/server/0082-Dispensers-place-anvils-option.patch similarity index 96% rename from patches/server/0080-Dispensers-place-anvils-option.patch rename to patches/server/0082-Dispensers-place-anvils-option.patch index dd0490702..f0175564f 100644 --- a/patches/server/0080-Dispensers-place-anvils-option.patch +++ b/patches/server/0082-Dispensers-place-anvils-option.patch @@ -41,7 +41,7 @@ index b4f5dbe9022dd20437c15c4f6fbe2ac06dacbadb..b52a9f05ada86f2d3767dd0d5ba8705e static void setEntityPokingOutOfBlock(BlockSource pointer, Entity entity, Direction direction) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c1e72cdb13d37f82721033dc619e643bc6d6aece..b52a5b3cee95528be6edfcc488ab043225c81f67 100644 +index 3d76106d20f1b03690957111d69c7dc5fa48c533..4c37ded57929b79936edd3446bd4c92acf21790c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -321,8 +321,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0081-Allow-anvil-colors.patch b/patches/server/0083-Allow-anvil-colors.patch similarity index 98% rename from patches/server/0081-Allow-anvil-colors.patch rename to patches/server/0083-Allow-anvil-colors.patch index 8460394cb..2c2c17e94 100644 --- a/patches/server/0081-Allow-anvil-colors.patch +++ b/patches/server/0083-Allow-anvil-colors.patch @@ -64,7 +64,7 @@ index b500a04b8135604f0159a741b3d228c9e87b2a46..8a7c30e316db4960b0b62ca0e366c19f } } else if (itemstack.hasCustomHoverName()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c59510a016cb29e8469c3de55e46eae0a52151f5..47e425967c120fa0abec8dacf4385ce3ad47f21e 100644 +index 4c37ded57929b79936edd3446bd4c92acf21790c..035a18d131fab9892a85b41663fc3dbe2f8bafe2 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -299,6 +299,13 @@ public class PurpurWorldConfig { diff --git a/patches/server/0082-Add-option-to-disable-dolphin-treasure-searching.patch b/patches/server/0084-Add-option-to-disable-dolphin-treasure-searching.patch similarity index 100% rename from patches/server/0082-Add-option-to-disable-dolphin-treasure-searching.patch rename to patches/server/0084-Add-option-to-disable-dolphin-treasure-searching.patch diff --git a/patches/server/0083-Short-enderman-height.patch b/patches/server/0085-Short-enderman-height.patch similarity index 90% rename from patches/server/0083-Short-enderman-height.patch rename to patches/server/0085-Short-enderman-height.patch index 73c080bd9..d01992b8a 100644 --- a/patches/server/0083-Short-enderman-height.patch +++ b/patches/server/0085-Short-enderman-height.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Short enderman height diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java -index 78937a0cf8ee9a1a57123451f873f962f53b9394..e4e1245aaae94762b61a2a4663a68a625681e351 100644 +index 08beb4c4dfcb0986cdebb4d0cacc25e4e9c17674..e413aa4650297ce2109beb6319f52fb476e291fe 100644 --- a/src/main/java/net/minecraft/world/entity/EntityType.java +++ b/src/main/java/net/minecraft/world/entity/EntityType.java -@@ -306,7 +306,8 @@ public class EntityType implements FeatureElement, EntityTypeT +@@ -308,7 +308,8 @@ public class EntityType implements FeatureElement, EntityTypeT private Component description; @Nullable private ResourceLocation lootTable; @@ -19,10 +19,10 @@ index 78937a0cf8ee9a1a57123451f873f962f53b9394..e4e1245aaae94762b61a2a4663a68a62 private static EntityType register(String id, EntityType.Builder type) { // CraftBukkit - decompile error diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index 54b59b7faf69d54c05bdfee9b1bd2f137a5dd958..a9de01b7043124d8460f1608c3b929e911e3bc6f 100644 +index da14c848694c7fa86ea3af082d39e11234fb57c6..92c28c7cdfc987afc5f5281a77f218fdfab441b0 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -@@ -423,6 +423,7 @@ public class EnderMan extends Monster implements NeutralMob { +@@ -429,6 +429,7 @@ public class EnderMan extends Monster implements NeutralMob { if (this.isInvulnerableTo(source)) { return false; } else if (getRider() != null && this.isControllable()) { return super.hurt(source, amount); // Purpur - no teleporting on damage diff --git a/patches/server/0084-Stop-squids-floating-on-top-of-water.patch b/patches/server/0086-Stop-squids-floating-on-top-of-water.patch similarity index 92% rename from patches/server/0084-Stop-squids-floating-on-top-of-water.patch rename to patches/server/0086-Stop-squids-floating-on-top-of-water.patch index c50362cea..4d6576937 100644 --- a/patches/server/0084-Stop-squids-floating-on-top-of-water.patch +++ b/patches/server/0086-Stop-squids-floating-on-top-of-water.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Stop squids floating on top of water diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 26cb7466872b6e5b503cbaec933a7de18c928422..1a96037e195b7689db52a0991e644f500b8a9663 100644 +index 2831d061ae0f5a7a5d70aef0715078c0607b5701..130e0505d9856d5efe660d7ac172aaf796c5b09a 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -4325,6 +4325,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -4359,6 +4359,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.yRotO = this.getYRot(); } @@ -19,7 +19,7 @@ index 26cb7466872b6e5b503cbaec933a7de18c928422..1a96037e195b7689db52a0991e644f50 + // Purpur end + public boolean updateFluidHeightAndDoFluidPushing(TagKey tag, double speed) { - if (this.touchingUnloadedChunk()) { + if (false && this.touchingUnloadedChunk()) { // Pufferfish - cost of a lookup here is the same cost as below, so skip return false; diff --git a/src/main/java/net/minecraft/world/entity/animal/Squid.java b/src/main/java/net/minecraft/world/entity/animal/Squid.java index 42ca9df0735b4f928fbbf1e695d1756f77be52fc..de0a015cc944c36358fc34a3142ecbf9d2a332b5 100644 diff --git a/patches/server/0085-Crying-obsidian-valid-for-portal-frames.patch b/patches/server/0087-Crying-obsidian-valid-for-portal-frames.patch similarity index 100% rename from patches/server/0085-Crying-obsidian-valid-for-portal-frames.patch rename to patches/server/0087-Crying-obsidian-valid-for-portal-frames.patch diff --git a/patches/server/0086-Entities-can-use-portals-configuration.patch b/patches/server/0088-Entities-can-use-portals-configuration.patch similarity index 90% rename from patches/server/0086-Entities-can-use-portals-configuration.patch rename to patches/server/0088-Entities-can-use-portals-configuration.patch index c6c7afdb0..781a65245 100644 --- a/patches/server/0086-Entities-can-use-portals-configuration.patch +++ b/patches/server/0088-Entities-can-use-portals-configuration.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Entities can use portals configuration diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 1a96037e195b7689db52a0991e644f500b8a9663..54b1404fed0df43795c24f2f84306fe7aceb7c6d 100644 +index 130e0505d9856d5efe660d7ac172aaf796c5b09a..43e08e2722d3324c06494f30358adf7c5a67bc70 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -3032,7 +3032,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3066,7 +3066,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { public void handleInsidePortal(BlockPos pos) { if (this.isOnPortalCooldown()) { this.setPortalCooldown(); @@ -17,7 +17,7 @@ index 1a96037e195b7689db52a0991e644f500b8a9663..54b1404fed0df43795c24f2f84306fe7 if (!this.level().isClientSide && !pos.equals(this.portalEntrancePos)) { this.portalEntrancePos = pos.immutable(); } -@@ -3728,7 +3728,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3762,7 +3762,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } public boolean canChangeDimensions() { @@ -27,7 +27,7 @@ index 1a96037e195b7689db52a0991e644f500b8a9663..54b1404fed0df43795c24f2f84306fe7 public float getBlockExplosionResistance(Explosion explosion, BlockGetter world, BlockPos pos, BlockState blockState, FluidState fluidState, float max) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 99ce124edf3cb3e747785675c17bd831bf68fc74..a36f35990fe315dbb87c453b501892009acaa342 100644 +index 1797098e86a4c0abf1431e1d266be6a977c64b95..d7c26045abf907cdc3c3906e78666c6d5e4bf5f9 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -100,6 +100,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0087-LivingEntity-broadcastItemBreak.patch b/patches/server/0089-LivingEntity-broadcastItemBreak.patch similarity index 100% rename from patches/server/0087-LivingEntity-broadcastItemBreak.patch rename to patches/server/0089-LivingEntity-broadcastItemBreak.patch diff --git a/patches/server/0088-Customizable-wither-health-and-healing.patch b/patches/server/0090-Customizable-wither-health-and-healing.patch similarity index 100% rename from patches/server/0088-Customizable-wither-health-and-healing.patch rename to patches/server/0090-Customizable-wither-health-and-healing.patch diff --git a/patches/server/0089-Allow-toggling-special-MobSpawners-per-world.patch b/patches/server/0091-Allow-toggling-special-MobSpawners-per-world.patch similarity index 96% rename from patches/server/0089-Allow-toggling-special-MobSpawners-per-world.patch rename to patches/server/0091-Allow-toggling-special-MobSpawners-per-world.patch index e2eb651f0..73384a118 100644 --- a/patches/server/0089-Allow-toggling-special-MobSpawners-per-world.patch +++ b/patches/server/0091-Allow-toggling-special-MobSpawners-per-world.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Allow toggling special MobSpawners per world In vanilla, these are all hardcoded on for world type 0 (overworld) and hardcoded off for every other world type. Default config behaviour matches this. diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 2cd6b08ef5d8a67175c86d33e938c088dd053a82..c8c52f0c430ed956f82a7554ec1cf5d44c842383 100644 +index 11f92c1011a1accaf485e5785d2e9ebc8440406c..af57326c8d461d3c5d84f582d5bc6345c3c9367b 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -663,7 +663,24 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -59,7 +59,7 @@ index 5d199fe497bd852827d3d18fb7566a09e70331a3..6cd8a50289a6404441e9e5e08d82d2eb if (NaturalSpawner.isSpawnPositionOk(SpawnPlacements.Type.ON_GROUND, world, blockposition2, EntityType.WANDERING_TRADER)) { blockposition1 = blockposition2; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index af5bc07bf5598dc4ecb88b05e36d0ce232441b1e..b707a91e9d73e39708f9a5eec579a6d20fb95e8c 100644 +index ea9eee84f879ccc7e21c15fef8dd75e8cad67d9c..41edeeb40010f9551f32d36b47c89eab8323f01d 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -71,6 +71,12 @@ public class PurpurWorldConfig { diff --git a/patches/server/0090-Raid-cooldown-setting.patch b/patches/server/0092-Raid-cooldown-setting.patch similarity index 97% rename from patches/server/0090-Raid-cooldown-setting.patch rename to patches/server/0092-Raid-cooldown-setting.patch index f0f0b2da0..78ec0342f 100644 --- a/patches/server/0090-Raid-cooldown-setting.patch +++ b/patches/server/0092-Raid-cooldown-setting.patch @@ -49,7 +49,7 @@ index 41457c9f27b18fa2734a6cca297ec5186470e82f..94356e0541f8f4da68211fa533347cc9 if (!this.raidMap.containsKey(raid.getId())) { this.raidMap.put(raid.getId(), raid); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 82b4e05b4f4ad23bc98e81385bf0e715bf8cda50..eddc7cffe43083edca3aad0696e15299e36b1a65 100644 +index 41edeeb40010f9551f32d36b47c89eab8323f01d..5ebab2b52a1b0c1fb7a2419b9495f9491d53abdc 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -111,6 +111,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0091-Despawn-rate-config-options-per-projectile-type.patch b/patches/server/0093-Despawn-rate-config-options-per-projectile-type.patch similarity index 96% rename from patches/server/0091-Despawn-rate-config-options-per-projectile-type.patch rename to patches/server/0093-Despawn-rate-config-options-per-projectile-type.patch index 5573c80d4..3484ec4ca 100644 --- a/patches/server/0091-Despawn-rate-config-options-per-projectile-type.patch +++ b/patches/server/0093-Despawn-rate-config-options-per-projectile-type.patch @@ -7,7 +7,7 @@ This patch's implementation has been removed in favor of Pufferfish's entity-tim The config remains for migration purposes. diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index eddc7cffe43083edca3aad0696e15299e36b1a65..9d3f312eabca30f9012acfe575eb13bf8ec221bd 100644 +index 5ebab2b52a1b0c1fb7a2419b9495f9491d53abdc..3d9bb6ffdc9f1ad65017327e338670879d1adbf6 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -292,6 +292,39 @@ public class PurpurWorldConfig { diff --git a/patches/server/0092-Add-option-to-disable-zombie-aggressiveness-towards-.patch b/patches/server/0094-Add-option-to-disable-zombie-aggressiveness-towards-.patch similarity index 100% rename from patches/server/0092-Add-option-to-disable-zombie-aggressiveness-towards-.patch rename to patches/server/0094-Add-option-to-disable-zombie-aggressiveness-towards-.patch diff --git a/patches/server/0093-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch b/patches/server/0095-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch similarity index 100% rename from patches/server/0093-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch rename to patches/server/0095-Add-predicate-to-recipe-s-ExactChoice-ingredient.patch diff --git a/patches/server/0094-Flying-squids-Oh-my.patch b/patches/server/0096-Flying-squids-Oh-my.patch similarity index 100% rename from patches/server/0094-Flying-squids-Oh-my.patch rename to patches/server/0096-Flying-squids-Oh-my.patch diff --git a/patches/server/0095-Infinity-bow-settings.patch b/patches/server/0097-Infinity-bow-settings.patch similarity index 97% rename from patches/server/0095-Infinity-bow-settings.patch rename to patches/server/0097-Infinity-bow-settings.patch index ccd8d3973..4663068b1 100644 --- a/patches/server/0095-Infinity-bow-settings.patch +++ b/patches/server/0097-Infinity-bow-settings.patch @@ -27,7 +27,7 @@ index 08d597db1a5345a343777a01427655e6bf2c926b..33df0ca406dc8321b76b393f317bbd1c } else { user.startUsingItem(hand); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index dd1eced37919d62f571b9b4a524fb08cbe0cdf41..8c3a81393bb2d0ff251277cf81d5d0b8276b3628 100644 +index 335189e415ed96c45d0d1b4e97098728da8512f3..415bd62b1631dd9a4f45ad03e1df4af0229ba034 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -142,6 +142,17 @@ public class PurpurWorldConfig { diff --git a/patches/server/0096-Configurable-daylight-cycle.patch b/patches/server/0098-Configurable-daylight-cycle.patch similarity index 93% rename from patches/server/0096-Configurable-daylight-cycle.patch rename to patches/server/0098-Configurable-daylight-cycle.patch index 99ce89807..939c10753 100644 --- a/patches/server/0096-Configurable-daylight-cycle.patch +++ b/patches/server/0098-Configurable-daylight-cycle.patch @@ -18,10 +18,10 @@ index 9ec6145fe04ec64bbee8ec6a837719caebdbc6f5..358d610ad020cada1bb83e393deeeaae public ClientboundSetTimePacket(long time, long timeOfDay, boolean doDaylightCycle) { this.gameTime = time; diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 2da0bb6f710562d9abd181c110b85e970285d446..6b7d87c337dc2cdbf1b7ad415a7ec0f709285ae3 100644 +index e187ca5cfb1a99ca3e8c25f9a89d4b12b66ab5cd..a8ca0d0b4bb6474f20c448439f517e280a480f50 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1517,7 +1517,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop recipe, NonNullList slots, int count) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 11938cd9c6196f5cc89a13ad7a81d4e4fa8d0879..ef6fe57cce6c6ef6c6820ab2bd676fbe4b30370e 100644 +index 2d747b550bd6a640de94467759bb53a48062ca7e..e7e698613ef8473bb13f18e127a4478822b73930 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -415,6 +415,17 @@ public class PurpurWorldConfig { diff --git a/patches/server/0099-Arrows-should-not-reset-despawn-counter.patch b/patches/server/0101-Arrows-should-not-reset-despawn-counter.patch similarity index 95% rename from patches/server/0099-Arrows-should-not-reset-despawn-counter.patch rename to patches/server/0101-Arrows-should-not-reset-despawn-counter.patch index ec77bb5fe..cf83c3d42 100644 --- a/patches/server/0099-Arrows-should-not-reset-despawn-counter.patch +++ b/patches/server/0101-Arrows-should-not-reset-despawn-counter.patch @@ -20,7 +20,7 @@ index 7226be19248a1ffb8ff2c89b55882529d33a6c0c..4f98d7f755ad692dd9589134524a604e @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ef6fe57cce6c6ef6c6820ab2bd676fbe4b30370e..d1d51f147c91cb99ff3dc03c5e461cf6acf529d4 100644 +index e7e698613ef8473bb13f18e127a4478822b73930..9bf633953526b1d5e31baa86474c2bc41f520b99 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -103,6 +103,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0100-Ability-to-re-add-farmland-mechanics-from-Alpha.patch b/patches/server/0102-Ability-to-re-add-farmland-mechanics-from-Alpha.patch similarity index 95% rename from patches/server/0100-Ability-to-re-add-farmland-mechanics-from-Alpha.patch rename to patches/server/0102-Ability-to-re-add-farmland-mechanics-from-Alpha.patch index c1e1ddf79..bbcea2db1 100644 --- a/patches/server/0100-Ability-to-re-add-farmland-mechanics-from-Alpha.patch +++ b/patches/server/0102-Ability-to-re-add-farmland-mechanics-from-Alpha.patch @@ -24,7 +24,7 @@ index d446b440e2bc5b73362fc3d30a10d2e52fde68e1..d4e3a32a0f9b49bff64cb43d77727ce3 return; } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d1d51f147c91cb99ff3dc03c5e461cf6acf529d4..78e2afcbe361e32a023a9a3b0708b9c1705138a4 100644 +index 9bf633953526b1d5e31baa86474c2bc41f520b99..5ed833c5642c5cbac6b6717d4d1a37a6936887eb 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -416,8 +416,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0101-Add-adjustable-breeding-cooldown-to-config.patch b/patches/server/0103-Add-adjustable-breeding-cooldown-to-config.patch similarity index 95% rename from patches/server/0101-Add-adjustable-breeding-cooldown-to-config.patch rename to patches/server/0103-Add-adjustable-breeding-cooldown-to-config.patch index aa15dc864..c6f1582a8 100644 --- a/patches/server/0101-Add-adjustable-breeding-cooldown-to-config.patch +++ b/patches/server/0103-Add-adjustable-breeding-cooldown-to-config.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add adjustable breeding cooldown to config diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java -index 7ec2ce1c9aa9a78b03770adc0c2faa28cdbe60f2..975eaac5d1e6cbf40454a0bebcea0ee4451c0cb2 100644 +index 1430f598073aab7387cf5985a7b3a84d3f53548c..9f6728184dffc4b5a93900ac6e8411f967eed26d 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Animal.java +++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java @@ -151,7 +151,7 @@ public abstract class Animal extends AgeableMob { @@ -42,7 +42,7 @@ index 7ec2ce1c9aa9a78b03770adc0c2faa28cdbe60f2..975eaac5d1e6cbf40454a0bebcea0ee4 org.bukkit.event.entity.EntityBreedEvent entityBreedEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityBreedEvent(entityageable, this, other, breeder, this.breedItem, experience); if (entityBreedEvent.isCancelled()) { diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 6e3d1122a2b7cdb91115bb8ed6c1578fa02ab58b..de6ca4b7e7549905d3ff53b13db28f1bde8f51bf 100644 +index 6b661982b217ae120d72ede3e19e82fbd3ebb69e..290d9fbeb71675d897b78d5c2b98ab477ce9f5fd 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java @@ -194,6 +194,49 @@ public abstract class Level implements LevelAccessor, AutoCloseable { @@ -95,7 +95,7 @@ index 6e3d1122a2b7cdb91115bb8ed6c1578fa02ab58b..de6ca4b7e7549905d3ff53b13db28f1b public CraftWorld getWorld() { return this.world; } -@@ -278,6 +321,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -289,6 +332,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper this.purpurConfig = new org.purpurmc.purpur.PurpurWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), env); // Purpur @@ -104,7 +104,7 @@ index 6e3d1122a2b7cdb91115bb8ed6c1578fa02ab58b..de6ca4b7e7549905d3ff53b13db28f1b this.world = new CraftWorld((ServerLevel) this, gen, biomeProvider, env); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 27f499f7a6924f9d3ca923c5c57d8770228c3c38..79f951f6275612234a26bff758ef3b0a67be9e52 100644 +index 5ed833c5642c5cbac6b6717d4d1a37a6936887eb..7a9ac5c8b6c2576e9a1728dc77f9a1e71013db22 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -117,6 +117,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0102-Make-entity-breeding-times-configurable.patch b/patches/server/0104-Make-entity-breeding-times-configurable.patch similarity index 99% rename from patches/server/0102-Make-entity-breeding-times-configurable.patch rename to patches/server/0104-Make-entity-breeding-times-configurable.patch index b8bdaacc4..a0c41822c 100644 --- a/patches/server/0102-Make-entity-breeding-times-configurable.patch +++ b/patches/server/0104-Make-entity-breeding-times-configurable.patch @@ -1,6 +1,6 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Jason Penilla <11360596+jpenilla@users.noreply.github.com> -Date: Sun, 15 Nov 2020 02:18:15 -0800 +From: granny +Date: Wed, 14 Jun 2023 22:36:44 -0700 Subject: [PATCH] Make entity breeding times configurable @@ -300,7 +300,7 @@ index c9ad084ce93eb618261221c7e19450c06fb8a5f5..074f1860e755348a5a3a8e9df3838966 protected void registerGoals() { this.goalSelector.addGoal(1, new FloatGoal(this)); diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -index 3b70849dca92ee4b0427396de6440f1c29fd724a..8b69eaf846d746e8c4a0d45378d85edcbfa4daf2 100644 +index 203aa1a885ab5d1770ac93f5346af27a9a47dbe8..5362778888890e43bcd4f6f8d68fcfbce22db966 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java @@ -120,6 +120,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder { @@ -346,7 +346,7 @@ index d4100aab149913a3146ce00f20baf15e2c3ecbfb..eab6d7bb5ae6635eb881156f50c8fd4e protected Brain.Provider brainProvider() { return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index 98f9489623a755778bec2f8977b57882ad2f0b4f..93b15328e00ee81925419aeb54ca2c3873aea924 100644 +index 1d9e2c93fa08d6f2f16b81021477294a6de3ce04..046a6cc61a9b823fe736bdfb15a338f8502f17f9 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -106,6 +106,11 @@ public class Goat extends Animal { @@ -506,7 +506,7 @@ index eedfd4dffdc5586a0b50769b17c5515e5ccac916..93dca4758ed995373fe1585930f22560 BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable(); diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -index 853fe631a7d665e2379296c89e433e761495a814..ae4d404b837da202e52d246dabfc00c8803e0260 100644 +index 66f2695403a04c2e9540bf2ec290bf1cc5a377ca..bd72dc99752faca3180ecb165b11406ada1a564e 100644 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java @@ -89,6 +89,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { diff --git a/patches/server/0103-Apply-display-names-from-item-forms-of-entities-to-e.patch b/patches/server/0105-Apply-display-names-from-item-forms-of-entities-to-e.patch similarity index 99% rename from patches/server/0103-Apply-display-names-from-item-forms-of-entities-to-e.patch rename to patches/server/0105-Apply-display-names-from-item-forms-of-entities-to-e.patch index 1e5c89fc3..d8ab5cab7 100644 --- a/patches/server/0103-Apply-display-names-from-item-forms-of-entities-to-e.patch +++ b/patches/server/0105-Apply-display-names-from-item-forms-of-entities-to-e.patch @@ -136,7 +136,7 @@ index b2ad6d230de2c29f371178bccde1111c7532ee70..6667926519a0f1c151e53f59cce36e74 if (((HangingEntity) object).survives()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e0074e78a66eb425d45d1d17da6663b2b5a1681b..1fea447181f3bf032962d9cc7ff402fff1d76d2a 100644 +index 852b8f4eee52840eac1feb8d98843e7d74a3a5f9..bbba0bf68ad619f3cde913bcd5cf84260efb9df0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -99,8 +99,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0104-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch b/patches/server/0106-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch similarity index 96% rename from patches/server/0104-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch rename to patches/server/0106-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch index 1aab57146..16b233ea3 100644 --- a/patches/server/0104-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch +++ b/patches/server/0106-Set-name-visible-when-using-a-Name-Tag-on-an-Armor-S.patch @@ -17,7 +17,7 @@ index 2941c16ef486345b57ab2dfcd26f0272285d3b5a..7cc6812bf6f2ba015f65fd1fc1eaac02 ((Mob) newEntityLiving).setPersistenceRequired(); // Paper end diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1fea447181f3bf032962d9cc7ff402fff1d76d2a..db4c2f00e8e1121426166ec0bf45d01e93fc3fa2 100644 +index bbba0bf68ad619f3cde913bcd5cf84260efb9df0..b0fac0182a8f20e41bf999cb99582c45b9569b44 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -100,9 +100,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0105-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch b/patches/server/0107-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch similarity index 93% rename from patches/server/0105-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch rename to patches/server/0107-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch index 8385e5afd..8fe728a2b 100644 --- a/patches/server/0105-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch +++ b/patches/server/0107-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch @@ -8,10 +8,10 @@ This should help to reduce the amount of dirt, gravel, grass, and etc. that Endermen like to randomly place all over the world. diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index a9de01b7043124d8460f1608c3b929e911e3bc6f..772402331f2a24c899ed7e7002ec981403574e22 100644 +index 92c28c7cdfc987afc5f5281a77f218fdfab441b0..1ff3c526ed34cbece3321de67aa90137f4380133 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -@@ -484,7 +484,7 @@ public class EnderMan extends Monster implements NeutralMob { +@@ -490,7 +490,7 @@ public class EnderMan extends Monster implements NeutralMob { @Override public boolean requiresCustomPersistence() { diff --git a/patches/server/0106-Add-configurable-snowball-damage.patch b/patches/server/0108-Add-configurable-snowball-damage.patch similarity index 95% rename from patches/server/0106-Add-configurable-snowball-damage.patch rename to patches/server/0108-Add-configurable-snowball-damage.patch index a8fbc68bc..a77149d33 100644 --- a/patches/server/0106-Add-configurable-snowball-damage.patch +++ b/patches/server/0108-Add-configurable-snowball-damage.patch @@ -18,7 +18,7 @@ index 718e120c9768cf716b32d3d652f53f1dda925168..b90cedad282e95a067aca176fafa9f72 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 448eaab8347dd66cf060d45783e5d4b0442a6774..f8df67b41acde045321dbfb9e2cefb008544a6dd 100644 +index b1ddc08a8a763854dd5f964a49fb88d3e1adcaac..0a4acc723a3f08b8274ba4d5a193b050dd2b49e0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -356,6 +356,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0107-Changeable-Mob-Left-Handed-Chance.patch b/patches/server/0109-Changeable-Mob-Left-Handed-Chance.patch similarity index 86% rename from patches/server/0107-Changeable-Mob-Left-Handed-Chance.patch rename to patches/server/0109-Changeable-Mob-Left-Handed-Chance.patch index 3b3f94ae9..748d9f0c9 100644 --- a/patches/server/0107-Changeable-Mob-Left-Handed-Chance.patch +++ b/patches/server/0109-Changeable-Mob-Left-Handed-Chance.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Changeable Mob Left Handed Chance diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 9f68247ffc31b67e1eb66d3b6449c44fe8549d0d..c8e394ebd6d2393ef77b95d6f20fcbf6040a1dc5 100644 +index 64a682ea339809adfb8304a7f14d4a596e5332be..4e5a261ccb7fb63b82ac7194598729fd60a20840 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java -@@ -1289,7 +1289,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1295,7 +1295,7 @@ public abstract class Mob extends LivingEntity implements Targeting { RandomSource randomsource = world.getRandom(); this.getAttribute(Attributes.FOLLOW_RANGE).addPermanentModifier(new AttributeModifier("Random spawn bonus", randomsource.triangle(0.0D, 0.11485000000000001D), AttributeModifier.Operation.MULTIPLY_BASE)); @@ -18,7 +18,7 @@ index 9f68247ffc31b67e1eb66d3b6449c44fe8549d0d..c8e394ebd6d2393ef77b95d6f20fcbf6 } else { this.setLeftHanded(false); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index f8df67b41acde045321dbfb9e2cefb008544a6dd..136b818e867be9c327bc1e0be590716445623953 100644 +index 0a4acc723a3f08b8274ba4d5a193b050dd2b49e0..2760a1b338e0b0e737e71ad2cb515d6e1608093c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -158,8 +158,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0108-Add-boat-fall-damage-config.patch b/patches/server/0110-Add-boat-fall-damage-config.patch similarity index 94% rename from patches/server/0108-Add-boat-fall-damage-config.patch rename to patches/server/0110-Add-boat-fall-damage-config.patch index a229d1aab..21c2064af 100644 --- a/patches/server/0108-Add-boat-fall-damage-config.patch +++ b/patches/server/0110-Add-boat-fall-damage-config.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add boat fall damage config diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index 14d5af88fb39af6bc6a8461972de3a96ad4f0de8..f71101057b89cd0393d8a64760d1ae9e7a50beb6 100644 +index 421aaf1fd85da9807bfe1b193bc13c5f3de2f474..3997d78770c503802bd354819d0258c16329858d 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -1112,7 +1112,16 @@ public class ServerPlayer extends Player { @@ -27,7 +27,7 @@ index 14d5af88fb39af6bc6a8461972de3a96ad4f0de8..f71101057b89cd0393d8a64760d1ae9e if (!flag && isSpawnInvulnerable() && !source.is(DamageTypeTags.BYPASSES_INVULNERABILITY)) { // Purpur diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 136b818e867be9c327bc1e0be590716445623953..b991de8c4761f6fd82d0c8f325d90fa9e2425d9f 100644 +index 2760a1b338e0b0e737e71ad2cb515d6e1608093c..8dab41636e046ae6cf8458d59a4bc2ecde5efcb4 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -114,6 +114,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0109-Snow-Golem-rate-of-fire-config.patch b/patches/server/0111-Snow-Golem-rate-of-fire-config.patch similarity index 100% rename from patches/server/0109-Snow-Golem-rate-of-fire-config.patch rename to patches/server/0111-Snow-Golem-rate-of-fire-config.patch diff --git a/patches/server/0110-EMC-Configurable-disable-give-dropping.patch b/patches/server/0112-EMC-Configurable-disable-give-dropping.patch similarity index 100% rename from patches/server/0110-EMC-Configurable-disable-give-dropping.patch rename to patches/server/0112-EMC-Configurable-disable-give-dropping.patch diff --git a/patches/server/0111-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch b/patches/server/0113-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch similarity index 98% rename from patches/server/0111-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch rename to patches/server/0113-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch index 080ff6ff1..4f7341b97 100644 --- a/patches/server/0111-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch +++ b/patches/server/0113-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch @@ -138,10 +138,10 @@ index cb1d91f9fe98f21c2afbe3894dfd9bca3bdd3ba6..d2703432af207c74ea8d298a784329c3 brain.setMemory(MemoryModuleType.SECONDARY_JOB_SITE, list); } else { diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 52a84f354cc51b3ca875756514588b2e6309fc25..0378faa19053dbcb74315e3fd6f96a37a226de4e 100644 +index 7d13a5308161d4093023b732bed7d06152f54737..605171aedb4f54dcd16837ad1e36097653a26ab6 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -221,7 +221,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -223,7 +223,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler brain.addActivity(Activity.PLAY, VillagerGoalPackages.getPlayPackage(0.5F)); } else { brain.setSchedule(Schedule.VILLAGER_DEFAULT); @@ -150,7 +150,7 @@ index 52a84f354cc51b3ca875756514588b2e6309fc25..0378faa19053dbcb74315e3fd6f96a37 } brain.addActivity(Activity.CORE, VillagerGoalPackages.getCorePackage(villagerprofession, 0.5F)); -@@ -972,6 +972,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -978,6 +978,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler public boolean hasFarmSeeds() { return this.getInventory().hasAnyMatching((itemstack) -> { diff --git a/patches/server/0112-Toggle-for-Zombified-Piglin-death-always-counting-as.patch b/patches/server/0114-Toggle-for-Zombified-Piglin-death-always-counting-as.patch similarity index 100% rename from patches/server/0112-Toggle-for-Zombified-Piglin-death-always-counting-as.patch rename to patches/server/0114-Toggle-for-Zombified-Piglin-death-always-counting-as.patch diff --git a/patches/server/0113-Configurable-chance-for-wolves-to-spawn-rabid.patch b/patches/server/0115-Configurable-chance-for-wolves-to-spawn-rabid.patch similarity index 100% rename from patches/server/0113-Configurable-chance-for-wolves-to-spawn-rabid.patch rename to patches/server/0115-Configurable-chance-for-wolves-to-spawn-rabid.patch diff --git a/patches/server/0114-Configurable-default-collar-color.patch b/patches/server/0116-Configurable-default-collar-color.patch similarity index 100% rename from patches/server/0114-Configurable-default-collar-color.patch rename to patches/server/0116-Configurable-default-collar-color.patch diff --git a/patches/server/0115-Phantom-flames-on-swoop.patch b/patches/server/0117-Phantom-flames-on-swoop.patch similarity index 100% rename from patches/server/0115-Phantom-flames-on-swoop.patch rename to patches/server/0117-Phantom-flames-on-swoop.patch diff --git a/patches/server/0116-Option-for-chests-to-open-even-with-a-solid-block-on.patch b/patches/server/0118-Option-for-chests-to-open-even-with-a-solid-block-on.patch similarity index 94% rename from patches/server/0116-Option-for-chests-to-open-even-with-a-solid-block-on.patch rename to patches/server/0118-Option-for-chests-to-open-even-with-a-solid-block-on.patch index e0d11ab75..a9d31a015 100644 --- a/patches/server/0116-Option-for-chests-to-open-even-with-a-solid-block-on.patch +++ b/patches/server/0118-Option-for-chests-to-open-even-with-a-solid-block-on.patch @@ -17,7 +17,7 @@ index 5e22d175b1048a58802cdf64ac70a8b56329e915..d81946b400f208c39941128ce823ff77 return world.getBlockState(blockposition1).isRedstoneConductor(world, blockposition1); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 27b506558ad224c46fb47b984129ed392398ea09..a2a630df5880a32ae6cc05af7a4c39c0885ccc03 100644 +index a1912de4f504597b80d3ccde91ddc1c30a9af081..30b0f2da508f6f4ccb7493646a6f3a32f354f84c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -425,6 +425,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0117-Implement-TPSBar.patch b/patches/server/0119-Implement-TPSBar.patch similarity index 97% rename from patches/server/0117-Implement-TPSBar.patch rename to patches/server/0119-Implement-TPSBar.patch index f1ab676aa..460801e4a 100644 --- a/patches/server/0117-Implement-TPSBar.patch +++ b/patches/server/0119-Implement-TPSBar.patch @@ -17,10 +17,10 @@ index e5b1b6ad32c48a4ba13b4930954fad18669677ad..4e721dfca7559620d8ce65a6703f2089 if (environment.includeIntegrated) { diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 6b7d87c337dc2cdbf1b7ad415a7ec0f709285ae3..c89c7c78612cf86c2632832ab85ea8cdfb71c0ed 100644 +index a8ca0d0b4bb6474f20c448439f517e280a480f50..f69ea0d2137419079d8ee59e009fcebab8f3d7e6 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1021,6 +1021,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause return; } -@@ -1291,6 +1293,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1292,6 +1294,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic if (byteTotal > byteAllowed) { ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send too large of a book. Book Size: " + byteTotal + " - Allowed: "+ byteAllowed + " - Pages: " + pageList.size()); diff --git a/patches/server/0120-Full-netherite-armor-grants-fire-resistance.patch b/patches/server/0122-Full-netherite-armor-grants-fire-resistance.patch similarity index 97% rename from patches/server/0120-Full-netherite-armor-grants-fire-resistance.patch rename to patches/server/0122-Full-netherite-armor-grants-fire-resistance.patch index 6fcc6f866..dc52b1570 100644 --- a/patches/server/0120-Full-netherite-armor-grants-fire-resistance.patch +++ b/patches/server/0122-Full-netherite-armor-grants-fire-resistance.patch @@ -26,7 +26,7 @@ index fa2a0cc24bbe31abd49ce0f3f41bab2aa5d9c81f..04e816f01db7d2de7ffa9bbaaa72daad protected ItemCooldowns createItemCooldowns() { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 0f41f154f74d056e507742bea279c4fb2d2ffae5..2d521598a6c02f8c64bf64e5abb0a23b65efb73a 100644 +index bb1f9729fd2c2043290c23c90fdbf33618576985..76a7444b120d377c4329a900bf6e692ecf20dfe0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -297,6 +297,19 @@ public class PurpurWorldConfig { diff --git a/patches/server/0121-Fix-rotating-UP-DOWN-CW-and-CCW.patch b/patches/server/0123-Fix-rotating-UP-DOWN-CW-and-CCW.patch similarity index 100% rename from patches/server/0121-Fix-rotating-UP-DOWN-CW-and-CCW.patch rename to patches/server/0123-Fix-rotating-UP-DOWN-CW-and-CCW.patch diff --git a/patches/server/0122-Add-mobGriefing-bypass-to-everything-affected.patch b/patches/server/0124-Add-mobGriefing-bypass-to-everything-affected.patch similarity index 98% rename from patches/server/0122-Add-mobGriefing-bypass-to-everything-affected.patch rename to patches/server/0124-Add-mobGriefing-bypass-to-everything-affected.patch index bec478830..8912ee04e 100644 --- a/patches/server/0122-Add-mobGriefing-bypass-to-everything-affected.patch +++ b/patches/server/0124-Add-mobGriefing-bypass-to-everything-affected.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add mobGriefing bypass to everything affected diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index dc3c1ef2595ffbbf8d2c7093bb48c60a10c231b7..39e09f82094c9c04b2bfd0e4aaba75e7f33635a7 100644 +index acd9c48a247b13be2d06e5fd6ada033f6084341d..5e97951e2645bd3225b64cf8f21ba8d6ba7e68d7 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -1770,7 +1770,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -1778,7 +1778,7 @@ public abstract class LivingEntity extends Entity implements Attackable { boolean flag = false; if (this.dead && adversary instanceof WitherBoss) { // Paper @@ -18,10 +18,10 @@ index dc3c1ef2595ffbbf8d2c7093bb48c60a10c231b7..39e09f82094c9c04b2bfd0e4aaba75e7 BlockState iblockdata = Blocks.WITHER_ROSE.defaultBlockState(); diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index c8e394ebd6d2393ef77b95d6f20fcbf6040a1dc5..16bb50d154622073d017fa350ec4610c1de7046e 100644 +index 4e5a261ccb7fb63b82ac7194598729fd60a20840..d24f94f2c27523af10184cae27157169d5deabae 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java -@@ -701,7 +701,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -703,7 +703,7 @@ public abstract class Mob extends LivingEntity implements Targeting { public void aiStep() { super.aiStep(); this.level().getProfiler().push("looting"); @@ -157,10 +157,10 @@ index c2f4ae412684cc2f8d3cc2206003be5c9e3b2769..d5f0636053fa0ed246ae2413a5b04f70 j = Mth.floor(this.getX()); int i1 = Mth.floor(this.getZ()); diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index d7a53c2a4906bfa8e69d8db12b89851deb174970..11b2bec9cb2c5a8f66361cec3006f59d7d20d99b 100644 +index 1ff3c526ed34cbece3321de67aa90137f4380133..fed9d13ff3fd87b22a2d974f94de3da37362b65a 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -@@ -532,7 +532,15 @@ public class EnderMan extends Monster implements NeutralMob { +@@ -538,7 +538,15 @@ public class EnderMan extends Monster implements NeutralMob { @Override public boolean canUse() { if (!enderman.level().purpurConfig.endermanAllowGriefing) return false; // Purpur @@ -177,7 +177,7 @@ index d7a53c2a4906bfa8e69d8db12b89851deb174970..11b2bec9cb2c5a8f66361cec3006f59d } @Override -@@ -580,7 +588,15 @@ public class EnderMan extends Monster implements NeutralMob { +@@ -586,7 +594,15 @@ public class EnderMan extends Monster implements NeutralMob { @Override public boolean canUse() { if (!enderman.level().purpurConfig.endermanAllowGriefing) return false; // Purpur @@ -243,10 +243,10 @@ index 0a78b3231700ff4ec4bc6ab9d3cbaebc261601e1..dbde54c4a616d6baba672a470b9886c9 BlockPos blockposition = BlockPos.containing(this.mob.getX(), this.mob.getY() + 0.5D, this.mob.getZ()).relative(this.selectedDirection); BlockState iblockdata = this.mob.level().getBlockState(blockposition); diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -index 24b8fc91775bc3a305b0293916600d34fdd7eb00..b40e43c94c7a7bb39e4428c4fa35f5697d8e954c 100644 +index e45c061931c5ca03e204b78e60010a906d3ec945..e2e9545a583deb1e2bbdcb76e459d8bd481d5d77 100644 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -@@ -428,7 +428,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento +@@ -429,7 +429,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento @Override public boolean wantsToPickUp(ItemStack stack) { @@ -284,10 +284,10 @@ index 251e6bc87eb02ec4372062ef22b21249ac5164ff..6b60597a0e837054b0d1891c1e6e5e7c // CraftBukkit start - fire ExplosionPrimeEvent ExplosionPrimeEvent event = new ExplosionPrimeEvent((org.bukkit.entity.Explosive) this.getBukkitEntity()); diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java -index 1b7cf6d06bdf36f146656727511a461f2520762e..ddc84a02fa0dd7201925aa329b8101c6468b7dc6 100644 +index 459aee61b519a40d9136546c0d9356562f5757c8..134b5758e5c6335a52ffb2703c3fa98dc792948e 100644 --- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java +++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java -@@ -289,6 +289,6 @@ public abstract class Projectile extends Entity implements TraceableEntity { +@@ -319,6 +319,6 @@ public abstract class Projectile extends Entity implements TraceableEntity { public boolean mayInteract(Level world, BlockPos pos) { Entity entity = this.getOwner(); diff --git a/patches/server/0123-Config-to-allow-Note-Block-sounds-when-blocked.patch b/patches/server/0125-Config-to-allow-Note-Block-sounds-when-blocked.patch similarity index 97% rename from patches/server/0123-Config-to-allow-Note-Block-sounds-when-blocked.patch rename to patches/server/0125-Config-to-allow-Note-Block-sounds-when-blocked.patch index 573c2f6bf..bbd865868 100644 --- a/patches/server/0123-Config-to-allow-Note-Block-sounds-when-blocked.patch +++ b/patches/server/0125-Config-to-allow-Note-Block-sounds-when-blocked.patch @@ -22,7 +22,7 @@ index 6bc29eeb5771a3dc9aa23c7d184c895717797b36..244857755f269eedd57d1c8d4657b4b4 // org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, pos, state.getValue(NoteBlock.INSTRUMENT), state.getValue(NoteBlock.NOTE)); // if (event.isCancelled()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index dfe8c4e6c904e0153e7874392098b207abcc5e38..4cc37f929b9875e52e029be163f4725f289d1aa9 100644 +index 8ce247a83c417b42670a045be00f68f501331245..d742c26c4e7b0f4c7868220d524165a3589d18b3 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -120,6 +120,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0124-Add-EntityTeleportHinderedEvent.patch b/patches/server/0126-Add-EntityTeleportHinderedEvent.patch similarity index 100% rename from patches/server/0124-Add-EntityTeleportHinderedEvent.patch rename to patches/server/0126-Add-EntityTeleportHinderedEvent.patch diff --git a/patches/server/0125-Farmland-trampling-changes.patch b/patches/server/0127-Farmland-trampling-changes.patch similarity index 97% rename from patches/server/0125-Farmland-trampling-changes.patch rename to patches/server/0127-Farmland-trampling-changes.patch index 54e0f5cfe..258885d74 100644 --- a/patches/server/0125-Farmland-trampling-changes.patch +++ b/patches/server/0127-Farmland-trampling-changes.patch @@ -37,7 +37,7 @@ index 090d232af0183c9c9ffeb4e75125514d827648f2..1064a13f37b991e60213b052e252a183 if (CraftEventFactory.callEntityChangeBlockEvent(entity, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) { return; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index f0ac7b1e9157870c396f7abdbc66363e6c609029..56049d177f9e483bc68b694cb4c4d1031269eb91 100644 +index 2eb890cc5de4be9da69940ecd9974c157a6c8cd3..c4faf116a0a99f817998ad3b305c95dd618a895a 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -463,10 +463,16 @@ public class PurpurWorldConfig { diff --git a/patches/server/0126-Movement-options-for-armor-stands.patch b/patches/server/0128-Movement-options-for-armor-stands.patch similarity index 94% rename from patches/server/0126-Movement-options-for-armor-stands.patch rename to patches/server/0128-Movement-options-for-armor-stands.patch index 58a016300..70a382d8b 100644 --- a/patches/server/0126-Movement-options-for-armor-stands.patch +++ b/patches/server/0128-Movement-options-for-armor-stands.patch @@ -17,10 +17,10 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 54b1404fed0df43795c24f2f84306fe7aceb7c6d..c3311e8d49b874323afa28e4f4891fe7d312334c 100644 +index 43e08e2722d3324c06494f30358adf7c5a67bc70..6e240eb1c656fb362d2b8005145fd840d0a088fb 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -1828,7 +1828,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1862,7 +1862,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return this.isInWater() || flag; } @@ -66,7 +66,7 @@ index 9eb196ee4061bb4c5713f33e8b16d91ec52711cd..ffb3ae1d36dda5f521cf3b292d819cb3 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2f8a7e1ea33e1dae5390a5ee42fe74ce56e952d7..0b4147b270f5683661686873a662df04347a702d 100644 +index c4faf116a0a99f817998ad3b305c95dd618a895a..b88ae6e8f6d2c8d647bce63183a7645a220906e8 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -101,10 +101,16 @@ public class PurpurWorldConfig { diff --git a/patches/server/0127-Fix-stuck-in-portals.patch b/patches/server/0129-Fix-stuck-in-portals.patch similarity index 90% rename from patches/server/0127-Fix-stuck-in-portals.patch rename to patches/server/0129-Fix-stuck-in-portals.patch index b75e30f65..4439bb8f3 100644 --- a/patches/server/0127-Fix-stuck-in-portals.patch +++ b/patches/server/0129-Fix-stuck-in-portals.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix stuck in portals diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index 81947e1dc48b91600f9b6417c13d153a41a9d502..026e3035167d41c18735cf57c63025bdadbb4ca0 100644 +index c177b6ebf0e2d10d19674094a4fed8637d305bda..81bfdafb84c543938375a1a90dab49a8452f78d8 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -1271,6 +1271,7 @@ public class ServerPlayer extends Player { @@ -17,10 +17,10 @@ index 81947e1dc48b91600f9b6417c13d153a41a9d502..026e3035167d41c18735cf57c63025bd // CraftBukkit end this.setServerLevel(worldserver); diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index c3311e8d49b874323afa28e4f4891fe7d312334c..49639113d0fb81acb0cc795d8a28e487a303de90 100644 +index 6e240eb1c656fb362d2b8005145fd840d0a088fb..b6f854a5f3dc79ef19aa20c7fde642e703091453 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -3029,12 +3029,15 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3063,12 +3063,15 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return Vec3.directionFromRotation(this.getRotationVector()); } @@ -37,7 +37,7 @@ index c3311e8d49b874323afa28e4f4891fe7d312334c..49639113d0fb81acb0cc795d8a28e487 this.isInsidePortal = true; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 0b4147b270f5683661686873a662df04347a702d..1cb4be76d5903cf85103a248c0ff0720c75aaef5 100644 +index b88ae6e8f6d2c8d647bce63183a7645a220906e8..35e12751aec9006da16ca69a60c2b82cc40aced6 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -337,6 +337,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0128-Toggle-for-water-sensitive-mob-damage.patch b/patches/server/0130-Toggle-for-water-sensitive-mob-damage.patch similarity index 99% rename from patches/server/0128-Toggle-for-water-sensitive-mob-damage.patch rename to patches/server/0130-Toggle-for-water-sensitive-mob-damage.patch index 1450d0d0b..8bc113796 100644 --- a/patches/server/0128-Toggle-for-water-sensitive-mob-damage.patch +++ b/patches/server/0130-Toggle-for-water-sensitive-mob-damage.patch @@ -21,7 +21,7 @@ index b1ba0f24dd6f1ec4c60208564e4eb84bdcd457f4..1a67f46b57e398d23fbc495ee81ae62e protected ParticleOptions getInkParticle() { return ParticleTypes.GLOW_SQUID_INK; diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java -index 45297abb703c82f13cc206896758458afcfb3b51..98221b38722e5cc009b12c1bc57fd63dc9418706 100644 +index 42ab8b3828f66e84cf0d89169fe28867f387be6b..7b731e6d5f50904b211c58cc3a3e0cf350f39e91 100644 --- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java +++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java @@ -290,6 +290,11 @@ public class Bat extends AmbientCreature { @@ -411,7 +411,7 @@ index 89627025c0b5464900a5ea818c7aaf5d676f7a5f..0ab3e4a854fd1c5369fc734981d16fa6 protected void registerGoals() { this.goalSelector.addGoal(1, new FloatGoal(this)); diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -index 8b69eaf846d746e8c4a0d45378d85edcbfa4daf2..b0b0176ce1660d71fbbb96e60bba43f8deff3cd8 100644 +index 5362778888890e43bcd4f6f8d68fcfbce22db966..755d8907c1bb86f495588e0bef9e4aeade3af826 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java @@ -125,6 +125,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder getModelRotationValues() { return this.modelRotationValues; diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index 93b15328e00ee81925419aeb54ca2c3873aea924..fad539b4804204b9d5730962e6a7de114dda3f1a 100644 +index 046a6cc61a9b823fe736bdfb15a338f8502f17f9..6a917ef18f1f3797903e6f8b4516c0df8757c573 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -111,6 +111,11 @@ public class Goat extends Animal { @@ -673,7 +673,7 @@ index 48c28b5177c26c8ab07bb4960a71cddb7d4f543d..b494d5689beb19d621f5d7c9c22d84e1 return Guardian.createAttributes().add(Attributes.MOVEMENT_SPEED, 0.30000001192092896D).add(Attributes.ATTACK_DAMAGE, 8.0D).add(Attributes.MAX_HEALTH, 80.0D); } diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index cda9662affdac0f42f27d4b2edfa412b9cd16283..2c59a40a1c9f898c859063919659e91628131af1 100644 +index fed9d13ff3fd87b22a2d974f94de3da37362b65a..1f95363385c5ae9ce06495db5bebfec8346a534c 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java @@ -89,7 +89,7 @@ public class EnderMan extends Monster implements NeutralMob { @@ -1117,7 +1117,7 @@ index 67fd554cfd6b848ca1f2cf804ad4543ad2c88845..21ba6ea58dfbfd9a7c0bf7d518d7f127 public boolean jockeyOnlyBaby() { return level().purpurConfig.zombifiedPiglinJockeyOnlyBaby; diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -index ae4d404b837da202e52d246dabfc00c8803e0260..3b99761fabc02255a66ec84f5c6cf199848455dc 100644 +index bd72dc99752faca3180ecb165b11406ada1a564e..1fd65b47b1bd56bc09902324b1dd22dad2e0bc2d 100644 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java @@ -94,6 +94,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { @@ -1133,7 +1133,7 @@ index ae4d404b837da202e52d246dabfc00c8803e0260..3b99761fabc02255a66ec84f5c6cf199 public boolean canBeLeashed(Player player) { return !this.isLeashed(); diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -index b40e43c94c7a7bb39e4428c4fa35f5697d8e954c..e2d04fc258e093b0b2b5d11ae061a81f286d55ce 100644 +index e2e9545a583deb1e2bbdcb76e459d8bd481d5d77..83e9873138fb178511119effbe21449c303a5063 100644 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java @@ -118,6 +118,11 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento @@ -1165,10 +1165,10 @@ index 04e54c241078e6cd6419a21ba1bf913fd3b413d1..b63d87df0f48dd63c89118f91b31dc4e return Monster.createMonsterAttributes().add(Attributes.MAX_HEALTH, 50.0D).add(Attributes.MOVEMENT_SPEED, (double)0.35F).add(Attributes.ATTACK_DAMAGE, 7.0D); } diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 0378faa19053dbcb74315e3fd6f96a37a226de4e..7efc2d1c7fb65b17bdad0d212e660d71d5528cc9 100644 +index 605171aedb4f54dcd16837ad1e36097653a26ab6..01a1732ca13300b60979d250ebf156ca68bb014f 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -187,6 +187,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -189,6 +189,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler return level().purpurConfig.villagerCanBeLeashed && !this.isLeashed(); } diff --git a/patches/server/0129-Config-to-always-tame-in-Creative.patch b/patches/server/0131-Config-to-always-tame-in-Creative.patch similarity index 98% rename from patches/server/0129-Config-to-always-tame-in-Creative.patch rename to patches/server/0131-Config-to-always-tame-in-Creative.patch index 6a89f74d0..152c7d84e 100644 --- a/patches/server/0129-Config-to-always-tame-in-Creative.patch +++ b/patches/server/0131-Config-to-always-tame-in-Creative.patch @@ -59,7 +59,7 @@ index 0ab3e4a854fd1c5369fc734981d16fa6b844807f..b2902e01ff2e9add8258bfd0b32d0002 this.navigation.stop(); this.setTarget((LivingEntity) null); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1853fb621d58bb93c0c1f350325c43ca2d863351..8ba4b14265597e5433825dddae108a9bfc9e408a 100644 +index 2ae3a4c36466374855c77ef1255f5761b4736197..310e902718f7130637774fe6059e57302e7a4adc 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -119,6 +119,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0130-End-crystal-explosion-options.patch b/patches/server/0132-End-crystal-explosion-options.patch similarity index 97% rename from patches/server/0130-End-crystal-explosion-options.patch rename to patches/server/0132-End-crystal-explosion-options.patch index d581898cf..fa9b61346 100644 --- a/patches/server/0130-End-crystal-explosion-options.patch +++ b/patches/server/0132-End-crystal-explosion-options.patch @@ -5,7 +5,7 @@ Subject: [PATCH] End crystal explosion options diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java -index 767cd1dad6bb9857501abe04f5023ca3ffa5fdd2..ee5ba341d481d5a0fa874c3c707398c9c1eb1ed4 100644 +index e73446de9a58643609fedcbd0a503d95e5ce8271..ad0bf89f7aa3c71b683f8ade930a7b91df69b058 100644 --- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java +++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EndCrystal.java @@ -48,6 +48,22 @@ public class EndCrystal extends Entity { @@ -54,7 +54,7 @@ index 767cd1dad6bb9857501abe04f5023ca3ffa5fdd2..ee5ba341d481d5a0fa874c3c707398c9 this.onDestroyedBy(source); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 8ba4b14265597e5433825dddae108a9bfc9e408a..81d720ae34e0daa6b55c46dd2f65464abe9e87a5 100644 +index 310e902718f7130637774fe6059e57302e7a4adc..5a3a24dc9fa017a27b7cc1adb23b457b3b26e0fd 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -470,6 +470,43 @@ public class PurpurWorldConfig { diff --git a/patches/server/0131-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch b/patches/server/0133-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch similarity index 100% rename from patches/server/0131-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch rename to patches/server/0133-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch diff --git a/patches/server/0132-Dont-run-with-scissors.patch b/patches/server/0134-Dont-run-with-scissors.patch similarity index 96% rename from patches/server/0132-Dont-run-with-scissors.patch rename to patches/server/0134-Dont-run-with-scissors.patch index b28ea5daa..fb3a11bf1 100644 --- a/patches/server/0132-Dont-run-with-scissors.patch +++ b/patches/server/0134-Dont-run-with-scissors.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Dont run with scissors! diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 1eef184e0d8415acb9f65fbc4028bfc9db14338d..7f3b2ea667325fe66ba13c9babad4a3162ff425b 100644 +index 6d192a45f73c8a4dc2cd5f76bb081ae700dc188e..872f1ccc1b1253127ee37a8637de8ed3a95d43f1 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -1697,6 +1697,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1698,6 +1698,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic this.player.resetFallDistance(); } @@ -22,7 +22,7 @@ index 1eef184e0d8415acb9f65fbc4028bfc9db14338d..7f3b2ea667325fe66ba13c9babad4a31 this.player.checkMovementStatistics(this.player.getX() - d3, this.player.getY() - d4, this.player.getZ() - d5); this.lastGoodX = this.player.getX(); this.lastGoodY = this.player.getY(); -@@ -1729,6 +1736,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1730,6 +1737,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic } } // Paper end - optimise out extra getCubes diff --git a/patches/server/0133-One-Punch-Man.patch b/patches/server/0135-One-Punch-Man.patch similarity index 94% rename from patches/server/0133-One-Punch-Man.patch rename to patches/server/0135-One-Punch-Man.patch index 37e24af44..17d3dbf59 100644 --- a/patches/server/0133-One-Punch-Man.patch +++ b/patches/server/0135-One-Punch-Man.patch @@ -5,10 +5,10 @@ Subject: [PATCH] One Punch Man! diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 39e09f82094c9c04b2bfd0e4aaba75e7f33635a7..917962b430ab3b3f0d61dd6a813b0cd0a78f7497 100644 +index 5e97951e2645bd3225b64cf8f21ba8d6ba7e68d7..ad73979034b726979f0c032924e248bfb2ff09ef 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -2281,6 +2281,20 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -2303,6 +2303,20 @@ public abstract class LivingEntity extends Entity implements Attackable { } } diff --git a/patches/server/0134-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch b/patches/server/0136-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch similarity index 98% rename from patches/server/0134-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch rename to patches/server/0136-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch index ea4361c05..4cf915e2c 100644 --- a/patches/server/0134-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch +++ b/patches/server/0136-Configurable-Ender-Pearl-cooldown-damage-and-Endermi.patch @@ -43,7 +43,7 @@ index 749ab72edc0d2e9c6f1161415ab8d59d3d6ca976..897c202c0905040072a06fdfa2032a7f // Paper end if (user instanceof net.minecraft.server.level.ServerPlayer) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 99df4cbc3317bc6223e70e7f53439557bf4447b7..c957ff745cf466b0bb9e3a00bf811349b56a4188 100644 +index 446f19dcf8d2acac442051f024b9727cc85531cc..1c81cd77081fb5b055ef64d78760f3325da79b7c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -203,6 +203,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0135-Config-to-ignore-nearby-mobs-when-sleeping.patch b/patches/server/0137-Config-to-ignore-nearby-mobs-when-sleeping.patch similarity index 92% rename from patches/server/0135-Config-to-ignore-nearby-mobs-when-sleeping.patch rename to patches/server/0137-Config-to-ignore-nearby-mobs-when-sleeping.patch index 44abc59a3..1ca2beda2 100644 --- a/patches/server/0135-Config-to-ignore-nearby-mobs-when-sleeping.patch +++ b/patches/server/0137-Config-to-ignore-nearby-mobs-when-sleeping.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Config to ignore nearby mobs when sleeping diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index 026e3035167d41c18735cf57c63025bdadbb4ca0..0c22824240c260c86237a47680c1c2492a2201e2 100644 +index 81bfdafb84c543938375a1a90dab49a8452f78d8..2bff2de19769a20a68373abe14ed45249e4504ab 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -1429,7 +1429,7 @@ public class ServerPlayer extends Player { @@ -18,7 +18,7 @@ index 026e3035167d41c18735cf57c63025bdadbb4ca0..0c22824240c260c86237a47680c1c249 } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c957ff745cf466b0bb9e3a00bf811349b56a4188..5829cd48c964ead93500a31b145ddf0370287ee4 100644 +index 1c81cd77081fb5b055ef64d78760f3325da79b7c..890ee7eae3b2de48c285c1683ddd9d2dcd8805aa 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -357,6 +357,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0136-Add-back-player-spawned-endermite-API.patch b/patches/server/0138-Add-back-player-spawned-endermite-API.patch similarity index 100% rename from patches/server/0136-Add-back-player-spawned-endermite-API.patch rename to patches/server/0138-Add-back-player-spawned-endermite-API.patch diff --git a/patches/server/0137-Config-Enderman-aggressiveness-towards-Endermites.patch b/patches/server/0139-Config-Enderman-aggressiveness-towards-Endermites.patch similarity index 97% rename from patches/server/0137-Config-Enderman-aggressiveness-towards-Endermites.patch rename to patches/server/0139-Config-Enderman-aggressiveness-towards-Endermites.patch index c456a1784..af4d36f48 100644 --- a/patches/server/0137-Config-Enderman-aggressiveness-towards-Endermites.patch +++ b/patches/server/0139-Config-Enderman-aggressiveness-towards-Endermites.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Config Enderman aggressiveness towards Endermites diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index 2c59a40a1c9f898c859063919659e91628131af1..f579a092670b3e076008dc8c588ec2de0c2337b6 100644 +index 1f95363385c5ae9ce06495db5bebfec8346a534c..38708753709de108a6ea841ab8545f2d61d2b621 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java @@ -128,7 +128,7 @@ public class EnderMan extends Monster implements NeutralMob { diff --git a/patches/server/0138-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch b/patches/server/0140-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch similarity index 96% rename from patches/server/0138-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch rename to patches/server/0140-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch index 4cef81e2d..9ad6a6a2f 100644 --- a/patches/server/0138-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch +++ b/patches/server/0140-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch @@ -7,7 +7,7 @@ Prevents Enderman from becoming aggresive towards players that are wearing a Dra Adds functionality to a useless item! diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index f579a092670b3e076008dc8c588ec2de0c2337b6..1c8e2813ee24a73a8f83c74b90dc5f6eafe3689d 100644 +index 38708753709de108a6ea841ab8545f2d61d2b621..2d09b2c15833d1a724df15894bee18825ecafcee 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java @@ -265,7 +265,7 @@ public class EnderMan extends Monster implements NeutralMob { diff --git a/patches/server/0139-Tick-fluids-config.patch b/patches/server/0141-Tick-fluids-config.patch similarity index 97% rename from patches/server/0139-Tick-fluids-config.patch rename to patches/server/0141-Tick-fluids-config.patch index a38797216..4747a9800 100644 --- a/patches/server/0139-Tick-fluids-config.patch +++ b/patches/server/0141-Tick-fluids-config.patch @@ -36,7 +36,7 @@ index bbabe4ad8afcc3a2069f6e9d4a9adcb643266894..55419bd653f7f5391fa13cd15a0b00fb } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ef805260ea5ea8e4ada93be50abc43b8f6ab277c..998947e5f110e00af1dfcc5043be936ef460ef71 100644 +index 5c4c30d8ccf491fe394cb374bdebeeeaad04fdc4..00a34d17e187b025d4c6276e00a205a717b09e29 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -131,6 +131,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0140-Config-to-disable-Llama-caravans.patch b/patches/server/0142-Config-to-disable-Llama-caravans.patch similarity index 100% rename from patches/server/0140-Config-to-disable-Llama-caravans.patch rename to patches/server/0142-Config-to-disable-Llama-caravans.patch diff --git a/patches/server/0141-Config-to-make-Creepers-explode-on-death.patch b/patches/server/0143-Config-to-make-Creepers-explode-on-death.patch similarity index 100% rename from patches/server/0141-Config-to-make-Creepers-explode-on-death.patch rename to patches/server/0143-Config-to-make-Creepers-explode-on-death.patch diff --git a/patches/server/0142-Configurable-ravager-griefable-blocks-list.patch b/patches/server/0144-Configurable-ravager-griefable-blocks-list.patch similarity index 100% rename from patches/server/0142-Configurable-ravager-griefable-blocks-list.patch rename to patches/server/0144-Configurable-ravager-griefable-blocks-list.patch diff --git a/patches/server/0143-Sneak-to-bulk-process-composter.patch b/patches/server/0145-Sneak-to-bulk-process-composter.patch similarity index 98% rename from patches/server/0143-Sneak-to-bulk-process-composter.patch rename to patches/server/0145-Sneak-to-bulk-process-composter.patch index c2e954e9f..8eb670b43 100644 --- a/patches/server/0143-Sneak-to-bulk-process-composter.patch +++ b/patches/server/0145-Sneak-to-bulk-process-composter.patch @@ -90,7 +90,7 @@ index 87153b5576fed05103183a9860d804c2c8cfbe1c..e8ee608aa5e352d741694f50cdf77f06 int i = (Integer) state.getValue(ComposterBlock.LEVEL); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index be9dcd118cc5a7f105589e5dc2f0fb5e2b80b2bd..72ef41fcb32d91361eefe6fcb0930c91160aa20d 100644 +index f5a26ea78419e14ea4a6af08a14e677181763784..62035c2b1b4a41296405a5b252469dbac0bf2d17 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -485,6 +485,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0144-Config-for-skipping-night.patch b/patches/server/0146-Config-for-skipping-night.patch similarity index 92% rename from patches/server/0144-Config-for-skipping-night.patch rename to patches/server/0146-Config-for-skipping-night.patch index 99be01d97..3a180543a 100644 --- a/patches/server/0144-Config-for-skipping-night.patch +++ b/patches/server/0146-Config-for-skipping-night.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Config for skipping night diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index baf3924a522793a7584ba3ccf6b57e90a9b8a64b..100ca2bdc0b537407e6bb3b82ce2112860e586c7 100644 +index 0e8452f6a8300992f397fb15db763304d72fe3b9..49c412f46854ee877de1721b08629e8a3cd319f9 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -805,7 +805,7 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -18,7 +18,7 @@ index baf3924a522793a7584ba3ccf6b57e90a9b8a64b..100ca2bdc0b537407e6bb3b82ce21128 j = this.levelData.getDayTime() + 24000L; TimeSkipEvent event = new TimeSkipEvent(this.getWorld(), TimeSkipEvent.SkipReason.NIGHT_SKIP, (j - j % 24000L) - this.getDayTime()); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 72ef41fcb32d91361eefe6fcb0930c91160aa20d..2c83ed4bec42d5d463c152a03213517615e6d622 100644 +index 62035c2b1b4a41296405a5b252469dbac0bf2d17..3fb96a14928d24920999336a40920f0a4db65e9b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -360,6 +360,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0145-Add-config-for-villager-trading.patch b/patches/server/0147-Add-config-for-villager-trading.patch similarity index 96% rename from patches/server/0145-Add-config-for-villager-trading.patch rename to patches/server/0147-Add-config-for-villager-trading.patch index 430ce72ad..6f1e65b1e 100644 --- a/patches/server/0145-Add-config-for-villager-trading.patch +++ b/patches/server/0147-Add-config-for-villager-trading.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add config for villager trading diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 7efc2d1c7fb65b17bdad0d212e660d71d5528cc9..d78240487b934921509a26b7fca0bce0aaaa40b8 100644 +index 01a1732ca13300b60979d250ebf156ca68bb014f..444dbab9a1c95d1f8bc97e165e5302473a29c7e8 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -365,7 +365,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -371,7 +371,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler return tryRide(player, hand, InteractionResult.sidedSuccess(this.level().isClientSide)); // Purpur } else { if (level().purpurConfig.villagerRidable && itemstack.isEmpty()) return tryRide(player, hand); // Purpur diff --git a/patches/server/0146-Allow-infinity-on-crossbows.patch b/patches/server/0148-Allow-infinity-on-crossbows.patch similarity index 100% rename from patches/server/0146-Allow-infinity-on-crossbows.patch rename to patches/server/0148-Allow-infinity-on-crossbows.patch diff --git a/patches/server/0147-Drowning-Settings.patch b/patches/server/0149-Drowning-Settings.patch similarity index 86% rename from patches/server/0147-Drowning-Settings.patch rename to patches/server/0149-Drowning-Settings.patch index 05c31c3dc..39560626a 100644 --- a/patches/server/0147-Drowning-Settings.patch +++ b/patches/server/0149-Drowning-Settings.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Drowning Settings diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 49639113d0fb81acb0cc795d8a28e487a303de90..0734602a64f169665ca416efa37aa52d649e900c 100644 +index b6f854a5f3dc79ef19aa20c7fde642e703091453..ab112953d312af47948b7d86b8574753410c1658 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -3274,7 +3274,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3308,7 +3308,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } public int getMaxAirSupply() { @@ -18,10 +18,10 @@ index 49639113d0fb81acb0cc795d8a28e487a303de90..0734602a64f169665ca416efa37aa52d public int getAirSupply() { diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index e7725f76f3c9f0e3e414fc72b7d076e573ca0cd5..20a9562db4ea7cbd33ea84eab52646a30f4adca8 100644 +index ad73979034b726979f0c032924e248bfb2ff09ef..06f05449cc1fc30c3023c09e2995bf8116ea329b 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -441,7 +441,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -440,7 +440,7 @@ public abstract class LivingEntity extends Entity implements Attackable { if (flag1) { this.setAirSupply(this.decreaseAirSupply(this.getAirSupply())); @@ -30,7 +30,7 @@ index e7725f76f3c9f0e3e414fc72b7d076e573ca0cd5..20a9562db4ea7cbd33ea84eab52646a3 this.setAirSupply(0); Vec3 vec3d = this.getDeltaMovement(); -@@ -453,7 +453,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -452,7 +452,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.level().addParticle(ParticleTypes.BUBBLE, this.getX() + d2, this.getY() + d3, this.getZ() + d4, vec3d.x, vec3d.y, vec3d.z); } @@ -40,7 +40,7 @@ index e7725f76f3c9f0e3e414fc72b7d076e573ca0cd5..20a9562db4ea7cbd33ea84eab52646a3 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c1b28f0a964b83a3f887c78c7f0b75c3c79e8734..35a43f76f8c388f0d1e2b16d0ec0f3e421c4ddbd 100644 +index 315144150854861df1d9d0f8dce877dad7d73812..168805cdeb57398c906ac1c135e21d70198431ec 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -166,6 +166,15 @@ public class PurpurWorldConfig { diff --git a/patches/server/0148-Break-individual-slabs-when-sneaking.patch b/patches/server/0150-Break-individual-slabs-when-sneaking.patch similarity index 97% rename from patches/server/0148-Break-individual-slabs-when-sneaking.patch rename to patches/server/0150-Break-individual-slabs-when-sneaking.patch index e2f558aa9..ba0523035 100644 --- a/patches/server/0148-Break-individual-slabs-when-sneaking.patch +++ b/patches/server/0150-Break-individual-slabs-when-sneaking.patch @@ -47,7 +47,7 @@ index 18b603d646081926343dea108b55d641df1c2c34..370772b1297b78bcc7419684015830a8 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 35a43f76f8c388f0d1e2b16d0ec0f3e421c4ddbd..8aba6dd9ea9d2d915d33bdfb16a161ea6b20bc0a 100644 +index 168805cdeb57398c906ac1c135e21d70198431ec..b24dbf8c891a048e570966a5743fdf5b9475c074 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -606,6 +606,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0149-Config-to-disable-hostile-mob-spawn-on-ice.patch b/patches/server/0151-Config-to-disable-hostile-mob-spawn-on-ice.patch similarity index 96% rename from patches/server/0149-Config-to-disable-hostile-mob-spawn-on-ice.patch rename to patches/server/0151-Config-to-disable-hostile-mob-spawn-on-ice.patch index 7980fffad..cd1dbb501 100644 --- a/patches/server/0149-Config-to-disable-hostile-mob-spawn-on-ice.patch +++ b/patches/server/0151-Config-to-disable-hostile-mob-spawn-on-ice.patch @@ -24,7 +24,7 @@ index 55c245d0dfa369dc6de2197ae37335fba4fae4ae..c9b40515f4c2ff1eedfc9510930c3bae return false; } else { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index cd2de2f0a6aeda4b87f18e97e2c5999e1fd3246e..d3f930cc1892e6d2853e8d2e938534c69d10e3a2 100644 +index b24dbf8c891a048e570966a5743fdf5b9475c074..cc8d49bbc8167922b0a6e8b776dbb52f52296e2a 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -571,6 +571,13 @@ public class PurpurWorldConfig { diff --git a/patches/server/0150-Config-to-show-Armor-Stand-arms-on-spawn.patch b/patches/server/0152-Config-to-show-Armor-Stand-arms-on-spawn.patch similarity index 96% rename from patches/server/0150-Config-to-show-Armor-Stand-arms-on-spawn.patch rename to patches/server/0152-Config-to-show-Armor-Stand-arms-on-spawn.patch index f8e966382..9dc8271af 100644 --- a/patches/server/0150-Config-to-show-Armor-Stand-arms-on-spawn.patch +++ b/patches/server/0152-Config-to-show-Armor-Stand-arms-on-spawn.patch @@ -17,7 +17,7 @@ index ffb3ae1d36dda5f521cf3b292d819cb354844806..8ba5701ebec928ba52d88a6671332c80 public ArmorStand(Level world, double x, double y, double z) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d3f930cc1892e6d2853e8d2e938534c69d10e3a2..f675a120cb0e41880b277db60974f2d016fcc4fb 100644 +index cc8d49bbc8167922b0a6e8b776dbb52f52296e2a..b9afe3409fe69fa16365b02b5856d4bf328192af 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -104,6 +104,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0151-Option-to-make-doors-require-redstone.patch b/patches/server/0153-Option-to-make-doors-require-redstone.patch similarity index 98% rename from patches/server/0151-Option-to-make-doors-require-redstone.patch rename to patches/server/0153-Option-to-make-doors-require-redstone.patch index 344c2bc1f..355988dfe 100644 --- a/patches/server/0151-Option-to-make-doors-require-redstone.patch +++ b/patches/server/0153-Option-to-make-doors-require-redstone.patch @@ -67,7 +67,7 @@ index c028a7158e41a0754abb8e24dcd647633fbf3fe8..cd65d32f4af016d4937e598c71386a30 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index f675a120cb0e41880b277db60974f2d016fcc4fb..5c53c323296fc264f6a436b78c7def11deb742d2 100644 +index b9afe3409fe69fa16365b02b5856d4bf328192af..ac05f4a9e1b98c5770fb76c6ad86e5e42676fac7 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -510,6 +510,16 @@ public class PurpurWorldConfig { diff --git a/patches/server/0152-Config-to-allow-for-unsafe-enchants.patch b/patches/server/0154-Config-to-allow-for-unsafe-enchants.patch similarity index 97% rename from patches/server/0152-Config-to-allow-for-unsafe-enchants.patch rename to patches/server/0154-Config-to-allow-for-unsafe-enchants.patch index 32236c60b..b8ce13b92 100644 --- a/patches/server/0152-Config-to-allow-for-unsafe-enchants.patch +++ b/patches/server/0154-Config-to-allow-for-unsafe-enchants.patch @@ -27,7 +27,7 @@ index 664cbce2e06fcb95d3d3d6c5302fc9119f938925..bc9778c705d23acd84fa1cdeff6b403b ++i; } else if (targets.size() == 1) { diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java -index 6fc5699ad90127dc48fa9ff5cb6ba5367031ce83..c179fd1ee55116e1bbdd8f8fadd18825c6ba2cde 100644 +index 8a7c30e316db4960b0b62ca0e366c19febead214..29ba769c5f803ce2dc5285e65284febf9ee28eb2 100644 --- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java +++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java @@ -228,7 +228,8 @@ public class AnvilMenu extends ItemCombinerMenu { @@ -70,7 +70,7 @@ index 6fc5699ad90127dc48fa9ff5cb6ba5367031ce83..c179fd1ee55116e1bbdd8f8fadd18825 ((ServerPlayer) player).connection.send(new ClientboundContainerSetDataPacket(containerId, 0, cost.get())); } diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java -index 0addb98459b9de0fc954531f8c09b0af73abcc45..5a6a80b544ff5a0259da9bd49baf8ef43c220480 100644 +index 190a446ba6c41a8da7e11b953c8fb2cb8119c412..43ed450fbd7472495b1965dcbdc7ad107ba91dcc 100644 --- a/src/main/java/net/minecraft/world/item/ItemStack.java +++ b/src/main/java/net/minecraft/world/item/ItemStack.java @@ -1202,6 +1202,12 @@ public final class ItemStack { diff --git a/patches/server/0153-Configurable-sponge-absorption.patch b/patches/server/0155-Configurable-sponge-absorption.patch similarity index 95% rename from patches/server/0153-Configurable-sponge-absorption.patch rename to patches/server/0155-Configurable-sponge-absorption.patch index 830f1e0ef..3ee119cff 100644 --- a/patches/server/0153-Configurable-sponge-absorption.patch +++ b/patches/server/0155-Configurable-sponge-absorption.patch @@ -21,7 +21,7 @@ index 4bce895268542531598a01a1bccd8ac1ed703b7d..e4e926dc89f843886d0df5da31e00053 int i = aenumdirection.length; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 5c53c323296fc264f6a436b78c7def11deb742d2..cbc07c2cc6166293fa2f5af64abf9d20ac57b2d3 100644 +index ac05f4a9e1b98c5770fb76c6ad86e5e42676fac7..fa5d2e7139259331674b63d6587b28728e1c738e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -635,6 +635,13 @@ public class PurpurWorldConfig { diff --git a/patches/server/0154-Projectile-offset-config.patch b/patches/server/0156-Projectile-offset-config.patch similarity index 98% rename from patches/server/0154-Projectile-offset-config.patch rename to patches/server/0156-Projectile-offset-config.patch index 89495818f..c439e203b 100644 --- a/patches/server/0154-Projectile-offset-config.patch +++ b/patches/server/0156-Projectile-offset-config.patch @@ -18,7 +18,7 @@ index 33df0ca406dc8321b76b393f317bbd1c8ebe6366..220513d3fd5645322886522ea4f6b8c5 entityarrow.setCritArrow(true); } diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java -index 795803bbb89e8f19a308ece7b5d1359da1538519..1a2ce6fb16e8fed7c90ce99510b25531087a0699 100644 +index ae6ba3c0a7722674b304291f643960b0a58fca57..561e9acb90639031f19b5ff8685852599672f468 100644 --- a/src/main/java/net/minecraft/world/item/CrossbowItem.java +++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java @@ -64,7 +64,7 @@ public class CrossbowItem extends ProjectileWeaponItem implements Vanishable { @@ -96,7 +96,7 @@ index 06c2f30b77a2c8aecc65e0c305f643d53798f364..6d1573161f0d8c7999f84925ba7bbf53 entitythrowntrident.pickup = AbstractArrow.Pickup.CREATIVE_ONLY; } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index cbc07c2cc6166293fa2f5af64abf9d20ac57b2d3..53a98b4131a84bdcdfa618dd3e11fbe5a3a88e3a 100644 +index fa5d2e7139259331674b63d6587b28728e1c738e..37233d0416327cc9ae5ed190de008d2ccbd5a657 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -428,6 +428,23 @@ public class PurpurWorldConfig { diff --git a/patches/server/0155-Config-for-powered-rail-activation-distance.patch b/patches/server/0157-Config-for-powered-rail-activation-distance.patch similarity index 94% rename from patches/server/0155-Config-for-powered-rail-activation-distance.patch rename to patches/server/0157-Config-for-powered-rail-activation-distance.patch index 10f7b48c3..c259590a5 100644 --- a/patches/server/0155-Config-for-powered-rail-activation-distance.patch +++ b/patches/server/0157-Config-for-powered-rail-activation-distance.patch @@ -18,7 +18,7 @@ index 7fddb6fa8fd30ef88346a59f7867aae792f13772..40893e71fe8447b695350273bef9623b } else { int j = pos.getX(); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 53a98b4131a84bdcdfa618dd3e11fbe5a3a88e3a..5e0648856dcb71f218464d8b0b74e00e2d520efa 100644 +index 37233d0416327cc9ae5ed190de008d2ccbd5a657..8aa812f7dc8853cf9299f6273a1b57d6047a849f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -621,6 +621,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0156-Piglin-portal-spawn-modifier.patch b/patches/server/0158-Piglin-portal-spawn-modifier.patch similarity index 100% rename from patches/server/0156-Piglin-portal-spawn-modifier.patch rename to patches/server/0158-Piglin-portal-spawn-modifier.patch diff --git a/patches/server/0157-Config-to-change-max-number-of-bees.patch b/patches/server/0159-Config-to-change-max-number-of-bees.patch similarity index 100% rename from patches/server/0157-Config-to-change-max-number-of-bees.patch rename to patches/server/0159-Config-to-change-max-number-of-bees.patch diff --git a/patches/server/0158-Config-for-wither-explosion-radius.patch b/patches/server/0160-Config-for-wither-explosion-radius.patch similarity index 100% rename from patches/server/0158-Config-for-wither-explosion-radius.patch rename to patches/server/0160-Config-for-wither-explosion-radius.patch diff --git a/patches/server/0159-Gamemode-extra-permissions.patch b/patches/server/0161-Gamemode-extra-permissions.patch similarity index 100% rename from patches/server/0159-Gamemode-extra-permissions.patch rename to patches/server/0161-Gamemode-extra-permissions.patch diff --git a/patches/server/0160-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch b/patches/server/0162-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch similarity index 96% rename from patches/server/0160-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch rename to patches/server/0162-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch index 288e649f2..b1c629cef 100644 --- a/patches/server/0160-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch +++ b/patches/server/0162-Config-for-changing-the-blocks-that-turn-into-dirt-p.patch @@ -18,7 +18,7 @@ index c7195f2e12bbd6545f7bffcc2b4ba5cc3d48df20..5e730bc9c8ff94b16ac2bf8567dda8ae Runnable afterAction = null; // Paper if (blockState2 != null && level.getBlockState(blockPos.above()).isAir()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 3ff04b2071b6a8d52fd122a39f215ff816eed393..40b7de2a34f835fab827f884384029a14b76e632 100644 +index 7f23e61bc86b64a312b8c47e21a91371a565ceda..0c81a2bad4041f8d26a45dfef8a855d7ba467f49 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -450,6 +450,21 @@ public class PurpurWorldConfig { diff --git a/patches/server/0161-Configurable-piston-push-limit.patch b/patches/server/0163-Configurable-piston-push-limit.patch similarity index 96% rename from patches/server/0161-Configurable-piston-push-limit.patch rename to patches/server/0163-Configurable-piston-push-limit.patch index 96f48d80c..30ec72c58 100644 --- a/patches/server/0161-Configurable-piston-push-limit.patch +++ b/patches/server/0163-Configurable-piston-push-limit.patch @@ -36,7 +36,7 @@ index 744d91546d1a810f60a43c15ed74b4158f341a4a..354538daefa603f6df5a139b6bff87db } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 40b7de2a34f835fab827f884384029a14b76e632..d6d023d6742abcbe4cfacf0ea2b12c8780015261 100644 +index 0c81a2bad4041f8d26a45dfef8a855d7ba467f49..8bd2f3ea54754906aaeb73503ecf9f313445a13e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -631,6 +631,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0162-Configurable-broadcast-settings.patch b/patches/server/0164-Configurable-broadcast-settings.patch similarity index 97% rename from patches/server/0162-Configurable-broadcast-settings.patch rename to patches/server/0164-Configurable-broadcast-settings.patch index 77e689836..94a2ef5aa 100644 --- a/patches/server/0162-Configurable-broadcast-settings.patch +++ b/patches/server/0164-Configurable-broadcast-settings.patch @@ -17,7 +17,7 @@ index 52891c4a4260d1938f2f4565b5219ad303555638..69d349613f01ab0ac1890734657da529 // Paper end } diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index 0c22824240c260c86237a47680c1c2492a2201e2..2f7edbf425ebf2985fdcd3f347cdf211b64d15ec 100644 +index 2bff2de19769a20a68373abe14ed45249e4504ab..eabe8e197faa4e24ad5b31533a3de8470ef8f083 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -1003,6 +1003,7 @@ public class ServerPlayer extends Player { diff --git a/patches/server/0163-Configurable-mob-blindness.patch b/patches/server/0165-Configurable-mob-blindness.patch similarity index 92% rename from patches/server/0163-Configurable-mob-blindness.patch rename to patches/server/0165-Configurable-mob-blindness.patch index dc2e853d6..de6a53e29 100644 --- a/patches/server/0163-Configurable-mob-blindness.patch +++ b/patches/server/0165-Configurable-mob-blindness.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Configurable mob blindness Ported from https://github.com/raltsmc/mobblindness diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 2f48ddb7d2731bd05d149d6286ae8292dfbec94b..9cf87d4009e8d71d844cf1583a1457b45a523fff 100644 +index 06f05449cc1fc30c3023c09e2995bf8116ea329b..513f58b00293134fade28a289afde71a69e9f447 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -1038,6 +1038,17 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -1037,6 +1037,17 @@ public abstract class LivingEntity extends Entity implements Attackable { if (entitytypes == EntityType.SKELETON && itemstack.is(Items.SKELETON_SKULL) || entitytypes == EntityType.ZOMBIE && itemstack.is(Items.ZOMBIE_HEAD) || entitytypes == EntityType.PIGLIN && itemstack.is(Items.PIGLIN_HEAD) || entitytypes == EntityType.PIGLIN_BRUTE && itemstack.is(Items.PIGLIN_HEAD) || entitytypes == EntityType.CREEPER && itemstack.is(Items.CREEPER_HEAD)) { d0 *= 0.5D; } @@ -28,7 +28,7 @@ index 2f48ddb7d2731bd05d149d6286ae8292dfbec94b..9cf87d4009e8d71d844cf1583a1457b4 return d0; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d6d023d6742abcbe4cfacf0ea2b12c8780015261..5fcbfa39b9a22e9ceae21bab71c7686ca7722c1d 100644 +index 8bd2f3ea54754906aaeb73503ecf9f313445a13e..4149d8f762aad98f43600400b6a896c13a80417b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -134,6 +134,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0164-Hide-hidden-players-from-entity-selector.patch b/patches/server/0166-Hide-hidden-players-from-entity-selector.patch similarity index 100% rename from patches/server/0164-Hide-hidden-players-from-entity-selector.patch rename to patches/server/0166-Hide-hidden-players-from-entity-selector.patch diff --git a/patches/server/0165-Config-for-health-to-impact-Creeper-explosion-radius.patch b/patches/server/0167-Config-for-health-to-impact-Creeper-explosion-radius.patch similarity index 100% rename from patches/server/0165-Config-for-health-to-impact-Creeper-explosion-radius.patch rename to patches/server/0167-Config-for-health-to-impact-Creeper-explosion-radius.patch diff --git a/patches/server/0166-Iron-golem-calm-anger-options.patch b/patches/server/0168-Iron-golem-calm-anger-options.patch similarity index 100% rename from patches/server/0166-Iron-golem-calm-anger-options.patch rename to patches/server/0168-Iron-golem-calm-anger-options.patch diff --git a/patches/server/0167-Breedable-parrots.patch b/patches/server/0169-Breedable-parrots.patch similarity index 100% rename from patches/server/0167-Breedable-parrots.patch rename to patches/server/0169-Breedable-parrots.patch diff --git a/patches/server/0168-Configurable-powered-rail-boost-modifier.patch b/patches/server/0170-Configurable-powered-rail-boost-modifier.patch similarity index 96% rename from patches/server/0168-Configurable-powered-rail-boost-modifier.patch rename to patches/server/0170-Configurable-powered-rail-boost-modifier.patch index 4b74523a2..70e1fece6 100644 --- a/patches/server/0168-Configurable-powered-rail-boost-modifier.patch +++ b/patches/server/0170-Configurable-powered-rail-boost-modifier.patch @@ -18,7 +18,7 @@ index 5cdcc5792f19766d2d55d16859f8e0f68bd6479b..b99b94c6ec4767aba16d82eaca8b2761 Vec3 vec3d5 = this.getDeltaMovement(); double d21 = vec3d5.x; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 460a9d7191caa63a896b39e6e4b72239bfd3d967..afc59c56d8d60a51ddd6ce1a9f9f937d2398b381 100644 +index 7aeec14af9993e123d35a53ffa41750519c20027..692942076f5b9c90515a6b98d94cf6bba5d41458 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -277,6 +277,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0169-Add-config-change-multiplier-critical-damage-value.patch b/patches/server/0171-Add-config-change-multiplier-critical-damage-value.patch similarity index 96% rename from patches/server/0169-Add-config-change-multiplier-critical-damage-value.patch rename to patches/server/0171-Add-config-change-multiplier-critical-damage-value.patch index 94ff86b58..628cedba5 100644 --- a/patches/server/0169-Add-config-change-multiplier-critical-damage-value.patch +++ b/patches/server/0171-Add-config-change-multiplier-critical-damage-value.patch @@ -18,7 +18,7 @@ index 04e816f01db7d2de7ffa9bbaaa72daadaab34831..81ba8875f0077ac1be80533061bcb0e6 f += f1; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index afc59c56d8d60a51ddd6ce1a9f9f937d2398b381..7b7a97a2cea5b4e6567a96e3b23366e8dd446171 100644 +index 692942076f5b9c90515a6b98d94cf6bba5d41458..c5221022d8652d56a1e42a8ccb2ec2f7daedd459 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -376,6 +376,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0170-Option-to-disable-dragon-egg-teleporting.patch b/patches/server/0172-Option-to-disable-dragon-egg-teleporting.patch similarity index 95% rename from patches/server/0170-Option-to-disable-dragon-egg-teleporting.patch rename to patches/server/0172-Option-to-disable-dragon-egg-teleporting.patch index b3daafa92..461a2976e 100644 --- a/patches/server/0170-Option-to-disable-dragon-egg-teleporting.patch +++ b/patches/server/0172-Option-to-disable-dragon-egg-teleporting.patch @@ -19,7 +19,7 @@ index 7e1edcc7b9f170b7c649437c2f0dd78c0bab9be4..5f8ac1fdac2c334951261f2b9702f5e7 BlockPos blockposition1 = pos.offset(world.random.nextInt(16) - world.random.nextInt(16), world.random.nextInt(8) - world.random.nextInt(8), world.random.nextInt(16) - world.random.nextInt(16)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7b7a97a2cea5b4e6567a96e3b23366e8dd446171..5660dacaa679b41e0a72daf09f6b2ae948377eef 100644 +index c5221022d8652d56a1e42a8ccb2ec2f7daedd459..527a0163e2415c3f4bf2f61e1b49343b811d4fcb 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -558,6 +558,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0171-Config-for-unverified-username-message.patch b/patches/server/0173-Config-for-unverified-username-message.patch similarity index 100% rename from patches/server/0171-Config-for-unverified-username-message.patch rename to patches/server/0173-Config-for-unverified-username-message.patch diff --git a/patches/server/0172-Make-anvil-cumulative-cost-configurable.patch b/patches/server/0174-Make-anvil-cumulative-cost-configurable.patch similarity index 95% rename from patches/server/0172-Make-anvil-cumulative-cost-configurable.patch rename to patches/server/0174-Make-anvil-cumulative-cost-configurable.patch index ce75059d2..9fb33f8a3 100644 --- a/patches/server/0172-Make-anvil-cumulative-cost-configurable.patch +++ b/patches/server/0174-Make-anvil-cumulative-cost-configurable.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Make anvil cumulative cost configurable diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java -index c179fd1ee55116e1bbdd8f8fadd18825c6ba2cde..d5ac94043f833355dbd84252c490c06a691d9aa6 100644 +index 29ba769c5f803ce2dc5285e65284febf9ee28eb2..cb4a1cd39f12d90d30dd95efa2de58f57d9c6ee0 100644 --- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java +++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java @@ -399,7 +399,7 @@ public class AnvilMenu extends ItemCombinerMenu { diff --git a/patches/server/0173-ShulkerBox-allow-oversized-stacks.patch b/patches/server/0175-ShulkerBox-allow-oversized-stacks.patch similarity index 97% rename from patches/server/0173-ShulkerBox-allow-oversized-stacks.patch rename to patches/server/0175-ShulkerBox-allow-oversized-stacks.patch index ce4cc992f..7d545d883 100644 --- a/patches/server/0173-ShulkerBox-allow-oversized-stacks.patch +++ b/patches/server/0175-ShulkerBox-allow-oversized-stacks.patch @@ -35,7 +35,7 @@ index b51155ad12515b2d0dd0f202580b9f455c114d9a..dd6c82a418ee299d7a5614cb0260949c blockEntity.saveToItem(itemStack); if (shulkerBoxBlockEntity.hasCustomName()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 3965a9f456d7815a4f375bc5792f888a38c149ef..e508637fabd5b8688230f6e6aed82480f5c513e9 100644 +index 527a0163e2415c3f4bf2f61e1b49343b811d4fcb..d82f4c439795d8a4683dd5ee3b6ef16bb8783332 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -678,6 +678,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0174-Bee-can-work-when-raining-or-at-night.patch b/patches/server/0176-Bee-can-work-when-raining-or-at-night.patch similarity index 97% rename from patches/server/0174-Bee-can-work-when-raining-or-at-night.patch rename to patches/server/0176-Bee-can-work-when-raining-or-at-night.patch index 0a3f739cd..23a6d15ac 100644 --- a/patches/server/0174-Bee-can-work-when-raining-or-at-night.patch +++ b/patches/server/0176-Bee-can-work-when-raining-or-at-night.patch @@ -31,7 +31,7 @@ index a16a1df28258d605cf5908dbe19bda5d71ad4f45..7b82842b97ce795745cf6ee6399f618c return false; } else { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e508637fabd5b8688230f6e6aed82480f5c513e9..0ca2f8e83c449ccaa6d5758a14802f60435e5cee 100644 +index d82f4c439795d8a4683dd5ee3b6ef16bb8783332..431fb7829722ba447558afe7ab9994b65eca1f50 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -790,6 +790,8 @@ public class PurpurWorldConfig { diff --git a/patches/server/0175-API-for-any-mob-to-burn-daylight.patch b/patches/server/0177-API-for-any-mob-to-burn-daylight.patch similarity index 96% rename from patches/server/0175-API-for-any-mob-to-burn-daylight.patch rename to patches/server/0177-API-for-any-mob-to-burn-daylight.patch index 8a5124a70..1a16878d9 100644 --- a/patches/server/0175-API-for-any-mob-to-burn-daylight.patch +++ b/patches/server/0177-API-for-any-mob-to-burn-daylight.patch @@ -6,10 +6,10 @@ Subject: [PATCH] API for any mob to burn daylight Co-authored by: Encode42 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 23dd4900b64e8204870d5f1314bacc6d1f46a95c..c0c4c15e2bbdad8ee4cde98a971c3a1c3479c43f 100644 +index ab112953d312af47948b7d86b8574753410c1658..1aad0bed631b0a47a93de131136c90f8d567cb77 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -478,6 +478,21 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -484,6 +484,21 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { return true; } @@ -32,10 +32,10 @@ index 23dd4900b64e8204870d5f1314bacc6d1f46a95c..c0c4c15e2bbdad8ee4cde98a971c3a1c return this.hardCollides; } diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 81133745db9362ceda55cc410ecd2c65df0fb7cc..ac9b48a59b197648a6781629c4409712d0af44ab 100644 +index 513f58b00293134fade28a289afde71a69e9f447..6d7cb3e8f82cc6424db12fa9efbda6f2c7978228 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -265,6 +265,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -264,6 +264,7 @@ public abstract class LivingEntity extends Entity implements Attackable { public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // Paper @@ -43,7 +43,7 @@ index 81133745db9362ceda55cc410ecd2c65df0fb7cc..ac9b48a59b197648a6781629c4409712 @Override public float getBukkitYaw() { -@@ -806,6 +807,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -805,6 +806,7 @@ public abstract class LivingEntity extends Entity implements Attackable { dataresult.resultOrPartial(logger::error).ifPresent((nbtbase) -> { nbt.put("Brain", nbtbase); }); @@ -51,7 +51,7 @@ index 81133745db9362ceda55cc410ecd2c65df0fb7cc..ac9b48a59b197648a6781629c4409712 } @Override -@@ -890,6 +892,11 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -889,6 +891,11 @@ public abstract class LivingEntity extends Entity implements Attackable { this.brain = this.makeBrain(new Dynamic(NbtOps.INSTANCE, nbt.get("Brain"))); } @@ -63,7 +63,7 @@ index 81133745db9362ceda55cc410ecd2c65df0fb7cc..ac9b48a59b197648a6781629c4409712 } // CraftBukkit start -@@ -3525,6 +3532,27 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3547,6 +3554,27 @@ public abstract class LivingEntity extends Entity implements Attackable { this.hurt(this.damageSources().drown(), 1.0F); } @@ -92,10 +92,10 @@ index 81133745db9362ceda55cc410ecd2c65df0fb7cc..ac9b48a59b197648a6781629c4409712 public boolean isSensitiveToWater() { diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 16bb50d154622073d017fa350ec4610c1de7046e..e3634d7dfd2558173a5c9d05e4ab285c80237684 100644 +index d24f94f2c27523af10184cae27157169d5deabae..7dae759b777cf9077bf46d2e1189c20c1c2db60e 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java -@@ -1733,17 +1733,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1739,17 +1739,7 @@ public abstract class Mob extends LivingEntity implements Targeting { } public boolean isSunBurnTick() { diff --git a/patches/server/0176-Config-MobEffect-by-world.patch b/patches/server/0178-Config-MobEffect-by-world.patch similarity index 98% rename from patches/server/0176-Config-MobEffect-by-world.patch rename to patches/server/0178-Config-MobEffect-by-world.patch index 59c541679..106ecb8cd 100644 --- a/patches/server/0176-Config-MobEffect-by-world.patch +++ b/patches/server/0178-Config-MobEffect-by-world.patch @@ -40,7 +40,7 @@ index bcce17f884b57e619749351b7b2047f0a5f9be71..878f3da0067f89f47141f41c733bef67 ((ServerPlayer) entityhuman).connection.send(new ClientboundSetHealthPacket(((ServerPlayer) entityhuman).getBukkitEntity().getScaledHealth(), entityhuman.getFoodData().foodLevel, entityhuman.getFoodData().saturationLevel)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d7486913a8077c591a0f3969c517dd0a73b5b0b2..aea7982a0e507bd33b53fb0569acb6da3a270835 100644 +index 431fb7829722ba447558afe7ab9994b65eca1f50..cc90dc900c469469badd1c5b5f1db7bb32598dbb 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -333,6 +333,21 @@ public class PurpurWorldConfig { diff --git a/patches/server/0177-Beacon-Activation-Range-Configurable.patch b/patches/server/0179-Beacon-Activation-Range-Configurable.patch similarity index 96% rename from patches/server/0177-Beacon-Activation-Range-Configurable.patch rename to patches/server/0179-Beacon-Activation-Range-Configurable.patch index c43c9ee2c..33ab8cb18 100644 --- a/patches/server/0177-Beacon-Activation-Range-Configurable.patch +++ b/patches/server/0179-Beacon-Activation-Range-Configurable.patch @@ -26,7 +26,7 @@ index 59246e24558569f7f50b4d4d508616798091c888..cc03c02f290ee8d58a2fea54b1f977f4 } else { return effectRange; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index aea7982a0e507bd33b53fb0569acb6da3a270835..5ab074818ee68a1d41e4bddd0e04e652d343eabd 100644 +index cc90dc900c469469badd1c5b5f1db7bb32598dbb..00c111bddb01db5cbc8c5e026728d646dca9ad47 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -525,6 +525,17 @@ public class PurpurWorldConfig { diff --git a/patches/server/0178-Add-toggle-for-sand-duping-fix.patch b/patches/server/0180-Add-toggle-for-sand-duping-fix.patch similarity index 95% rename from patches/server/0178-Add-toggle-for-sand-duping-fix.patch rename to patches/server/0180-Add-toggle-for-sand-duping-fix.patch index f88dc8b80..4366cf60c 100644 --- a/patches/server/0178-Add-toggle-for-sand-duping-fix.patch +++ b/patches/server/0180-Add-toggle-for-sand-duping-fix.patch @@ -27,7 +27,7 @@ index eff81e846f696349b3bd3d26c02442f157b169f0..bdadc6bb8c0ddcbf4ec1a9d2b4267c9e } // Paper end - fix sand duping diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2e3a27c7392ba4e07f6c4bc7cee1ee2d4f27987e..b906d348b49c017a03337d599a1f87f2f8417c50 100644 +index 00c111bddb01db5cbc8c5e026728d646dca9ad47..03d86a351b1d2f02b8b7b0a27941ac90937df604 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -704,6 +704,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0179-Add-toggle-for-end-portal-safe-teleporting.patch b/patches/server/0181-Add-toggle-for-end-portal-safe-teleporting.patch similarity index 92% rename from patches/server/0179-Add-toggle-for-end-portal-safe-teleporting.patch rename to patches/server/0181-Add-toggle-for-end-portal-safe-teleporting.patch index 33864f421..151d46083 100644 --- a/patches/server/0179-Add-toggle-for-end-portal-safe-teleporting.patch +++ b/patches/server/0181-Add-toggle-for-end-portal-safe-teleporting.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add toggle for end portal safe teleporting diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 20fae6041a0a93c0de24f4e8bf0d2acf4b1bcced..f8caeea9c1ecd3c5dfe0f0a1e8aec342ca21f251 100644 +index 1aad0bed631b0a47a93de131136c90f8d567cb77..642146bfce20d46d95289728ec6e0059a27079b2 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -3103,7 +3103,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3137,7 +3137,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } this.processPortalCooldown(); @@ -45,7 +45,7 @@ index f80f6da484f4144e743079e5104bf503419074b2..2deddc746e43896584bd65ba8e7971a8 entity.portalWorld = ((ServerLevel)world); entity.portalBlock = pos.immutable(); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 4ebc5524a83992b90c4bb9dffa5c51ed8e1d6097..2bc1ab2989d2973dafad1951c579e27e17b650c8 100644 +index 03d86a351b1d2f02b8b7b0a27941ac90937df604..2bfbf53677b5d241492b0d969a22d241036867ac 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -652,6 +652,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0180-Make-lightning-rod-range-configurable.patch b/patches/server/0182-Make-lightning-rod-range-configurable.patch similarity index 93% rename from patches/server/0180-Make-lightning-rod-range-configurable.patch rename to patches/server/0182-Make-lightning-rod-range-configurable.patch index 21072c8fd..cc0acecf0 100644 --- a/patches/server/0180-Make-lightning-rod-range-configurable.patch +++ b/patches/server/0182-Make-lightning-rod-range-configurable.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Make lightning rod range configurable diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 100ca2bdc0b537407e6bb3b82ce2112860e586c7..aa43bec60f31dd8319ac74a4f91ff9771d3eaceb 100644 +index 49c412f46854ee877de1721b08629e8a3cd319f9..fea5481c98e4cbcaecb9f4adef35b7340ad0c9b8 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -1120,7 +1120,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1136,7 +1136,7 @@ public class ServerLevel extends Level implements WorldGenLevel { return holder.is(PoiTypes.LIGHTNING_ROD); }, (blockposition1) -> { return blockposition1.getY() == this.getHeight(Heightmap.Types.WORLD_SURFACE, blockposition1.getX(), blockposition1.getZ()) - 1; diff --git a/patches/server/0181-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch b/patches/server/0183-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch similarity index 97% rename from patches/server/0181-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch rename to patches/server/0183-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch index d8ca98511..ec71d9c58 100644 --- a/patches/server/0181-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch +++ b/patches/server/0183-Burp-delay-burp-after-eating-food-fills-hunger-bar-c.patch @@ -55,7 +55,7 @@ index 2038df72f8d7d33d4105de8129628daf21de6f0f..31ec6022b305df0ae02364c916ecf184 public void eat(Item item, ItemStack stack) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 08a62eed5b50b216ea4ef1884501c33faa996723..3f55bbf871336c1bedee4a1f867101dc1ae1242c 100644 +index 2bfbf53677b5d241492b0d969a22d241036867ac..fd9e016cc185ebcfb4465533b7a721409de7aacc 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -392,6 +392,8 @@ public class PurpurWorldConfig { diff --git a/patches/server/0182-Allow-player-join-full-server-by-permission.patch b/patches/server/0184-Allow-player-join-full-server-by-permission.patch similarity index 93% rename from patches/server/0182-Allow-player-join-full-server-by-permission.patch rename to patches/server/0184-Allow-player-join-full-server-by-permission.patch index 73cc3d46b..27f9b43cd 100644 --- a/patches/server/0182-Allow-player-join-full-server-by-permission.patch +++ b/patches/server/0184-Allow-player-join-full-server-by-permission.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Allow player join full server by permission diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 3e40080c6b1e74c80e762b385a7534bb1b8ee894..64a1fd3316f7b0b6e7feafc1be4649a4084d61a3 100644 +index 3cd656afdd612c265c812233736f5f343c0a6e48..7f46fac70a4cf041443197b1832a848974b6c45a 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -740,7 +740,7 @@ public abstract class PlayerList { diff --git a/patches/server/0183-Add-portal-waiting-option-permission-bypass.patch b/patches/server/0185-Add-portal-waiting-option-permission-bypass.patch similarity index 94% rename from patches/server/0183-Add-portal-waiting-option-permission-bypass.patch rename to patches/server/0185-Add-portal-waiting-option-permission-bypass.patch index ffa6fac47..d32c8a1f7 100644 --- a/patches/server/0183-Add-portal-waiting-option-permission-bypass.patch +++ b/patches/server/0185-Add-portal-waiting-option-permission-bypass.patch @@ -26,7 +26,7 @@ index bea9f52a6240794d45128659a62487f48f9f03dd..528aeec3f322ee2094098093e6016e41 @Override diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java -index cba6ead3f937f2b3d59c15a864e07e5cb2f2330c..ab75c82b96d0aea1ba1ba1065c8a16e5ad9cdbdd 100644 +index 0f3e696582cd288357598490e8af0131ab30bdfc..355797357f1c1cfceb8dbc016ef1b675c9a0759a 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java @@ -266,6 +266,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity { @@ -38,7 +38,7 @@ index cba6ead3f937f2b3d59c15a864e07e5cb2f2330c..ab75c82b96d0aea1ba1ba1065c8a16e5 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 3f55bbf871336c1bedee4a1f867101dc1ae1242c..77f776dc1ce999a135d539e8b478f2eb87e89d1f 100644 +index fd9e016cc185ebcfb4465533b7a721409de7aacc..d2e97de0e011715d7326ace3e5f083b180c63dcf 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -394,6 +394,8 @@ public class PurpurWorldConfig { diff --git a/patches/server/0184-Shulker-spawn-from-bullet-options.patch b/patches/server/0186-Shulker-spawn-from-bullet-options.patch similarity index 100% rename from patches/server/0184-Shulker-spawn-from-bullet-options.patch rename to patches/server/0186-Shulker-spawn-from-bullet-options.patch diff --git a/patches/server/0185-Eating-glow-berries-adds-glow-effect.patch b/patches/server/0187-Eating-glow-berries-adds-glow-effect.patch similarity index 97% rename from patches/server/0185-Eating-glow-berries-adds-glow-effect.patch rename to patches/server/0187-Eating-glow-berries-adds-glow-effect.patch index a0faaf6d9..2b0482e4b 100644 --- a/patches/server/0185-Eating-glow-berries-adds-glow-effect.patch +++ b/patches/server/0187-Eating-glow-berries-adds-glow-effect.patch @@ -18,7 +18,7 @@ index e6f8cb165f7e3da5f0edfc952d14059516de8acf..31f5ed9dd1727eee24804a384817d2b7 public static final Item SOUL_CAMPFIRE = registerBlock(Blocks.SOUL_CAMPFIRE); public static final Item SHROOMLIGHT = registerBlock(Blocks.SHROOMLIGHT); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 06065f28353e210bcacc4a578bc8d55587937a74..51f23d32fdaafe2edf83c1620023276fb96cc9d3 100644 +index 1f89f05884afa650feb948755aaaa3d071769412..726fa3439443994525ffd29a398b8ea39b778d75 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -222,6 +222,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0186-Option-to-make-drowned-break-doors.patch b/patches/server/0188-Option-to-make-drowned-break-doors.patch similarity index 100% rename from patches/server/0186-Option-to-make-drowned-break-doors.patch rename to patches/server/0188-Option-to-make-drowned-break-doors.patch diff --git a/patches/server/0187-Configurable-hunger-starvation-damage.patch b/patches/server/0189-Configurable-hunger-starvation-damage.patch similarity index 100% rename from patches/server/0187-Configurable-hunger-starvation-damage.patch rename to patches/server/0189-Configurable-hunger-starvation-damage.patch diff --git a/patches/server/0188-Enhance-SysoutCatcher.patch b/patches/server/0190-Enhance-SysoutCatcher.patch similarity index 100% rename from patches/server/0188-Enhance-SysoutCatcher.patch rename to patches/server/0190-Enhance-SysoutCatcher.patch diff --git a/patches/server/0189-Add-uptime-command.patch b/patches/server/0191-Add-uptime-command.patch similarity index 98% rename from patches/server/0189-Add-uptime-command.patch rename to patches/server/0191-Add-uptime-command.patch index 4ac071ef6..0c5c0c417 100644 --- a/patches/server/0189-Add-uptime-command.patch +++ b/patches/server/0191-Add-uptime-command.patch @@ -17,7 +17,7 @@ index 4e721dfca7559620d8ce65a6703f2089a839f4a0..7aae9e3c60ba15b8dcd8174a4d70866e } diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index c89c7c78612cf86c2632832ab85ea8cdfb71c0ed..f29fa70f7497282efe14248de50eca44dd71118d 100644 +index f69ea0d2137419079d8ee59e009fcebab8f3d7e6..ee822fadef35f45effa08c552b35a274599f11ce 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -294,6 +294,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0.0F) { this.playSound(this.getFallDamageSound((int) f3), 1.0F, 1.0F); diff --git a/patches/server/0200-Add-Option-for-disable-observer-clocks.patch b/patches/server/0202-Add-Option-for-disable-observer-clocks.patch similarity index 95% rename from patches/server/0200-Add-Option-for-disable-observer-clocks.patch rename to patches/server/0202-Add-Option-for-disable-observer-clocks.patch index 30dd5b913..6eefc1a6d 100644 --- a/patches/server/0200-Add-Option-for-disable-observer-clocks.patch +++ b/patches/server/0202-Add-Option-for-disable-observer-clocks.patch @@ -18,7 +18,7 @@ index 7b45d6b9a005036ca5051d089a7be792eb87012f..8806c97ecc6bdd8a64c2d82bb2f58f46 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 53f5a3496d09aaadb3ba7abc3e93f7206c3c060c..f08d302c7f8d163869067a80f5033e61b5cf3e40 100644 +index e6a26392252d70d842dfe1c9fb2d72132a1edef5..315fe5a2d00eb89563bea320a7cf5cb9964bce96 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -371,6 +371,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0201-Customizeable-Zombie-Villager-curing-times.patch b/patches/server/0203-Customizeable-Zombie-Villager-curing-times.patch similarity index 100% rename from patches/server/0201-Customizeable-Zombie-Villager-curing-times.patch rename to patches/server/0203-Customizeable-Zombie-Villager-curing-times.patch diff --git a/patches/server/0202-Option-for-sponges-to-work-on-lava.patch b/patches/server/0204-Option-for-sponges-to-work-on-lava.patch similarity index 95% rename from patches/server/0202-Option-for-sponges-to-work-on-lava.patch rename to patches/server/0204-Option-for-sponges-to-work-on-lava.patch index c5cf425d6..d16e4ec1f 100644 --- a/patches/server/0202-Option-for-sponges-to-work-on-lava.patch +++ b/patches/server/0204-Option-for-sponges-to-work-on-lava.patch @@ -18,7 +18,7 @@ index e4e926dc89f843886d0df5da31e00053284f5dae..5964949a6048194476e6dd501503caf0 // NOP } else if (iblockdata.getBlock() instanceof LiquidBlock) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1956541b29e264d9dc0cfda5569d708a2df83378..adb662181b627e7cd5aa34fc2947afd8c32a5ba6 100644 +index fdbb8bb236f2180d0a278bb614b24647111bb6c5..f74fd68281bc1895839b592a3b1bd49017e3f96f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -931,9 +931,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0203-Toggle-for-Wither-s-spawn-sound.patch b/patches/server/0205-Toggle-for-Wither-s-spawn-sound.patch similarity index 100% rename from patches/server/0203-Toggle-for-Wither-s-spawn-sound.patch rename to patches/server/0205-Toggle-for-Wither-s-spawn-sound.patch diff --git a/patches/server/0204-Cactus-breaks-from-solid-neighbors-config.patch b/patches/server/0206-Cactus-breaks-from-solid-neighbors-config.patch similarity index 95% rename from patches/server/0204-Cactus-breaks-from-solid-neighbors-config.patch rename to patches/server/0206-Cactus-breaks-from-solid-neighbors-config.patch index 43c6087ef..c053ca427 100644 --- a/patches/server/0204-Cactus-breaks-from-solid-neighbors-config.patch +++ b/patches/server/0206-Cactus-breaks-from-solid-neighbors-config.patch @@ -18,7 +18,7 @@ index 0003fb51ae3a6575575e10b4c86719f3061e2577..c2ca3432a47124d02e1aaf8ffb621f9a return false; } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 96871b1bbf2f7760da0d6a7426664af183ccbf04..b9e362088aacba6b8475ddfac94d184313ed989a 100644 +index 471020063a8e1f5fb23c3f66823ff7fc19b3ddff..ac0152a420285d9ae772671408d788cbca59dff3 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -757,6 +757,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0205-Config-to-remove-curse-of-binding-with-weakness.patch b/patches/server/0207-Config-to-remove-curse-of-binding-with-weakness.patch similarity index 96% rename from patches/server/0205-Config-to-remove-curse-of-binding-with-weakness.patch rename to patches/server/0207-Config-to-remove-curse-of-binding-with-weakness.patch index 649cc56ef..87c97964b 100644 --- a/patches/server/0205-Config-to-remove-curse-of-binding-with-weakness.patch +++ b/patches/server/0207-Config-to-remove-curse-of-binding-with-weakness.patch @@ -26,7 +26,7 @@ index c549618421c5d077c3d977d8d2064eca2acc438a..5972fa434847d24fa98b7895fd8386d2 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index b9e362088aacba6b8475ddfac94d184313ed989a..fad6f824b761ad41b462ed741e5476856638d0c8 100644 +index ac0152a420285d9ae772671408d788cbca59dff3..825a3acacbc04805a9616bbe6a4f0f1acd48cc74 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -410,6 +410,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0206-Conduit-behavior-configuration.patch b/patches/server/0208-Conduit-behavior-configuration.patch similarity index 100% rename from patches/server/0206-Conduit-behavior-configuration.patch rename to patches/server/0208-Conduit-behavior-configuration.patch diff --git a/patches/server/0207-Cauldron-fill-chances.patch b/patches/server/0209-Cauldron-fill-chances.patch similarity index 100% rename from patches/server/0207-Cauldron-fill-chances.patch rename to patches/server/0209-Cauldron-fill-chances.patch diff --git a/patches/server/0208-Config-to-allow-mobs-to-pathfind-over-rails.patch b/patches/server/0210-Config-to-allow-mobs-to-pathfind-over-rails.patch similarity index 97% rename from patches/server/0208-Config-to-allow-mobs-to-pathfind-over-rails.patch rename to patches/server/0210-Config-to-allow-mobs-to-pathfind-over-rails.patch index 7418fb3e1..61bcb36d4 100644 --- a/patches/server/0208-Config-to-allow-mobs-to-pathfind-over-rails.patch +++ b/patches/server/0210-Config-to-allow-mobs-to-pathfind-over-rails.patch @@ -18,7 +18,7 @@ index 3583fcf5284bc5883308876dbd9886664b391e28..d976a6df54c1e817def2d588692abe25 if (node != null && (node.type == BlockPathTypes.OPEN || node.type == BlockPathTypes.WALKABLE) && this.mob.getBbWidth() < 1.0F) { double g = (double)(x - direction.getStepX()) + 0.5D; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e9be1c59292882b5a5239e305fb1a3ad008d9b81..ce0e0e10eb677facd729d45c1c4f39a1fe92b72f 100644 +index 194e6417d980a29c3c910f1a47f26387f0825e02..80f1be7379bd03eb604daf7c8a30f06c3da1c661 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -140,6 +140,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0209-Shulker-change-color-with-dye.patch b/patches/server/0211-Shulker-change-color-with-dye.patch similarity index 100% rename from patches/server/0209-Shulker-change-color-with-dye.patch rename to patches/server/0211-Shulker-change-color-with-dye.patch diff --git a/patches/server/0210-Extended-OfflinePlayer-API.patch b/patches/server/0212-Extended-OfflinePlayer-API.patch similarity index 100% rename from patches/server/0210-Extended-OfflinePlayer-API.patch rename to patches/server/0212-Extended-OfflinePlayer-API.patch diff --git a/patches/server/0211-Added-the-ability-to-add-combustible-items.patch b/patches/server/0213-Added-the-ability-to-add-combustible-items.patch similarity index 96% rename from patches/server/0211-Added-the-ability-to-add-combustible-items.patch rename to patches/server/0213-Added-the-ability-to-add-combustible-items.patch index 2650cac6d..cb15e7b41 100644 --- a/patches/server/0211-Added-the-ability-to-add-combustible-items.patch +++ b/patches/server/0213-Added-the-ability-to-add-combustible-items.patch @@ -51,10 +51,10 @@ index ca2052804ad829a1528a9c5a0a792275beead113..997d0fab71eacc6466ffe3bc8f6349e5 private int maxStack = MAX_STACK; public List transaction = new java.util.ArrayList(); diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index af64a42eba7b23e8a0f085d874a66dcbb060cb75..ac85de5112975097e20d319059deee42a3961fa2 100644 +index 08df637e9d8f08c14392b2dd61240cd4f1a48f76..6403d721e7ab1f2251d4c083c4580797f71647bd 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -@@ -1448,6 +1448,19 @@ public final class CraftServer implements Server { +@@ -1453,6 +1453,19 @@ public final class CraftServer implements Server { return true; } diff --git a/patches/server/0212-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch b/patches/server/0214-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch similarity index 90% rename from patches/server/0212-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch rename to patches/server/0214-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch index e85b118f5..cf0f976c3 100644 --- a/patches/server/0212-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch +++ b/patches/server/0214-Option-for-if-rain-and-thunder-should-stop-on-sleep.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Option for if rain and thunder should stop on sleep diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 2a857449a95fab2738d16f7c9e1488d58c645e9b..a3841f5aa7dfc2176f64d8be6c453d2a4c8cf817 100644 +index df8efd93ad6ab30974e3025187cd234b37111129..8cbb36b2dbcb9a1470c95746d7d481a142419164 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java -@@ -1328,6 +1328,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1344,6 +1344,7 @@ public class ServerLevel extends Level implements WorldGenLevel { private void resetWeatherCycle() { // CraftBukkit start @@ -16,7 +16,7 @@ index 2a857449a95fab2738d16f7c9e1488d58c645e9b..a3841f5aa7dfc2176f64d8be6c453d2a this.serverLevelData.setRaining(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - when passing the night // If we stop due to everyone sleeping we should reset the weather duration to some other random value. // Not that everyone ever manages to get the whole server to sleep at the same time.... -@@ -1335,6 +1336,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1351,6 +1352,7 @@ public class ServerLevel extends Level implements WorldGenLevel { this.serverLevelData.setRainTime(0); } // CraftBukkit end @@ -25,7 +25,7 @@ index 2a857449a95fab2738d16f7c9e1488d58c645e9b..a3841f5aa7dfc2176f64d8be6c453d2a // CraftBukkit start // If we stop due to everyone sleeping we should reset the weather duration to some other random value. diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 31892e1ddcdb59580a1588219bc85757f3a926ea..2cfef0036198d3c0716a97c8def74f6a82e98abb 100644 +index 900ef275e68bcdea7eb8c1ca096a953f9e8658d4..03cfb9a60fd812dd741684567c1bed72942aa53f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -141,6 +141,8 @@ public class PurpurWorldConfig { diff --git a/patches/server/0213-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch b/patches/server/0215-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch similarity index 98% rename from patches/server/0213-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch rename to patches/server/0215-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch index a693191e7..88aa66445 100644 --- a/patches/server/0213-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch +++ b/patches/server/0215-Chance-for-azalea-blocks-to-grow-into-trees-naturall.patch @@ -45,7 +45,7 @@ index 0453397c157c8c7968947445f41bc46b68b111e8..ed35878fdb9dffcd46c27d26ee837940 public static final Block PINK_PETALS = register("pink_petals", new PinkPetalsBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.PINK_PETALS).pushReaction(PushReaction.DESTROY))); public static final Block MOSS_BLOCK = register("moss_block", new MossBlock(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_GREEN).strength(0.1F).sound(SoundType.MOSS).pushReaction(PushReaction.DESTROY))); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2cfef0036198d3c0716a97c8def74f6a82e98abb..b1a41951a7822fc78cece7bb0863e5d69e0c9473 100644 +index 03cfb9a60fd812dd741684567c1bed72942aa53f..dd0e9af64399c07b19d2f2afa4e67d082eadd365 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -717,6 +717,11 @@ public class PurpurWorldConfig { diff --git a/patches/server/0214-Shift-right-click-to-use-exp-for-mending.patch b/patches/server/0216-Shift-right-click-to-use-exp-for-mending.patch similarity index 96% rename from patches/server/0214-Shift-right-click-to-use-exp-for-mending.patch rename to patches/server/0216-Shift-right-click-to-use-exp-for-mending.patch index f6298201f..a3ed586a2 100644 --- a/patches/server/0214-Shift-right-click-to-use-exp-for-mending.patch +++ b/patches/server/0216-Shift-right-click-to-use-exp-for-mending.patch @@ -36,10 +36,10 @@ index 7ddc9a7ff7b1d6de234ea5b1c8f4246d6ba7976d..02f615e797ac22b8a6226233d815346c + // Purpur end } diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 7f3b2ea667325fe66ba13c9babad4a3162ff425b..c0c515fb95813c5fb9482ac44cd2980d73a363a3 100644 +index 872f1ccc1b1253127ee37a8637de8ed3a95d43f1..14462c45d07e07ee8329ab2f9448b776e3e0a73a 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2088,6 +2088,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2089,6 +2089,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic boolean cancelled; if (movingobjectposition == null || movingobjectposition.getType() != HitResult.Type.BLOCK) { diff --git a/patches/server/0215-Dolphins-naturally-aggressive-to-players-chance.patch b/patches/server/0217-Dolphins-naturally-aggressive-to-players-chance.patch similarity index 100% rename from patches/server/0215-Dolphins-naturally-aggressive-to-players-chance.patch rename to patches/server/0217-Dolphins-naturally-aggressive-to-players-chance.patch diff --git a/patches/server/0216-Cows-naturally-aggressive-to-players-chance.patch b/patches/server/0218-Cows-naturally-aggressive-to-players-chance.patch similarity index 100% rename from patches/server/0216-Cows-naturally-aggressive-to-players-chance.patch rename to patches/server/0218-Cows-naturally-aggressive-to-players-chance.patch diff --git a/patches/server/0217-Option-for-beds-to-explode-on-villager-sleep.patch b/patches/server/0219-Option-for-beds-to-explode-on-villager-sleep.patch similarity index 90% rename from patches/server/0217-Option-for-beds-to-explode-on-villager-sleep.patch rename to patches/server/0219-Option-for-beds-to-explode-on-villager-sleep.patch index 201d93e93..ff9b8cbba 100644 --- a/patches/server/0217-Option-for-beds-to-explode-on-villager-sleep.patch +++ b/patches/server/0219-Option-for-beds-to-explode-on-villager-sleep.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Option for beds to explode on villager sleep diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index d78240487b934921509a26b7fca0bce0aaaa40b8..e862035b5e2cc8005a4e98779ee40e3ac80224e4 100644 +index 444dbab9a1c95d1f8bc97e165e5302473a29c7e8..2ffceda6ce3cfe515f9348dafc28b04689d5a460 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -1104,6 +1104,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -1110,6 +1110,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler @Override public void startSleeping(BlockPos pos) { @@ -22,7 +22,7 @@ index d78240487b934921509a26b7fca0bce0aaaa40b8..e862035b5e2cc8005a4e98779ee40e3a this.brain.setMemory(MemoryModuleType.LAST_SLEPT, this.level().getGameTime()); // CraftBukkit - decompile error this.brain.eraseMemory(MemoryModuleType.WALK_TARGET); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 95e15e3a3e2915fa7b62079a9da137f08ba42231..a22f1730b956c8effd9594758ce66aa63230b822 100644 +index 0118bdeb8857e1562e2392cb7eac26232d07980c..7b4303dedc0950b6fc3132d890ab5480dc76d370 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -736,6 +736,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0218-Halloween-options-and-optimizations.patch b/patches/server/0220-Halloween-options-and-optimizations.patch similarity index 92% rename from patches/server/0218-Halloween-options-and-optimizations.patch rename to patches/server/0220-Halloween-options-and-optimizations.patch index 0c3a0fe2a..89acaa4ed 100644 --- a/patches/server/0218-Halloween-options-and-optimizations.patch +++ b/patches/server/0220-Halloween-options-and-optimizations.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Halloween options and optimizations diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java -index 98221b38722e5cc009b12c1bc57fd63dc9418706..c61700a0f1055ee8fe290646814c3e71d917e338 100644 +index 7b731e6d5f50904b211c58cc3a3e0cf350f39e91..acd453eefe78eb29c914ee2ce93202dfec9e8d63 100644 --- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java +++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java @@ -314,7 +314,7 @@ public class Bat extends AmbientCreature { @@ -17,14 +17,14 @@ index 98221b38722e5cc009b12c1bc57fd63dc9418706..c61700a0f1055ee8fe290646814c3e71 b0 = 7; } else if (random.nextBoolean()) { return false; -@@ -324,6 +324,7 @@ public class Bat extends AmbientCreature { - } - } - +@@ -328,6 +328,7 @@ public class Bat extends AmbientCreature { + private static boolean isSpookySeason = false; + private static final int ONE_HOUR = 20 * 60 * 60; + private static int lastSpookyCheck = -ONE_HOUR; + public static boolean isHalloweenSeason(Level level) { return level.purpurConfig.forceHalloweenSeason || isHalloween(); } // Purpur private static boolean isHalloween() { + if (net.minecraft.server.MinecraftServer.currentTick - lastSpookyCheck > ONE_HOUR) { LocalDate localdate = LocalDate.now(); - int i = localdate.get(ChronoField.DAY_OF_MONTH); diff --git a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java index 892ae3a9ac2395896ff7881c49eaece8d46e831e..41376b705748e14c1c4174e07732ce09ad8e581f 100644 --- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java diff --git a/patches/server/0219-Config-for-grindstones.patch b/patches/server/0221-Config-for-grindstones.patch similarity index 100% rename from patches/server/0219-Config-for-grindstones.patch rename to patches/server/0221-Config-for-grindstones.patch diff --git a/patches/server/0220-UPnP-Port-Forwarding.patch b/patches/server/0222-UPnP-Port-Forwarding.patch similarity index 92% rename from patches/server/0220-UPnP-Port-Forwarding.patch rename to patches/server/0222-UPnP-Port-Forwarding.patch index a86aaaf31..fb79b2ee2 100644 --- a/patches/server/0220-UPnP-Port-Forwarding.patch +++ b/patches/server/0222-UPnP-Port-Forwarding.patch @@ -5,7 +5,7 @@ Subject: [PATCH] UPnP Port Forwarding diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index f29fa70f7497282efe14248de50eca44dd71118d..7fc8f42c315d1bc81585b0147d59d662e7941d8c 100644 +index ee822fadef35f45effa08c552b35a274599f11ce..922373558de4ee1492335711c07494a59227b626 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -309,6 +309,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop getModelRotationValues() { return this.modelRotationValues; diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index fad539b4804204b9d5730962e6a7de114dda3f1a..0ebb9ac9d951741eb9dea8475380cfcc68becae3 100644 +index 6a917ef18f1f3797903e6f8b4516c0df8757c573..df08f220b7c25fd9e7daa6a23816cb8d6ff4c003 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -116,6 +116,11 @@ public class Goat extends Animal { @@ -645,7 +645,7 @@ index b494d5689beb19d621f5d7c9c22d84e12d303fa0..b30f13d2a7198f568bc36c0d974fd6dc return Guardian.createAttributes().add(Attributes.MOVEMENT_SPEED, 0.30000001192092896D).add(Attributes.ATTACK_DAMAGE, 8.0D).add(Attributes.MAX_HEALTH, 80.0D); } diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java -index 8db82eaa2355b15aa78fc9500368acf2c7f75ffc..1cb816cee305969d4215ef2baa1a255b1c88d6e5 100644 +index bf9b9f3de67ff918e0a2288b3582af5e77e54b04..a315a5ff2674610675a819a9cf6d7c22ea0d6adc 100644 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java @@ -114,6 +114,11 @@ public class EnderMan extends Monster implements NeutralMob { @@ -1077,7 +1077,7 @@ index 21ba6ea58dfbfd9a7c0bf7d518d7f12730841a08..7bb99d7fd8e05805e0cac7bec0b27719 public void setPersistentAngerTarget(@Nullable UUID angryAt) { this.persistentAngerTarget = angryAt; diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -index 3b99761fabc02255a66ec84f5c6cf199848455dc..5bc0bf6486b146ecefe747f029f79ab504dc6423 100644 +index 1fd65b47b1bd56bc09902324b1dd22dad2e0bc2d..0ddcff8d4cd22cc01462c412c3db39238237ca49 100644 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java @@ -99,6 +99,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { @@ -1093,7 +1093,7 @@ index 3b99761fabc02255a66ec84f5c6cf199848455dc..5bc0bf6486b146ecefe747f029f79ab5 public boolean canBeLeashed(Player player) { return !this.isLeashed(); diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -index e2d04fc258e093b0b2b5d11ae061a81f286d55ce..18879b75aeedf8df321c2cf93ee8b94e0d321333 100644 +index 83e9873138fb178511119effbe21449c303a5063..9fb7f6d0532a7419674cc20e4fc6cb4b08c73514 100644 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java @@ -123,6 +123,11 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento @@ -1125,10 +1125,10 @@ index b63d87df0f48dd63c89118f91b31dc4e3622e3b8..61e8f2d030fc50840c3f80dfb6fc8107 return Monster.createMonsterAttributes().add(Attributes.MAX_HEALTH, 50.0D).add(Attributes.MOVEMENT_SPEED, (double)0.35F).add(Attributes.ATTACK_DAMAGE, 7.0D); } diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index e862035b5e2cc8005a4e98779ee40e3ac80224e4..1369fb8aec7d28359669aecd2d6c0c90e31b3f63 100644 +index 2ffceda6ce3cfe515f9348dafc28b04689d5a460..903016cc402bc688f4fd92f339b242db6dfe3841 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -192,6 +192,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -194,6 +194,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler return this.level().purpurConfig.villagerTakeDamageFromWater; } diff --git a/patches/server/0228-Potion-NamespacedKey.patch b/patches/server/0230-Potion-NamespacedKey.patch similarity index 100% rename from patches/server/0228-Potion-NamespacedKey.patch rename to patches/server/0230-Potion-NamespacedKey.patch diff --git a/patches/server/0229-Grindstone-API.patch b/patches/server/0231-Grindstone-API.patch similarity index 100% rename from patches/server/0229-Grindstone-API.patch rename to patches/server/0231-Grindstone-API.patch diff --git a/patches/server/0230-Ability-for-hoe-to-replant-crops-and-nether-warts.patch b/patches/server/0232-Ability-for-hoe-to-replant-crops-and-nether-warts.patch similarity index 98% rename from patches/server/0230-Ability-for-hoe-to-replant-crops-and-nether-warts.patch rename to patches/server/0232-Ability-for-hoe-to-replant-crops-and-nether-warts.patch index 7aa56ee64..eca29dc7f 100644 --- a/patches/server/0230-Ability-for-hoe-to-replant-crops-and-nether-warts.patch +++ b/patches/server/0232-Ability-for-hoe-to-replant-crops-and-nether-warts.patch @@ -74,7 +74,7 @@ index e55720c4d2fbdf6aae526910e87a67c29cf906fd..0e4026e9d39735b840f12e59f84469b9 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ae989cb0a749b70163a2de680c897c0a98a74087..ed178813ce4a467be74cc3d146c0782445ca551a 100644 +index c15de0704b93f32dee41917c3e7ed48ec41aaffb..c9e7dc60f96cf9e69e5fd132234f4f099bda157b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -563,6 +563,8 @@ public class PurpurWorldConfig { diff --git a/patches/server/0231-Shearing-jeb-produces-random-color-wool.patch b/patches/server/0233-Shearing-jeb-produces-random-color-wool.patch similarity index 100% rename from patches/server/0231-Shearing-jeb-produces-random-color-wool.patch rename to patches/server/0233-Shearing-jeb-produces-random-color-wool.patch diff --git a/patches/server/0232-Turtle-eggs-random-tick-crack-chance.patch b/patches/server/0234-Turtle-eggs-random-tick-crack-chance.patch similarity index 95% rename from patches/server/0232-Turtle-eggs-random-tick-crack-chance.patch rename to patches/server/0234-Turtle-eggs-random-tick-crack-chance.patch index 422e9e6ad..588216d06 100644 --- a/patches/server/0232-Turtle-eggs-random-tick-crack-chance.patch +++ b/patches/server/0234-Turtle-eggs-random-tick-crack-chance.patch @@ -18,7 +18,7 @@ index 7495e0e8beedad59fff24ebf189b58b307f7d796..70997b83fd7631ebf3c5bda67ef77bef @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 569dba7fae83989f209f83c1f9da9bf64918139f..2f139bc7a088e721e2da2823f163faa07ba5153b 100644 +index d724d7366ff54ce770b9510a511c37e6db6e13ad..f465c6ab76a5a0b7afca7801d98cdda7ebcd3dca 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -991,11 +991,13 @@ public class PurpurWorldConfig { diff --git a/patches/server/0233-Mob-head-visibility-percent.patch b/patches/server/0235-Mob-head-visibility-percent.patch similarity index 97% rename from patches/server/0233-Mob-head-visibility-percent.patch rename to patches/server/0235-Mob-head-visibility-percent.patch index 1cb5f03f4..26b61f65b 100644 --- a/patches/server/0233-Mob-head-visibility-percent.patch +++ b/patches/server/0235-Mob-head-visibility-percent.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Mob head visibility percent diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 48fa05e80483e470572ecc8b2f7feb58e2f36dd0..fd276495ddcf160660a725c721d3c3f1d6bdd72b 100644 +index 777853b5afc7b170fe6caffa21f55468b4321a1d..e2e470892ced1e350a841707f0c3266550e015f2 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -1042,9 +1042,20 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -1041,9 +1041,20 @@ public abstract class LivingEntity extends Entity implements Attackable { ItemStack itemstack = this.getItemBySlot(EquipmentSlot.HEAD); EntityType entitytypes = entity.getType(); diff --git a/patches/server/0234-Configurable-valid-characters-for-usernames.patch b/patches/server/0236-Configurable-valid-characters-for-usernames.patch similarity index 100% rename from patches/server/0234-Configurable-valid-characters-for-usernames.patch rename to patches/server/0236-Configurable-valid-characters-for-usernames.patch diff --git a/patches/server/0235-Shears-can-have-looting-enchantment.patch b/patches/server/0237-Shears-can-have-looting-enchantment.patch similarity index 100% rename from patches/server/0235-Shears-can-have-looting-enchantment.patch rename to patches/server/0237-Shears-can-have-looting-enchantment.patch diff --git a/patches/server/0236-Stop-bees-from-dying-after-stinging.patch b/patches/server/0238-Stop-bees-from-dying-after-stinging.patch similarity index 95% rename from patches/server/0236-Stop-bees-from-dying-after-stinging.patch rename to patches/server/0238-Stop-bees-from-dying-after-stinging.patch index e40f0a0a5..4c7cbf013 100644 --- a/patches/server/0236-Stop-bees-from-dying-after-stinging.patch +++ b/patches/server/0238-Stop-bees-from-dying-after-stinging.patch @@ -17,7 +17,7 @@ index fad2da0ba194d349de73777a7ab43bb6447298e7..2afe5a4f3abaa3f9883b13fa3895e1e1 ++this.timeSinceSting; if (this.timeSinceSting % 5 == 0 && this.random.nextInt(Mth.clamp(1200 - this.timeSinceSting, 1, 1200)) == 0) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e4b6a301db66dd27a8d1cb275cb792043bc59e46..cfa93e40311b3abdbd0dd6b88158e333289692d9 100644 +index d65dbd63062d637554a16bd648bf49adbf62e748..09588ad21b2464f7f36702a7bfdaa5e2c7086502 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -1086,6 +1086,7 @@ public class PurpurWorldConfig { diff --git a/patches/server/0237-Give-bee-counts-in-beehives-to-Purpur-clients.patch b/patches/server/0239-Give-bee-counts-in-beehives-to-Purpur-clients.patch similarity index 91% rename from patches/server/0237-Give-bee-counts-in-beehives-to-Purpur-clients.patch rename to patches/server/0239-Give-bee-counts-in-beehives-to-Purpur-clients.patch index a99da1fa8..154484fc1 100644 --- a/patches/server/0237-Give-bee-counts-in-beehives-to-Purpur-clients.patch +++ b/patches/server/0239-Give-bee-counts-in-beehives-to-Purpur-clients.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Give bee counts in beehives to Purpur clients diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 7fc8f42c315d1bc81585b0147d59d662e7941d8c..462760b366697979e09ac65ee7787c2ab8338342 100644 +index 922373558de4ee1492335711c07494a59227b626..0255f5f21da2a108a25c8a166717706d300b0cae 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1032,6 +1032,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop entityType, Level world) { - this(entityType, world, VillagerType.PLAINS); -@@ -197,6 +199,47 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + public long nextGolemPanic = -1; // Pufferfish + +@@ -199,6 +201,47 @@ public class Villager extends AbstractVillager implements ReputationEventHandler return this.level().purpurConfig.villagerAlwaysDropExp; } @@ -65,7 +65,7 @@ index 573d99bea295253804c9486a52ff724422fba432..43afded0ddd88094971ace2dd02d2aca @Override public Brain getBrain() { return (Brain) super.getBrain(); // CraftBukkit - decompile error -@@ -293,11 +336,21 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -296,14 +339,21 @@ public class Villager extends AbstractVillager implements ReputationEventHandler // Paper start this.customServerAiStep(false); } @@ -73,6 +73,9 @@ index 573d99bea295253804c9486a52ff724422fba432..43afded0ddd88094971ace2dd02d2aca + protected void customServerAiStep(boolean inactive) { // Purpur - not final // Paper end this.level().getProfiler().push("villagerBrain"); +- // Pufferfish start +- if (!inactive && (getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) { // Purpur - only use brain if no rider +- this.getBrain().tick((ServerLevel) this.level(), this); // Paper + // Purpur start + if (this.level().purpurConfig.villagerLobotomizeEnabled) { + // treat as inactive if lobotomized @@ -80,9 +83,10 @@ index 573d99bea295253804c9486a52ff724422fba432..43afded0ddd88094971ace2dd02d2aca + } else { + // clean up state for API + this.isLobotomized = false; -+ } - if (!inactive) this.getBrain().tick((ServerLevel) this.level(), this); // Paper - // if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch + } +- // Pufferfish end ++ if (!inactive && (getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Purpur - only use brain if no rider ++ this.getBrain().tick((ServerLevel) this.level(), this); // Paper + else if (this.isLobotomized && shouldRestock()) restock(); + // Purpur end this.level().getProfiler().pop(); diff --git a/patches/server/0247-Option-for-villager-display-trade-item.patch b/patches/server/0249-Option-for-villager-display-trade-item.patch similarity index 100% rename from patches/server/0247-Option-for-villager-display-trade-item.patch rename to patches/server/0249-Option-for-villager-display-trade-item.patch diff --git a/patches/server/0248-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch b/patches/server/0250-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch similarity index 95% rename from patches/server/0248-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch rename to patches/server/0250-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch index b425ed67a..b86bcdd2e 100644 --- a/patches/server/0248-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch +++ b/patches/server/0250-MC-238526-Fix-spawner-not-spawning-water-animals-cor.patch @@ -17,7 +17,7 @@ index cd2ce5bcb8c30e4657cd0e340d80544c7e805905..c8c6fed3f93903bb5c6145930538d415 } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 069d28e17d85f1ac35999b02f79e4cef4d34a502..b1f3bc498678603e7a2e78708cb84cb351e373e4 100644 +index f7a8af3efed3254459f8a42f997368fccaf5f741..a14382cbf663839f1eaa162be231c95bab4041f8 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -980,8 +980,10 @@ public class PurpurWorldConfig { diff --git a/patches/server/0249-Config-for-mob-last-hurt-by-player-time.patch b/patches/server/0251-Config-for-mob-last-hurt-by-player-time.patch similarity index 96% rename from patches/server/0249-Config-for-mob-last-hurt-by-player-time.patch rename to patches/server/0251-Config-for-mob-last-hurt-by-player-time.patch index cd4ea357f..4e119afe3 100644 --- a/patches/server/0249-Config-for-mob-last-hurt-by-player-time.patch +++ b/patches/server/0251-Config-for-mob-last-hurt-by-player-time.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Config for mob last hurt by player time diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 93036336e221912507820acec5d4744aba9a6b68..ecaf3cc5abda30d2b13c92ebb9f31442894064d3 100644 +index e2e470892ced1e350a841707f0c3266550e015f2..5ad5bc75af60a16b02c9604dd027403b5b6a67e6 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -1504,13 +1504,13 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -1512,13 +1512,13 @@ public abstract class LivingEntity extends Entity implements Attackable { if (entity1 instanceof net.minecraft.world.entity.player.Player) { net.minecraft.world.entity.player.Player entityhuman = (net.minecraft.world.entity.player.Player) entity1; diff --git a/patches/server/0250-Anvil-repair-damage-options.patch b/patches/server/0252-Anvil-repair-damage-options.patch similarity index 98% rename from patches/server/0250-Anvil-repair-damage-options.patch rename to patches/server/0252-Anvil-repair-damage-options.patch index ad057ff25..945b06ed7 100644 --- a/patches/server/0250-Anvil-repair-damage-options.patch +++ b/patches/server/0252-Anvil-repair-damage-options.patch @@ -64,7 +64,7 @@ index 5c5a3b169795bf8a527b316c666cbc2105c66622..020afeca950d2c7fb6c7b179d424548f return InteractionResult.SUCCESS; } else { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 301b8c0217eb8f7bddfcc7e25832b2994628ac75..39f0c7be1d0023178b34bc7699aa5c4445b02c13 100644 +index b89da9fabbda3a5b02262b08aba180818f6b7ec7..e7da44aae8a1f4c5c58e3b5b0086294adff7152d 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -732,9 +732,13 @@ public class PurpurWorldConfig { diff --git a/patches/server/0251-Option-to-disable-turtle-egg-trampling-with-feather-.patch b/patches/server/0253-Option-to-disable-turtle-egg-trampling-with-feather-.patch similarity index 100% rename from patches/server/0251-Option-to-disable-turtle-egg-trampling-with-feather-.patch rename to patches/server/0253-Option-to-disable-turtle-egg-trampling-with-feather-.patch diff --git a/patches/server/0252-Add-toggle-for-enchant-level-clamping.patch b/patches/server/0254-Add-toggle-for-enchant-level-clamping.patch similarity index 100% rename from patches/server/0252-Add-toggle-for-enchant-level-clamping.patch rename to patches/server/0254-Add-toggle-for-enchant-level-clamping.patch diff --git a/patches/server/0253-Skip-junit-tests-for-purpur-commands.patch b/patches/server/0255-Skip-junit-tests-for-purpur-commands.patch similarity index 100% rename from patches/server/0253-Skip-junit-tests-for-purpur-commands.patch rename to patches/server/0255-Skip-junit-tests-for-purpur-commands.patch diff --git a/patches/server/0254-Implement-configurable-search-radius-for-villagers-t.patch b/patches/server/0256-Implement-configurable-search-radius-for-villagers-t.patch similarity index 94% rename from patches/server/0254-Implement-configurable-search-radius-for-villagers-t.patch rename to patches/server/0256-Implement-configurable-search-radius-for-villagers-t.patch index 8e0a23198..1263153e0 100644 --- a/patches/server/0254-Implement-configurable-search-radius-for-villagers-t.patch +++ b/patches/server/0256-Implement-configurable-search-radius-for-villagers-t.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Implement configurable search radius for villagers to spawn diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 43afded0ddd88094971ace2dd02d2aca6c3e86ae..25bf930258065b6cc6d6c3a790835ddf1a0aba36 100644 +index 3eb7ac97ea11d0c47ecbc047e2e64c17baaa70f4..85c8854691070d8867a5eaf410fe7a2f75fadb9f 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -1089,6 +1089,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -1092,6 +1092,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler } public void spawnGolemIfNeeded(ServerLevel world, long time, int requiredCount) { diff --git a/patches/server/0255-Stonecutter-damage.patch b/patches/server/0257-Stonecutter-damage.patch similarity index 100% rename from patches/server/0255-Stonecutter-damage.patch rename to patches/server/0257-Stonecutter-damage.patch diff --git a/patches/server/0256-Configurable-damage-settings-for-magma-blocks.patch b/patches/server/0258-Configurable-damage-settings-for-magma-blocks.patch similarity index 100% rename from patches/server/0256-Configurable-damage-settings-for-magma-blocks.patch rename to patches/server/0258-Configurable-damage-settings-for-magma-blocks.patch diff --git a/patches/server/0257-Add-config-for-snow-on-blue-ice.patch b/patches/server/0259-Add-config-for-snow-on-blue-ice.patch similarity index 100% rename from patches/server/0257-Add-config-for-snow-on-blue-ice.patch rename to patches/server/0259-Add-config-for-snow-on-blue-ice.patch diff --git a/patches/server/0258-Skeletons-eat-wither-roses.patch b/patches/server/0260-Skeletons-eat-wither-roses.patch similarity index 100% rename from patches/server/0258-Skeletons-eat-wither-roses.patch rename to patches/server/0260-Skeletons-eat-wither-roses.patch diff --git a/patches/server/0259-Enchantment-Table-Persists-Lapis.patch b/patches/server/0261-Enchantment-Table-Persists-Lapis.patch similarity index 100% rename from patches/server/0259-Enchantment-Table-Persists-Lapis.patch rename to patches/server/0261-Enchantment-Table-Persists-Lapis.patch diff --git a/patches/server/0260-Spark-Profiler.patch b/patches/server/0262-Spark-Profiler.patch similarity index 100% rename from patches/server/0260-Spark-Profiler.patch rename to patches/server/0262-Spark-Profiler.patch diff --git a/patches/server/0261-Option-to-disable-kick-for-out-of-order-chat.patch b/patches/server/0263-Option-to-disable-kick-for-out-of-order-chat.patch similarity index 92% rename from patches/server/0261-Option-to-disable-kick-for-out-of-order-chat.patch rename to patches/server/0263-Option-to-disable-kick-for-out-of-order-chat.patch index e96e70ee5..fb65a4e88 100644 --- a/patches/server/0261-Option-to-disable-kick-for-out-of-order-chat.patch +++ b/patches/server/0263-Option-to-disable-kick-for-out-of-order-chat.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Option to disable kick for out of order chat diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index c0c515fb95813c5fb9482ac44cd2980d73a363a3..5ab726833006672a5256c90f4d8d056511be5b5f 100644 +index 14462c45d07e07ee8329ab2f9448b776e3e0a73a..8303cdf0590dc50452b1fd747ec78e46026152f9 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2452,7 +2452,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2454,7 +2454,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic do { instant1 = (Instant) this.lastChatTimeStamp.get(); if (timestamp.isBefore(instant1)) { diff --git a/patches/server/0262-Config-for-sculk-shrieker-can_summon-state.patch b/patches/server/0264-Config-for-sculk-shrieker-can_summon-state.patch similarity index 100% rename from patches/server/0262-Config-for-sculk-shrieker-can_summon-state.patch rename to patches/server/0264-Config-for-sculk-shrieker-can_summon-state.patch diff --git a/patches/server/0263-Config-to-not-let-coral-die.patch b/patches/server/0265-Config-to-not-let-coral-die.patch similarity index 100% rename from patches/server/0263-Config-to-not-let-coral-die.patch rename to patches/server/0265-Config-to-not-let-coral-die.patch diff --git a/patches/server/0264-Add-local-difficulty-api.patch b/patches/server/0266-Add-local-difficulty-api.patch similarity index 100% rename from patches/server/0264-Add-local-difficulty-api.patch rename to patches/server/0266-Add-local-difficulty-api.patch diff --git a/patches/server/0265-Add-toggle-for-RNG-manipulation.patch b/patches/server/0267-Add-toggle-for-RNG-manipulation.patch similarity index 94% rename from patches/server/0265-Add-toggle-for-RNG-manipulation.patch rename to patches/server/0267-Add-toggle-for-RNG-manipulation.patch index a0faf4871..77c3bb323 100644 --- a/patches/server/0265-Add-toggle-for-RNG-manipulation.patch +++ b/patches/server/0267-Add-toggle-for-RNG-manipulation.patch @@ -7,10 +7,10 @@ Paper patches RNG maniplulation by using a shared (and locked) random source. This comes with a performance gain, but technical players may prefer the ability to manipulate RNG. diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 44161f9333e043cbe7309a65ce9256687da5ae64..3fc1388cfadb401e16a7793428ac40c30a44a16e 100644 +index 642146bfce20d46d95289728ec6e0059a27079b2..db30761805fe90279297ea939fba45530d7a5db0 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -575,7 +575,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -603,7 +603,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.bb = Entity.INITIAL_AABB; this.stuckSpeedMultiplier = Vec3.ZERO; this.nextStep = 1.0F; diff --git a/patches/server/0266-Send-client-custom-name-of-BE.patch b/patches/server/0268-Send-client-custom-name-of-BE.patch similarity index 100% rename from patches/server/0266-Send-client-custom-name-of-BE.patch rename to patches/server/0268-Send-client-custom-name-of-BE.patch diff --git a/patches/server/0267-PaperPR-7822-Fix-exact-choice-recipe-book-clicks.patch b/patches/server/0269-PaperPR-7822-Fix-exact-choice-recipe-book-clicks.patch similarity index 100% rename from patches/server/0267-PaperPR-7822-Fix-exact-choice-recipe-book-clicks.patch rename to patches/server/0269-PaperPR-7822-Fix-exact-choice-recipe-book-clicks.patch diff --git a/patches/server/0268-Allow-custom-ChatDecorators.patch b/patches/server/0270-Allow-custom-ChatDecorators.patch similarity index 90% rename from patches/server/0268-Allow-custom-ChatDecorators.patch rename to patches/server/0270-Allow-custom-ChatDecorators.patch index 14fb5d529..4c87febfc 100644 --- a/patches/server/0268-Allow-custom-ChatDecorators.patch +++ b/patches/server/0270-Allow-custom-ChatDecorators.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Allow custom ChatDecorators Requires NMS to utilize. I'll write an API for this once our upstreams calm down with the changes. diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 462760b366697979e09ac65ee7787c2ab8338342..a556e23c774c107ab95400a73c9f6a7df6e1bb00 100644 +index 0255f5f21da2a108a25c8a166717706d300b0cae..e5399649e6a34145dfe2154acdd9887ba4f9f1cb 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -2655,6 +2655,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { return ichunkaccess1; -@@ -448,17 +448,17 @@ public class ServerChunkCache extends ChunkSource { +@@ -451,17 +451,17 @@ public class ServerChunkCache extends ChunkSource { public void save(boolean flush) { this.runDistanceManagerUpdates(); @@ -365,7 +365,7 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f } // Paper end -@@ -488,22 +488,22 @@ public class ServerChunkCache extends ChunkSource { +@@ -491,22 +491,22 @@ public class ServerChunkCache extends ChunkSource { @Override public void tick(BooleanSupplier shouldKeepTicking, boolean tickChunks) { this.level.getProfiler().push("purge"); @@ -394,7 +394,7 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f this.level.getProfiler().pop(); this.clearCache(); } -@@ -557,7 +557,7 @@ public class ServerChunkCache extends ChunkSource { +@@ -561,7 +561,7 @@ public class ServerChunkCache extends ChunkSource { boolean flag1 = level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && worlddata.getGameTime() % level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit gameprofilerfiller.push("naturalSpawnCount"); @@ -403,14 +403,14 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f int l = this.distanceManager.getNaturalSpawnChunkCount(); // Paper start - per player mob spawning NaturalSpawner.SpawnState spawnercreature_d; // moved down -@@ -571,12 +571,12 @@ public class ServerChunkCache extends ChunkSource { - spawnercreature_d = NaturalSpawner.createState(l, this.level.getAllEntities(), this::getFullChunk, this.chunkMap.playerMobDistanceMap == null ? new LocalMobCapCalculator(this.chunkMap) : null, false); +@@ -582,12 +582,12 @@ public class ServerChunkCache extends ChunkSource { + // Pufferfish end } // Paper end - this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings + //this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings // Purpur - this.lastSpawnState = spawnercreature_d; + //this.lastSpawnState = spawnercreature_d; // Pufferfish - this is managed asynchronously gameprofilerfiller.popPush("filteringLoadedChunks"); // Paper - moved down - this.level.timings.chunkTicks.startTiming(); // Paper @@ -418,7 +418,7 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f // Paper - moved down -@@ -631,17 +631,17 @@ public class ServerChunkCache extends ChunkSource { +@@ -642,17 +642,17 @@ public class ServerChunkCache extends ChunkSource { } } // Paper end - optimise chunk tick iteration @@ -440,7 +440,7 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f if (!this.chunkMap.needsChangeBroadcasting.isEmpty()) { ReferenceOpenHashSet copy = this.chunkMap.needsChangeBroadcasting.clone(); this.chunkMap.needsChangeBroadcasting.clear(); -@@ -653,7 +653,7 @@ public class ServerChunkCache extends ChunkSource { +@@ -664,7 +664,7 @@ public class ServerChunkCache extends ChunkSource { } } } @@ -450,7 +450,7 @@ index 488a253e218409b5f0b4a872cee0928578fa7582..c4601ee883ecff651585aaaf33fe3a9f // Paper end - use set of chunks requiring updates, rather than iterating every single one loaded // Paper start - controlled flush for entity tracker packets diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d53005722859 100644 +index 122defeec159165c5fef295ec1dd2da4a6ada622..5b7507db055d7be59b369f66e659e128c9c7e00b 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -828,7 +828,7 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -506,9 +506,9 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 - timings.entityTick.startTiming(); // Spigot + //timings.entityTick.startTiming(); // Spigot // Purpur this.entityTickList.forEach((entity) -> { + entity.activatedPriorityReset = false; // Pufferfish - DAB if (!entity.isRemoved()) { - if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed -@@ -896,8 +896,8 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -910,8 +910,8 @@ public class ServerLevel extends Level implements WorldGenLevel { } } }); @@ -519,7 +519,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 gameprofilerfiller.pop(); this.tickBlockEntities(); } -@@ -1077,7 +1077,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1093,7 +1093,7 @@ public class ServerLevel extends Level implements WorldGenLevel { // Paper start - optimise random block ticking gameprofilerfiller.popPush("randomTick"); @@ -528,7 +528,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 if (randomTickSpeed > 0) { LevelChunkSection[] sections = chunk.getSections(); int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this); -@@ -1111,7 +1111,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1127,7 +1127,7 @@ public class ServerLevel extends Level implements WorldGenLevel { } } // Paper end - optimise random block ticking @@ -537,7 +537,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 gameprofilerfiller.pop(); } -@@ -1404,8 +1404,8 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1420,8 +1420,8 @@ public class ServerLevel extends Level implements WorldGenLevel { // Spigot end // Paper start- timings final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity); @@ -548,7 +548,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 // Paper end - timings entity.setOldPosAndRot(); ProfilerFiller gameprofilerfiller = this.getProfiler(); -@@ -1421,7 +1421,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1437,7 +1437,7 @@ public class ServerLevel extends Level implements WorldGenLevel { entity.postTick(); // CraftBukkit } else { entity.inactiveTick(); } // Paper - EAR 2 this.getProfiler().pop(); @@ -557,7 +557,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 Iterator iterator = entity.getPassengers().iterator(); while (iterator.hasNext()) { -@@ -1444,8 +1444,8 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1460,8 +1460,8 @@ public class ServerLevel extends Level implements WorldGenLevel { if (passenger instanceof Player || this.entityTickList.contains(passenger)) { // Paper - EAR 2 final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(passenger); @@ -568,7 +568,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 // Paper end passenger.setOldPosAndRot(); ++passenger.tickCount; -@@ -1475,7 +1475,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1491,7 +1491,7 @@ public class ServerLevel extends Level implements WorldGenLevel { this.tickPassenger(passenger, entity2); } @@ -577,7 +577,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 } } else { passenger.stopRiding(); -@@ -1495,14 +1495,14 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1511,14 +1511,14 @@ public class ServerLevel extends Level implements WorldGenLevel { org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); } @@ -595,7 +595,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 // Copied from save() // CraftBukkit start - moved from MinecraftServer.saveChunks -@@ -1514,7 +1514,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1530,7 +1530,7 @@ public class ServerLevel extends Level implements WorldGenLevel { this.convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData()); } // CraftBukkit end @@ -604,7 +604,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 } // Paper end -@@ -1528,7 +1528,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1544,7 +1544,7 @@ public class ServerLevel extends Level implements WorldGenLevel { if (!savingDisabled) { org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit @@ -613,7 +613,7 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 if (progressListener != null) { progressListener.progressStartNoAbort(Component.translatable("menu.savingLevel")); } -@@ -1538,11 +1538,11 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1554,11 +1554,11 @@ public class ServerLevel extends Level implements WorldGenLevel { progressListener.progressStage(Component.translatable("menu.savingChunks")); } @@ -629,10 +629,10 @@ index 19df5bf9323eb10e22e87fcd29d941698d6705fb..55f892e0b9eb098f3cdd922fa5d5d530 } else if (close) { chunkproviderserver.close(false); } // Paper - rewrite chunk system diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 5ab726833006672a5256c90f4d8d056511be5b5f..6eab3a061bb0c649b83440c07e2cee92814d9ae7 100644 +index 8303cdf0590dc50452b1fd747ec78e46026152f9..52b9d600409dd4accb78f6eff2ffbaefcae8d322 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -@@ -2589,7 +2589,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2591,7 +2591,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic } } // Paper End @@ -641,7 +641,7 @@ index 5ab726833006672a5256c90f4d8d056511be5b5f..6eab3a061bb0c649b83440c07e2cee92 if ( org.spigotmc.SpigotConfig.logCommands ) // Spigot this.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + s); -@@ -2599,7 +2599,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2601,7 +2601,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic this.cserver.getPluginManager().callEvent(event); if (event.isCancelled()) { @@ -650,7 +650,7 @@ index 5ab726833006672a5256c90f4d8d056511be5b5f..6eab3a061bb0c649b83440c07e2cee92 return; } -@@ -2612,7 +2612,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -2614,7 +2614,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic java.util.logging.Logger.getLogger(ServerGamePacketListenerImpl.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); return; } finally { @@ -731,10 +731,10 @@ index fcdb9bde8e1605e30dde3e580491522d4b62cdc0..7094701d213c73ba47ace806962244c1 } diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index de6ca4b7e7549905d3ff53b13db28f1bde8f51bf..000697994299163fa3287450652be551a81cf466 100644 +index 290d9fbeb71675d897b78d5c2b98ab477ce9f5fd..6a3b55031188d920d2c7bfc67df791bdd89fba62 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -912,15 +912,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1015,15 +1015,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable { ProfilerFiller gameprofilerfiller = this.getProfiler(); gameprofilerfiller.push("blockEntities"); @@ -753,7 +753,7 @@ index de6ca4b7e7549905d3ff53b13db28f1bde8f51bf..000697994299163fa3287450652be551 // Spigot start // Iterator iterator = this.blockEntityTickers.iterator(); int tilesThisCycle = 0; -@@ -953,7 +953,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1056,7 +1056,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { } this.blockEntityTickers.removeAll(toRemove); @@ -763,7 +763,7 @@ index de6ca4b7e7549905d3ff53b13db28f1bde8f51bf..000697994299163fa3287450652be551 co.aikar.timings.TimingHistory.tileEntityTicks += this.blockEntityTickers.size(); // Paper gameprofilerfiller.pop(); diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java -index 089dd93d4cd4c1f72e63c4944b3b82c1e2ba732d..4e2611c9a7df8343f76e3be3f01f2f828cdf8a1d 100644 +index 5d19ef5231752c6cccc73b9adfb67e53e87baf7a..0001860bb3862ee8cb489774cecbd92a64d75a34 100644 --- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java +++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java @@ -133,7 +133,7 @@ public final class NaturalSpawner { @@ -785,10 +785,10 @@ index 089dd93d4cd4c1f72e63c4944b3b82c1e2ba732d..4e2611c9a7df8343f76e3be3f01f2f82 } diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -index 4ff0d2fc9fd76e92e64abd69f2c9e299aa08ac32..5de3b6cd73a45348d0feba858d96a500bf236ce7 100644 +index dbb0593a6feb60216379bde6720ca16f3ca827ae..4dab159024cf91cd297dcb31833f9d57e2132326 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -@@ -881,7 +881,7 @@ public class LevelChunk extends ChunkAccess { +@@ -895,7 +895,7 @@ public class LevelChunk extends ChunkAccess { this.chunkHolder.getEntityChunk().callEntitiesLoadEvent(); // Paper - rewrite chunk system if (this.needsDecoration) { @@ -797,7 +797,7 @@ index 4ff0d2fc9fd76e92e64abd69f2c9e299aa08ac32..5de3b6cd73a45348d0feba858d96a500 this.needsDecoration = false; java.util.Random random = new java.util.Random(); random.setSeed(this.level.getSeed()); -@@ -901,7 +901,7 @@ public class LevelChunk extends ChunkAccess { +@@ -915,7 +915,7 @@ public class LevelChunk extends ChunkAccess { } } server.getPluginManager().callEvent(new org.bukkit.event.world.ChunkPopulateEvent(bukkitChunk)); @@ -806,7 +806,7 @@ index 4ff0d2fc9fd76e92e64abd69f2c9e299aa08ac32..5de3b6cd73a45348d0feba858d96a500 } } } -@@ -1259,7 +1259,7 @@ public class LevelChunk extends ChunkAccess { +@@ -1273,7 +1273,7 @@ public class LevelChunk extends ChunkAccess { ProfilerFiller gameprofilerfiller = LevelChunk.this.level.getProfiler(); gameprofilerfiller.push(this::getType); @@ -815,7 +815,7 @@ index 4ff0d2fc9fd76e92e64abd69f2c9e299aa08ac32..5de3b6cd73a45348d0feba858d96a500 BlockState iblockdata = LevelChunk.this.getBlockState(blockposition); if (this.blockEntity.getType().isValid(iblockdata)) { -@@ -1281,7 +1281,7 @@ public class LevelChunk extends ChunkAccess { +@@ -1295,7 +1295,7 @@ public class LevelChunk extends ChunkAccess { // Paper end // Spigot start } finally { @@ -902,10 +902,10 @@ index 7674939964894a56ce495e47d400cbf12cd0475b..0ae73cd79548dfd887edcd1de030579d // Paper end - add timings for scoreboard search } diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java -index 603514710e812bd69fac1b088a91f5446ec120b6..89ad326fbc9862623a1bed4f15f6243e231da455 100644 +index 79d027e517ce08443d86b877a55df24cc20d102b..43d9e7287cf0e498ccbff9b865bb813e7fb567c0 100644 --- a/src/main/java/org/spigotmc/ActivationRange.java +++ b/src/main/java/org/spigotmc/ActivationRange.java -@@ -166,7 +166,7 @@ public class ActivationRange +@@ -170,7 +170,7 @@ public class ActivationRange */ public static void activateEntities(Level world) { @@ -914,7 +914,7 @@ index 603514710e812bd69fac1b088a91f5446ec120b6..89ad326fbc9862623a1bed4f15f6243e final int miscActivationRange = world.spigotConfig.miscActivationRange; final int raiderActivationRange = world.spigotConfig.raiderActivationRange; final int animalActivationRange = world.spigotConfig.animalActivationRange; -@@ -222,7 +222,7 @@ public class ActivationRange +@@ -245,7 +245,7 @@ public class ActivationRange } // Paper end } diff --git a/patches/server/0270-Remove-Mojang-Profiler.patch b/patches/server/0272-Remove-Mojang-Profiler.patch similarity index 88% rename from patches/server/0270-Remove-Mojang-Profiler.patch rename to patches/server/0272-Remove-Mojang-Profiler.patch index cf436340a..624f6bcbc 100644 --- a/patches/server/0270-Remove-Mojang-Profiler.patch +++ b/patches/server/0272-Remove-Mojang-Profiler.patch @@ -39,10 +39,10 @@ index 5f6cc8b16af6dce3b74f0c2c662b0ecf84ae8d36..52b06c34d9d3ffb8844556e7b0eaed5a return b0; diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 1ce02d0c14a57101e0c0e88bad2e2d93a2dedf3b..dceb8fbf8a6d895bab0fba63b3b4c809e7e67c6a 100644 +index dc70b971a37ef71e6c44dc6d3204ccfd60ce5b88..5fbf050a5f6a6c59089cb67e880f02f99844e384 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -339,13 +339,13 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0 && this.tickCount % autosavePeriod == 0; try { this.isSaving = true; -@@ -1442,7 +1442,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0; // Paper worldserver.hasRidableMoveEvent = org.purpurmc.purpur.event.entity.RidableMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Purpur @@ -192,7 +192,7 @@ index 1ce02d0c14a57101e0c0e88bad2e2d93a2dedf3b..dceb8fbf8a6d895bab0fba63b3b4c809 try { //worldserver.timings.doTick.startTiming(); // Spigot // Purpur -@@ -1588,17 +1588,17 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { this.executeBlocking(() -> { this.saveDebugReport(path.resolve("server")); -@@ -2533,40 +2534,40 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop loadedChunkMap = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(8192, 0.5f); + + private final LevelChunk[] lastLoadedChunks = new LevelChunk[4 * 4]; +- ++ + public boolean firstRunSpawnCounts = true; // Pufferfish + public final java.util.concurrent.atomic.AtomicBoolean _pufferfish_spawnCountsReady = new java.util.concurrent.atomic.AtomicBoolean(false); // Pufferfish - optimize countmobs + +@@ -280,16 +280,16 @@ public class ServerChunkCache extends ChunkSource { return ifLoaded; } // Paper end @@ -440,7 +450,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 CompletableFuture> completablefuture = this.getChunkFutureMainThread(x, z, leastStatus, create, true); // Paper ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor; -@@ -475,24 +475,24 @@ public class ServerChunkCache extends ChunkSource { +@@ -478,24 +478,24 @@ public class ServerChunkCache extends ChunkSource { // CraftBukkit start - modelled on below public void purgeUnload() { if (true) return; // Paper - tickets will be removed later, this behavior isn't really well accounted for by the chunk system @@ -470,7 +480,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 if (tickChunks) { //this.level.timings.chunks.startTiming(); // Paper - timings // Purpur this.chunkMap.level.playerChunkLoader.tick(); // Paper - replace player chunk loader - this is mostly required to account for view distance changes -@@ -501,10 +501,10 @@ public class ServerChunkCache extends ChunkSource { +@@ -504,10 +504,10 @@ public class ServerChunkCache extends ChunkSource { } //this.level.timings.doChunkUnload.startTiming(); // Spigot // Purpur @@ -483,7 +493,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 this.clearCache(); } -@@ -550,13 +550,13 @@ public class ServerChunkCache extends ChunkSource { +@@ -553,14 +553,14 @@ public class ServerChunkCache extends ChunkSource { } // Paper end - optimize isOutisdeRange LevelData worlddata = this.level.getLevelData(); @@ -492,6 +502,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 - gameprofilerfiller.push("pollingChunks"); + //gameprofilerfiller.push("pollingChunks"); // Purpur + this.level.resetIceAndSnowTick(); // Pufferfish - reset ice & snow tick random int k = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING); boolean flag1 = level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && worlddata.getGameTime() % level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit @@ -500,10 +511,10 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 //this.level.timings.countNaturalMobs.startTiming(); // Paper - timings // Purpur int l = this.distanceManager.getNaturalSpawnChunkCount(); // Paper start - per player mob spawning -@@ -574,13 +574,13 @@ public class ServerChunkCache extends ChunkSource { +@@ -585,13 +585,13 @@ public class ServerChunkCache extends ChunkSource { //this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings // Purpur - this.lastSpawnState = spawnercreature_d; + //this.lastSpawnState = spawnercreature_d; // Pufferfish - this is managed asynchronously - gameprofilerfiller.popPush("filteringLoadedChunks"); + //gameprofilerfiller.popPush("filteringLoadedChunks"); // Purpur // Paper - moved down @@ -516,7 +527,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 boolean flag2 = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit // Paper - only shuffle if per-player mob spawning is disabled -@@ -632,15 +632,15 @@ public class ServerChunkCache extends ChunkSource { +@@ -643,15 +643,15 @@ public class ServerChunkCache extends ChunkSource { } // Paper end - optimise chunk tick iteration //this.level.timings.chunkTicks.stopTiming(); // Paper // Purpur @@ -535,7 +546,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 //this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timing // Purpur if (!this.chunkMap.needsChangeBroadcasting.isEmpty()) { ReferenceOpenHashSet copy = this.chunkMap.needsChangeBroadcasting.clone(); -@@ -654,7 +654,7 @@ public class ServerChunkCache extends ChunkSource { +@@ -665,7 +665,7 @@ public class ServerChunkCache extends ChunkSource { } } //this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timing // Purpur @@ -544,7 +555,16 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 // Paper end - use set of chunks requiring updates, rather than iterating every single one loaded // Paper start - controlled flush for entity tracker packets List disabledFlushes = new java.util.ArrayList<>(this.level.players.size()); -@@ -845,7 +845,7 @@ public class ServerChunkCache extends ChunkSource { +@@ -686,7 +686,7 @@ public class ServerChunkCache extends ChunkSource { + } + // Paper end - controlled flush for entity tracker packets + } +- ++ + // Pufferfish start - optimize mob spawning + if (gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncMobSpawning) { + for (ServerPlayer player : this.level.players) { +@@ -880,7 +880,7 @@ public class ServerChunkCache extends ChunkSource { @Override protected void doRunTask(Runnable task) { @@ -554,7 +574,7 @@ index c4601ee883ecff651585aaaf33fe3a9f747d4338..f75f7b39aa4ed5c18cd2d761a1337df5 } diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e3816b3c8 100644 +index 5b7507db055d7be59b369f66e659e128c9c7e00b..221d1d0e1b4b46de6ebca5faac09bbda875fae17 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -795,12 +795,12 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -630,7 +650,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e } org.spigotmc.ActivationRange.activateEntities(this); // Spigot -@@ -875,9 +875,9 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -876,9 +876,9 @@ public class ServerLevel extends Level implements WorldGenLevel { if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed entity.discard(); } else { @@ -642,13 +662,19 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e if (true || this.chunkSource.chunkMap.getDistanceManager().inEntityTickingRange(entity.chunkPosition().toLong())) { // Paper - now always true if in the ticking list Entity entity1 = entity.getVehicle(); -@@ -889,22 +889,21 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -890,7 +890,7 @@ public class ServerLevel extends Level implements WorldGenLevel { entity.stopRiding(); } - gameprofilerfiller.push("tick"); + //gameprofilerfiller.push("tick"); // Purpur - this.guardEntityTick(this::tickNonPassenger, entity); + // Pufferfish start - copied from this.guardEntityTick + try { + this.tickNonPassenger(entity); // Pufferfish - changed +@@ -905,20 +905,19 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Paper end + } + // Pufferfish end - gameprofilerfiller.pop(); + //gameprofilerfiller.pop(); // Purpur } @@ -669,7 +695,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e } @Override -@@ -984,9 +983,9 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1000,9 +999,9 @@ public class ServerLevel extends Level implements WorldGenLevel { boolean flag = this.isRaining(); int j = chunkcoordintpair.getMinBlockX(); int k = chunkcoordintpair.getMinBlockZ(); @@ -680,8 +706,8 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e + //gameprofilerfiller.push("thunder"); // Purpur final BlockPos.MutableBlockPos blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change - if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder -@@ -1024,7 +1023,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && /*this.random.nextInt(this.spigotConfig.thunderChance) == 0 &&*/ chunk.shouldDoLightning(this.random)) { // Spigot // Paper - disable thunder // Pufferfish - replace random with shouldDoLightning +@@ -1040,7 +1039,7 @@ public class ServerLevel extends Level implements WorldGenLevel { } } @@ -690,7 +716,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e int l; int i1; -@@ -1076,7 +1075,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1092,7 +1091,7 @@ public class ServerLevel extends Level implements WorldGenLevel { } // Paper start - optimise random block ticking @@ -699,7 +725,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e //timings.chunkTicksBlocks.startTiming(); // Paper // Purpur if (randomTickSpeed > 0) { LevelChunkSection[] sections = chunk.getSections(); -@@ -1112,7 +1111,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1128,7 +1127,7 @@ public class ServerLevel extends Level implements WorldGenLevel { } // Paper end - optimise random block ticking //timings.chunkTicksBlocks.stopTiming(); // Paper // Purpur @@ -708,7 +734,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e } public Optional findLightningRod(BlockPos pos) { -@@ -1408,19 +1407,19 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1424,19 +1423,19 @@ public class ServerLevel extends Level implements WorldGenLevel { //try { // Purpur // Paper end - timings entity.setOldPosAndRot(); @@ -733,7 +759,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e //} finally { timer.stopTiming(); } // Paper - timings // Purpur Iterator iterator = entity.getPassengers().iterator(); -@@ -1449,12 +1448,12 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1465,12 +1464,12 @@ public class ServerLevel extends Level implements WorldGenLevel { // Paper end passenger.setOldPosAndRot(); ++passenger.tickCount; @@ -750,7 +776,7 @@ index 55f892e0b9eb098f3cdd922fa5d5d53005722859..653e469c726e6e44b93452e0cac2448e // Paper start - EAR 2 if (isActive) { passenger.rideTick(); -@@ -1466,7 +1465,7 @@ public class ServerLevel extends Level implements WorldGenLevel { +@@ -1482,7 +1481,7 @@ public class ServerLevel extends Level implements WorldGenLevel { vehicle.positionRider(passenger); } // Paper end - EAR 2 @@ -793,7 +819,7 @@ index fe66f37a2b385870bf72f97e73b297b9bc2ef9c3..0540ccd4137b5fb65440e5013d67e349 this.connection.send(new ClientboundPlayerAbilitiesPacket(this.getAbilities())); playerlist.sendLevelInfo(this, worldserver); diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 6eab3a061bb0c649b83440c07e2cee92814d9ae7..882f5dae523b712dc27997dee9f6f450d7561739 100644 +index 52b9d600409dd4accb78f6eff2ffbaefcae8d322..6ca00bc5da778f3f53f87ec539b8605c4f013e45 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java @@ -410,7 +410,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @@ -1019,19 +1045,28 @@ index 2e6e8eac987c4ef6b2dcd3de592d8a51d2b29792..863343a87fe34d72f04af89d75268b47 }; } diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f068276b0e450 100644 +index db30761805fe90279297ea939fba45530d7a5db0..7648d6faf9ef9308c92bdbd481b6339ecf6ce85f 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java -@@ -816,7 +816,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { - // CraftBukkit end - - public void baseTick() { +@@ -426,7 +426,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + public int activatedPriority = gg.pufferfish.pufferfish.PufferfishConfig.maximumActivationPrio; // golf score + public final BlockPos.MutableBlockPos cachedBlockPos = new BlockPos.MutableBlockPos(); // used where needed + // Pufferfish end +- ++ + public float getBukkitYaw() { + return this.yRot; + } +@@ -850,7 +850,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + return; + } + // Pufferfish end - entity TTL - this.level().getProfiler().push("entityBaseTick"); + //this.level().getProfiler().push("entityBaseTick"); // Purpur if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking this.feetBlockState = null; if (this.isPassenger() && this.getVehicle().isRemoved()) { -@@ -877,7 +877,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -911,7 +911,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } this.firstTick = false; @@ -1040,7 +1075,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 } public void setSharedFlagOnFire(boolean onFire) { -@@ -1096,7 +1096,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1130,7 +1130,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } } @@ -1049,7 +1084,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 if (this.stuckSpeedMultiplier.lengthSqr() > 1.0E-7D) { movement = movement.multiply(this.stuckSpeedMultiplier); this.stuckSpeedMultiplier = Vec3.ZERO; -@@ -1105,7 +1105,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1139,7 +1139,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { // Paper start - ignore movement changes while inactive. if (isTemporarilyActive && !(this instanceof ItemEntity || this instanceof net.minecraft.world.entity.vehicle.AbstractMinecart) && movement == getDeltaMovement() && movementType == MoverType.SELF) { setDeltaMovement(Vec3.ZERO); @@ -1058,7 +1093,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 return; } // Paper end -@@ -1126,8 +1126,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1160,8 +1160,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.setPos(this.getX() + vec3d1.x, this.getY() + vec3d1.y, this.getZ() + vec3d1.z); } @@ -1069,7 +1104,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 boolean flag = !Mth.equal(movement.x, vec3d1.x); boolean flag1 = !Mth.equal(movement.z, vec3d1.z); -@@ -1146,7 +1146,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1180,7 +1180,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.checkFallDamage(vec3d1.y, this.onGround(), iblockdata, blockposition); if (this.isRemoved()) { @@ -1078,7 +1113,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 } else { if (this.horizontalCollision) { Vec3 vec3d2 = this.getDeltaMovement(); -@@ -1284,7 +1284,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -1318,7 +1318,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.setRemainingFireTicks(-this.getFireImmuneTicks()); } @@ -1087,7 +1122,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 } } // Paper start - detailed watchdog information -@@ -3070,7 +3070,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3104,7 +3104,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { ServerLevel worldserver1 = minecraftserver.getLevel(resourcekey); if (true && !this.isPassenger() && this.portalTime++ >= i) { // CraftBukkit @@ -1096,7 +1131,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 this.portalTime = i; // Paper start io.papermc.paper.event.entity.EntityPortalReadyEvent event = new io.papermc.paper.event.entity.EntityPortalReadyEvent(this.getBukkitEntity(), worldserver1 == null ? null : worldserver1.getWorld(), org.bukkit.PortalType.NETHER); -@@ -3088,7 +3088,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3122,7 +3122,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } } // Paper // CraftBukkit end @@ -1105,7 +1140,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 } this.isInsidePortal = false; -@@ -3559,14 +3559,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3593,14 +3593,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } // Paper end if (this.level() instanceof ServerLevel && !this.isRemoved()) { @@ -1122,7 +1157,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 PortalInfo shapedetectorshape = (location == null) ? this.findDimensionEntryPoint(worldserver) : new PortalInfo(new Vec3(location.x(), location.y(), location.z()), Vec3.ZERO, this.yRot, this.xRot, worldserver, null); // CraftBukkit if (shapedetectorshape == null) { -@@ -3600,7 +3600,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3634,7 +3634,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { this.unRide(); // CraftBukkit end @@ -1131,7 +1166,7 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 // Paper start - Change lead drop timing to prevent dupe if (this instanceof Mob) { ((Mob) this).dropLeash(true, true); // Paper drop lead -@@ -3623,10 +3623,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { +@@ -3657,10 +3657,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { } this.removeAfterChangingDimensions(); @@ -1145,10 +1180,10 @@ index 3fc1388cfadb401e16a7793428ac40c30a44a16e..411abadee2e9b659c7022ad26e5f0682 } } else { diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf94c2ca4e6 100644 +index 5ad5bc75af60a16b02c9604dd027403b5b6a67e6..5427fb8c2f5a53a8d293fb4c36f6620ca0205e38 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java -@@ -412,7 +412,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -411,7 +411,7 @@ public abstract class LivingEntity extends Entity implements Attackable { } super.baseTick(); @@ -1157,7 +1192,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 if (this.fireImmune() || this.level().isClientSide) { this.clearFire(); } -@@ -515,7 +515,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -514,7 +514,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.yHeadRotO = this.yHeadRot; this.yRotO = this.getYRot(); this.xRotO = this.getXRot(); @@ -1166,7 +1201,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 } public boolean canSpawnSoulSpeedParticle() { -@@ -3111,10 +3111,10 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3133,10 +3133,10 @@ public abstract class LivingEntity extends Entity implements Attackable { } this.run += (f3 - this.run) * 0.3F; @@ -1180,7 +1215,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 // Paper start - stop large pitch and yaw changes from crashing the server this.yRotO += Math.round((this.getYRot() - this.yRotO) / 360.0F) * 360.0F; -@@ -3126,7 +3126,7 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3148,7 +3148,7 @@ public abstract class LivingEntity extends Entity implements Attackable { this.yHeadRotO += Math.round((this.yHeadRot - this.yHeadRotO) / 360.0F) * 360.0F; // Paper end @@ -1189,7 +1224,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 this.animStep += f2; if (this.isFallFlying()) { ++this.fallFlyTicks; -@@ -3415,19 +3415,19 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3437,19 +3437,19 @@ public abstract class LivingEntity extends Entity implements Attackable { } this.setDeltaMovement(d4, d5, d6); @@ -1214,7 +1249,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 if (this.jumping && this.isAffectedByFluids()) { double d7; -@@ -3454,8 +3454,8 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3476,8 +3476,8 @@ public abstract class LivingEntity extends Entity implements Attackable { this.noJumpDelay = 0; } @@ -1225,7 +1260,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 this.xxa *= 0.98F; this.zza *= 0.98F; this.updateFallFlying(); -@@ -3482,8 +3482,8 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3504,8 +3504,8 @@ public abstract class LivingEntity extends Entity implements Attackable { this.travel(vec3d1); } @@ -1236,7 +1271,7 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 if (!this.level().isClientSide && !this.isDeadOrDying() && !freezeLocked) { // Paper - Freeze Tick Lock API int i = this.getTicksFrozen(); -@@ -3500,15 +3500,15 @@ public abstract class LivingEntity extends Entity implements Attackable { +@@ -3522,15 +3522,15 @@ public abstract class LivingEntity extends Entity implements Attackable { this.hurt(this.damageSources().freeze(), 1.0F); } @@ -1256,10 +1291,10 @@ index ecaf3cc5abda30d2b13c92ebb9f31442894064d3..86b95f1ef689860c0a8b728811c68cf9 // Purpur start if (this.xo != this.getX() || this.yo != this.getY() || this.zo != this.getZ() || this.yRotO != this.getYRot() || this.xRotO != this.getXRot()) { diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846d0b6cae0 100644 +index 7dae759b777cf9077bf46d2e1189c20c1c2db60e..19d9d3a9f634631e2ec5a6fa7f2cd9dd18f62f89 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java -@@ -363,13 +363,13 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -365,13 +365,13 @@ public abstract class Mob extends LivingEntity implements Targeting { @Override public void baseTick() { super.baseTick(); @@ -1275,7 +1310,7 @@ index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846 incrementTicksSinceLastInteraction(); // Purpur } -@@ -700,7 +700,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -702,7 +702,7 @@ public abstract class Mob extends LivingEntity implements Targeting { @Override public void aiStep() { super.aiStep(); @@ -1284,7 +1319,7 @@ index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846 if (!this.level().isClientSide && this.canPickUpLoot() && this.isAlive() && !this.dead && (this.level().purpurConfig.entitiesPickUpLootBypassMobGriefing || this.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { Vec3i baseblockposition = this.getPickupReach(); List list = this.level().getEntitiesOfClass(ItemEntity.class, this.getBoundingBox().inflate((double) baseblockposition.getX(), (double) baseblockposition.getY(), (double) baseblockposition.getZ())); -@@ -720,7 +720,7 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -722,7 +722,7 @@ public abstract class Mob extends LivingEntity implements Targeting { } } @@ -1293,7 +1328,7 @@ index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846 } protected Vec3i getPickupReach() { -@@ -932,42 +932,42 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -934,46 +934,46 @@ public abstract class Mob extends LivingEntity implements Targeting { return; } // Paper end @@ -1307,22 +1342,26 @@ index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846 if (i % 2 != 0 && this.tickCount > 1) { - this.level().getProfiler().push("targetSelector"); + //this.level().getProfiler().push("targetSelector"); // Purpur + if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking this.targetSelector.tickRunningGoals(false); - this.level().getProfiler().pop(); - this.level().getProfiler().push("goalSelector"); + //this.level().getProfiler().pop(); // Purpur + //this.level().getProfiler().push("goalSelector"); // Purpur + if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking this.goalSelector.tickRunningGoals(false); - this.level().getProfiler().pop(); + //this.level().getProfiler().pop(); // Purpur } else { - this.level().getProfiler().push("targetSelector"); -+ //this.level().getProfiler().push("targetSelector"); // Purpur ++ //this.level().getProfiler().push("targetSelector"); + if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking this.targetSelector.tick(); - this.level().getProfiler().pop(); - this.level().getProfiler().push("goalSelector"); + //this.level().getProfiler().pop(); // Purpur + //this.level().getProfiler().push("goalSelector"); // Purpur + if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking this.goalSelector.tick(); - this.level().getProfiler().pop(); + //this.level().getProfiler().pop(); // Purpur @@ -1357,10 +1396,10 @@ index e3634d7dfd2558173a5c9d05e4ab285c80237684..3162c27ee305f5280a326b953288c846 } diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java -index b738ee2d3801fadfd09313f05ae24593e56b0ec6..8a70bc63e12838f45fa3eade74f2899438715886 100644 +index 1635818fc4b1788c0d397085239df6dd75b210ab..02978315bc2b828cc603ce7478408f3f82c249c2 100644 --- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java +++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java -@@ -102,8 +102,8 @@ public class GoalSelector { +@@ -105,8 +105,8 @@ public class GoalSelector { } public void tick() { @@ -1371,7 +1410,7 @@ index b738ee2d3801fadfd09313f05ae24593e56b0ec6..8a70bc63e12838f45fa3eade74f28994 for(WrappedGoal wrappedGoal : this.availableGoals) { if (wrappedGoal.isRunning() && (goalContainsAnyFlags(wrappedGoal, this.goalTypes) || !wrappedGoal.canContinueToUse())) { -@@ -120,8 +120,8 @@ public class GoalSelector { +@@ -123,8 +123,8 @@ public class GoalSelector { } } @@ -1382,7 +1421,7 @@ index b738ee2d3801fadfd09313f05ae24593e56b0ec6..8a70bc63e12838f45fa3eade74f28994 for(WrappedGoal wrappedGoal2 : this.availableGoals) { // Paper start -@@ -141,13 +141,13 @@ public class GoalSelector { +@@ -144,13 +144,13 @@ public class GoalSelector { } } @@ -1399,7 +1438,7 @@ index b738ee2d3801fadfd09313f05ae24593e56b0ec6..8a70bc63e12838f45fa3eade74f28994 for(WrappedGoal wrappedGoal : this.availableGoals) { if (wrappedGoal.isRunning() && (tickAll || wrappedGoal.requiresUpdateEveryTick())) { -@@ -155,7 +155,7 @@ public class GoalSelector { +@@ -158,7 +158,7 @@ public class GoalSelector { } } @@ -1444,15 +1483,16 @@ index 51772f03a3469b11e7166ec6f3a1b9c64a606221..02f2f46ccc48bb4d9bd08555818b0489 this.seen.add(i); } else { diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java -index 9588f9adad23aa6f2240d1ddb2f92aa82e8e740b..15c4531865d829ea90d060ee83122a80ab39028b 100644 +index 801dde462d5ff785691157520270f6f20e1bd1b2..cff8d4a00d560ffac1a3b4b3d7dfaa9ff5fcd1d0 100644 --- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java -@@ -259,12 +259,12 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS - +@@ -260,13 +260,13 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS + private int behaviorTick = 0; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("allayBrain"); + //this.level().getProfiler().push("allayBrain"); // Purpur + if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish this.getBrain().tick((ServerLevel) this.level(), this); - this.level().getProfiler().pop(); - this.level().getProfiler().push("allayActivityUpdate"); @@ -1465,15 +1505,16 @@ index 9588f9adad23aa6f2240d1ddb2f92aa82e8e740b..15c4531865d829ea90d060ee83122a80 } diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -index ec49c2af2fb09b8ead5529d0ec5cf59d2ab70e6b..a8cb79c25d49ef4f99de2b290ef5e60f3f175c34 100644 +index 7ae53657d9c5be90fa2f92d0fb3dbcb78ed35abf..cb95571ad2119b8bad5bbba036ebaeb058fcc00f 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java -@@ -324,12 +324,12 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder { - +@@ -218,13 +218,13 @@ public class Frog extends Animal implements VariantHolder { + private int behaviorTick = 0; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("frogBrain"); + //this.level().getProfiler().push("frogBrain"); // Purpur + if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish this.getBrain().tick((ServerLevel)this.level(), this); - this.level().getProfiler().pop(); - this.level().getProfiler().push("frogActivityUpdate"); @@ -1529,15 +1571,16 @@ index eab6d7bb5ae6635eb881156f50c8fd4ed2adb11a..21f0554ae9281ddd088cf36c79bb005e } diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java -index 955e112f52898ffde28e1b49b6e91d3e33e057b5..9db4817cf503c361a6bcb9a4174d8c4319c664b2 100644 +index 05545b399d068e5c88f4fcd2729e616222fe1e3a..98e3155b5d5d499a12122b9eb91cde22a72d2cad 100644 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java -@@ -116,12 +116,12 @@ public class Tadpole extends AbstractFish { - +@@ -117,13 +117,13 @@ public class Tadpole extends AbstractFish { + private int behaviorTick = 0; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("tadpoleBrain"); + //this.level().getProfiler().push("tadpoleBrain"); // Purpur + if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish this.getBrain().tick((ServerLevel) this.level(), this); - this.level().getProfiler().pop(); - this.level().getProfiler().push("tadpoleActivityUpdate"); @@ -1550,16 +1593,17 @@ index 955e112f52898ffde28e1b49b6e91d3e33e057b5..9db4817cf503c361a6bcb9a4174d8c43 } diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index 0ebb9ac9d951741eb9dea8475380cfcc68becae3..a707954d8e5b88ed37c2640437a10781ab7e56ce 100644 +index df08f220b7c25fd9e7daa6a23816cb8d6ff4c003..1a989f9fbeaf51b9dc3ba32e1f6fb838db5af13e 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -@@ -222,13 +222,13 @@ public class Goat extends Animal { - +@@ -223,13 +223,14 @@ public class Goat extends Animal { + private int behaviorTick = 0; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("goatBrain"); + //this.level().getProfiler().push("goatBrain"); // Purpur - //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch ++ //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch this.getBrain().tick((ServerLevel) this.level(), this); - this.level().getProfiler().pop(); - this.level().getProfiler().push("goatActivityUpdate"); @@ -1608,16 +1652,16 @@ index fc5272e8671ff4bda3bd17abe5c31cc0ff4114f8..399e9baedaf37597c539aa5432a51336 } diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -index 5bc0bf6486b146ecefe747f029f79ab504dc6423..13beaa4b701b75a4387c96a63c6021632ebad479 100644 +index 0ddcff8d4cd22cc01462c412c3db39238237ca49..ecc445bb3cda2d79d64c580b72544567dd304f53 100644 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java -@@ -165,10 +165,10 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { - +@@ -166,10 +166,10 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { + private int behaviorTick; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("hoglinBrain"); + //this.level().getProfiler().push("hoglinBrain"); // Purpur - //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider this.getBrain().tick((ServerLevel)this.level(), this); - this.level().getProfiler().pop(); + //this.level().getProfiler().pop(); // Purpur @@ -1625,16 +1669,16 @@ index 5bc0bf6486b146ecefe747f029f79ab504dc6423..13beaa4b701b75a4387c96a63c602163 if (this.isConverting()) { ++this.timeInOverworld; diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -index 18879b75aeedf8df321c2cf93ee8b94e0d321333..257bb62ee42d119cbc6e75aaa6b973507e20dc12 100644 +index 9fb7f6d0532a7419674cc20e4fc6cb4b08c73514..79f969ea76fc2073e10c050c2aa64b5b5e473181 100644 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java -@@ -339,10 +339,10 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento - +@@ -340,10 +340,10 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento + private int behaviorTick; // Pufferfish @Override protected void customServerAiStep() { - this.level().getProfiler().push("piglinBrain"); + //this.level().getProfiler().push("piglinBrain"); // Purpur - //if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider this.getBrain().tick((ServerLevel) this.level(), this); - this.level().getProfiler().pop(); + //this.level().getProfiler().pop(); // Purpur @@ -1659,15 +1703,16 @@ index 61e8f2d030fc50840c3f80dfb6fc810797ec440f..856e6e02c9424a6c06e310262cb4f5bd PiglinBruteAi.maybePlayActivitySound(this); super.customServerAiStep(); diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java -index 9f5e44d3d44a7ca546c410a40c9397a4e3b27b79..22553da189370405f6f97ceff5e66596e1e12f5f 100644 +index 0aa6874022d4ee8e38f2d85c45a2a4201c2a83fe..3fa46affc4d77d01909cfeaeaba6e06ba9fd5592 100644 --- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java -@@ -299,9 +299,9 @@ public class Warden extends Monster implements VibrationSystem { +@@ -300,10 +300,10 @@ public class Warden extends Monster implements VibrationSystem { protected void customServerAiStep() { ServerLevel worldserver = (ServerLevel) this.level(); - worldserver.getProfiler().push("wardenBrain"); + //worldserver.getProfiler().push("wardenBrain"); // Purpur + if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish this.getBrain().tick(worldserver, this); - this.level().getProfiler().pop(); + //this.level().getProfiler().pop(); // Purpur @@ -1675,10 +1720,10 @@ index 9f5e44d3d44a7ca546c410a40c9397a4e3b27b79..22553da189370405f6f97ceff5e66596 if ((this.tickCount + this.getId()) % 120 == 0) { Warden.applyDarknessAround(worldserver, this.position(), this, 20); diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java -index 25bf930258065b6cc6d6c3a790835ddf1a0aba36..a372d34d195a2a419215f109eb36654df1cb04a2 100644 +index 85c8854691070d8867a5eaf410fe7a2f75fadb9f..2ea19f72dd8e86d5821f734c13ac2dc6f53e9c30 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java -@@ -338,7 +338,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler +@@ -341,7 +341,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler } protected void customServerAiStep(boolean inactive) { // Purpur - not final // Paper end @@ -1687,8 +1732,8 @@ index 25bf930258065b6cc6d6c3a790835ddf1a0aba36..a372d34d195a2a419215f109eb36654d // Purpur start if (this.level().purpurConfig.villagerLobotomizeEnabled) { // treat as inactive if lobotomized -@@ -351,7 +351,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler - // if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider // Purpur - TODO: Uncomment when pufferfish patch +@@ -354,7 +354,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + this.getBrain().tick((ServerLevel) this.level(), this); // Paper else if (this.isLobotomized && shouldRestock()) restock(); // Purpur end - this.level().getProfiler().pop(); @@ -1719,10 +1764,10 @@ index 8f97c9df726ac20cfce7bdddd5dd4f8c5aa76c35..e35ebb5b923c2f63e37e5dae006bc4a0 } diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 000697994299163fa3287450652be551a81cf466..5287a6fe5742bdfe179fe669ee1f1edfbbd0fae6 100644 +index 6a3b55031188d920d2c7bfc67df791bdd89fba62..fdd55ac3720d44e3d246e05fe9a07b5f73bed0e8 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -909,9 +909,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1012,9 +1012,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable { } protected void tickBlockEntities() { @@ -1734,7 +1779,7 @@ index 000697994299163fa3287450652be551a81cf466..5287a6fe5742bdfe179fe669ee1f1edf //timings.tileEntityPending.startTiming(); // Spigot // Purpur this.tickingBlockEntities = true; if (!this.pendingBlockEntityTickers.isEmpty()) { -@@ -956,7 +956,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1059,7 +1059,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { //timings.tileEntityTick.stopTiming(); // Spigot // Purpur this.tickingBlockEntities = false; co.aikar.timings.TimingHistory.tileEntityTicks += this.blockEntityTickers.size(); // Paper @@ -1743,7 +1788,7 @@ index 000697994299163fa3287450652be551a81cf466..5287a6fe5742bdfe179fe669ee1f1edf spigotConfig.currentPrimedTnt = 0; // Spigot } -@@ -1149,7 +1149,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1252,7 +1252,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { @Override public List getEntities(@Nullable Entity except, AABB box, Predicate predicate) { @@ -1752,7 +1797,7 @@ index 000697994299163fa3287450652be551a81cf466..5287a6fe5742bdfe179fe669ee1f1edf List list = Lists.newArrayList(); ((ServerLevel)this).getEntityLookup().getEntities(except, box, list, predicate); // Paper - optimise this call return list; -@@ -1168,7 +1168,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1271,7 +1271,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { } public void getEntities(EntityTypeTest filter, AABB box, Predicate predicate, List result, int limit) { @@ -1761,16 +1806,17 @@ index 000697994299163fa3287450652be551a81cf466..5287a6fe5742bdfe179fe669ee1f1edf // Paper start - optimise this call //TODO use limit if (filter instanceof net.minecraft.world.entity.EntityType entityTypeTest) { -@@ -1425,6 +1425,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1528,7 +1528,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { } public ProfilerFiller getProfiler() { -+ // if (true || gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish // Purpur - TODO: Uncomment when pufferfish patch +- if (gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish ++ if (true || gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish // Purpur return (ProfilerFiller) this.profiler.get(); } diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java -index 4e2611c9a7df8343f76e3be3f01f2f828cdf8a1d..03fc9c6ef0fb320924038f2730c6f08426f0842c 100644 +index 0001860bb3862ee8cb489774cecbd92a64d75a34..1894348413f3b30bd9c4286fa533c1037f07f870 100644 --- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java +++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java @@ -132,7 +132,7 @@ public final class NaturalSpawner { @@ -1792,10 +1838,10 @@ index 4e2611c9a7df8343f76e3be3f01f2f828cdf8a1d..03fc9c6ef0fb320924038f2730c6f084 // Paper start diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -index 5de3b6cd73a45348d0feba858d96a500bf236ce7..f4849ed39a7da7454a611d0d9f1a828286121c1c 100644 +index 4dab159024cf91cd297dcb31833f9d57e2132326..c17b04880b4032984b43dd4fbe1c08f96112abac 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java -@@ -538,11 +538,11 @@ public class LevelChunk extends ChunkAccess { +@@ -552,11 +552,11 @@ public class LevelChunk extends ChunkAccess { if (LightEngine.hasDifferentLightProperties(this, blockposition, iblockdata1, iblockdata)) { ProfilerFiller gameprofilerfiller = this.level.getProfiler(); @@ -1810,7 +1856,7 @@ index 5de3b6cd73a45348d0feba858d96a500bf236ce7..f4849ed39a7da7454a611d0d9f1a8282 } boolean flag3 = iblockdata1.hasBlockEntity(); -@@ -1256,9 +1256,9 @@ public class LevelChunk extends ChunkAccess { +@@ -1270,9 +1270,9 @@ public class LevelChunk extends ChunkAccess { if (LevelChunk.this.isTicking(blockposition)) { try { @@ -1822,7 +1868,7 @@ index 5de3b6cd73a45348d0feba858d96a500bf236ce7..f4849ed39a7da7454a611d0d9f1a8282 //this.blockEntity.tickTimer.startTiming(); // Spigot // Purpur BlockState iblockdata = LevelChunk.this.getBlockState(blockposition); -@@ -1270,7 +1270,7 @@ public class LevelChunk extends ChunkAccess { +@@ -1284,7 +1284,7 @@ public class LevelChunk extends ChunkAccess { LevelChunk.LOGGER.warn("Block entity {} @ {} state {} invalid for ticking:", new Object[]{LogUtils.defer(this::getType), LogUtils.defer(this::getPos), iblockdata}); } diff --git a/patches/server/0271-Add-more-logger-output-for-invalid-movement-kicks.patch b/patches/server/0273-Add-more-logger-output-for-invalid-movement-kicks.patch similarity index 94% rename from patches/server/0271-Add-more-logger-output-for-invalid-movement-kicks.patch rename to patches/server/0273-Add-more-logger-output-for-invalid-movement-kicks.patch index e7df92636..7ca924a8a 100644 --- a/patches/server/0271-Add-more-logger-output-for-invalid-movement-kicks.patch +++ b/patches/server/0273-Add-more-logger-output-for-invalid-movement-kicks.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add more logger output for invalid movement kicks diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java -index 882f5dae523b712dc27997dee9f6f450d7561739..09a5bc8bc8f619df674d9c1c797cb25b61510ce5 100644 +index 6ca00bc5da778f3f53f87ec539b8605c4f013e45..924c08489582444ae7b061c52eac91759c8f4484 100644 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java @@ -865,6 +865,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @@ -16,7 +16,7 @@ index 882f5dae523b712dc27997dee9f6f450d7561739..09a5bc8bc8f619df674d9c1c797cb25b return; } -@@ -1440,8 +1441,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic +@@ -1441,8 +1442,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic @Override public void handleMovePlayer(ServerboundMovePlayerPacket packet) { PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); diff --git a/patches/server/0272-Add-Bee-API.patch b/patches/server/0274-Add-Bee-API.patch similarity index 100% rename from patches/server/0272-Add-Bee-API.patch rename to patches/server/0274-Add-Bee-API.patch diff --git a/patches/server/0273-Debug-Marker-API.patch b/patches/server/0275-Debug-Marker-API.patch similarity index 97% rename from patches/server/0273-Debug-Marker-API.patch rename to patches/server/0275-Debug-Marker-API.patch index c6729b401..c2bf038c3 100644 --- a/patches/server/0273-Debug-Marker-API.patch +++ b/patches/server/0275-Debug-Marker-API.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Debug Marker API diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index ac85de5112975097e20d319059deee42a3961fa2..788bd3f4f9ed03d2dd05329afdff05f78a135f49 100644 +index 6403d721e7ab1f2251d4c083c4580797f71647bd..9a5cdb530cf4c649585fa4d13a6a11abe77919fc 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -@@ -1459,6 +1459,42 @@ public final class CraftServer implements Server { +@@ -1464,6 +1464,42 @@ public final class CraftServer implements Server { public void removeFuel(org.bukkit.Material material) { net.minecraft.world.level.block.entity.AbstractFurnaceBlockEntity.removeFuel(net.minecraft.world.item.ItemStack.fromBukkitCopy(new ItemStack(material))); } diff --git a/patches/server/0274-mob-spawning-option-to-ignore-creative-players.patch b/patches/server/0276-mob-spawning-option-to-ignore-creative-players.patch similarity index 97% rename from patches/server/0274-mob-spawning-option-to-ignore-creative-players.patch rename to patches/server/0276-mob-spawning-option-to-ignore-creative-players.patch index c04ae12a1..f39b1c49e 100644 --- a/patches/server/0274-mob-spawning-option-to-ignore-creative-players.patch +++ b/patches/server/0276-mob-spawning-option-to-ignore-creative-players.patch @@ -5,7 +5,7 @@ Subject: [PATCH] mob spawning option to ignore creative players diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java -index 03fc9c6ef0fb320924038f2730c6f08426f0842c..029cceb339c86abe05d9eee944b60c081bffd804 100644 +index 1894348413f3b30bd9c4286fa533c1037f07f870..327a3d5cd5ea4db98e6bad90fc0bb1464033c71e 100644 --- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java +++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java @@ -260,7 +260,7 @@ public final class NaturalSpawner { diff --git a/patches/server/0275-Add-skeleton-bow-accuracy-option.patch b/patches/server/0277-Add-skeleton-bow-accuracy-option.patch similarity index 100% rename from patches/server/0275-Add-skeleton-bow-accuracy-option.patch rename to patches/server/0277-Add-skeleton-bow-accuracy-option.patch diff --git a/patches/server/0276-Allay-respect-item-NBT.patch b/patches/server/0278-Allay-respect-item-NBT.patch similarity index 94% rename from patches/server/0276-Allay-respect-item-NBT.patch rename to patches/server/0278-Allay-respect-item-NBT.patch index cf8cf91c8..9e0da4a78 100644 --- a/patches/server/0276-Allay-respect-item-NBT.patch +++ b/patches/server/0278-Allay-respect-item-NBT.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Allay respect item NBT diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java -index 15c4531865d829ea90d060ee83122a80ab39028b..379d168eb4ba958622398efa79fa43d5340ca0f2 100644 +index cff8d4a00d560ffac1a3b4b3d7dfaa9ff5fcd1d0..b9ca6f9522c004cdc337903a1e3d11d6c05cc1c6 100644 --- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java -@@ -405,9 +405,31 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS +@@ -407,9 +407,31 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS @Override public boolean wantsToPickUp(ItemStack stack) { diff --git a/patches/server/0277-Add-death-screen-API.patch b/patches/server/0279-Add-death-screen-API.patch similarity index 100% rename from patches/server/0277-Add-death-screen-API.patch rename to patches/server/0279-Add-death-screen-API.patch diff --git a/patches/removed/server/0284-Make-pufferfish-config-relocatable.patch b/patches/server/0280-Make-pufferfish-config-relocatable.patch similarity index 90% rename from patches/removed/server/0284-Make-pufferfish-config-relocatable.patch rename to patches/server/0280-Make-pufferfish-config-relocatable.patch index 932793103..8e16d6d0f 100644 --- a/patches/removed/server/0284-Make-pufferfish-config-relocatable.patch +++ b/patches/server/0280-Make-pufferfish-config-relocatable.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Make pufferfish config relocatable diff --git a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java -index 5c691db595ee412b77f729e90172bc4f8ae57226..47e77541e558e18758ae0fcc2aa4e47261e928b6 100644 +index 960c0555a001fe63de78d77d5ea47d08a520d029..b4e5fbace85c67e7bd347e6a90514bbc2c132d5e 100644 --- a/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java +++ b/src/main/java/gg/pufferfish/pufferfish/PufferfishConfig.java @@ -28,6 +28,7 @@ public class PufferfishConfig { @@ -26,7 +26,7 @@ index 5c691db595ee412b77f729e90172bc4f8ae57226..47e77541e558e18758ae0fcc2aa4e472 if (configFile.exists()) { try { diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java -index bed0267d42a8dbbd2996bd19c65d09a5ab27b5d2..582467e3419c23446b20d3076fbfce22115250a8 100644 +index fa258f1a15a93db0c3401397433b184938412a9b..41db72915baa4c02b11a701dfdde09b66ba72476 100644 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java @@ -230,6 +230,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface @@ -38,7 +38,7 @@ index bed0267d42a8dbbd2996bd19c65d09a5ab27b5d2..582467e3419c23446b20d3076fbfce22 gg.pufferfish.pufferfish.PufferfishCommand.init(); // Pufferfish diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java -index f1755b7f71672383566a9591348b5af5c658350b..d2e20a03bf031011b64d0ae15c09ab7105e0cffa 100644 +index 20aed44f6d50ff279002259c05c84e7d15904142..5afc4c3f865a21f3a2799f3a1a690f01768d9b4a 100644 --- a/src/main/java/org/bukkit/craftbukkit/Main.java +++ b/src/main/java/org/bukkit/craftbukkit/Main.java @@ -179,6 +179,12 @@ public class Main { diff --git a/patches/server/0278-Implement-ram-and-rambar-commands.patch b/patches/server/0281-Implement-ram-and-rambar-commands.patch similarity index 100% rename from patches/server/0278-Implement-ram-and-rambar-commands.patch rename to patches/server/0281-Implement-ram-and-rambar-commands.patch diff --git a/patches/server/0279-Add-item-packet-serialize-event.patch b/patches/server/0282-Add-item-packet-serialize-event.patch similarity index 92% rename from patches/server/0279-Add-item-packet-serialize-event.patch rename to patches/server/0282-Add-item-packet-serialize-event.patch index 0a6d792d8..8d37e17ae 100644 --- a/patches/server/0279-Add-item-packet-serialize-event.patch +++ b/patches/server/0282-Add-item-packet-serialize-event.patch @@ -36,10 +36,10 @@ index 9938bb90bef84cf784f9a1ceb02a1a45aa8b48a1..1f4b64a5f812376c499c98cb4be62469 this.writeId(BuiltInRegistries.ITEM, item); diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index dceb8fbf8a6d895bab0fba63b3b4c809e7e67c6a..0cbf5598a65bf9a91f85aadb717f195b373c13d3 100644 +index 5fbf050a5f6a6c59089cb67e880f02f99844e384..7c09843aafb4f744ecd0f36d6a0abc253fb5322d 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java -@@ -1543,6 +1543,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop this.getY() >= v) && (!(this instanceof Player player) || !player.getAbilities().invulnerable))) { // Paper end diff --git a/patches/server/0292-Added-got-ram-event.patch b/patches/server/0295-Added-got-ram-event.patch similarity index 86% rename from patches/server/0292-Added-got-ram-event.patch rename to patches/server/0295-Added-got-ram-event.patch index 20d3279ca..38efc1ae3 100644 --- a/patches/server/0292-Added-got-ram-event.patch +++ b/patches/server/0295-Added-got-ram-event.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Added got ram event diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -index a707954d8e5b88ed37c2640437a10781ab7e56ce..2c185cdc21534a9b50fa5c3be10be9c17485ff5d 100644 +index 1a989f9fbeaf51b9dc3ba32e1f6fb838db5af13e..07b76abf75057bc6ba5731e8c0a10d1153598928 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java -@@ -420,6 +420,7 @@ public class Goat extends Animal { +@@ -422,6 +422,7 @@ public class Goat extends Animal { // Paper start - Goat ram API public void ram(net.minecraft.world.entity.LivingEntity entity) { diff --git a/patches/server/0293-Log-skipped-entity-s-position.patch b/patches/server/0296-Log-skipped-entity-s-position.patch similarity index 86% rename from patches/server/0293-Log-skipped-entity-s-position.patch rename to patches/server/0296-Log-skipped-entity-s-position.patch index f88021f7f..cef4c4549 100644 --- a/patches/server/0293-Log-skipped-entity-s-position.patch +++ b/patches/server/0296-Log-skipped-entity-s-position.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Log skipped entity's position diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java -index e4e1245aaae94762b61a2a4663a68a625681e351..342eea645d66faecc68a5855351d6d850a5d13c7 100644 +index e413aa4650297ce2109beb6319f52fb476e291fe..a8ffa403ac48041e17aa4ce057be0539e5468fd4 100644 --- a/src/main/java/net/minecraft/world/entity/EntityType.java +++ b/src/main/java/net/minecraft/world/entity/EntityType.java -@@ -610,6 +610,12 @@ public class EntityType implements FeatureElement, EntityTypeT +@@ -612,6 +612,12 @@ public class EntityType implements FeatureElement, EntityTypeT entity.load(nbt); }, () -> { EntityType.LOGGER.warn("Skipping Entity with id {}", nbt.getString("id")); diff --git a/patches/server/0294-End-Crystal-Cramming.patch b/patches/server/0297-End-Crystal-Cramming.patch similarity index 100% rename from patches/server/0294-End-Crystal-Cramming.patch rename to patches/server/0297-End-Crystal-Cramming.patch diff --git a/patches/server/0295-Option-to-allow-beacon-effects-when-covered-by-tinte.patch b/patches/server/0298-Option-to-allow-beacon-effects-when-covered-by-tinte.patch similarity index 100% rename from patches/server/0295-Option-to-allow-beacon-effects-when-covered-by-tinte.patch rename to patches/server/0298-Option-to-allow-beacon-effects-when-covered-by-tinte.patch diff --git a/patches/server/0296-Add-attribute-clamping-and-armor-limit-config.patch b/patches/server/0299-Add-attribute-clamping-and-armor-limit-config.patch similarity index 100% rename from patches/server/0296-Add-attribute-clamping-and-armor-limit-config.patch rename to patches/server/0299-Add-attribute-clamping-and-armor-limit-config.patch diff --git a/patches/server/0297-Config-to-remove-explosion-radius-clamp.patch b/patches/server/0300-Config-to-remove-explosion-radius-clamp.patch similarity index 100% rename from patches/server/0297-Config-to-remove-explosion-radius-clamp.patch rename to patches/server/0300-Config-to-remove-explosion-radius-clamp.patch diff --git a/patches/server/0298-bonemealable-sugarcane-cactus-and-netherwart.patch b/patches/server/0301-bonemealable-sugarcane-cactus-and-netherwart.patch similarity index 100% rename from patches/server/0298-bonemealable-sugarcane-cactus-and-netherwart.patch rename to patches/server/0301-bonemealable-sugarcane-cactus-and-netherwart.patch diff --git a/patches/server/0299-Add-PreExplodeEvents.patch b/patches/server/0302-Add-PreExplodeEvents.patch similarity index 100% rename from patches/server/0299-Add-PreExplodeEvents.patch rename to patches/server/0302-Add-PreExplodeEvents.patch diff --git a/patches/server/0300-Improve-output-of-plugins-command.patch b/patches/server/0303-Improve-output-of-plugins-command.patch similarity index 100% rename from patches/server/0300-Improve-output-of-plugins-command.patch rename to patches/server/0303-Improve-output-of-plugins-command.patch diff --git a/patches/server/0301-Add-mending-multiplier.patch b/patches/server/0304-Add-mending-multiplier.patch similarity index 100% rename from patches/server/0301-Add-mending-multiplier.patch rename to patches/server/0304-Add-mending-multiplier.patch diff --git a/patches/server/0302-Make-GUI-Great-Again.patch b/patches/server/0305-Make-GUI-Great-Again.patch similarity index 99% rename from patches/server/0302-Make-GUI-Great-Again.patch rename to patches/server/0305-Make-GUI-Great-Again.patch index c71486966..f8bc36295 100644 --- a/patches/server/0302-Make-GUI-Great-Again.patch +++ b/patches/server/0305-Make-GUI-Great-Again.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Make GUI Great Again diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java -index f7238261f9797d127ff6e5dcdd62dd20bc65cdba..27dec01dbed8b1836ab5b5af579b9ed95bc09582 100644 +index 41db72915baa4c02b11a701dfdde09b66ba72476..12124d6fbc0406bb62bd95a0f7bab68afa43377c 100644 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java @@ -99,6 +99,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface