diff --git a/patches/server/0361-Anti-Xray.patch b/patches/server/0361-Anti-Xray.patch new file mode 100644 index 000000000..7a1e2464a --- /dev/null +++ b/patches/server/0361-Anti-Xray.patch @@ -0,0 +1,1638 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: stonar96 +Date: Thu, 25 Nov 2021 13:27:51 +0100 +Subject: [PATCH] Anti-Xray + + +diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +index c81364946460a6366bf70457c2025d4275f50f77..b18d35bc67f3124ca8f4a67e3dadabef52e2588a 100644 +--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java ++++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +@@ -1,11 +1,13 @@ + package com.destroystokyo.paper; + ++import java.util.Arrays; + import java.util.List; + + import java.util.stream.Collectors; + import it.unimi.dsi.fastutil.objects.Reference2IntMap; + import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; + import net.minecraft.world.entity.MobCategory; ++import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode; + import org.bukkit.Bukkit; + import org.bukkit.configuration.file.YamlConfiguration; + import org.spigotmc.SpigotWorldConfig; +@@ -523,5 +525,40 @@ public class PaperWorldConfig { + private void lightQueueSize() { + lightQueueSize = getInt("light-queue-size", lightQueueSize); + } ++ ++ public boolean antiXray; ++ public EngineMode engineMode; ++ public int maxBlockHeight; ++ public int updateRadius; ++ public boolean lavaObscures; ++ public boolean usePermission; ++ public List hiddenBlocks; ++ public List replacementBlocks; ++ private void antiXray() { ++ antiXray = getBoolean("anti-xray.enabled", false); ++ engineMode = EngineMode.getById(getInt("anti-xray.engine-mode", EngineMode.HIDE.getId())); ++ engineMode = engineMode == null ? EngineMode.HIDE : engineMode; ++ maxBlockHeight = getInt("anti-xray.max-block-height", 64); ++ updateRadius = getInt("anti-xray.update-radius", 2); ++ lavaObscures = getBoolean("anti-xray.lava-obscures", false); ++ usePermission = getBoolean("anti-xray.use-permission", false); ++ hiddenBlocks = getList("anti-xray.hidden-blocks", Arrays.asList("copper_ore", "deepslate_copper_ore", "gold_ore", "deepslate_gold_ore", "iron_ore", "deepslate_iron_ore", ++ "coal_ore", "deepslate_coal_ore", "lapis_ore", "deepslate_lapis_ore", "mossy_cobblestone", "obsidian", "chest", "diamond_ore", "deepslate_diamond_ore", ++ "redstone_ore", "deepslate_redstone_ore", "clay", "emerald_ore", "deepslate_emerald_ore", "ender_chest")); ++ replacementBlocks = getList("anti-xray.replacement-blocks", Arrays.asList("stone", "oak_planks", "deepslate")); ++ if (PaperConfig.version < 19) { ++ hiddenBlocks.remove("lit_redstone_ore"); ++ int index = replacementBlocks.indexOf("planks"); ++ if (index != -1) { ++ replacementBlocks.set(index, "oak_planks"); ++ } ++ set("anti-xray.hidden-blocks", hiddenBlocks); ++ set("anti-xray.replacement-blocks", replacementBlocks); ++ } ++ log("Anti-Xray: " + (antiXray ? "enabled" : "disabled") + " / Engine Mode: " + engineMode.getDescription() + " / Up to " + ((maxBlockHeight >> 4) << 4) + " blocks / Update Radius: " + updateRadius); ++ if (antiXray && usePermission) { ++ Bukkit.getLogger().warning("You have enabled permission-based Anti-Xray checking - depending on your permission plugin, this may cause performance issues"); ++ } ++ } + } + +diff --git a/src/main/java/com/destroystokyo/paper/antixray/BitStorageReader.java b/src/main/java/com/destroystokyo/paper/antixray/BitStorageReader.java +new file mode 100644 +index 0000000000000000000000000000000000000000..e448c26327b5f6189c3c52e698cff66c8f9ad81a +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/BitStorageReader.java +@@ -0,0 +1,51 @@ ++package com.destroystokyo.paper.antixray; ++ ++public final class BitStorageReader { ++ ++ private byte[] buffer; ++ private int bits; ++ private int mask; ++ private int longInBufferIndex; ++ private int bitInLongIndex; ++ private long current; ++ ++ public void setBuffer(byte[] buffer) { ++ this.buffer = buffer; ++ } ++ ++ public void setBits(int bits) { ++ this.bits = bits; ++ mask = (1 << bits) - 1; ++ } ++ ++ public void setIndex(int index) { ++ longInBufferIndex = index; ++ bitInLongIndex = 0; ++ init(); ++ } ++ ++ private void init() { ++ if (buffer.length > longInBufferIndex + 7) { ++ current = ((((long) buffer[longInBufferIndex]) << 56) ++ | (((long) buffer[longInBufferIndex + 1] & 0xff) << 48) ++ | (((long) buffer[longInBufferIndex + 2] & 0xff) << 40) ++ | (((long) buffer[longInBufferIndex + 3] & 0xff) << 32) ++ | (((long) buffer[longInBufferIndex + 4] & 0xff) << 24) ++ | (((long) buffer[longInBufferIndex + 5] & 0xff) << 16) ++ | (((long) buffer[longInBufferIndex + 6] & 0xff) << 8) ++ | (((long) buffer[longInBufferIndex + 7] & 0xff))); ++ } ++ } ++ ++ public int read() { ++ if (bitInLongIndex + bits > 64) { ++ bitInLongIndex = 0; ++ longInBufferIndex += 8; ++ init(); ++ } ++ ++ int value = (int) (current >>> bitInLongIndex) & mask; ++ bitInLongIndex += bits; ++ return value; ++ } ++} +diff --git a/src/main/java/com/destroystokyo/paper/antixray/BitStorageWriter.java b/src/main/java/com/destroystokyo/paper/antixray/BitStorageWriter.java +new file mode 100644 +index 0000000000000000000000000000000000000000..e4540ea278f2dc871cb6a3cb8897559bfd65e134 +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/BitStorageWriter.java +@@ -0,0 +1,79 @@ ++package com.destroystokyo.paper.antixray; ++ ++public final class BitStorageWriter { ++ ++ private byte[] buffer; ++ private int bits; ++ private long mask; ++ private int longInBufferIndex; ++ private int bitInLongIndex; ++ private long current; ++ private boolean dirty; ++ ++ public void setBuffer(byte[] buffer) { ++ this.buffer = buffer; ++ } ++ ++ public void setBits(int bits) { ++ this.bits = bits; ++ mask = (1L << bits) - 1; ++ } ++ ++ public void setIndex(int index) { ++ longInBufferIndex = index; ++ bitInLongIndex = 0; ++ init(); ++ } ++ ++ private void init() { ++ if (buffer.length > longInBufferIndex + 7) { ++ current = ((((long) buffer[longInBufferIndex]) << 56) ++ | (((long) buffer[longInBufferIndex + 1] & 0xff) << 48) ++ | (((long) buffer[longInBufferIndex + 2] & 0xff) << 40) ++ | (((long) buffer[longInBufferIndex + 3] & 0xff) << 32) ++ | (((long) buffer[longInBufferIndex + 4] & 0xff) << 24) ++ | (((long) buffer[longInBufferIndex + 5] & 0xff) << 16) ++ | (((long) buffer[longInBufferIndex + 6] & 0xff) << 8) ++ | (((long) buffer[longInBufferIndex + 7] & 0xff))); ++ } ++ ++ dirty = false; ++ } ++ ++ public void flush() { ++ if (dirty && buffer.length > longInBufferIndex + 7) { ++ buffer[longInBufferIndex] = (byte) (current >> 56 & 0xff); ++ buffer[longInBufferIndex + 1] = (byte) (current >> 48 & 0xff); ++ buffer[longInBufferIndex + 2] = (byte) (current >> 40 & 0xff); ++ buffer[longInBufferIndex + 3] = (byte) (current >> 32 & 0xff); ++ buffer[longInBufferIndex + 4] = (byte) (current >> 24 & 0xff); ++ buffer[longInBufferIndex + 5] = (byte) (current >> 16 & 0xff); ++ buffer[longInBufferIndex + 6] = (byte) (current >> 8 & 0xff); ++ buffer[longInBufferIndex + 7] = (byte) (current & 0xff); ++ } ++ } ++ ++ public void write(int value) { ++ if (bitInLongIndex + bits > 64) { ++ flush(); ++ bitInLongIndex = 0; ++ longInBufferIndex += 8; ++ init(); ++ } ++ ++ current = current & ~(mask << bitInLongIndex) | (value & mask) << bitInLongIndex; ++ dirty = true; ++ bitInLongIndex += bits; ++ } ++ ++ public void skip() { ++ bitInLongIndex += bits; ++ ++ if (bitInLongIndex > 64) { ++ flush(); ++ bitInLongIndex = bits; ++ longInBufferIndex += 8; ++ init(); ++ } ++ } ++} +diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java +new file mode 100644 +index 0000000000000000000000000000000000000000..aabad39d13ead83042ec2e4dd7f4ed4966af650d +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockController.java +@@ -0,0 +1,45 @@ ++package com.destroystokyo.paper.antixray; ++ ++import net.minecraft.core.BlockPos; ++import net.minecraft.core.Direction; ++import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket; ++import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket; ++import net.minecraft.server.level.ServerPlayer; ++import net.minecraft.server.level.ServerPlayerGameMode; ++import net.minecraft.world.level.ChunkPos; ++import net.minecraft.world.level.Level; ++import net.minecraft.world.level.block.state.BlockState; ++import net.minecraft.world.level.chunk.LevelChunk; ++ ++public class ChunkPacketBlockController { ++ ++ public static final ChunkPacketBlockController NO_OPERATION_INSTANCE = new ChunkPacketBlockController(); ++ ++ protected ChunkPacketBlockController() { ++ ++ } ++ ++ public BlockState[] getPresetBlockStates(Level level, ChunkPos chunkPos, int bottomBlockY) { ++ return null; ++ } ++ ++ public boolean shouldModify(ServerPlayer player, LevelChunk chunk) { ++ return false; ++ } ++ ++ public ChunkPacketInfo getChunkPacketInfo(ClientboundLevelChunkWithLightPacket chunkPacket, LevelChunk chunk) { ++ return null; ++ } ++ ++ public void modifyBlocks(ClientboundLevelChunkWithLightPacket chunkPacket, ChunkPacketInfo chunkPacketInfo) { ++ chunkPacket.setReady(true); ++ } ++ ++ public void onBlockChange(Level level, BlockPos blockPos, BlockState newBlockState, BlockState oldBlockState, int flags, int maxUpdateDepth) { ++ ++ } ++ ++ public void onPlayerLeftClickBlock(ServerPlayerGameMode serverPlayerGameMode, BlockPos blockPos, ServerboundPlayerActionPacket.Action action, Direction direction, int worldHeight) { ++ ++ } ++} +diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java +new file mode 100644 +index 0000000000000000000000000000000000000000..999b39127a42c2ccec0be4110c93453d38bda397 +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketBlockControllerAntiXray.java +@@ -0,0 +1,659 @@ ++package com.destroystokyo.paper.antixray; ++ ++import com.destroystokyo.paper.PaperWorldConfig; ++import net.minecraft.core.BlockPos; ++import net.minecraft.core.Direction; ++import net.minecraft.core.Registry; ++import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket; ++import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket; ++import net.minecraft.resources.ResourceLocation; ++import net.minecraft.server.MinecraftServer; ++import net.minecraft.server.level.ServerLevel; ++import net.minecraft.server.level.ServerPlayer; ++import net.minecraft.server.level.ServerPlayerGameMode; ++import net.minecraft.world.level.ChunkPos; ++import net.minecraft.world.level.Level; ++import net.minecraft.world.level.block.Block; ++import net.minecraft.world.level.block.Blocks; ++import net.minecraft.world.level.block.EntityBlock; ++import net.minecraft.world.level.block.state.BlockState; ++import net.minecraft.world.level.chunk.*; ++import org.bukkit.Bukkit; ++ ++import java.util.*; ++import java.util.concurrent.Executor; ++import java.util.concurrent.ThreadLocalRandom; ++import java.util.function.IntSupplier; ++ ++public final class ChunkPacketBlockControllerAntiXray extends ChunkPacketBlockController { ++ ++ private static final Palette GLOBAL_BLOCKSTATE_PALETTE = new GlobalPalette<>(Block.BLOCK_STATE_REGISTRY); ++ private static final LevelChunkSection EMPTY_SECTION = null; ++ private final Executor executor; ++ private final EngineMode engineMode; ++ private final int maxBlockHeight; ++ private final int updateRadius; ++ private final boolean usePermission; ++ private final BlockState[] presetBlockStates; ++ private final BlockState[] presetBlockStatesFull; ++ private final BlockState[] presetBlockStatesStone; ++ private final BlockState[] presetBlockStatesNetherrack; ++ private final BlockState[] presetBlockStatesEndStone; ++ private final int[] presetBlockStateBitsGlobal; ++ private final int[] presetBlockStateBitsStoneGlobal; ++ private final int[] presetBlockStateBitsNetherrackGlobal; ++ private final int[] presetBlockStateBitsEndStoneGlobal; ++ private final boolean[] solidGlobal = new boolean[Block.BLOCK_STATE_REGISTRY.size()]; ++ private final boolean[] obfuscateGlobal = new boolean[Block.BLOCK_STATE_REGISTRY.size()]; ++ private final LevelChunkSection[] emptyNearbyChunkSections = {EMPTY_SECTION, EMPTY_SECTION, EMPTY_SECTION, EMPTY_SECTION}; ++ private final int maxBlockHeightUpdatePosition; ++ ++ public ChunkPacketBlockControllerAntiXray(Level level, Executor executor) { ++ this.executor = executor; ++ PaperWorldConfig paperWorldConfig = level.paperConfig; ++ engineMode = paperWorldConfig.engineMode; ++ maxBlockHeight = paperWorldConfig.maxBlockHeight >> 4 << 4; ++ updateRadius = paperWorldConfig.updateRadius; ++ usePermission = paperWorldConfig.usePermission; ++ List toObfuscate; ++ ++ if (engineMode == EngineMode.HIDE) { ++ toObfuscate = paperWorldConfig.hiddenBlocks; ++ presetBlockStates = null; ++ presetBlockStatesFull = null; ++ presetBlockStatesStone = new BlockState[]{Blocks.STONE.defaultBlockState()}; ++ presetBlockStatesNetherrack = new BlockState[]{Blocks.NETHERRACK.defaultBlockState()}; ++ presetBlockStatesEndStone = new BlockState[]{Blocks.END_STONE.defaultBlockState()}; ++ presetBlockStateBitsGlobal = null; ++ presetBlockStateBitsStoneGlobal = new int[]{GLOBAL_BLOCKSTATE_PALETTE.idFor(Blocks.STONE.defaultBlockState())}; ++ presetBlockStateBitsNetherrackGlobal = new int[]{GLOBAL_BLOCKSTATE_PALETTE.idFor(Blocks.NETHERRACK.defaultBlockState())}; ++ presetBlockStateBitsEndStoneGlobal = new int[]{GLOBAL_BLOCKSTATE_PALETTE.idFor(Blocks.END_STONE.defaultBlockState())}; ++ } else { ++ toObfuscate = new ArrayList<>(paperWorldConfig.replacementBlocks); ++ List presetBlockStateList = new LinkedList<>(); ++ ++ for (String id : paperWorldConfig.hiddenBlocks) { ++ Block block = Registry.BLOCK.getOptional(new ResourceLocation(id)).orElse(null); ++ ++ if (block != null && !(block instanceof EntityBlock)) { ++ toObfuscate.add(id); ++ presetBlockStateList.add(block.defaultBlockState()); ++ } ++ } ++ ++ // The doc of the LinkedHashSet(Collection) constructor doesn't specify that the insertion order is the predictable iteration order of the specified Collection, although it is in the implementation ++ Set presetBlockStateSet = new LinkedHashSet<>(); ++ // Therefore addAll(Collection) is used, which guarantees this order in the doc ++ presetBlockStateSet.addAll(presetBlockStateList); ++ presetBlockStates = presetBlockStateSet.isEmpty() ? new BlockState[]{Blocks.DIAMOND_ORE.defaultBlockState()} : presetBlockStateSet.toArray(new BlockState[0]); ++ presetBlockStatesFull = presetBlockStateSet.isEmpty() ? new BlockState[]{Blocks.DIAMOND_ORE.defaultBlockState()} : presetBlockStateList.toArray(new BlockState[0]); ++ presetBlockStatesStone = null; ++ presetBlockStatesNetherrack = null; ++ presetBlockStatesEndStone = null; ++ presetBlockStateBitsGlobal = new int[presetBlockStatesFull.length]; ++ ++ for (int i = 0; i < presetBlockStatesFull.length; i++) { ++ presetBlockStateBitsGlobal[i] = GLOBAL_BLOCKSTATE_PALETTE.idFor(presetBlockStatesFull[i]); ++ } ++ ++ presetBlockStateBitsStoneGlobal = null; ++ presetBlockStateBitsNetherrackGlobal = null; ++ presetBlockStateBitsEndStoneGlobal = null; ++ } ++ ++ for (String id : toObfuscate) { ++ Block block = Registry.BLOCK.getOptional(new ResourceLocation(id)).orElse(null); ++ ++ // Don't obfuscate air because air causes unnecessary block updates and causes block updates to fail in the void ++ if (block != null && !block.defaultBlockState().isAir()) { ++ // Replace all block states of a specified block ++ for (BlockState blockState : block.getStateDefinition().getPossibleStates()) { ++ obfuscateGlobal[GLOBAL_BLOCKSTATE_PALETTE.idFor(blockState)] = true; ++ } ++ } ++ } ++ ++ EmptyLevelChunk emptyChunk = new EmptyLevelChunk(level, new ChunkPos(0, 0)); ++ BlockPos zeroPos = new BlockPos(0, 0, 0); ++ ++ for (int i = 0; i < solidGlobal.length; i++) { ++ BlockState blockState = GLOBAL_BLOCKSTATE_PALETTE.valueFor(i); ++ ++ if (blockState != null) { ++ solidGlobal[i] = blockState.isRedstoneConductor(emptyChunk, zeroPos) ++ && blockState.getBlock() != Blocks.SPAWNER && blockState.getBlock() != Blocks.BARRIER && blockState.getBlock() != Blocks.SHULKER_BOX && blockState.getBlock() != Blocks.SLIME_BLOCK || paperWorldConfig.lavaObscures && blockState == Blocks.LAVA.defaultBlockState(); ++ // Comparing blockState == Blocks.LAVA.defaultBlockState() instead of blockState.getBlock() == Blocks.LAVA ensures that only "stationary lava" is used ++ // shulker box checks TE. ++ } ++ } ++ ++ maxBlockHeightUpdatePosition = maxBlockHeight + updateRadius - 1; ++ } ++ ++ private int getPresetBlockStatesFullLength() { ++ return engineMode == EngineMode.HIDE ? 1 : presetBlockStatesFull.length; ++ } ++ ++ @Override ++ public BlockState[] getPresetBlockStates(Level level, ChunkPos chunkPos, int bottomBlockY) { ++ // Return the block states to be added to the paletted containers so that they can be used for obfuscation ++ if (bottomBlockY < maxBlockHeight) { ++ if (engineMode == EngineMode.HIDE) { ++ return switch (level.getWorld().getEnvironment()) { ++ case NETHER -> presetBlockStatesNetherrack; ++ case THE_END -> presetBlockStatesEndStone; ++ default -> presetBlockStatesStone; ++ }; ++ } ++ ++ return presetBlockStates; ++ } ++ ++ return null; ++ } ++ ++ @Override ++ public boolean shouldModify(ServerPlayer player, LevelChunk chunk) { ++ return !usePermission || !player.getBukkitEntity().hasPermission("paper.antixray.bypass"); ++ } ++ ++ @Override ++ public ChunkPacketInfoAntiXray getChunkPacketInfo(ClientboundLevelChunkWithLightPacket chunkPacket, LevelChunk chunk) { ++ // Return a new instance to collect data and objects in the right state while creating the chunk packet for thread safe access later ++ return new ChunkPacketInfoAntiXray(chunkPacket, chunk, this); ++ } ++ ++ @Override ++ public void modifyBlocks(ClientboundLevelChunkWithLightPacket chunkPacket, ChunkPacketInfo chunkPacketInfo) { ++ if (!(chunkPacketInfo instanceof ChunkPacketInfoAntiXray)) { ++ chunkPacket.setReady(true); ++ return; ++ } ++ ++ if (!Bukkit.isPrimaryThread()) { ++ // Plugins? ++ MinecraftServer.getServer().scheduleOnMain(() -> modifyBlocks(chunkPacket, chunkPacketInfo)); ++ return; ++ } ++ ++ LevelChunk chunk = chunkPacketInfo.getChunk(); ++ int x = chunk.getPos().x; ++ int z = chunk.getPos().z; ++ Level level = chunk.getLevel(); ++ ((ChunkPacketInfoAntiXray) chunkPacketInfo).setNearbyChunks(level.getChunkIfLoaded(x - 1, z), level.getChunkIfLoaded(x + 1, z), level.getChunkIfLoaded(x, z - 1), level.getChunkIfLoaded(x, z + 1)); ++ executor.execute((Runnable) chunkPacketInfo); ++ } ++ ++ // Actually these fields should be variables inside the obfuscate method but in sync mode or with SingleThreadExecutor in async mode it's okay (even without ThreadLocal) ++ // If an ExecutorService with multiple threads is used, ThreadLocal must be used here ++ private final ThreadLocal presetBlockStateBits = ThreadLocal.withInitial(() -> new int[getPresetBlockStatesFullLength()]); ++ private static final ThreadLocal SOLID = ThreadLocal.withInitial(() -> new boolean[Block.BLOCK_STATE_REGISTRY.size()]); ++ private static final ThreadLocal OBFUSCATE = ThreadLocal.withInitial(() -> new boolean[Block.BLOCK_STATE_REGISTRY.size()]); ++ // These boolean arrays represent chunk layers, true means don't obfuscate, false means obfuscate ++ private static final ThreadLocal CURRENT = ThreadLocal.withInitial(() -> new boolean[16][16]); ++ private static final ThreadLocal NEXT = ThreadLocal.withInitial(() -> new boolean[16][16]); ++ private static final ThreadLocal NEXT_NEXT = ThreadLocal.withInitial(() -> new boolean[16][16]); ++ ++ public void obfuscate(ChunkPacketInfoAntiXray chunkPacketInfoAntiXray) { ++ int[] presetBlockStateBits = this.presetBlockStateBits.get(); ++ boolean[] solid = SOLID.get(); ++ boolean[] obfuscate = OBFUSCATE.get(); ++ boolean[][] current = CURRENT.get(); ++ boolean[][] next = NEXT.get(); ++ boolean[][] nextNext = NEXT_NEXT.get(); ++ // bitStorageReader, bitStorageWriter and nearbyChunkSections could also be reused (with ThreadLocal if necessary) but it's not worth it ++ BitStorageReader bitStorageReader = new BitStorageReader(); ++ BitStorageWriter bitStorageWriter = new BitStorageWriter(); ++ LevelChunkSection[] nearbyChunkSections = new LevelChunkSection[4]; ++ LevelChunk chunk = chunkPacketInfoAntiXray.getChunk(); ++ Level level = chunk.getLevel(); ++ int maxChunkSectionIndex = Math.min((maxBlockHeight >> 4) - chunk.getMinSection(), chunk.getSectionsCount() - 1); ++ boolean[] solidTemp = null; ++ boolean[] obfuscateTemp = null; ++ bitStorageReader.setBuffer(chunkPacketInfoAntiXray.getBuffer()); ++ bitStorageWriter.setBuffer(chunkPacketInfoAntiXray.getBuffer()); ++ int numberOfBlocks = presetBlockStateBits.length; ++ // Keep the lambda expressions as simple as possible. They are used very frequently. ++ IntSupplier random = numberOfBlocks == 1 ? (() -> 0) : new IntSupplier() { ++ private int state; ++ ++ { ++ while ((state = ThreadLocalRandom.current().nextInt()) == 0) ; ++ } ++ ++ @Override ++ public int getAsInt() { ++ // https://en.wikipedia.org/wiki/Xorshift ++ state ^= state << 13; ++ state ^= state >>> 17; ++ state ^= state << 5; ++ // https://www.pcg-random.org/posts/bounded-rands.html ++ return (int) ((Integer.toUnsignedLong(state) * numberOfBlocks) >>> 32); ++ } ++ }; ++ ++ for (int chunkSectionIndex = 0; chunkSectionIndex <= maxChunkSectionIndex; chunkSectionIndex++) { ++ if (chunkPacketInfoAntiXray.isWritten(chunkSectionIndex) && chunkPacketInfoAntiXray.getPresetValues(chunkSectionIndex) != null) { ++ int[] presetBlockStateBitsTemp; ++ ++ if (chunkPacketInfoAntiXray.getPalette(chunkSectionIndex) instanceof GlobalPalette) { ++ if (engineMode == EngineMode.HIDE) { ++ presetBlockStateBitsTemp = switch (level.getWorld().getEnvironment()) { ++ case NETHER -> presetBlockStateBitsNetherrackGlobal; ++ case THE_END -> presetBlockStateBitsEndStoneGlobal; ++ default -> presetBlockStateBitsStoneGlobal; ++ }; ++ } else { ++ presetBlockStateBitsTemp = presetBlockStateBitsGlobal; ++ } ++ } else { ++ // If it's presetBlockStates, use this.presetBlockStatesFull instead ++ BlockState[] presetBlockStatesFull = chunkPacketInfoAntiXray.getPresetValues(chunkSectionIndex) == presetBlockStates ? this.presetBlockStatesFull : chunkPacketInfoAntiXray.getPresetValues(chunkSectionIndex); ++ presetBlockStateBitsTemp = presetBlockStateBits; ++ ++ for (int i = 0; i < presetBlockStateBitsTemp.length; i++) { ++ // This is thread safe because we only request IDs that are guaranteed to be in the palette and are visible ++ // For more details see the comments in the readPalette method ++ presetBlockStateBitsTemp[i] = chunkPacketInfoAntiXray.getPalette(chunkSectionIndex).idFor(presetBlockStatesFull[i]); ++ } ++ } ++ ++ bitStorageWriter.setIndex(chunkPacketInfoAntiXray.getIndex(chunkSectionIndex)); ++ ++ // Check if the chunk section below was not obfuscated ++ if (chunkSectionIndex == 0 || !chunkPacketInfoAntiXray.isWritten(chunkSectionIndex - 1) || chunkPacketInfoAntiXray.getPresetValues(chunkSectionIndex - 1) == null) { ++ // If so, initialize some stuff ++ bitStorageReader.setBits(chunkPacketInfoAntiXray.getBits(chunkSectionIndex)); ++ bitStorageReader.setIndex(chunkPacketInfoAntiXray.getIndex(chunkSectionIndex)); ++ solidTemp = readPalette(chunkPacketInfoAntiXray.getPalette(chunkSectionIndex), solid, solidGlobal); ++ obfuscateTemp = readPalette(chunkPacketInfoAntiXray.getPalette(chunkSectionIndex), obfuscate, obfuscateGlobal); ++ // Read the blocks of the upper layer of the chunk section below if it exists ++ LevelChunkSection belowChunkSection = null; ++ boolean skipFirstLayer = chunkSectionIndex == 0 || (belowChunkSection = chunk.getSections()[chunkSectionIndex - 1]) == EMPTY_SECTION; ++ ++ for (int z = 0; z < 16; z++) { ++ for (int x = 0; x < 16; x++) { ++ current[z][x] = true; ++ next[z][x] = skipFirstLayer || isTransparent(belowChunkSection, x, 15, z); ++ } ++ } ++ ++ // Abuse the obfuscateLayer method to read the blocks of the first layer of the current chunk section ++ bitStorageWriter.setBits(0); ++ obfuscateLayer(-1, bitStorageReader, bitStorageWriter, solidTemp, obfuscateTemp, presetBlockStateBitsTemp, current, next, nextNext, emptyNearbyChunkSections, random); ++ } ++ ++ bitStorageWriter.setBits(chunkPacketInfoAntiXray.getBits(chunkSectionIndex)); ++ nearbyChunkSections[0] = chunkPacketInfoAntiXray.getNearbyChunks()[0] == null ? EMPTY_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[0].getSections()[chunkSectionIndex]; ++ nearbyChunkSections[1] = chunkPacketInfoAntiXray.getNearbyChunks()[1] == null ? EMPTY_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[1].getSections()[chunkSectionIndex]; ++ nearbyChunkSections[2] = chunkPacketInfoAntiXray.getNearbyChunks()[2] == null ? EMPTY_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[2].getSections()[chunkSectionIndex]; ++ nearbyChunkSections[3] = chunkPacketInfoAntiXray.getNearbyChunks()[3] == null ? EMPTY_SECTION : chunkPacketInfoAntiXray.getNearbyChunks()[3].getSections()[chunkSectionIndex]; ++ ++ // Obfuscate all layers of the current chunk section except the upper one ++ for (int y = 0; y < 15; y++) { ++ boolean[][] temp = current; ++ current = next; ++ next = nextNext; ++ nextNext = temp; ++ obfuscateLayer(y, bitStorageReader, bitStorageWriter, solidTemp, obfuscateTemp, presetBlockStateBitsTemp, current, next, nextNext, nearbyChunkSections, random); ++ } ++ ++ // Check if the chunk section above doesn't need obfuscation ++ if (chunkSectionIndex == maxChunkSectionIndex || !chunkPacketInfoAntiXray.isWritten(chunkSectionIndex + 1) || chunkPacketInfoAntiXray.getPresetValues(chunkSectionIndex + 1) == null) { ++ // If so, obfuscate the upper layer of the current chunk section by reading blocks of the first layer from the chunk section above if it exists ++ LevelChunkSection aboveChunkSection; ++ ++ if (chunkSectionIndex != chunk.getSectionsCount() - 1 && (aboveChunkSection = chunk.getSections()[chunkSectionIndex + 1]) != EMPTY_SECTION) { ++ boolean[][] temp = current; ++ current = next; ++ next = nextNext; ++ nextNext = temp; ++ ++ for (int z = 0; z < 16; z++) { ++ for (int x = 0; x < 16; x++) { ++ if (isTransparent(aboveChunkSection, x, 0, z)) { ++ current[z][x] = true; ++ } ++ } ++ } ++ ++ // There is nothing to read anymore ++ bitStorageReader.setBits(0); ++ solid[0] = true; ++ obfuscateLayer(15, bitStorageReader, bitStorageWriter, solid, obfuscateTemp, presetBlockStateBitsTemp, current, next, nextNext, nearbyChunkSections, random); ++ } ++ } else { ++ // If not, initialize the reader and other stuff for the chunk section above to obfuscate the upper layer of the current chunk section ++ bitStorageReader.setBits(chunkPacketInfoAntiXray.getBits(chunkSectionIndex + 1)); ++ bitStorageReader.setIndex(chunkPacketInfoAntiXray.getIndex(chunkSectionIndex + 1)); ++ solidTemp = readPalette(chunkPacketInfoAntiXray.getPalette(chunkSectionIndex + 1), solid, solidGlobal); ++ obfuscateTemp = readPalette(chunkPacketInfoAntiXray.getPalette(chunkSectionIndex + 1), obfuscate, obfuscateGlobal); ++ boolean[][] temp = current; ++ current = next; ++ next = nextNext; ++ nextNext = temp; ++ obfuscateLayer(15, bitStorageReader, bitStorageWriter, solidTemp, obfuscateTemp, presetBlockStateBitsTemp, current, next, nextNext, nearbyChunkSections, random); ++ } ++ ++ bitStorageWriter.flush(); ++ } ++ } ++ ++ chunkPacketInfoAntiXray.getChunkPacket().setReady(true); ++ } ++ ++ private void obfuscateLayer(int y, BitStorageReader bitStorageReader, BitStorageWriter bitStorageWriter, boolean[] solid, boolean[] obfuscate, int[] presetBlockStateBits, boolean[][] current, boolean[][] next, boolean[][] nextNext, LevelChunkSection[] nearbyChunkSections, IntSupplier random) { ++ // First block of first line ++ int bits = bitStorageReader.read(); ++ ++ if (nextNext[0][0] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[0][1] = true; ++ next[1][0] = true; ++ } else { ++ if (current[0][0] || isTransparent(nearbyChunkSections[2], 0, y, 15) || isTransparent(nearbyChunkSections[0], 15, y, 0)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[0][0] = true; ++ } ++ ++ // First line ++ for (int x = 1; x < 15; x++) { ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[0][x] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[0][x - 1] = true; ++ next[0][x + 1] = true; ++ next[1][x] = true; ++ } else { ++ if (current[0][x] || isTransparent(nearbyChunkSections[2], x, y, 15)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[0][x] = true; ++ } ++ } ++ ++ // Last block of first line ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[0][15] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[0][14] = true; ++ next[1][15] = true; ++ } else { ++ if (current[0][15] || isTransparent(nearbyChunkSections[2], 15, y, 15) || isTransparent(nearbyChunkSections[1], 0, y, 0)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[0][15] = true; ++ } ++ ++ // All inner lines ++ for (int z = 1; z < 15; z++) { ++ // First block ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[z][0] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[z][1] = true; ++ next[z - 1][0] = true; ++ next[z + 1][0] = true; ++ } else { ++ if (current[z][0] || isTransparent(nearbyChunkSections[0], 15, y, z)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[z][0] = true; ++ } ++ ++ // All inner blocks ++ for (int x = 1; x < 15; x++) { ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[z][x] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[z][x - 1] = true; ++ next[z][x + 1] = true; ++ next[z - 1][x] = true; ++ next[z + 1][x] = true; ++ } else { ++ if (current[z][x]) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[z][x] = true; ++ } ++ } ++ ++ // Last block ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[z][15] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[z][14] = true; ++ next[z - 1][15] = true; ++ next[z + 1][15] = true; ++ } else { ++ if (current[z][15] || isTransparent(nearbyChunkSections[1], 0, y, z)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[z][15] = true; ++ } ++ } ++ ++ // First block of last line ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[15][0] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[15][1] = true; ++ next[14][0] = true; ++ } else { ++ if (current[15][0] || isTransparent(nearbyChunkSections[3], 0, y, 0) || isTransparent(nearbyChunkSections[0], 15, y, 15)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[15][0] = true; ++ } ++ ++ // Last line ++ for (int x = 1; x < 15; x++) { ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[15][x] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[15][x - 1] = true; ++ next[15][x + 1] = true; ++ next[14][x] = true; ++ } else { ++ if (current[15][x] || isTransparent(nearbyChunkSections[3], x, y, 0)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[15][x] = true; ++ } ++ } ++ ++ // Last block of last line ++ bits = bitStorageReader.read(); ++ ++ if (nextNext[15][15] = !solid[bits]) { ++ bitStorageWriter.skip(); ++ next[15][14] = true; ++ next[14][15] = true; ++ } else { ++ if (current[15][15] || isTransparent(nearbyChunkSections[3], 15, y, 0) || isTransparent(nearbyChunkSections[1], 0, y, 15)) { ++ bitStorageWriter.skip(); ++ } else { ++ bitStorageWriter.write(presetBlockStateBits[random.getAsInt()]); ++ } ++ } ++ ++ if (!obfuscate[bits]) { ++ next[15][15] = true; ++ } ++ } ++ ++ private boolean isTransparent(LevelChunkSection chunkSection, int x, int y, int z) { ++ if (chunkSection == EMPTY_SECTION) { ++ return true; ++ } ++ ++ try { ++ return !solidGlobal[GLOBAL_BLOCKSTATE_PALETTE.idFor(chunkSection.getBlockState(x, y, z))]; ++ } catch (MissingPaletteEntryException e) { ++ // Race condition / visibility issue / no happens-before relationship ++ // We don't care and treat the block as transparent ++ // Internal implementation details of PalettedContainer, LinearPalette, HashMapPalette, CrudeIncrementalIntIdentityHashBiMap, ... guarantee us that no (other) exceptions will occur ++ return true; ++ } ++ } ++ ++ private boolean[] readPalette(Palette palette, boolean[] temp, boolean[] global) { ++ if (palette instanceof GlobalPalette) { ++ return global; ++ } ++ ++ try { ++ for (int i = 0; i < palette.getSize(); i++) { ++ temp[i] = global[GLOBAL_BLOCKSTATE_PALETTE.idFor(palette.valueFor(i))]; ++ } ++ } catch (MissingPaletteEntryException e) { ++ // Race condition / visibility issue / no happens-before relationship ++ // We don't care because we at least see the state as it was when the chunk packet was created ++ // Internal implementation details of PalettedContainer, LinearPalette, HashMapPalette, CrudeIncrementalIntIdentityHashBiMap, ... guarantee us that no (other) exceptions will occur until we have all the data that we need here ++ // Since all palettes have a fixed initial maximum size and there is no internal restructuring and no values are removed from palettes, we are also guaranteed to see the data ++ } ++ ++ return temp; ++ } ++ ++ @Override ++ public void onBlockChange(Level level, BlockPos blockPos, BlockState newBlockState, BlockState oldBlockState, int flags, int maxUpdateDepth) { ++ if (oldBlockState != null && solidGlobal[GLOBAL_BLOCKSTATE_PALETTE.idFor(oldBlockState)] && !solidGlobal[GLOBAL_BLOCKSTATE_PALETTE.idFor(newBlockState)] && blockPos.getY() <= maxBlockHeightUpdatePosition) { ++ updateNearbyBlocks(level, blockPos); ++ } ++ } ++ ++ @Override ++ public void onPlayerLeftClickBlock(ServerPlayerGameMode serverPlayerGameMode, BlockPos blockPos, ServerboundPlayerActionPacket.Action action, Direction direction, int worldHeight) { ++ if (blockPos.getY() <= maxBlockHeightUpdatePosition) { ++ updateNearbyBlocks(serverPlayerGameMode.level, blockPos); ++ } ++ } ++ ++ private void updateNearbyBlocks(Level level, BlockPos blockPos) { ++ if (updateRadius >= 2) { ++ BlockPos temp = blockPos.west(); ++ updateBlock(level, temp); ++ updateBlock(level, temp.west()); ++ updateBlock(level, temp.below()); ++ updateBlock(level, temp.above()); ++ updateBlock(level, temp.north()); ++ updateBlock(level, temp.south()); ++ updateBlock(level, temp = blockPos.east()); ++ updateBlock(level, temp.east()); ++ updateBlock(level, temp.below()); ++ updateBlock(level, temp.above()); ++ updateBlock(level, temp.north()); ++ updateBlock(level, temp.south()); ++ updateBlock(level, temp = blockPos.below()); ++ updateBlock(level, temp.below()); ++ updateBlock(level, temp.north()); ++ updateBlock(level, temp.south()); ++ updateBlock(level, temp = blockPos.above()); ++ updateBlock(level, temp.above()); ++ updateBlock(level, temp.north()); ++ updateBlock(level, temp.south()); ++ updateBlock(level, temp = blockPos.north()); ++ updateBlock(level, temp.north()); ++ updateBlock(level, temp = blockPos.south()); ++ updateBlock(level, temp.south()); ++ } else if (updateRadius == 1) { ++ updateBlock(level, blockPos.west()); ++ updateBlock(level, blockPos.east()); ++ updateBlock(level, blockPos.below()); ++ updateBlock(level, blockPos.above()); ++ updateBlock(level, blockPos.north()); ++ updateBlock(level, blockPos.south()); ++ } else { ++ // Do nothing if updateRadius <= 0 (test mode) ++ } ++ } ++ ++ private void updateBlock(Level level, BlockPos blockPos) { ++ BlockState blockState = level.getTypeIfLoaded(blockPos); ++ ++ if (blockState != null && obfuscateGlobal[GLOBAL_BLOCKSTATE_PALETTE.idFor(blockState)]) { ++ ((ServerLevel) level).getChunkSource().blockChanged(blockPos); ++ } ++ } ++ ++ public enum EngineMode { ++ ++ HIDE(1, "hide ores"), ++ OBFUSCATE(2, "obfuscate"); ++ ++ private final int id; ++ private final String description; ++ ++ EngineMode(int id, String description) { ++ this.id = id; ++ this.description = description; ++ } ++ ++ public static EngineMode getById(int id) { ++ for (EngineMode engineMode : values()) { ++ if (engineMode.id == id) { ++ return engineMode; ++ } ++ } ++ ++ return null; ++ } ++ ++ public int getId() { ++ return id; ++ } ++ ++ public String getDescription() { ++ return description; ++ } ++ } ++} +diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java +new file mode 100644 +index 0000000000000000000000000000000000000000..d98a3f5c54c67a673eb7dc456dd039cd78f9c34d +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfo.java +@@ -0,0 +1,80 @@ ++package com.destroystokyo.paper.antixray; ++ ++import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket; ++import net.minecraft.world.level.chunk.LevelChunk; ++import net.minecraft.world.level.chunk.Palette; ++ ++public class ChunkPacketInfo { ++ ++ private final ClientboundLevelChunkWithLightPacket chunkPacket; ++ private final LevelChunk chunk; ++ private final int[] bits; ++ private final Object[] palettes; ++ private final int[] indexes; ++ private final Object[][] presetValues; ++ private byte[] buffer; ++ ++ public ChunkPacketInfo(ClientboundLevelChunkWithLightPacket chunkPacket, LevelChunk chunk) { ++ this.chunkPacket = chunkPacket; ++ this.chunk = chunk; ++ int sections = chunk.getSectionsCount(); ++ bits = new int[sections]; ++ palettes = new Object[sections]; ++ indexes = new int[sections]; ++ presetValues = new Object[sections][]; ++ } ++ ++ public ClientboundLevelChunkWithLightPacket getChunkPacket() { ++ return chunkPacket; ++ } ++ ++ public LevelChunk getChunk() { ++ return chunk; ++ } ++ ++ public byte[] getBuffer() { ++ return buffer; ++ } ++ ++ public void setBuffer(byte[] buffer) { ++ this.buffer = buffer; ++ } ++ ++ public int getBits(int chunkSectionIndex) { ++ return bits[chunkSectionIndex]; ++ } ++ ++ public void setBits(int chunkSectionIndex, int bits) { ++ this.bits[chunkSectionIndex] = bits; ++ } ++ ++ @SuppressWarnings("unchecked") ++ public Palette getPalette(int chunkSectionIndex) { ++ return (Palette) palettes[chunkSectionIndex]; ++ } ++ ++ public void setPalette(int chunkSectionIndex, Palette palette) { ++ palettes[chunkSectionIndex] = palette; ++ } ++ ++ public int getIndex(int chunkSectionIndex) { ++ return indexes[chunkSectionIndex]; ++ } ++ ++ public void setIndex(int chunkSectionIndex, int index) { ++ indexes[chunkSectionIndex] = index; ++ } ++ ++ @SuppressWarnings("unchecked") ++ public T[] getPresetValues(int chunkSectionIndex) { ++ return (T[]) presetValues[chunkSectionIndex]; ++ } ++ ++ public void setPresetValues(int chunkSectionIndex, T[] presetValues) { ++ this.presetValues[chunkSectionIndex] = presetValues; ++ } ++ ++ public boolean isWritten(int chunkSectionIndex) { ++ return bits[chunkSectionIndex] != 0; ++ } ++} +diff --git a/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java +new file mode 100644 +index 0000000000000000000000000000000000000000..80a2dfb266ae1221680a7b24fee2f7e2a8330b7d +--- /dev/null ++++ b/src/main/java/com/destroystokyo/paper/antixray/ChunkPacketInfoAntiXray.java +@@ -0,0 +1,29 @@ ++package com.destroystokyo.paper.antixray; ++ ++import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket; ++import net.minecraft.world.level.block.state.BlockState; ++import net.minecraft.world.level.chunk.LevelChunk; ++ ++public final class ChunkPacketInfoAntiXray extends ChunkPacketInfo implements Runnable { ++ ++ private final ChunkPacketBlockControllerAntiXray chunkPacketBlockControllerAntiXray; ++ private LevelChunk[] nearbyChunks; ++ ++ public ChunkPacketInfoAntiXray(ClientboundLevelChunkWithLightPacket chunkPacket, LevelChunk chunk, ChunkPacketBlockControllerAntiXray chunkPacketBlockControllerAntiXray) { ++ super(chunkPacket, chunk); ++ this.chunkPacketBlockControllerAntiXray = chunkPacketBlockControllerAntiXray; ++ } ++ ++ public LevelChunk[] getNearbyChunks() { ++ return nearbyChunks; ++ } ++ ++ public void setNearbyChunks(LevelChunk... nearbyChunks) { ++ this.nearbyChunks = nearbyChunks; ++ } ++ ++ @Override ++ public void run() { ++ chunkPacketBlockControllerAntiXray.obfuscate(this); ++ } ++} +diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java +index dba11f277f3703e1ee7f5a62f021d319e4ab18fc..0e75764c108c24b3e2c453f2b4f14e798add0eb4 100644 +--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java ++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java +@@ -33,7 +33,10 @@ public class ClientboundLevelChunkPacketData { + } + // Paper end + +- public ClientboundLevelChunkPacketData(LevelChunk chunk) { ++ // Paper start - Anti-Xray - Add chunk packet info ++ @Deprecated public ClientboundLevelChunkPacketData(LevelChunk chunk) { this(chunk, null); } // Notice for updates: Please make sure this constructor isn't used anywhere ++ public ClientboundLevelChunkPacketData(LevelChunk chunk, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo) { ++ // Paper end + this.heightmaps = new CompoundTag(); + + for(Entry entry : chunk.getHeightmaps()) { +@@ -43,7 +46,13 @@ public class ClientboundLevelChunkPacketData { + } + + this.buffer = new byte[calculateChunkSize(chunk)]; +- extractChunkData(new FriendlyByteBuf(this.getWriteBuffer()), chunk); ++ // Paper start - Anti-Xray - Add chunk packet info ++ if (chunkPacketInfo != null) { ++ chunkPacketInfo.setBuffer(this.buffer); ++ } ++ ++ extractChunkData(new FriendlyByteBuf(this.getWriteBuffer()), chunk, chunkPacketInfo); ++ // Paper end + this.blockEntitiesData = Lists.newArrayList(); + int totalTileEntities = 0; // Paper + +@@ -103,9 +112,12 @@ public class ClientboundLevelChunkPacketData { + return byteBuf; + } + +- public static void extractChunkData(FriendlyByteBuf buf, LevelChunk chunk) { ++ // Paper start - Anti-Xray - Add chunk packet info ++ @Deprecated public static void extractChunkData(FriendlyByteBuf buf, LevelChunk chunk) { ClientboundLevelChunkPacketData.extractChunkData(buf, chunk, null); } // Notice for updates: Please make sure this function isn't used anywhere ++ public static void extractChunkData(FriendlyByteBuf buf, LevelChunk chunk, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo) { + for(LevelChunkSection levelChunkSection : chunk.getSections()) { +- levelChunkSection.write(buf); ++ levelChunkSection.write(buf, chunkPacketInfo); ++ // Paper end + } + + } +diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java +index 7825d6f0fdcfda6212cff8033ec55fb7db236154..2072aa8710f6e285f7c8f76c63b7bcf85cc11030 100644 +--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java ++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java +@@ -13,13 +13,30 @@ public class ClientboundLevelChunkWithLightPacket implements Packet chunkPacketInfo = modifyBlocks ? chunk.getLevel().chunkPacketBlockController.getChunkPacketInfo(this, chunk) : null; + ChunkPos chunkPos = chunk.getPos(); + this.x = chunkPos.x; + this.z = chunkPos.z; +- this.chunkData = new ClientboundLevelChunkPacketData(chunk); ++ this.chunkData = new ClientboundLevelChunkPacketData(chunk, chunkPacketInfo); ++ // Paper end + this.lightData = new ClientboundLightUpdatePacketData(chunkPos, lightProvider, skyBits, blockBits, nonEdge); ++ chunk.getLevel().chunkPacketBlockController.modifyBlocks(this, chunkPacketInfo); // Paper - Anti-Xray - Modify blocks + } + + public ClientboundLevelChunkWithLightPacket(FriendlyByteBuf buf) { +diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java +index 8120d74d0016bc9c57ac6f6284b62c14464b9a2c..c5e3c46e7eb44e43f705a912891e6f6b42e52e6c 100644 +--- a/src/main/java/net/minecraft/server/level/ChunkMap.java ++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java +@@ -976,7 +976,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + completablefuture1.thenAcceptAsync((either) -> { + either.ifLeft((chunk) -> { + this.tickingGenerated.getAndIncrement(); +- MutableObject mutableobject = new MutableObject(); ++ MutableObject> mutableobject = new MutableObject<>(); // Paper - Anti-Xray - Bypass + + this.getPlayers(chunkcoordintpair, false).forEach((entityplayer) -> { + this.playerLoadedChunk(entityplayer, mutableobject, chunk); +@@ -1143,7 +1143,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + while (objectiterator.hasNext()) { + ChunkHolder playerchunk = (ChunkHolder) objectiterator.next(); + ChunkPos chunkcoordintpair = playerchunk.getPos(); +- MutableObject mutableobject = new MutableObject(); ++ MutableObject> mutableobject = new MutableObject<>(); // Paper - Anti-Xray - Bypass + + this.getPlayers(chunkcoordintpair, false).forEach((entityplayer) -> { + boolean flag = ChunkMap.isChunkInEuclideanRange(chunkcoordintpair, entityplayer, true, k); +@@ -1156,7 +1156,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + + } + +- protected void updateChunkTracking(ServerPlayer player, ChunkPos pos, MutableObject mutableobject, boolean oldWithinViewDistance, boolean newWithinViewDistance) { ++ protected void updateChunkTracking(ServerPlayer player, ChunkPos pos, MutableObject> mutableobject, boolean oldWithinViewDistance, boolean newWithinViewDistance) { // Paper - Anti-Xray - Bypass + if (player.level == this.level) { + if (newWithinViewDistance && !oldWithinViewDistance) { + ChunkHolder playerchunk = this.getVisibleChunkIfPresent(pos.toLong()); +@@ -1679,12 +1679,17 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + + } + +- private void playerLoadedChunk(ServerPlayer player, MutableObject cachedDataPacket, LevelChunk chunk) { +- if (cachedDataPacket.getValue() == null) { +- cachedDataPacket.setValue(new ClientboundLevelChunkWithLightPacket(chunk, this.lightEngine, (BitSet) null, (BitSet) null, true)); ++ // Paper start - Anti-Xray - Bypass ++ private void playerLoadedChunk(ServerPlayer player, MutableObject> cachedDataPackets, LevelChunk chunk) { ++ if (cachedDataPackets.getValue() == null) { ++ cachedDataPackets.setValue(new java.util.HashMap<>()); + } + +- player.trackChunk(chunk.getPos(), (Packet) cachedDataPacket.getValue()); ++ Boolean shouldModify = chunk.getLevel().chunkPacketBlockController.shouldModify(player, chunk); ++ player.trackChunk(chunk.getPos(), cachedDataPackets.getValue().computeIfAbsent(shouldModify, (s) -> { ++ return new ClientboundLevelChunkWithLightPacket(chunk, this.lightEngine, (BitSet) null, (BitSet) null, true, (Boolean) s); ++ })); ++ // Paper end + DebugPackets.sendPoiPacketsForChunk(this.level, chunk.getPos()); + List list = Lists.newArrayList(); + List list1 = Lists.newArrayList(); +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index db123ef36fc4cb0206349ac696572714b806454c..d26e42449a1f75898d06aba384178c0ef30d9aa7 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -391,7 +391,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Add env and gen to constructor, WorldData -> WorldDataServer + public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, ServerLevelData iworlddataserver, ResourceKey resourcekey, DimensionType dimensionmanager, ChunkProgressListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) { + // Objects.requireNonNull(minecraftserver); // CraftBukkit - decompile error +- super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getProfiler, false, flag, i, gen, biomeProvider, env); ++ super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getProfiler, false, flag, i, gen, biomeProvider, env, executor); // Paper - Async-Anti-Xray - Pass executor + this.pvpMode = minecraftserver.isPvpAllowed(); + this.convertable = convertable_conversionsession; + this.uuid = WorldUUID.getUUID(convertable_conversionsession.levelPath.toFile()); +diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +index 44e5ab0b545de41b937c7ce304ce643f78a43734..a85b89a0d525e623e154c8b1bea55470d2072dcb 100644 +--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java ++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +@@ -48,7 +48,7 @@ import org.bukkit.event.player.PlayerInteractEvent; + public class ServerPlayerGameMode { + + private static final Logger LOGGER = LogManager.getLogger(); +- protected ServerLevel level; ++ public ServerLevel level; // Paper - Anti-Xray - protected -> public + protected final ServerPlayer player; + private GameType gameModeForPlayer; + @Nullable +@@ -314,6 +314,8 @@ public class ServerPlayerGameMode { + } + + } ++ ++ this.level.chunkPacketBlockController.onPlayerLeftClickBlock(this, pos, action, direction, worldHeight); // Paper - Anti-Xray + } + + public void destroyAndAck(BlockPos pos, ServerboundPlayerActionPacket.Action action, String reason) { +diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java +index 77e58257dc3fb517aeca8f8436a4279aa133b570..8cde961332f4671bdd361e8f88d0eedd595bf745 100644 +--- a/src/main/java/net/minecraft/world/level/Level.java ++++ b/src/main/java/net/minecraft/world/level/Level.java +@@ -167,6 +167,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + public final org.spigotmc.SpigotWorldConfig spigotConfig; // Spigot + + public final com.destroystokyo.paper.PaperWorldConfig paperConfig; // Paper ++ public final com.destroystokyo.paper.antixray.ChunkPacketBlockController chunkPacketBlockController; // Paper - Anti-Xray + + public final co.aikar.timings.WorldTimingsHandler timings; // Paper + public static BlockPos lastPhysicsProblem; // Spigot +@@ -186,7 +187,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + + public abstract ResourceKey getTypeKey(); + +- protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env) { ++ protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor + this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot + this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), this.spigotConfig); // Paper + this.generator = gen; +@@ -262,6 +263,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + this.keepSpawnInMemory = this.paperConfig.keepSpawnInMemory; // Paper + this.entityLimiter = new org.spigotmc.TickLimiter(spigotConfig.entityMaxTickTime); + this.tileLimiter = new org.spigotmc.TickLimiter(spigotConfig.tileMaxTickTime); ++ this.chunkPacketBlockController = this.paperConfig.antiXray ? new com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray(this, executor) : com.destroystokyo.paper.antixray.ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray + } + + // Paper start +@@ -442,6 +444,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + // CraftBukkit end + + BlockState iblockdata1 = chunk.setBlockState(pos, state, (flags & 64) != 0, (flags & 1024) == 0); // CraftBukkit custom NO_PLACE flag ++ this.chunkPacketBlockController.onBlockChange(this, pos, state, iblockdata1, flags, maxUpdateDepth); // Paper - Anti-Xray + + if (iblockdata1 == null) { + // CraftBukkit start - remove blockstate if failed (or the same) +diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java +index 96dc50a24821016e53dfeac344c0e61f110a5a53..0a2f9e93666a5b2123f84e5cf409e4355d3cad86 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java ++++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java +@@ -110,7 +110,7 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom + private static void replaceMissingSections(LevelHeightAccessor world, Registry biome, LevelChunkSection[] sectionArray) { + for (int i = 0; i < sectionArray.length; ++i) { + if (sectionArray[i] == null) { +- sectionArray[i] = new LevelChunkSection(world.getSectionYFromSectionIndex(i), biome); ++ sectionArray[i] = new LevelChunkSection(world.getSectionYFromSectionIndex(i), biome, null, world instanceof net.minecraft.world.level.Level ? (net.minecraft.world.level.Level) world : null); // Paper - Anti-Xray - Add parameters + } + } + +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 a009122a8ea9dc2b04a178248f20ef01886e832b..0e89cf3fd6edf28b52ec113af31267642fd2b195 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +@@ -93,7 +93,7 @@ public class LevelChunk extends ChunkAccess { + } + + public LevelChunk(Level world, ChunkPos pos, UpgradeData upgradeData, LevelChunkTicks blockTickScheduler, LevelChunkTicks fluidTickScheduler, long inhabitedTime, @Nullable LevelChunkSection[] sectionArrayInitializer, @Nullable LevelChunk.PostLoadProcessor entityLoader, @Nullable BlendingData blendingData) { +- super(pos, upgradeData, world, world.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), inhabitedTime, sectionArrayInitializer, blendingData); ++ super(pos, upgradeData, world, net.minecraft.server.MinecraftServer.getServer().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), inhabitedTime, sectionArrayInitializer, blendingData); // Paper - Anti-Xray - The world isnt ready yet, use server singleton for registry + this.tickersInLevel = Maps.newHashMap(); + this.clientLightReady = false; + this.level = (ServerLevel) world; // CraftBukkit - type +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 50b6ecfea7a342be0d21e37ae87777a4b4860026..512f53b24de14ea48eab85a0e725556d92def6e9 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java +@@ -33,10 +33,13 @@ public class LevelChunkSection { + this.recalcBlockCounts(); + } + +- public LevelChunkSection(int chunkPos, Registry biomeRegistry) { ++ // Paper start - Anti-Xray - Add parameters ++ @Deprecated public LevelChunkSection(int chunkPos, Registry biomeRegistry) { this(chunkPos, biomeRegistry, null, null); } // Notice for updates: Please make sure this constructor isn't used anywhere ++ public LevelChunkSection(int chunkPos, Registry biomeRegistry, net.minecraft.world.level.ChunkPos pos, net.minecraft.world.level.Level level) { ++ // Paper end + this.bottomBlockY = LevelChunkSection.getBottomBlockY(chunkPos); +- this.states = new PalettedContainer<>(Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES); +- this.biomes = new PalettedContainer<>(biomeRegistry, (Biome) biomeRegistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES); ++ this.states = new PalettedContainer<>(Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES, level == null || level.chunkPacketBlockController == null ? null : level.chunkPacketBlockController.getPresetBlockStates(level, pos, this.bottomBlockY())); // Paper - Anti-Xray - Add preset block states ++ this.biomes = new PalettedContainer<>(biomeRegistry, (Biome) biomeRegistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES, null); // Paper - Anti-Xray - Add preset biomes + } + + public static int getBottomBlockY(int chunkPos) { +@@ -158,10 +161,13 @@ public class LevelChunkSection { + this.biomes.read(buf); + } + +- public void write(FriendlyByteBuf buf) { ++ // Paper start - Anti-Xray - Add chunk packet info ++ @Deprecated public void write(FriendlyByteBuf buf) { this.write(buf, null); } // Notice for updates: Please make sure this method isn't used anywhere ++ public void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo) { + buf.writeShort(this.nonEmptyBlockCount); +- this.states.write(buf); +- this.biomes.write(buf); ++ this.states.write(buf, chunkPacketInfo, this.bottomBlockY()); ++ this.biomes.write(buf, null, this.bottomBlockY()); ++ // Paper end + } + + public int getSerializedSize() { +diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +index 911bf2b7bbe627f98d21681b0c6d5b8a5170c8a8..cdd357a8dd82cfd2a8abd45c1b7937b409af4b05 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java ++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +@@ -29,6 +29,7 @@ public class PalettedContainer implements PaletteResize { + return 0; + }; + public final IdMap registry; ++ private final T[] presetValues; // Paper - Anti-Xray - Add preset values + private volatile PalettedContainer.Data data; + private final PalettedContainer.Strategy strategy; + private final ThreadingDetector threadingDetector = new ThreadingDetector("PalettedContainer"); +@@ -41,29 +42,65 @@ public class PalettedContainer implements PaletteResize { + this.threadingDetector.checkAndUnlock(); + } + +- public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object) { ++ // Paper start - Anti-Xray - Add preset values ++ @Deprecated public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object) { return PalettedContainer.codec(idList, entryCodec, provider, object, null); } // Notice for updates: Please make sure this function isn't used anywhere ++ public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object, T[] presetValues) { + return RecordCodecBuilder.create((instance) -> { + return instance.group(entryCodec.mapResult(ExtraCodecs.orElsePartial(object)).listOf().fieldOf("palette").forGetter(PalettedContainer.DiscData::paletteEntries), Codec.LONG_STREAM.optionalFieldOf("data").forGetter(PalettedContainer.DiscData::storage)).apply(instance, PalettedContainer.DiscData::new); + }).comapFlatMap((serialized) -> { +- return read(idList, provider, serialized); ++ return read(idList, provider, serialized, object, presetValues); ++ // Paper end + }, (container) -> { + return container.write(idList, provider); + }); + } + +- public PalettedContainer(IdMap idList, PalettedContainer.Strategy paletteProvider, PalettedContainer.Configuration dataProvider, BitStorage storage, List paletteEntries) { ++ // Paper start - Anti-Xray - Add preset values ++ @Deprecated public PalettedContainer(IdMap idList, PalettedContainer.Strategy paletteProvider, PalettedContainer.Configuration dataProvider, BitStorage storage, List paletteEntries) { this(idList, paletteProvider, dataProvider, storage, paletteEntries, null, null); } // Notice for updates: Please make sure this constructor isn't used anywhere ++ public PalettedContainer(IdMap idList, PalettedContainer.Strategy paletteProvider, PalettedContainer.Configuration dataProvider, BitStorage storage, List paletteEntries, T defaultValue, T[] presetValues) { ++ this.presetValues = presetValues; + this.registry = idList; + this.strategy = paletteProvider; + this.data = new PalettedContainer.Data<>(dataProvider, storage, dataProvider.factory().create(dataProvider.bits(), idList, this, paletteEntries)); ++ ++ if (presetValues != null && (dataProvider.factory() == PalettedContainer.Strategy.SINGLE_VALUE_PALETTE_FACTORY ? this.data.palette.valueFor(0) != defaultValue : dataProvider.factory() != PalettedContainer.Strategy.GLOBAL_PALETTE_FACTORY)) { ++ // In 1.18 Mojang unfortunately removed code that already handled possible resize operations on read from disk for us ++ // We readd this here but in a smarter way than it was before ++ int maxSize = 1 << dataProvider.bits(); ++ ++ for (T presetValue : presetValues) { ++ if (this.data.palette.getSize() >= maxSize) { ++ java.util.Set allValues = new java.util.HashSet<>(paletteEntries); ++ allValues.addAll(Arrays.asList(presetValues)); ++ int newBits = Mth.ceillog2(allValues.size()); ++ ++ if (newBits > dataProvider.bits()) { ++ this.onResize(newBits, null); ++ } ++ ++ break; ++ } ++ ++ this.data.palette.idFor(presetValue); ++ } ++ } ++ // Paper end + } + +- private PalettedContainer(IdMap idList, PalettedContainer.Strategy paletteProvider, PalettedContainer.Data data) { ++ // Paper start - Anti-Xray - Add preset values ++ private PalettedContainer(IdMap idList, PalettedContainer.Strategy paletteProvider, PalettedContainer.Data data, T[] presetValues) { ++ this.presetValues = presetValues; ++ // Paper end + this.registry = idList; + this.strategy = paletteProvider; + this.data = data; + } + +- public PalettedContainer(IdMap idList, T object, PalettedContainer.Strategy paletteProvider) { ++ // Paper start - Anti-Xray - Add preset values ++ @Deprecated public PalettedContainer(IdMap idList, T object, PalettedContainer.Strategy paletteProvider) { this(idList, object, paletteProvider, null); } // Notice for updates: Please make sure this constructor isn't used anywhere ++ public PalettedContainer(IdMap idList, T object, PalettedContainer.Strategy paletteProvider, T[] presetValues) { ++ this.presetValues = presetValues; ++ // Paper end + this.strategy = paletteProvider; + this.registry = idList; + this.data = this.createOrReuseData((PalettedContainer.Data)null, 0); +@@ -78,11 +115,33 @@ public class PalettedContainer implements PaletteResize { + @Override + public int onResize(int newBits, T object) { + PalettedContainer.Data data = this.data; ++ ++ // Paper start - Anti-Xray - Add preset values ++ if (this.presetValues != null && object != null && data.configuration().factory() == PalettedContainer.Strategy.SINGLE_VALUE_PALETTE_FACTORY) { ++ int duplicates = 0; ++ List presetValues = Arrays.asList(this.presetValues); ++ duplicates += presetValues.contains(object) ? 1 : 0; ++ duplicates += presetValues.contains(data.palette.valueFor(0)) ? 1 : 0; ++ newBits = Mth.ceillog2((1 << this.strategy.calculateBitsForSerialization(this.registry, 1 << newBits)) + presetValues.size() - duplicates); ++ } ++ + PalettedContainer.Data data2 = this.createOrReuseData(data, newBits); + data2.copyFrom(data.palette, data.storage); + this.data = data2; +- return data2.palette.idFor(object); ++ this.addPresetValues(); ++ return object == null ? -1 : data2.palette.idFor(object); ++ // Paper end ++ } ++ ++ // Paper start - Anti-Xray - Add preset values ++ private void addPresetValues() { ++ if (this.presetValues != null && this.data.configuration().factory() != PalettedContainer.Strategy.GLOBAL_PALETTE_FACTORY) { ++ for (T presetValue : this.presetValues) { ++ this.data.palette.idFor(presetValue); ++ } ++ } + } ++ // Paper end + + public T getAndSet(int x, int y, int z, T value) { + this.acquire(); +@@ -150,24 +209,34 @@ public class PalettedContainer implements PaletteResize { + data.palette.read(buf); + buf.readLongArray(data.storage.getRaw()); + this.data = data; ++ this.addPresetValues(); // Paper - Anti-Xray - Add preset values (inefficient, but this not used by the server) + } finally { + this.release(); + } + + } + +- public void write(FriendlyByteBuf buf) { ++ // Paper start - Anti-Xray - Add chunk packet info ++ @Deprecated public void write(FriendlyByteBuf buf) { this.write(buf, null, 0); } // Notice for updates: Please make sure this method isn't used anywhere ++ public void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo, int bottomBlockY) { + this.acquire(); + + try { +- this.data.write(buf); ++ this.data.write(buf, chunkPacketInfo, bottomBlockY); ++ ++ if (chunkPacketInfo != null) { ++ // Bottom block to 0 based chunk section index ++ int chunkSectionIndex = (bottomBlockY >> 4) - chunkPacketInfo.getChunk().getMinSection(); ++ chunkPacketInfo.setPresetValues(chunkSectionIndex, this.presetValues); ++ } ++ // Paper end + } finally { + this.release(); + } + + } + +- private static DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized) { ++ private static DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized, T defaultValue, T[] presetValues) { // Paper - Anti-Xray - Add preset values + List list = serialized.paletteEntries(); + int i = provider.size(); + int j = provider.calculateBitsForSerialization(idList, list.size()); +@@ -203,7 +272,7 @@ public class PalettedContainer implements PaletteResize { + } + } + +- return DataResult.success(new PalettedContainer<>(idList, provider, configuration, bitStorage, list)); ++ return DataResult.success(new PalettedContainer<>(idList, provider, configuration, bitStorage, list, defaultValue, presetValues)); // Paper - Anti-Xray - Add preset values + } + + private PalettedContainer.DiscData write(IdMap idList, PalettedContainer.Strategy provider) { +@@ -260,7 +329,7 @@ public class PalettedContainer implements PaletteResize { + } + + public PalettedContainer copy() { +- return new PalettedContainer<>(this.registry, this.strategy, new PalettedContainer.Data<>(this.data.configuration(), this.data.storage().copy(), this.data.palette().copy())); ++ return new PalettedContainer<>(this.registry, this.strategy, new PalettedContainer.Data<>(this.data.configuration(), this.data.storage().copy(), this.data.palette().copy()), this.presetValues); // Paper - Anti-Xray - Add preset values + } + + public void count(PalettedContainer.CountConsumer counter) { +@@ -304,9 +373,20 @@ public class PalettedContainer implements PaletteResize { + return 1 + this.palette.getSerializedSize() + FriendlyByteBuf.getVarIntSize(this.storage.getSize()) + this.storage.getRaw().length * 8; + } + +- public void write(FriendlyByteBuf buf) { ++ // Paper start - Anti-Xray - Add chunk packet info ++ public void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo, int bottomBlockY) { + buf.writeByte(this.storage.getBits()); + this.palette.write(buf); ++ ++ if (chunkPacketInfo != null) { ++ // Bottom block to 0 based chunk section index ++ int chunkSectionIndex = (bottomBlockY >> 4) - chunkPacketInfo.getChunk().getMinSection(); ++ chunkPacketInfo.setBits(chunkSectionIndex, this.configuration.bits()); ++ chunkPacketInfo.setPalette(chunkSectionIndex, this.palette); ++ chunkPacketInfo.setIndex(chunkSectionIndex, buf.writerIndex() + FriendlyByteBuf.getVarIntSize(this.storage.getRaw().length)); ++ } ++ // Paper end ++ + buf.writeLongArray(this.storage.getRaw()); + } + } +diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +index cf86755050632b158576849b786079787db11763..1267e93d1e315d55086a87670fd098db552c3afd 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java ++++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +@@ -67,7 +67,7 @@ import org.apache.logging.log4j.Logger; + + public class ChunkSerializer { + +- public static final Codec> BLOCK_STATE_CODEC = PalettedContainer.codec(Block.BLOCK_STATE_REGISTRY, BlockState.CODEC, PalettedContainer.Strategy.SECTION_STATES, Blocks.AIR.defaultBlockState()); ++ public static final Codec> BLOCK_STATE_CODEC = PalettedContainer.codec(Block.BLOCK_STATE_REGISTRY, BlockState.CODEC, PalettedContainer.Strategy.SECTION_STATES, Blocks.AIR.defaultBlockState(), null); // Paper - Anti-Xray - Add preset block states + private static final Logger LOGGER = LogManager.getLogger(); + private static final String TAG_UPGRADE_DATA = "UpgradeData"; + private static final String BLOCK_TICKS_TAG = "block_ticks"; +@@ -146,16 +146,20 @@ public class ChunkSerializer { + if (k >= 0 && k < achunksection.length) { + Logger logger; + PalettedContainer datapaletteblock; ++ // Paper start - Anti-Xray - Add preset block states ++ BlockState[] presetBlockStates = world.chunkPacketBlockController.getPresetBlockStates(world, chunkPos, b0 << 4); + + if (nbttagcompound1.contains("block_states", 10)) { +- dataresult = ChunkSerializer.BLOCK_STATE_CODEC.parse(NbtOps.INSTANCE, nbttagcompound1.getCompound("block_states")).promotePartial((s) -> { ++ Codec> blockStateCodec = presetBlockStates == null ? ChunkSerializer.BLOCK_STATE_CODEC : PalettedContainer.codec(Block.BLOCK_STATE_REGISTRY, BlockState.CODEC, PalettedContainer.Strategy.SECTION_STATES, Blocks.AIR.defaultBlockState(), presetBlockStates); ++ dataresult = blockStateCodec.parse(NbtOps.INSTANCE, nbttagcompound1.getCompound("block_states")).promotePartial((s) -> { + ChunkSerializer.logErrors(chunkPos, b0, s); + }); + logger = ChunkSerializer.LOGGER; + Objects.requireNonNull(logger); + datapaletteblock = (PalettedContainer) dataresult.getOrThrow(false, logger::error); + } else { +- datapaletteblock = new PalettedContainer<>(Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES); ++ datapaletteblock = new PalettedContainer<>(Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES, presetBlockStates); ++ // Paper end + } + + PalettedContainer datapaletteblock1; +@@ -168,7 +172,7 @@ public class ChunkSerializer { + Objects.requireNonNull(logger); + datapaletteblock1 = (PalettedContainer) dataresult.getOrThrow(false, logger::error); + } else { +- datapaletteblock1 = new PalettedContainer<>(iregistry, (Biome) iregistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES); ++ datapaletteblock1 = new PalettedContainer<>(iregistry, (Biome) iregistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES, null); // Paper - Anti-Xray - Add preset biomes + } + + LevelChunkSection chunksection = new LevelChunkSection(b0, datapaletteblock, datapaletteblock1); +@@ -421,7 +425,7 @@ public class ChunkSerializer { + } + + private static Codec> makeBiomeCodec(Registry biomeRegistry) { +- return PalettedContainer.codec(biomeRegistry, biomeRegistry.byNameCodec(), PalettedContainer.Strategy.SECTION_BIOMES, (Biome) biomeRegistry.getOrThrow(Biomes.PLAINS)); ++ return PalettedContainer.codec(biomeRegistry, biomeRegistry.byNameCodec(), PalettedContainer.Strategy.SECTION_BIOMES, (Biome) biomeRegistry.getOrThrow(Biomes.PLAINS), null); // Paper - Anti-Xray - Add preset biomes + } + + public static CompoundTag write(ServerLevel world, ChunkAccess chunk) { +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java +index 7bc1219523eeb0880493e6fb42692f1fdb30c110..d6efa18ba9c032858071f6c87f1bdc0ce2ddb20f 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java +@@ -52,7 +52,7 @@ public class CraftChunk implements Chunk { + private final ServerLevel worldServer; + private final int x; + private final int z; +- private static final PalettedContainer emptyBlockIDs = new PalettedContainer<>(net.minecraft.world.level.block.Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES); ++ private static final PalettedContainer emptyBlockIDs = new PalettedContainer<>(net.minecraft.world.level.block.Block.BLOCK_STATE_REGISTRY, Blocks.AIR.defaultBlockState(), PalettedContainer.Strategy.SECTION_STATES, null); // Paper - Anti-Xray - Add preset block states + private static final byte[] emptyLight = new byte[2048]; + + public CraftChunk(net.minecraft.world.level.chunk.LevelChunk chunk) { +@@ -325,7 +325,7 @@ public class CraftChunk implements Chunk { + PalettedContainer[] biome = (includeBiome || includeBiomeTempRain) ? new PalettedContainer[cs.length] : null; + + Registry iregistry = this.worldServer.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY); +- Codec> biomeCodec = PalettedContainer.codec(iregistry, iregistry.byNameCodec(), PalettedContainer.Strategy.SECTION_BIOMES, iregistry.getOrThrow(Biomes.PLAINS)); ++ Codec> biomeCodec = PalettedContainer.codec(iregistry, iregistry.byNameCodec(), PalettedContainer.Strategy.SECTION_BIOMES, iregistry.getOrThrow(Biomes.PLAINS), null); // Paper - Anti-Xray - Add preset biomes + + for (int i = 0; i < cs.length; i++) { + CompoundTag data = new CompoundTag(); +@@ -390,7 +390,7 @@ public class CraftChunk implements Chunk { + + if (biome != null) { + Registry iregistry = world.getHandle().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY); +- biome[i] = new PalettedContainer<>(iregistry, iregistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES); ++ biome[i] = new PalettedContainer<>(iregistry, iregistry.getOrThrow(Biomes.PLAINS), PalettedContainer.Strategy.SECTION_BIOMES, null); // Paper - Anti-Xray - Add preset biomes + } + } + +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +index 8d1cbefc82f64a120eeea8c6bdd6361ffa513099..6a16faf62f6d93c1ada5942e5886b37bd9f78c83 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +@@ -2204,7 +2204,7 @@ public final class CraftServer implements Server { + public ChunkGenerator.ChunkData createChunkData(World world) { + Validate.notNull(world, "World cannot be null"); + ServerLevel handle = ((CraftWorld) world).getHandle(); +- return new OldCraftChunkData(world.getMinHeight(), world.getMaxHeight(), handle.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY)); ++ return new OldCraftChunkData(world.getMinHeight(), world.getMaxHeight(), handle.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), world); // Paper - Anti-Xray - Add parameters + } + + @Override +diff --git a/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java b/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java +index 960405935e395a31c0300773c41413801cf0d290..6f6bf950cd15b34031618782c82824cf0b191ff8 100644 +--- a/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java ++++ b/src/main/java/org/bukkit/craftbukkit/generator/OldCraftChunkData.java +@@ -27,8 +27,13 @@ public final class OldCraftChunkData implements ChunkGenerator.ChunkData { + private final Registry biomes; + private Set tiles; + private final Set lights = new HashSet<>(); ++ // Paper start - Anti-Xray - Add parameters ++ private final World world; + +- public OldCraftChunkData(int minHeight, int maxHeight, Registry biomes) { ++ @Deprecated public OldCraftChunkData(int minHeight, int maxHeight, Registry biomes) { this(minHeight, maxHeight, biomes, null); } // Notice for updates: Please make sure this constructor isn't used anywhere ++ public OldCraftChunkData(int minHeight, int maxHeight, Registry biomes, World world) { ++ this.world = world; ++ // Paper end + this.minHeight = minHeight; + this.maxHeight = maxHeight; + this.biomes = biomes; +@@ -176,7 +181,7 @@ public final class OldCraftChunkData implements ChunkGenerator.ChunkData { + int offset = (y - this.minHeight) >> 4; + LevelChunkSection section = this.sections[offset]; + if (create && section == null) { +- this.sections[offset] = section = new LevelChunkSection(offset + (this.minHeight >> 4), this.biomes); ++ this.sections[offset] = section = new LevelChunkSection(offset + (this.minHeight >> 4), this.biomes, null, this.world instanceof org.bukkit.craftbukkit.CraftWorld ? ((org.bukkit.craftbukkit.CraftWorld) this.world).getHandle() : null); // Paper - Anti-Xray - Add parameters + } + return section; + } diff --git a/patches/server/0361-Implement-alternative-item-despawn-rate.patch b/patches/server/0362-Implement-alternative-item-despawn-rate.patch similarity index 93% rename from patches/server/0361-Implement-alternative-item-despawn-rate.patch rename to patches/server/0362-Implement-alternative-item-despawn-rate.patch index cffe96bbc..dc64e0960 100644 --- a/patches/server/0361-Implement-alternative-item-despawn-rate.patch +++ b/patches/server/0362-Implement-alternative-item-despawn-rate.patch @@ -5,12 +5,12 @@ Subject: [PATCH] Implement alternative item-despawn-rate diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index c81364946460a6366bf70457c2025d4275f50f77..2395fa36a230ee48f6b86b60121217d0c60f5327 100644 +index b18d35bc67f3124ca8f4a67e3dadabef52e2588a..977b4f05eaafaf5c19b84d1cbeb853e66e7aab4f 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -523,5 +523,52 @@ public class PaperWorldConfig { - private void lightQueueSize() { - lightQueueSize = getInt("light-queue-size", lightQueueSize); +@@ -560,5 +560,52 @@ public class PaperWorldConfig { + Bukkit.getLogger().warning("You have enabled permission-based Anti-Xray checking - depending on your permission plugin, this may cause performance issues"); + } } -} diff --git a/patches/server/0362-Tracking-Range-Improvements.patch b/patches/server/0363-Tracking-Range-Improvements.patch similarity index 95% rename from patches/server/0362-Tracking-Range-Improvements.patch rename to patches/server/0363-Tracking-Range-Improvements.patch index 68efc9d6e..0eac74d3f 100644 --- a/patches/server/0362-Tracking-Range-Improvements.patch +++ b/patches/server/0363-Tracking-Range-Improvements.patch @@ -8,10 +8,10 @@ Sets tracking range of watermobs to animals instead of misc and simplifies code Also ignores Enderdragon, defaulting it to Mojang's setting diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index 8120d74d0016bc9c57ac6f6284b62c14464b9a2c..34249b4eb28c9d0f157eebf0a2c1c50501df2a36 100644 +index c5e3c46e7eb44e43f705a912891e6f6b42e52e6c..37a22b2bb36a609ade42483d666e8c1c25dff192 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java -@@ -1862,6 +1862,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider +@@ -1867,6 +1867,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider while (iterator.hasNext()) { Entity entity = (Entity) iterator.next(); int j = entity.getType().clientTrackingRange() * 16; diff --git a/patches/server/0363-Fix-items-vanishing-through-end-portal.patch b/patches/server/0364-Fix-items-vanishing-through-end-portal.patch similarity index 100% rename from patches/server/0363-Fix-items-vanishing-through-end-portal.patch rename to patches/server/0364-Fix-items-vanishing-through-end-portal.patch diff --git a/patches/server/0364-implement-optional-per-player-mob-spawns.patch b/patches/server/0365-implement-optional-per-player-mob-spawns.patch similarity index 99% rename from patches/server/0364-implement-optional-per-player-mob-spawns.patch rename to patches/server/0365-implement-optional-per-player-mob-spawns.patch index 784578d94..6201ceba7 100644 --- a/patches/server/0364-implement-optional-per-player-mob-spawns.patch +++ b/patches/server/0365-implement-optional-per-player-mob-spawns.patch @@ -25,10 +25,10 @@ index fe79c0add4f7cb18d487c5bb9415c40c5b551ea2..8d9ddad1879e7616d980ca70de8aecac poiUnload = Timings.ofSafe(name + "Chunk unload - POI"); chunkUnload = Timings.ofSafe(name + "Chunk unload - Chunk"); diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 2395fa36a230ee48f6b86b60121217d0c60f5327..14d96b70a56946f21e7ffb5841e7eda3f24e087b 100644 +index 977b4f05eaafaf5c19b84d1cbeb853e66e7aab4f..6e93a6e97dd03c0c0ed9673fa932ba81a42b1139 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -571,4 +571,12 @@ public class PaperWorldConfig { +@@ -608,4 +608,12 @@ public class PaperWorldConfig { } } } @@ -547,7 +547,7 @@ index 0000000000000000000000000000000000000000..11de56afaf059b00fa5bec293516bcdc + } +} diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index cb46732f78748864117cafa94f6d3af14205d71f..f1fa28fb90f07a4e2de541b2f7ca2f2d7c1d6a31 100644 +index 37a22b2bb36a609ade42483d666e8c1c25dff192..0d3c4ce4f5de65a7a6446cde133d51ec76c25ffc 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -151,6 +151,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -593,7 +593,7 @@ index cb46732f78748864117cafa94f6d3af14205d71f..f1fa28fb90f07a4e2de541b2f7ca2f2d double d0 = (double) SectionPos.sectionToBlockCoord(pos.x, 8); double d1 = (double) SectionPos.sectionToBlockCoord(pos.z, 8); diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 30b38f85870bd3fd5f04e8ed37c360ee3a10abad..dd0237a92a02d3239119234b3ef74328ce8e5b92 100644 +index 1dc1005142f822c05eb9065b4a5da456ec936ff2..7ffebfa03a2a92d285c837b97d5190a052006e36 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -916,7 +916,22 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0365-Avoid-hopper-searches-if-there-are-no-items.patch b/patches/server/0366-Avoid-hopper-searches-if-there-are-no-items.patch similarity index 97% rename from patches/server/0365-Avoid-hopper-searches-if-there-are-no-items.patch rename to patches/server/0366-Avoid-hopper-searches-if-there-are-no-items.patch index 39a2c52b7..dbe0e9739 100644 --- a/patches/server/0365-Avoid-hopper-searches-if-there-are-no-items.patch +++ b/patches/server/0366-Avoid-hopper-searches-if-there-are-no-items.patch @@ -14,10 +14,10 @@ And since minecart hoppers are used _very_ rarely near we can avoid alot of sear Combined, this adds up a lot. diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 77e58257dc3fb517aeca8f8436a4279aa133b570..9842e4d39130f45481b643df38ee4b25076c5c08 100644 +index 8cde961332f4671bdd361e8f88d0eedd595bf745..9154f434ab1a1b11d19cef8fc80f351f3eefcb57 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -985,7 +985,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -988,7 +988,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { } } diff --git a/patches/server/0366-Bees-get-gravity-in-void.-Fixes-MC-167279.patch b/patches/server/0367-Bees-get-gravity-in-void.-Fixes-MC-167279.patch similarity index 100% rename from patches/server/0366-Bees-get-gravity-in-void.-Fixes-MC-167279.patch rename to patches/server/0367-Bees-get-gravity-in-void.-Fixes-MC-167279.patch diff --git a/patches/server/0367-Optimise-getChunkAt-calls-for-loaded-chunks.patch b/patches/server/0368-Optimise-getChunkAt-calls-for-loaded-chunks.patch similarity index 96% rename from patches/server/0367-Optimise-getChunkAt-calls-for-loaded-chunks.patch rename to patches/server/0368-Optimise-getChunkAt-calls-for-loaded-chunks.patch index a513ec960..dd76a8c68 100644 --- a/patches/server/0367-Optimise-getChunkAt-calls-for-loaded-chunks.patch +++ b/patches/server/0368-Optimise-getChunkAt-calls-for-loaded-chunks.patch @@ -7,7 +7,7 @@ bypass the need to get a player chunk, then get the either, then unwrap it... diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index dd0237a92a02d3239119234b3ef74328ce8e5b92..3156badcef61c028df3e78e97019093c9ac01cb4 100644 +index 7ffebfa03a2a92d285c837b97d5190a052006e36..fa95322c02f9eee7d2cca06c48c19383d414032f 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -612,6 +612,12 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0368-Add-debug-for-sync-chunk-loads.patch b/patches/server/0369-Add-debug-for-sync-chunk-loads.patch similarity index 98% rename from patches/server/0368-Add-debug-for-sync-chunk-loads.patch rename to patches/server/0369-Add-debug-for-sync-chunk-loads.patch index 697dd597d..1d43ed1c3 100644 --- a/patches/server/0368-Add-debug-for-sync-chunk-loads.patch +++ b/patches/server/0369-Add-debug-for-sync-chunk-loads.patch @@ -305,7 +305,7 @@ index 0000000000000000000000000000000000000000..0bb4aaa546939b67a5d22865190f3047 + } +} diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 3156badcef61c028df3e78e97019093c9ac01cb4..0af558b8246cc5661c2be6655cc0658519456202 100644 +index fa95322c02f9eee7d2cca06c48c19383d414032f..1eab367b375bb7bf6fadb602f378f6817e519371 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -644,6 +644,7 @@ public class ServerChunkCache extends ChunkSource { @@ -317,7 +317,7 @@ index 3156badcef61c028df3e78e97019093c9ac01cb4..0af558b8246cc5661c2be6655cc06585 chunkproviderserver_b.managedBlock(completablefuture::isDone); com.destroystokyo.paper.io.chunk.ChunkTaskManager.popChunkWait(); // Paper - async chunk debug diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 37e9ef7b6378c0dca958426e223fb181b6ca12ff..e7ae70ae59b65a8577bf4dc065fb729a3d5c5d95 100644 +index d26e42449a1f75898d06aba384178c0ef30d9aa7..a21300a866dc6c9f7097a894e0506515210090f5 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -379,6 +379,12 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0369-Allow-overriding-the-java-version-check.patch b/patches/server/0370-Allow-overriding-the-java-version-check.patch similarity index 100% rename from patches/server/0369-Allow-overriding-the-java-version-check.patch rename to patches/server/0370-Allow-overriding-the-java-version-check.patch diff --git a/patches/server/0370-Add-ThrownEggHatchEvent.patch b/patches/server/0371-Add-ThrownEggHatchEvent.patch similarity index 100% rename from patches/server/0370-Add-ThrownEggHatchEvent.patch rename to patches/server/0371-Add-ThrownEggHatchEvent.patch diff --git a/patches/server/0371-Entity-Jump-API.patch b/patches/server/0372-Entity-Jump-API.patch similarity index 94% rename from patches/server/0371-Entity-Jump-API.patch rename to patches/server/0372-Entity-Jump-API.patch index 95c36ea08..336c3cf12 100644 --- a/patches/server/0371-Entity-Jump-API.patch +++ b/patches/server/0372-Entity-Jump-API.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Entity Jump API diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 8217a8e2c170aa78586ae0054a35fc9158f70bae..06c32d50d6672d2816c8cb1b4ef0dc038ffce817 100644 +index b8877b52e4ba032fc43d95647d177cd38fb6aaf8..e8501f18f5021678fad09cb5e600c7fc3660fe52 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java @@ -3164,8 +3164,10 @@ public abstract class LivingEntity extends Entity { @@ -20,7 +20,7 @@ index 8217a8e2c170aa78586ae0054a35fc9158f70bae..06c32d50d6672d2816c8cb1b4ef0dc03 } else { this.noJumpDelay = 0; diff --git a/src/main/java/net/minecraft/world/entity/animal/Panda.java b/src/main/java/net/minecraft/world/entity/animal/Panda.java -index 77be09e63eecef2ecb0b8002e0201c040323e7a5..52b9eb1546dac1c7f5b866e4afdce2e5a91cf3f3 100644 +index 7b75f6863144b5f3307f72692529377aa61e7f43..29372c8a0c54e4bae518e09846f0e9caba263896 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Panda.java +++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java @@ -515,7 +515,9 @@ public class Panda extends Animal { diff --git a/patches/server/0372-Add-option-to-nerf-pigmen-from-nether-portals.patch b/patches/server/0373-Add-option-to-nerf-pigmen-from-nether-portals.patch similarity index 95% rename from patches/server/0372-Add-option-to-nerf-pigmen-from-nether-portals.patch rename to patches/server/0373-Add-option-to-nerf-pigmen-from-nether-portals.patch index 0553ffd64..1b8d05c00 100644 --- a/patches/server/0372-Add-option-to-nerf-pigmen-from-nether-portals.patch +++ b/patches/server/0373-Add-option-to-nerf-pigmen-from-nether-portals.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add option to nerf pigmen from nether portals diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 14d96b70a56946f21e7ffb5841e7eda3f24e087b..8ce19dcc8eb55557186b4716b54937dc6bc09a47 100644 +index 6e93a6e97dd03c0c0ed9673fa932ba81a42b1139..2ea220c4d3247c78f97c57f205b0019d5016d09e 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -519,6 +519,11 @@ public class PaperWorldConfig { +@@ -521,6 +521,11 @@ public class PaperWorldConfig { log("Hopper Ignore Occluding Blocks: " + (hoppersIgnoreOccludingBlocks ? "enabled" : "disabled")); } diff --git a/patches/server/0373-Make-the-GUI-graph-fancier.patch b/patches/server/0374-Make-the-GUI-graph-fancier.patch similarity index 100% rename from patches/server/0373-Make-the-GUI-graph-fancier.patch rename to patches/server/0374-Make-the-GUI-graph-fancier.patch diff --git a/patches/server/0374-add-hand-to-BlockMultiPlaceEvent.patch b/patches/server/0375-add-hand-to-BlockMultiPlaceEvent.patch similarity index 100% rename from patches/server/0374-add-hand-to-BlockMultiPlaceEvent.patch rename to patches/server/0375-add-hand-to-BlockMultiPlaceEvent.patch diff --git a/patches/server/0375-Prevent-teleporting-dead-entities.patch b/patches/server/0376-Prevent-teleporting-dead-entities.patch similarity index 100% rename from patches/server/0375-Prevent-teleporting-dead-entities.patch rename to patches/server/0376-Prevent-teleporting-dead-entities.patch diff --git a/patches/server/0376-Validate-tripwire-hook-placement-before-update.patch b/patches/server/0377-Validate-tripwire-hook-placement-before-update.patch similarity index 100% rename from patches/server/0376-Validate-tripwire-hook-placement-before-update.patch rename to patches/server/0377-Validate-tripwire-hook-placement-before-update.patch diff --git a/patches/server/0377-Add-option-to-allow-iron-golems-to-spawn-in-air.patch b/patches/server/0378-Add-option-to-allow-iron-golems-to-spawn-in-air.patch similarity index 92% rename from patches/server/0377-Add-option-to-allow-iron-golems-to-spawn-in-air.patch rename to patches/server/0378-Add-option-to-allow-iron-golems-to-spawn-in-air.patch index ac668446b..73410ca6f 100644 --- a/patches/server/0377-Add-option-to-allow-iron-golems-to-spawn-in-air.patch +++ b/patches/server/0378-Add-option-to-allow-iron-golems-to-spawn-in-air.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add option to allow iron golems to spawn in air diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 8ce19dcc8eb55557186b4716b54937dc6bc09a47..8d6998dbccafc5443c9efa90642e57a5ab8f7ac6 100644 +index 2ea220c4d3247c78f97c57f205b0019d5016d09e..f8cabe3a0388e78f4a5b47b5f33224ae17c8fcb0 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -421,6 +421,11 @@ public class PaperWorldConfig { +@@ -423,6 +423,11 @@ public class PaperWorldConfig { scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true); } diff --git a/patches/server/0378-Configurable-chance-of-villager-zombie-infection.patch b/patches/server/0379-Configurable-chance-of-villager-zombie-infection.patch similarity index 94% rename from patches/server/0378-Configurable-chance-of-villager-zombie-infection.patch rename to patches/server/0379-Configurable-chance-of-villager-zombie-infection.patch index bf7fe2d12..0b7259d5a 100644 --- a/patches/server/0378-Configurable-chance-of-villager-zombie-infection.patch +++ b/patches/server/0379-Configurable-chance-of-villager-zombie-infection.patch @@ -8,10 +8,10 @@ This allows you to solve an issue in vanilla behavior where: * On normal difficulty they will have a 50% of getting infected or dying. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 8d6998dbccafc5443c9efa90642e57a5ab8f7ac6..043cdbfe6c339f8d99a2251ccd5e293997f32b09 100644 +index f8cabe3a0388e78f4a5b47b5f33224ae17c8fcb0..54f21ef0614d0282253baf8d3c00375c8cf22578 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -529,6 +529,11 @@ public class PaperWorldConfig { +@@ -531,6 +531,11 @@ public class PaperWorldConfig { nerfNetherPortalPigmen = getBoolean("game-mechanics.nerf-pigmen-from-nether-portals", nerfNetherPortalPigmen); } diff --git a/patches/server/0379-Optimise-Chunk-getFluid.patch b/patches/server/0380-Optimise-Chunk-getFluid.patch similarity index 92% rename from patches/server/0379-Optimise-Chunk-getFluid.patch rename to patches/server/0380-Optimise-Chunk-getFluid.patch index d8c61122b..9c772f1f6 100644 --- a/patches/server/0379-Optimise-Chunk-getFluid.patch +++ b/patches/server/0380-Optimise-Chunk-getFluid.patch @@ -8,7 +8,7 @@ faster on its own, however removing the try catch makes it easier to inline due to code size 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 a009122a8ea9dc2b04a178248f20ef01886e832b..e3b57c423244be04662576ecdc90a98fefe8e1b4 100644 +index 0e89cf3fd6edf28b52ec113af31267642fd2b195..a80762a8acc5669dd9531d6514032318bae725f6 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -373,18 +373,20 @@ public class LevelChunk extends ChunkAccess { @@ -47,10 +47,10 @@ index a009122a8ea9dc2b04a178248f20ef01886e832b..e3b57c423244be04662576ecdc90a98f // 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 50b6ecfea7a342be0d21e37ae87777a4b4860026..f9e871cff9318e6fea92d5b7a7035b3bfa259bca 100644 +index 512f53b24de14ea48eab85a0e725556d92def6e9..836f036550cf76f40d6e0eb8b229238d311c1e35 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java -@@ -48,7 +48,7 @@ public class LevelChunkSection { +@@ -51,7 +51,7 @@ public class LevelChunkSection { } public FluidState getFluidState(int x, int y, int z) { diff --git a/patches/server/0380-Set-spigots-verbose-world-setting-to-false-by-def.patch b/patches/server/0381-Set-spigots-verbose-world-setting-to-false-by-def.patch similarity index 89% rename from patches/server/0380-Set-spigots-verbose-world-setting-to-false-by-def.patch rename to patches/server/0381-Set-spigots-verbose-world-setting-to-false-by-def.patch index 8fb045eb9..4b0c8ea94 100644 --- a/patches/server/0380-Set-spigots-verbose-world-setting-to-false-by-def.patch +++ b/patches/server/0381-Set-spigots-verbose-world-setting-to-false-by-def.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Set spigots verbose world setting to false by def diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java -index 6d36aa5006d3adc3ff30d196bdfd287ad38a564a..3de37f8eb99a41a8d99f22ed0afc81f44254f1d2 100644 +index 6dd8adabc23931c8e4b8f448bd867207ed25c385..f7f7313ff4ff4b2cb21b64ef29b5900e39f52ad1 100644 --- a/src/main/java/org/spigotmc/SpigotWorldConfig.java +++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java @@ -20,7 +20,7 @@ public class SpigotWorldConfig diff --git a/patches/server/0381-Add-tick-times-API-and-mspt-command.patch b/patches/server/0382-Add-tick-times-API-and-mspt-command.patch similarity index 98% rename from patches/server/0381-Add-tick-times-API-and-mspt-command.patch rename to patches/server/0382-Add-tick-times-API-and-mspt-command.patch index 2ff9bfcbc..c58f7b3e4 100644 --- a/patches/server/0381-Add-tick-times-API-and-mspt-command.patch +++ b/patches/server/0382-Add-tick-times-API-and-mspt-command.patch @@ -146,7 +146,7 @@ index b80a7d98d4b088e3cc98c3d6f9b053974a71c568..64370c9c5e443f8e84e7f2f018c56f02 + // Paper end } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 8d1cbefc82f64a120eeea8c6bdd6361ffa513099..f8ea93b531a3162f6d14dedf5f0c6abfa575930a 100644 +index 6a16faf62f6d93c1ada5942e5886b37bd9f78c83..1e80d1691ff62ec60b8ba71e526ef51b7a1a1c6c 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -2426,6 +2426,16 @@ public final class CraftServer implements Server { diff --git a/patches/server/0382-Expose-MinecraftServer-isRunning.patch b/patches/server/0383-Expose-MinecraftServer-isRunning.patch similarity index 90% rename from patches/server/0382-Expose-MinecraftServer-isRunning.patch rename to patches/server/0383-Expose-MinecraftServer-isRunning.patch index d3d2072d1..fa5dde576 100644 --- a/patches/server/0382-Expose-MinecraftServer-isRunning.patch +++ b/patches/server/0383-Expose-MinecraftServer-isRunning.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Expose MinecraftServer#isRunning This allows for plugins to detect if the server is actually turning off in onDisable rather than just plugins reloading. diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index f8ea93b531a3162f6d14dedf5f0c6abfa575930a..b9b5c7c3d4e991dd62ed7acb33e02c2523fe5d46 100644 +index 1e80d1691ff62ec60b8ba71e526ef51b7a1a1c6c..53c7e3bed9f116d9287b2881ca6c7c31346e22e6 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -2603,5 +2603,10 @@ public final class CraftServer implements Server { diff --git a/patches/server/0383-Add-Raw-Byte-ItemStack-Serialization.patch b/patches/server/0384-Add-Raw-Byte-ItemStack-Serialization.patch similarity index 96% rename from patches/server/0383-Add-Raw-Byte-ItemStack-Serialization.patch rename to patches/server/0384-Add-Raw-Byte-ItemStack-Serialization.patch index a923354dc..318f55574 100644 --- a/patches/server/0383-Add-Raw-Byte-ItemStack-Serialization.patch +++ b/patches/server/0384-Add-Raw-Byte-ItemStack-Serialization.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Add Raw Byte ItemStack Serialization Serializes using NBT which is safer for server data migrations than bukkits format. diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java -index 8f39acd1707fd8989b81fb715a8481733d1eb20d..0bb3290f3ff23d7f653ce87943d7c6d156770926 100644 +index 6487c87dbb3b8c019254581cb40875ad083d5a62..19401098850f3fecaaea1f27ff4febd7bda1f7c9 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java @@ -395,6 +395,53 @@ public final class CraftMagicNumbers implements UnsafeValues { diff --git a/patches/server/0384-Pillager-patrol-spawn-settings-and-per-player-option.patch b/patches/server/0385-Pillager-patrol-spawn-settings-and-per-player-option.patch similarity index 97% rename from patches/server/0384-Pillager-patrol-spawn-settings-and-per-player-option.patch rename to patches/server/0385-Pillager-patrol-spawn-settings-and-per-player-option.patch index f1c4bb7b1..466119167 100644 --- a/patches/server/0384-Pillager-patrol-spawn-settings-and-per-player-option.patch +++ b/patches/server/0385-Pillager-patrol-spawn-settings-and-per-player-option.patch @@ -10,10 +10,10 @@ When not per player it will use the Vanilla mechanic of one delay per world and the world age for the start day. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 043cdbfe6c339f8d99a2251ccd5e293997f32b09..30e11433fc1db8c2b7b247dd584f5288b2bb67b0 100644 +index 54f21ef0614d0282253baf8d3c00375c8cf22578..4934ad2cce62856429ffb5a7c7ccda55b5f6bf0b 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -503,10 +503,21 @@ public class PaperWorldConfig { +@@ -505,10 +505,21 @@ public class PaperWorldConfig { } public boolean disablePillagerPatrols = false; diff --git a/patches/server/0385-Remote-Connections-shouldn-t-hold-up-shutdown.patch b/patches/server/0386-Remote-Connections-shouldn-t-hold-up-shutdown.patch similarity index 100% rename from patches/server/0385-Remote-Connections-shouldn-t-hold-up-shutdown.patch rename to patches/server/0386-Remote-Connections-shouldn-t-hold-up-shutdown.patch diff --git a/patches/server/0386-Do-not-allow-bees-to-load-chunks-for-beehives.patch b/patches/server/0387-Do-not-allow-bees-to-load-chunks-for-beehives.patch similarity index 100% rename from patches/server/0386-Do-not-allow-bees-to-load-chunks-for-beehives.patch rename to patches/server/0387-Do-not-allow-bees-to-load-chunks-for-beehives.patch diff --git a/patches/server/0387-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch b/patches/server/0388-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch similarity index 93% rename from patches/server/0387-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch rename to patches/server/0388-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch index d956e5242..50383b784 100644 --- a/patches/server/0387-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch +++ b/patches/server/0388-Prevent-Double-PlayerChunkMap-adds-crashing-server.patch @@ -7,7 +7,7 @@ Suspected case would be around the technique used in .stopRiding Stack will identify any causer of this and warn instead of crashing. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index f1fa28fb90f07a4e2de541b2f7ca2f2d7c1d6a31..01f87e67d6760b295d7333973f39f8ff6ef3cee5 100644 +index 0d3c4ce4f5de65a7a6446cde133d51ec76c25ffc..d28657e541aa84f0aca2f4312636c1bdbb58a8f4 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -1579,6 +1579,14 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -26,7 +26,7 @@ index f1fa28fb90f07a4e2de541b2f7ca2f2d7c1d6a31..01f87e67d6760b295d7333973f39f8ff EntityType entitytypes = entity.getType(); int i = entitytypes.clientTrackingRange() * 16; diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index e7ae70ae59b65a8577bf4dc065fb729a3d5c5d95..cda574e825164587bd126029d5b556c049c18015 100644 +index a21300a866dc6c9f7097a894e0506515210090f5..3d4961418f3ee7e2d421738d8a8104aac09361d6 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -2170,7 +2170,7 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0388-Don-t-tick-dead-players.patch b/patches/server/0389-Don-t-tick-dead-players.patch similarity index 100% rename from patches/server/0388-Don-t-tick-dead-players.patch rename to patches/server/0389-Don-t-tick-dead-players.patch diff --git a/patches/server/0389-Dead-Player-s-shouldn-t-be-able-to-move.patch b/patches/server/0390-Dead-Player-s-shouldn-t-be-able-to-move.patch similarity index 90% rename from patches/server/0389-Dead-Player-s-shouldn-t-be-able-to-move.patch rename to patches/server/0390-Dead-Player-s-shouldn-t-be-able-to-move.patch index 5a142a932..b069a347d 100644 --- a/patches/server/0389-Dead-Player-s-shouldn-t-be-able-to-move.patch +++ b/patches/server/0390-Dead-Player-s-shouldn-t-be-able-to-move.patch @@ -7,7 +7,7 @@ This fixes a lot of game state issues where packets were delayed for processing due to 1.15's new queue but processed while dead. diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 6927eeb04a9aa1a33666f3655f2bb889bf046dc9..869c765fba6b8b7f37f0699a05b74b312dfde30d 100644 +index 09bb891fb1274027ea0696a0319816d05d4dc5bc..14bcc4642d7dd81e5bc30f40e3c9d8269d409d20 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -1106,7 +1106,7 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0390-Optimize-Collision-to-not-load-chunks.patch b/patches/server/0391-Optimize-Collision-to-not-load-chunks.patch similarity index 98% rename from patches/server/0390-Optimize-Collision-to-not-load-chunks.patch rename to patches/server/0391-Optimize-Collision-to-not-load-chunks.patch index 144ae76af..bac7f60c8 100644 --- a/patches/server/0390-Optimize-Collision-to-not-load-chunks.patch +++ b/patches/server/0391-Optimize-Collision-to-not-load-chunks.patch @@ -14,7 +14,7 @@ movement will load only the chunk the player enters anyways and avoids loading massive amounts of surrounding chunks due to large AABB lookups. diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 494b18a3dfa05b5e6ecbb9b99abf06bfe6e1d166..5c54bc74c668778161ae47c9160f8c4c9a566847 100644 +index 5d4ef973781eac558c1e8d749f751c04a67c4693..33b607227718e08f26d7ab5744bbbff806f33366 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -791,6 +791,7 @@ public abstract class PlayerList { diff --git a/patches/server/0391-Don-t-move-existing-players-to-world-spawn.patch b/patches/server/0392-Don-t-move-existing-players-to-world-spawn.patch similarity index 96% rename from patches/server/0391-Don-t-move-existing-players-to-world-spawn.patch rename to patches/server/0392-Don-t-move-existing-players-to-world-spawn.patch index e5f4afae4..f59f642d8 100644 --- a/patches/server/0391-Don-t-move-existing-players-to-world-spawn.patch +++ b/patches/server/0392-Don-t-move-existing-players-to-world-spawn.patch @@ -32,7 +32,7 @@ index fd609c7b757b570206c17444867f786c1767aa69..d507adcb538933fcf36e9a4bfb561106 this.gameMode.setLevel((ServerLevel) world); } diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 5c54bc74c668778161ae47c9160f8c4c9a566847..8901bb31524613bf3fbec3cc5d3c228f8b3f43a4 100644 +index 33b607227718e08f26d7ab5744bbbff806f33366..e1d729d86d11f9bc9452b7382f12aeb668c19936 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -210,6 +210,8 @@ public abstract class PlayerList { diff --git a/patches/server/0392-Optimize-GoalSelector-Goal.Flag-Set-operations.patch b/patches/server/0393-Optimize-GoalSelector-Goal.Flag-Set-operations.patch similarity index 100% rename from patches/server/0392-Optimize-GoalSelector-Goal.Flag-Set-operations.patch rename to patches/server/0393-Optimize-GoalSelector-Goal.Flag-Set-operations.patch diff --git a/patches/server/0393-Improved-Watchdog-Support.patch b/patches/server/0394-Improved-Watchdog-Support.patch similarity index 98% rename from patches/server/0393-Improved-Watchdog-Support.patch rename to patches/server/0394-Improved-Watchdog-Support.patch index 246d03f96..8b9e4d470 100644 --- a/patches/server/0393-Improved-Watchdog-Support.patch +++ b/patches/server/0394-Improved-Watchdog-Support.patch @@ -262,7 +262,7 @@ index 049eb5693dc98e1d0ec3bd88c73a41fdb2f59bff..0716aaf29f9d76240a0de4ca02daba44 } diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index b20e9664cc55c2da53b8aa3def5bf9376b68baf8..a87b62070b25ba429ec606ace2401b0b010de5bf 100644 +index d28657e541aa84f0aca2f4312636c1bdbb58a8f4..c8b31c031d276a883d7367f673a72e1f090062ed 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -552,6 +552,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -299,10 +299,10 @@ index 7bf4bf5cb2c1b54a7e2733091f48f3a824336d36..dcce05d2f4ab16424db4ab103a12188e } diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 9842e4d39130f45481b643df38ee4b25076c5c08..4a77494ddb94d5fd2d82665c6bd4e513b66f1d9f 100644 +index 9154f434ab1a1b11d19cef8fc80f351f3eefcb57..5abdb1c0247fde6da03e7689d5e2abab54f116d1 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -831,6 +831,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -834,6 +834,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { try { tickConsumer.accept(entity); } catch (Throwable throwable) { @@ -311,7 +311,7 @@ index 9842e4d39130f45481b643df38ee4b25076c5c08..4a77494ddb94d5fd2d82665c6bd4e513 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); 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 e3b57c423244be04662576ecdc90a98fefe8e1b4..8c4cd4a82dcf5295a992c37914d3124d6615148a 100644 +index a80762a8acc5669dd9531d6514032318bae725f6..f7388d37b467d1c153fcf8002eedd20417f93d52 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -1070,6 +1070,7 @@ public class LevelChunk extends ChunkAccess { @@ -323,7 +323,7 @@ index e3b57c423244be04662576ecdc90a98fefe8e1b4..8c4cd4a82dcf5295a992c37914d3124d final String msg = String.format("BlockEntity threw exception at %s:%s,%s,%s", LevelChunk.this.getLevel().getWorld().getName(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ()); net.minecraft.server.MinecraftServer.LOGGER.error(msg, throwable); diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index b9b5c7c3d4e991dd62ed7acb33e02c2523fe5d46..c7e2ce7d2fa80c6c97ebe94ec5c36c9eb7356f45 100644 +index 53c7e3bed9f116d9287b2881ca6c7c31346e22e6..406452c014e3bf9639a4e6ce20052c22da390c09 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -2049,7 +2049,7 @@ public final class CraftServer implements Server { diff --git a/patches/server/0394-Optimize-Pathfinding.patch b/patches/server/0395-Optimize-Pathfinding.patch similarity index 100% rename from patches/server/0394-Optimize-Pathfinding.patch rename to patches/server/0395-Optimize-Pathfinding.patch diff --git a/patches/server/0395-Reduce-Either-Optional-allocation.patch b/patches/server/0396-Reduce-Either-Optional-allocation.patch similarity index 100% rename from patches/server/0395-Reduce-Either-Optional-allocation.patch rename to patches/server/0396-Reduce-Either-Optional-allocation.patch diff --git a/patches/server/0396-Reduce-memory-footprint-of-NBTTagCompound.patch b/patches/server/0397-Reduce-memory-footprint-of-NBTTagCompound.patch similarity index 100% rename from patches/server/0396-Reduce-memory-footprint-of-NBTTagCompound.patch rename to patches/server/0397-Reduce-memory-footprint-of-NBTTagCompound.patch diff --git a/patches/server/0397-Prevent-opening-inventories-when-frozen.patch b/patches/server/0398-Prevent-opening-inventories-when-frozen.patch similarity index 100% rename from patches/server/0397-Prevent-opening-inventories-when-frozen.patch rename to patches/server/0398-Prevent-opening-inventories-when-frozen.patch diff --git a/patches/server/0398-Optimise-ArraySetSorted-removeIf.patch b/patches/server/0399-Optimise-ArraySetSorted-removeIf.patch similarity index 100% rename from patches/server/0398-Optimise-ArraySetSorted-removeIf.patch rename to patches/server/0399-Optimise-ArraySetSorted-removeIf.patch diff --git a/patches/server/0399-Don-t-run-entity-collision-code-if-not-needed.patch b/patches/server/0400-Don-t-run-entity-collision-code-if-not-needed.patch similarity index 93% rename from patches/server/0399-Don-t-run-entity-collision-code-if-not-needed.patch rename to patches/server/0400-Don-t-run-entity-collision-code-if-not-needed.patch index c41c482f7..26127f560 100644 --- a/patches/server/0399-Don-t-run-entity-collision-code-if-not-needed.patch +++ b/patches/server/0400-Don-t-run-entity-collision-code-if-not-needed.patch @@ -7,7 +7,7 @@ Will not run if max entity craming is disabled and the max collisions per entity is less than or equal to 0 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index 06c32d50d6672d2816c8cb1b4ef0dc038ffce817..ba3aae873c2bd23a1bb35bb7746907d0bcfd0dd3 100644 +index e8501f18f5021678fad09cb5e600c7fc3660fe52..f0af402ec09a1893e9d7ddd6aa355fd262f3b631 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java @@ -3261,10 +3261,16 @@ public abstract class LivingEntity extends Entity { diff --git a/patches/server/0400-Implement-Player-Client-Options-API.patch b/patches/server/0401-Implement-Player-Client-Options-API.patch similarity index 98% rename from patches/server/0400-Implement-Player-Client-Options-API.patch rename to patches/server/0401-Implement-Player-Client-Options-API.patch index 97ff1aa74..9a7b8bce1 100644 --- a/patches/server/0400-Implement-Player-Client-Options-API.patch +++ b/patches/server/0401-Implement-Player-Client-Options-API.patch @@ -97,7 +97,7 @@ index 9cbca14b0a111e57a1d01bcbcf2164ab8b53b1a5..cdb0eb8e21299ca70ed7ed5c1195d07f if (getMainArm() != packet.mainHand()) { PlayerChangedMainHandEvent event = new PlayerChangedMainHandEvent(this.getBukkitEntity(), getMainArm() == HumanoidArm.LEFT ? MainHand.LEFT : MainHand.RIGHT); diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index 74f1bee84823bf6dac9fdecd47ec492071c07169..c9d2777748f2df4260fa2a7df4ddb090524fa9f8 100644 +index 8059715ce7328cc81cb4decddf0fb012905a08a2..c852759b9a925b5d3377a3cf062a378d39c879fd 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -545,6 +545,24 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0401-Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch b/patches/server/0402-Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch similarity index 100% rename from patches/server/0401-Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch rename to patches/server/0402-Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch diff --git a/patches/server/0402-Broadcast-join-message-to-console.patch b/patches/server/0403-Broadcast-join-message-to-console.patch similarity index 92% rename from patches/server/0402-Broadcast-join-message-to-console.patch rename to patches/server/0403-Broadcast-join-message-to-console.patch index 52a54fe6e..2dc045191 100644 --- a/patches/server/0402-Broadcast-join-message-to-console.patch +++ b/patches/server/0403-Broadcast-join-message-to-console.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Broadcast join message to console diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 4e26475bf0f541d6b2f8b6eccfeaeb9ee5b4b2b8..7889f6bb645694b715eb832eb0675f79d80f09e8 100644 +index dc6ea42139774d1cd4ff856781abb0327fd0da4c..734f74e4ef178ae4b887bccdd571d9b269b29abe 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -293,7 +293,9 @@ public abstract class PlayerList { diff --git a/patches/server/0403-Fix-Chunk-Post-Processing-deadlock-risk.patch b/patches/server/0404-Fix-Chunk-Post-Processing-deadlock-risk.patch similarity index 94% rename from patches/server/0403-Fix-Chunk-Post-Processing-deadlock-risk.patch rename to patches/server/0404-Fix-Chunk-Post-Processing-deadlock-risk.patch index 18656d981..12b578aef 100644 --- a/patches/server/0403-Fix-Chunk-Post-Processing-deadlock-risk.patch +++ b/patches/server/0404-Fix-Chunk-Post-Processing-deadlock-risk.patch @@ -25,7 +25,7 @@ This successfully fixed a reoccurring and highly reproduceable crash for heightmaps. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index 368dc3a7bd04b106db5b83d73dcab2e09c8d8af9..dd73ab00d74b918548ae5ef810c07a8c1f349475 100644 +index c8b31c031d276a883d7367f673a72e1f090062ed..02412224e87603520a578c77b737f352ae0c4fb9 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -174,6 +174,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -46,7 +46,7 @@ index 368dc3a7bd04b106db5b83d73dcab2e09c8d8af9..dd73ab00d74b918548ae5ef810c07a8c completablefuture1.thenAcceptAsync((either) -> { diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 0af558b8246cc5661c2be6655cc0658519456202..a66d9d6df1fc0ad68f51ea96d4e1a2d725c73b05 100644 +index 1eab367b375bb7bf6fadb602f378f6817e519371..3c36dfa4f4c6025b02ec455d997f13226de75a64 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -1144,6 +1144,7 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0404-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch b/patches/server/0405-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch similarity index 96% rename from patches/server/0404-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch rename to patches/server/0405-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch index fb0ffb485..ee69ca475 100644 --- a/patches/server/0404-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch +++ b/patches/server/0405-Fix-Longstanding-Broken-behavior-of-PlayerJoinEvent.patch @@ -28,7 +28,7 @@ receives a deterministic result, and should no longer require 1 tick delays anymore. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index dd73ab00d74b918548ae5ef810c07a8c1f349475..0d4d400b6f0b0d939dac7887da793c21ac6bfb1b 100644 +index 02412224e87603520a578c77b737f352ae0c4fb9..64ae7eca9544d68826de8186142bb671153a8ba0 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -1588,6 +1588,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -52,7 +52,7 @@ index cdb0eb8e21299ca70ed7ed5c1195d07f44e47838..6d59a813aa752b4233dbe1894cfc8273 // CraftBukkit end public PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 7889f6bb645694b715eb832eb0675f79d80f09e8..792e2a4407dfcee691f53f1bc1342da2c2cebbb4 100644 +index 734f74e4ef178ae4b887bccdd571d9b269b29abe..0a097f5bd7ce5aab3f4fba111d6dfb3d16c229c9 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -276,6 +276,12 @@ public abstract class PlayerList { diff --git a/patches/server/0405-Load-Chunks-for-Login-Asynchronously.patch b/patches/server/0406-Load-Chunks-for-Login-Asynchronously.patch similarity index 99% rename from patches/server/0405-Load-Chunks-for-Login-Asynchronously.patch rename to patches/server/0406-Load-Chunks-for-Login-Asynchronously.patch index 7e7924a75..01f626cf5 100644 --- a/patches/server/0405-Load-Chunks-for-Login-Asynchronously.patch +++ b/patches/server/0406-Load-Chunks-for-Login-Asynchronously.patch @@ -96,7 +96,7 @@ index bb767f5b626225e70a8af273384bb74dbd21430d..301042e7a0d372a914f27ec0988dd938 try { ServerPlayer entityplayer1 = this.server.getPlayerList().getPlayerForLogin(this.gameProfile, s); // CraftBukkit - add player reference diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 792e2a4407dfcee691f53f1bc1342da2c2cebbb4..30fa9ac91be2ecc55efeee9222835cbedc53acff 100644 +index 0a097f5bd7ce5aab3f4fba111d6dfb3d16c229c9..9b7fcd8be912cd211b6226386bd3340076953442 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -39,6 +39,7 @@ import net.minecraft.network.protocol.Packet; diff --git a/patches/server/0406-Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch b/patches/server/0407-Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch similarity index 100% rename from patches/server/0406-Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch rename to patches/server/0407-Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch diff --git a/patches/server/0407-Add-PlayerAttackEntityCooldownResetEvent.patch b/patches/server/0408-Add-PlayerAttackEntityCooldownResetEvent.patch similarity index 95% rename from patches/server/0407-Add-PlayerAttackEntityCooldownResetEvent.patch rename to patches/server/0408-Add-PlayerAttackEntityCooldownResetEvent.patch index 9a5fb8020..8256db430 100644 --- a/patches/server/0407-Add-PlayerAttackEntityCooldownResetEvent.patch +++ b/patches/server/0408-Add-PlayerAttackEntityCooldownResetEvent.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add PlayerAttackEntityCooldownResetEvent diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java -index ba3aae873c2bd23a1bb35bb7746907d0bcfd0dd3..6c4fd054a06830947dbb4728e62dc320a51f43f0 100644 +index f0af402ec09a1893e9d7ddd6aa355fd262f3b631..d23b82e5b6168ea618922f46a0e1ee7f46fad8f9 100644 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java @@ -2039,7 +2039,16 @@ public abstract class LivingEntity extends Entity { diff --git a/patches/server/0408-Don-t-fire-BlockFade-on-worldgen-threads.patch b/patches/server/0409-Don-t-fire-BlockFade-on-worldgen-threads.patch similarity index 100% rename from patches/server/0408-Don-t-fire-BlockFade-on-worldgen-threads.patch rename to patches/server/0409-Don-t-fire-BlockFade-on-worldgen-threads.patch diff --git a/patches/server/0409-Add-phantom-creative-and-insomniac-controls.patch b/patches/server/0410-Add-phantom-creative-and-insomniac-controls.patch similarity index 96% rename from patches/server/0409-Add-phantom-creative-and-insomniac-controls.patch rename to patches/server/0410-Add-phantom-creative-and-insomniac-controls.patch index b098b72d3..4a32ba2cf 100644 --- a/patches/server/0409-Add-phantom-creative-and-insomniac-controls.patch +++ b/patches/server/0410-Add-phantom-creative-and-insomniac-controls.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add phantom creative and insomniac controls diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 30e11433fc1db8c2b7b247dd584f5288b2bb67b0..aa5c1f07dc743ccbbf7f60c9868a82b9ef38c08c 100644 +index 4934ad2cce62856429ffb5a7c7ccda55b5f6bf0b..04fc04422ae90ca636319e9c1a439ccbd0980a3a 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -605,4 +605,11 @@ public class PaperWorldConfig { +@@ -642,4 +642,11 @@ public class PaperWorldConfig { } perPlayerMobSpawns = getBoolean("per-player-mob-spawns", true); } diff --git a/patches/server/0410-Fix-numerous-item-duplication-issues-and-teleport-is.patch b/patches/server/0411-Fix-numerous-item-duplication-issues-and-teleport-is.patch similarity index 100% rename from patches/server/0410-Fix-numerous-item-duplication-issues-and-teleport-is.patch rename to patches/server/0411-Fix-numerous-item-duplication-issues-and-teleport-is.patch diff --git a/patches/server/0411-Villager-Restocks-API.patch b/patches/server/0412-Villager-Restocks-API.patch similarity index 100% rename from patches/server/0411-Villager-Restocks-API.patch rename to patches/server/0412-Villager-Restocks-API.patch diff --git a/patches/server/0412-Validate-PickItem-Packet-and-kick-for-invalid.patch b/patches/server/0413-Validate-PickItem-Packet-and-kick-for-invalid.patch similarity index 100% rename from patches/server/0412-Validate-PickItem-Packet-and-kick-for-invalid.patch rename to patches/server/0413-Validate-PickItem-Packet-and-kick-for-invalid.patch diff --git a/patches/server/0413-Expose-game-version.patch b/patches/server/0414-Expose-game-version.patch similarity index 89% rename from patches/server/0413-Expose-game-version.patch rename to patches/server/0414-Expose-game-version.patch index e2501256c..b95057d6e 100644 --- a/patches/server/0413-Expose-game-version.patch +++ b/patches/server/0414-Expose-game-version.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Expose game version diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index c7e2ce7d2fa80c6c97ebe94ec5c36c9eb7356f45..6b9fedc5abeab73a74ca86ee7c3893e0bdc24dd6 100644 +index 406452c014e3bf9639a4e6ce20052c22da390c09..0790dda63aa76b2f5e0133338f9f5accf8a6bdb9 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -579,6 +579,13 @@ public final class CraftServer implements Server { diff --git a/patches/server/0414-Optimize-Voxel-Shape-Merging.patch b/patches/server/0415-Optimize-Voxel-Shape-Merging.patch similarity index 100% rename from patches/server/0414-Optimize-Voxel-Shape-Merging.patch rename to patches/server/0415-Optimize-Voxel-Shape-Merging.patch diff --git a/patches/server/0415-Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch b/patches/server/0416-Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch similarity index 100% rename from patches/server/0415-Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch rename to patches/server/0416-Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch diff --git a/patches/server/0416-misc-debugging-dumps.patch b/patches/server/0417-misc-debugging-dumps.patch similarity index 96% rename from patches/server/0416-misc-debugging-dumps.patch rename to patches/server/0417-misc-debugging-dumps.patch index 9bb15646d..c33ba2d26 100644 --- a/patches/server/0416-misc-debugging-dumps.patch +++ b/patches/server/0417-misc-debugging-dumps.patch @@ -29,7 +29,7 @@ index 0000000000000000000000000000000000000000..2d5494d2813b773e60ddba6790b750a9 + } +} diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 77820cd4d464f2582b57f60d34bc0c2f3622e4ae..7ca3752aa6f4e626c4437857821000101162b2bc 100644 +index cab914abbc6c655895f09d71f253889a0dcc4e02..7792947e9eb8e2d5d4b3ccda4fa135bf57951a94 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -918,6 +918,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop list = Lists.newArrayList(); List list1 = this.level.players(); ObjectIterator objectiterator = this.entityMap.values().iterator(); -@@ -1777,23 +1875,31 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider +@@ -1782,23 +1880,31 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider DebugPackets.sendPoiPacketsForChunk(this.level, chunk.getPos()); List list = Lists.newArrayList(); List list1 = Lists.newArrayList(); @@ -236,7 +236,7 @@ index 8e009c52070e0a939a479942d0ff4202f4463ad0..ea61f5df9a0998272dd5da1332aa0fbb Iterator iterator; Entity entity1; -@@ -1869,6 +1975,42 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider +@@ -1874,6 +1980,42 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider this.lastSectionPos = SectionPos.of(entity); } diff --git a/patches/server/0434-Optimize-ServerLevels-chunk-level-checking-methods.patch b/patches/server/0435-Optimize-ServerLevels-chunk-level-checking-methods.patch similarity index 97% rename from patches/server/0434-Optimize-ServerLevels-chunk-level-checking-methods.patch rename to patches/server/0435-Optimize-ServerLevels-chunk-level-checking-methods.patch index 864655d94..de7b0077a 100644 --- a/patches/server/0434-Optimize-ServerLevels-chunk-level-checking-methods.patch +++ b/patches/server/0435-Optimize-ServerLevels-chunk-level-checking-methods.patch @@ -8,7 +8,7 @@ so inline where possible, and avoid the abstraction of the Either class. diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index cda574e825164587bd126029d5b556c049c18015..a5f0fe87bd5d75bf9a12ef284b0d635d8f6dd3a1 100644 +index 3d4961418f3ee7e2d421738d8a8104aac09361d6..fe572c99263a44a23e2dc5141295d98973684a88 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -2139,15 +2139,18 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0435-Delay-Chunk-Unloads-based-on-Player-Movement.patch b/patches/server/0436-Delay-Chunk-Unloads-based-on-Player-Movement.patch similarity index 93% rename from patches/server/0435-Delay-Chunk-Unloads-based-on-Player-Movement.patch rename to patches/server/0436-Delay-Chunk-Unloads-based-on-Player-Movement.patch index 800575190..ca87225a2 100644 --- a/patches/server/0435-Delay-Chunk-Unloads-based-on-Player-Movement.patch +++ b/patches/server/0436-Delay-Chunk-Unloads-based-on-Player-Movement.patch @@ -17,13 +17,14 @@ This allows servers with smaller worlds who do less long distance exploring to s wasting cpu cycles on saving/unloading/reloading chunks repeatedly. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 7b3d3b3c6c73fb146c3be29aaaac77fee5824f91..845f105457d659a4bd88d4a8ce91b20d6abb7865 100644 +index 23badcb54f89dc75d60017b7742568b30811c3f3..1b31b68ed00df972eb32b9749993478fbd9fab6b 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -550,6 +550,15 @@ public class PaperWorldConfig { - lightQueueSize = getInt("light-queue-size", lightQueueSize); +@@ -655,4 +655,13 @@ public class PaperWorldConfig { + expMergeMaxValue = getInt("experience-merge-max-value", -1); + log("Experience Merge Max Value: " + expMergeMaxValue); } - ++ + public long delayChunkUnloadsBy; + private void delayChunkUnloadsBy() { + delayChunkUnloadsBy = PaperConfig.getSeconds(getString("delay-chunk-unloads-by", "10s")); @@ -32,10 +33,7 @@ index 7b3d3b3c6c73fb146c3be29aaaac77fee5824f91..845f105457d659a4bd88d4a8ce91b20d + delayChunkUnloadsBy *= 20; + } + } -+ - public boolean altItemDespawnRateEnabled; - public java.util.Map altItemDespawnRateMap; - private void altItemDespawnRate() { + } diff --git a/src/main/java/net/minecraft/server/level/DistanceManager.java b/src/main/java/net/minecraft/server/level/DistanceManager.java index 95f195980e28bb59f43e5ca1d5e79ebe8c3ddaea..84dc1e94b4f7b8315d8422634dd49b1f85044d18 100644 --- a/src/main/java/net/minecraft/server/level/DistanceManager.java diff --git a/patches/server/0436-Fix-villager-trading-demand-MC-163962.patch b/patches/server/0437-Fix-villager-trading-demand-MC-163962.patch similarity index 100% rename from patches/server/0436-Fix-villager-trading-demand-MC-163962.patch rename to patches/server/0437-Fix-villager-trading-demand-MC-163962.patch diff --git a/patches/server/0437-Maps-shouldn-t-load-chunks.patch b/patches/server/0438-Maps-shouldn-t-load-chunks.patch similarity index 100% rename from patches/server/0437-Maps-shouldn-t-load-chunks.patch rename to patches/server/0438-Maps-shouldn-t-load-chunks.patch diff --git a/patches/server/0438-Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch b/patches/server/0439-Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch similarity index 100% rename from patches/server/0438-Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch rename to patches/server/0439-Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch diff --git a/patches/server/0439-Fix-missing-chunks-due-to-integer-overflow.patch b/patches/server/0440-Fix-missing-chunks-due-to-integer-overflow.patch similarity index 100% rename from patches/server/0439-Fix-missing-chunks-due-to-integer-overflow.patch rename to patches/server/0440-Fix-missing-chunks-due-to-integer-overflow.patch diff --git a/patches/server/0440-Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch b/patches/server/0441-Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch similarity index 100% rename from patches/server/0440-Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch rename to patches/server/0441-Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch diff --git a/patches/server/0441-Fix-piston-physics-inconsistency-MC-188840.patch b/patches/server/0442-Fix-piston-physics-inconsistency-MC-188840.patch similarity index 100% rename from patches/server/0441-Fix-piston-physics-inconsistency-MC-188840.patch rename to patches/server/0442-Fix-piston-physics-inconsistency-MC-188840.patch diff --git a/patches/server/0442-Fix-sand-duping.patch b/patches/server/0443-Fix-sand-duping.patch similarity index 100% rename from patches/server/0442-Fix-sand-duping.patch rename to patches/server/0443-Fix-sand-duping.patch diff --git a/patches/server/0443-Prevent-position-desync-in-playerconnection-causing-.patch b/patches/server/0444-Prevent-position-desync-in-playerconnection-causing-.patch similarity index 100% rename from patches/server/0443-Prevent-position-desync-in-playerconnection-causing-.patch rename to patches/server/0444-Prevent-position-desync-in-playerconnection-causing-.patch diff --git a/patches/server/0444-Inventory-getHolder-method-without-block-snapshot.patch b/patches/server/0445-Inventory-getHolder-method-without-block-snapshot.patch similarity index 100% rename from patches/server/0444-Inventory-getHolder-method-without-block-snapshot.patch rename to patches/server/0445-Inventory-getHolder-method-without-block-snapshot.patch diff --git a/patches/server/0445-Expose-Arrow-getItemStack.patch b/patches/server/0446-Expose-Arrow-getItemStack.patch similarity index 100% rename from patches/server/0445-Expose-Arrow-getItemStack.patch rename to patches/server/0446-Expose-Arrow-getItemStack.patch diff --git a/patches/server/0446-Add-and-implement-PlayerRecipeBookClickEvent.patch b/patches/server/0447-Add-and-implement-PlayerRecipeBookClickEvent.patch similarity index 100% rename from patches/server/0446-Add-and-implement-PlayerRecipeBookClickEvent.patch rename to patches/server/0447-Add-and-implement-PlayerRecipeBookClickEvent.patch diff --git a/patches/server/0447-Hide-sync-chunk-writes-behind-flag.patch b/patches/server/0448-Hide-sync-chunk-writes-behind-flag.patch similarity index 100% rename from patches/server/0447-Hide-sync-chunk-writes-behind-flag.patch rename to patches/server/0448-Hide-sync-chunk-writes-behind-flag.patch diff --git a/patches/server/0448-Add-permission-for-command-blocks.patch b/patches/server/0449-Add-permission-for-command-blocks.patch similarity index 97% rename from patches/server/0448-Add-permission-for-command-blocks.patch rename to patches/server/0449-Add-permission-for-command-blocks.patch index ac6e27327..07a74e38d 100644 --- a/patches/server/0448-Add-permission-for-command-blocks.patch +++ b/patches/server/0449-Add-permission-for-command-blocks.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add permission for command blocks diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -index 44e5ab0b545de41b937c7ce304ce643f78a43734..f087f48ad9e0b28d9874f3a9c1e3988ce6b60d87 100644 +index a85b89a0d525e623e154c8b1bea55470d2072dcb..4f1430c71aff4959b1db76200fe750a6c44cef68 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -@@ -389,7 +389,7 @@ public class ServerPlayerGameMode { +@@ -391,7 +391,7 @@ public class ServerPlayerGameMode { BlockEntity tileentity = this.level.getBlockEntity(pos); Block block = iblockdata.getBlock(); diff --git a/patches/server/0449-Ensure-Entity-AABB-s-are-never-invalid.patch b/patches/server/0450-Ensure-Entity-AABB-s-are-never-invalid.patch similarity index 100% rename from patches/server/0449-Ensure-Entity-AABB-s-are-never-invalid.patch rename to patches/server/0450-Ensure-Entity-AABB-s-are-never-invalid.patch diff --git a/patches/server/0450-Fix-Per-World-Difficulty-Remembering-Difficulty.patch b/patches/server/0451-Fix-Per-World-Difficulty-Remembering-Difficulty.patch similarity index 98% rename from patches/server/0450-Fix-Per-World-Difficulty-Remembering-Difficulty.patch rename to patches/server/0451-Fix-Per-World-Difficulty-Remembering-Difficulty.patch index 1ed13d030..ae51cdc94 100644 --- a/patches/server/0450-Fix-Per-World-Difficulty-Remembering-Difficulty.patch +++ b/patches/server/0451-Fix-Per-World-Difficulty-Remembering-Difficulty.patch @@ -94,7 +94,7 @@ index dd29bad410ff74ce3f1f94bc60560cf10b12375f..0bcafeb8008bd2556bcdc556b17d00ff } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index a603013de589fad75ff783771a04f10e3bf2ee90..835ff36cfd8c15bf11b3b6a70eb02f6c5b693b8a 100644 +index 6c55c5430ab7e221ec25ef50818a07327d4c9e46..1a0070045e34430f8d36ce2debde2bb41e731158 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -923,8 +923,8 @@ public final class CraftServer implements Server { diff --git a/patches/server/0451-Paper-dumpitem-command.patch b/patches/server/0452-Paper-dumpitem-command.patch similarity index 100% rename from patches/server/0451-Paper-dumpitem-command.patch rename to patches/server/0452-Paper-dumpitem-command.patch diff --git a/patches/server/0452-Don-t-allow-null-UUID-s-for-chat.patch b/patches/server/0453-Don-t-allow-null-UUID-s-for-chat.patch similarity index 100% rename from patches/server/0452-Don-t-allow-null-UUID-s-for-chat.patch rename to patches/server/0453-Don-t-allow-null-UUID-s-for-chat.patch diff --git a/patches/server/0453-Improve-Legacy-Component-serialization-size.patch b/patches/server/0454-Improve-Legacy-Component-serialization-size.patch similarity index 100% rename from patches/server/0453-Improve-Legacy-Component-serialization-size.patch rename to patches/server/0454-Improve-Legacy-Component-serialization-size.patch diff --git a/patches/server/0454-Optimize-Bit-Operations-by-inlining.patch b/patches/server/0455-Optimize-Bit-Operations-by-inlining.patch similarity index 100% rename from patches/server/0454-Optimize-Bit-Operations-by-inlining.patch rename to patches/server/0455-Optimize-Bit-Operations-by-inlining.patch diff --git a/patches/server/0455-Add-Plugin-Tickets-to-API-Chunk-Methods.patch b/patches/server/0456-Add-Plugin-Tickets-to-API-Chunk-Methods.patch similarity index 98% rename from patches/server/0455-Add-Plugin-Tickets-to-API-Chunk-Methods.patch rename to patches/server/0456-Add-Plugin-Tickets-to-API-Chunk-Methods.patch index 5c14cdfe5..05d7b13d1 100644 --- a/patches/server/0455-Add-Plugin-Tickets-to-API-Chunk-Methods.patch +++ b/patches/server/0456-Add-Plugin-Tickets-to-API-Chunk-Methods.patch @@ -22,7 +22,7 @@ wants it to collect even faster, they can restore that setting back to 1 instead Not adding it to .getType() though to keep behavior consistent with vanilla for performance reasons. diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 835ff36cfd8c15bf11b3b6a70eb02f6c5b693b8a..b1dfd1b13652807882e057ae4fb55f9a045d1a16 100644 +index 1a0070045e34430f8d36ce2debde2bb41e731158..2208b4da8293fc3627d6330f5061757ab4fab52b 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -373,7 +373,7 @@ public final class CraftServer implements Server { diff --git a/patches/server/0456-incremental-chunk-and-player-saving.patch b/patches/server/0457-incremental-chunk-and-player-saving.patch similarity index 97% rename from patches/server/0456-incremental-chunk-and-player-saving.patch rename to patches/server/0457-incremental-chunk-and-player-saving.patch index 4e15ac954..9b6f49e7b 100644 --- a/patches/server/0456-incremental-chunk-and-player-saving.patch +++ b/patches/server/0457-incremental-chunk-and-player-saving.patch @@ -24,10 +24,10 @@ index ebbbffd209c6796bc608992e293035141a122d1f..4fb6b2153117f54a2b0ca940de4c0ee2 + } } diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 845f105457d659a4bd88d4a8ce91b20d6abb7865..bf0c6e1b2b1934bc3fa5c17c414b3730c5ac0833 100644 +index 1b31b68ed00df972eb32b9749993478fbd9fab6b..c8bc6c34859542bbb761f1adf8030087d2ae9adc 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -62,6 +62,21 @@ public class PaperWorldConfig { +@@ -64,6 +64,21 @@ public class PaperWorldConfig { log( "Keep Spawn Loaded Range: " + (keepLoadedRange/16)); } @@ -165,7 +165,7 @@ index 626bcbc6dd013260c3f8b38a1d14e7ba35dc1e01..9e96b0465717bfa761289c255fd8d2f1 for (int i = 0; i < this.futures.length(); ++i) { CompletableFuture> completablefuture = (CompletableFuture) this.futures.get(i); diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index ea61f5df9a0998272dd5da1332aa0fbb8704cd5e..beb930fdb2535e32692906c54b8654401706086e 100644 +index 1e183b8a776de996bdb63d2ab892e63b9a4fb0f0..78d1fd9155f32fc8f98d9dc87116630a17b60f10 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -101,6 +101,7 @@ import net.minecraft.world.level.levelgen.structure.templatesystem.StructureMana @@ -295,7 +295,7 @@ index 76b56ea346d843aba482c52c4bfe877fdf0e9225..eb0c5ceb05f37bc653ea0cc91cc77886 public void close() throws IOException { // CraftBukkit start diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 44bc8657d1436114db9ac5f4bca23d330eb49d79..f82ad531d356a663bb085f50eeffbe8746fc6cd3 100644 +index fe572c99263a44a23e2dc5141295d98973684a88..d21a910f2cca26adedab0732d04c8613e5afcd4f 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1055,6 +1055,37 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -385,7 +385,7 @@ index 9b7fcd8be912cd211b6226386bd3340076953442..a8048e3af5bccb4cabe1ed1bc774aac6 MinecraftTimings.savePlayers.stopTiming(); // Paper return null; }); // Paper - ensure main diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java -index 96dc50a24821016e53dfeac344c0e61f110a5a53..5093e34dddbea0f0d5c26f25c257b85bdf841a47 100644 +index 0a2f9e93666a5b2123f84e5cf409e4355d3cad86..e3a92021b32aa74a37287504e0e539af5ec8216f 100644 --- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java +++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java @@ -457,6 +457,7 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom @@ -397,7 +397,7 @@ index 96dc50a24821016e53dfeac344c0e61f110a5a53..5093e34dddbea0f0d5c26f25c257b85b // CraftBukkit start - decompile error public static record TicksToSave(SerializableTickContainer blocks, SerializableTickContainer fluids) { 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 8c4cd4a82dcf5295a992c37914d3124d6615148a..93e9ef06f02e5dc0c1bd0e8d714f44b2fea24db0 100644 +index f7388d37b467d1c153fcf8002eedd20417f93d52..ed22486dafcecae454a932c1354cf26c31e95636 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -87,6 +87,12 @@ public class LevelChunk extends ChunkAccess { diff --git a/patches/server/0457-Stop-copy-on-write-operations-for-updating-light-dat.patch b/patches/server/0458-Stop-copy-on-write-operations-for-updating-light-dat.patch similarity index 100% rename from patches/server/0457-Stop-copy-on-write-operations-for-updating-light-dat.patch rename to patches/server/0458-Stop-copy-on-write-operations-for-updating-light-dat.patch diff --git a/patches/server/0458-Support-old-UUID-format-for-NBT.patch b/patches/server/0459-Support-old-UUID-format-for-NBT.patch similarity index 100% rename from patches/server/0458-Support-old-UUID-format-for-NBT.patch rename to patches/server/0459-Support-old-UUID-format-for-NBT.patch diff --git a/patches/server/0459-Clean-up-duplicated-GameProfile-Properties.patch b/patches/server/0460-Clean-up-duplicated-GameProfile-Properties.patch similarity index 100% rename from patches/server/0459-Clean-up-duplicated-GameProfile-Properties.patch rename to patches/server/0460-Clean-up-duplicated-GameProfile-Properties.patch diff --git a/patches/server/0460-Convert-legacy-attributes-in-Item-Meta.patch b/patches/server/0461-Convert-legacy-attributes-in-Item-Meta.patch similarity index 100% rename from patches/server/0460-Convert-legacy-attributes-in-Item-Meta.patch rename to patches/server/0461-Convert-legacy-attributes-in-Item-Meta.patch diff --git a/patches/server/0461-Remove-some-streams-from-structures.patch b/patches/server/0462-Remove-some-streams-from-structures.patch similarity index 100% rename from patches/server/0461-Remove-some-streams-from-structures.patch rename to patches/server/0462-Remove-some-streams-from-structures.patch diff --git a/patches/server/0462-Remove-streams-from-classes-related-villager-gossip.patch b/patches/server/0463-Remove-streams-from-classes-related-villager-gossip.patch similarity index 100% rename from patches/server/0462-Remove-streams-from-classes-related-villager-gossip.patch rename to patches/server/0463-Remove-streams-from-classes-related-villager-gossip.patch diff --git a/patches/server/0463-Support-components-in-ItemMeta.patch b/patches/server/0464-Support-components-in-ItemMeta.patch similarity index 100% rename from patches/server/0463-Support-components-in-ItemMeta.patch rename to patches/server/0464-Support-components-in-ItemMeta.patch diff --git a/patches/server/0464-Improve-EntityTargetLivingEntityEvent-for-1.16-mobs.patch b/patches/server/0465-Improve-EntityTargetLivingEntityEvent-for-1.16-mobs.patch similarity index 100% rename from patches/server/0464-Improve-EntityTargetLivingEntityEvent-for-1.16-mobs.patch rename to patches/server/0465-Improve-EntityTargetLivingEntityEvent-for-1.16-mobs.patch diff --git a/patches/server/0465-Add-entity-liquid-API.patch b/patches/server/0466-Add-entity-liquid-API.patch similarity index 100% rename from patches/server/0465-Add-entity-liquid-API.patch rename to patches/server/0466-Add-entity-liquid-API.patch diff --git a/patches/server/0466-Update-itemstack-legacy-name-and-lore.patch b/patches/server/0467-Update-itemstack-legacy-name-and-lore.patch similarity index 100% rename from patches/server/0466-Update-itemstack-legacy-name-and-lore.patch rename to patches/server/0467-Update-itemstack-legacy-name-and-lore.patch diff --git a/patches/server/0467-Spawn-player-in-correct-world-on-login.patch b/patches/server/0468-Spawn-player-in-correct-world-on-login.patch similarity index 94% rename from patches/server/0467-Spawn-player-in-correct-world-on-login.patch rename to patches/server/0468-Spawn-player-in-correct-world-on-login.patch index d8241f19f..bac42e47f 100644 --- a/patches/server/0467-Spawn-player-in-correct-world-on-login.patch +++ b/patches/server/0468-Spawn-player-in-correct-world-on-login.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Spawn player in correct world on login diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index a40ca089d92df8f3ea0a444e3293531e787b196b..ed4e13528cf0fe48384efcb3f55cb5149f4cf681 100644 +index a8048e3af5bccb4cabe1ed1bc774aac6b8486bec..c1bdd32fade0a613116b0ff848bfa5a4e8c428e6 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -196,7 +196,18 @@ public abstract class PlayerList { diff --git a/patches/server/0468-Add-PrepareResultEvent.patch b/patches/server/0469-Add-PrepareResultEvent.patch similarity index 100% rename from patches/server/0468-Add-PrepareResultEvent.patch rename to patches/server/0469-Add-PrepareResultEvent.patch diff --git a/patches/server/0469-Don-t-check-chunk-for-portal-on-world-gen-entity-add.patch b/patches/server/0470-Don-t-check-chunk-for-portal-on-world-gen-entity-add.patch similarity index 100% rename from patches/server/0469-Don-t-check-chunk-for-portal-on-world-gen-entity-add.patch rename to patches/server/0470-Don-t-check-chunk-for-portal-on-world-gen-entity-add.patch diff --git a/patches/server/0470-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch b/patches/server/0471-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch similarity index 99% rename from patches/server/0470-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch rename to patches/server/0471-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch index 651dabfc9..b97a26c23 100644 --- a/patches/server/0470-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch +++ b/patches/server/0471-Implement-Chunk-Priority-Urgency-System-for-Chunks.patch @@ -360,7 +360,7 @@ index 9e96b0465717bfa761289c255fd8d2f1df1be3d8..87271552aa85626f22f7f8569c8fb48f return this.isEntityTickingReady; } diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index beb930fdb2535e32692906c54b8654401706086e..849dbc24baa518145a63489e5616c9e11955955e 100644 +index 78d1fd9155f32fc8f98d9dc87116630a17b60f10..a81c53e3c03cf8e44e7c823a91a049b5ca66eb7b 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -128,6 +128,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -1164,7 +1164,7 @@ index fb2d5c768b7dc5255db7dc7199ed750809a8fb94..9b254d00eb0cf0c4d4fe73e7a955b0b6 public float yRotO; public float xRotO; 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 93e9ef06f02e5dc0c1bd0e8d714f44b2fea24db0..a8bc174d0b5016cf595267d2727ab06d90f2c794 100644 +index ed22486dafcecae454a932c1354cf26c31e95636..b641bf5b2d02bfc1443a84af3cb98aff0dc7a575 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -141,7 +141,7 @@ public class LevelChunk extends ChunkAccess { diff --git a/patches/server/0471-Optimize-NetworkManager-Exception-Handling.patch b/patches/server/0472-Optimize-NetworkManager-Exception-Handling.patch similarity index 100% rename from patches/server/0471-Optimize-NetworkManager-Exception-Handling.patch rename to patches/server/0472-Optimize-NetworkManager-Exception-Handling.patch diff --git a/patches/server/0472-Optimize-the-advancement-data-player-iteration-to-be.patch b/patches/server/0473-Optimize-the-advancement-data-player-iteration-to-be.patch similarity index 100% rename from patches/server/0472-Optimize-the-advancement-data-player-iteration-to-be.patch rename to patches/server/0473-Optimize-the-advancement-data-player-iteration-to-be.patch diff --git a/patches/server/0473-Fix-arrows-never-despawning-MC-125757.patch b/patches/server/0474-Fix-arrows-never-despawning-MC-125757.patch similarity index 100% rename from patches/server/0473-Fix-arrows-never-despawning-MC-125757.patch rename to patches/server/0474-Fix-arrows-never-despawning-MC-125757.patch diff --git a/patches/server/0474-Thread-Safe-Vanilla-Command-permission-checking.patch b/patches/server/0475-Thread-Safe-Vanilla-Command-permission-checking.patch similarity index 100% rename from patches/server/0474-Thread-Safe-Vanilla-Command-permission-checking.patch rename to patches/server/0475-Thread-Safe-Vanilla-Command-permission-checking.patch diff --git a/patches/server/0475-Move-range-check-for-block-placing-up.patch b/patches/server/0476-Move-range-check-for-block-placing-up.patch similarity index 100% rename from patches/server/0475-Move-range-check-for-block-placing-up.patch rename to patches/server/0476-Move-range-check-for-block-placing-up.patch diff --git a/patches/server/0476-Fix-SPIGOT-5989.patch b/patches/server/0477-Fix-SPIGOT-5989.patch similarity index 97% rename from patches/server/0476-Fix-SPIGOT-5989.patch rename to patches/server/0477-Fix-SPIGOT-5989.patch index 1d73b6dc7..bd7b4e439 100644 --- a/patches/server/0476-Fix-SPIGOT-5989.patch +++ b/patches/server/0477-Fix-SPIGOT-5989.patch @@ -10,7 +10,7 @@ This fixes that by checking if the modified spawn location is still at a respawn anchor. diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 55b7036a7b7fe45f2b8694bf8ab039d92de1c3bb..e655c806504d6e127e15dca479271d9b211975a3 100644 +index bcc4de5c0f970325efaa9d99bb0845c2ed422b6d..c75218775bb5e9745b863ef1db5280a4a3f2bed9 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -78,6 +78,7 @@ import net.minecraft.world.level.GameRules; diff --git a/patches/server/0477-Fix-SPIGOT-5824-Bukkit-world-container-is-not-used.patch b/patches/server/0478-Fix-SPIGOT-5824-Bukkit-world-container-is-not-used.patch similarity index 100% rename from patches/server/0477-Fix-SPIGOT-5824-Bukkit-world-container-is-not-used.patch rename to patches/server/0478-Fix-SPIGOT-5824-Bukkit-world-container-is-not-used.patch diff --git a/patches/server/0478-Fix-SPIGOT-5885-Unable-to-disable-advancements.patch b/patches/server/0479-Fix-SPIGOT-5885-Unable-to-disable-advancements.patch similarity index 100% rename from patches/server/0478-Fix-SPIGOT-5885-Unable-to-disable-advancements.patch rename to patches/server/0479-Fix-SPIGOT-5885-Unable-to-disable-advancements.patch diff --git a/patches/server/0479-Fix-AdvancementDataPlayer-leak-due-from-quitting-ear.patch b/patches/server/0480-Fix-AdvancementDataPlayer-leak-due-from-quitting-ear.patch similarity index 100% rename from patches/server/0479-Fix-AdvancementDataPlayer-leak-due-from-quitting-ear.patch rename to patches/server/0480-Fix-AdvancementDataPlayer-leak-due-from-quitting-ear.patch diff --git a/patches/server/0480-Add-missing-strikeLighting-call-to-World-spigot-stri.patch b/patches/server/0481-Add-missing-strikeLighting-call-to-World-spigot-stri.patch similarity index 100% rename from patches/server/0480-Add-missing-strikeLighting-call-to-World-spigot-stri.patch rename to patches/server/0481-Add-missing-strikeLighting-call-to-World-spigot-stri.patch diff --git a/patches/server/0481-Fix-some-rails-connecting-improperly.patch b/patches/server/0482-Fix-some-rails-connecting-improperly.patch similarity index 100% rename from patches/server/0481-Fix-some-rails-connecting-improperly.patch rename to patches/server/0482-Fix-some-rails-connecting-improperly.patch diff --git a/patches/server/0482-Fix-regex-mistake-in-CB-NBT-int-deserialization.patch b/patches/server/0483-Fix-regex-mistake-in-CB-NBT-int-deserialization.patch similarity index 100% rename from patches/server/0482-Fix-regex-mistake-in-CB-NBT-int-deserialization.patch rename to patches/server/0483-Fix-regex-mistake-in-CB-NBT-int-deserialization.patch diff --git a/patches/server/0483-Do-not-let-the-server-load-chunks-from-newer-version.patch b/patches/server/0484-Do-not-let-the-server-load-chunks-from-newer-version.patch similarity index 95% rename from patches/server/0483-Do-not-let-the-server-load-chunks-from-newer-version.patch rename to patches/server/0484-Do-not-let-the-server-load-chunks-from-newer-version.patch index 40d367608..0ab51e6a0 100644 --- a/patches/server/0483-Do-not-let-the-server-load-chunks-from-newer-version.patch +++ b/patches/server/0484-Do-not-let-the-server-load-chunks-from-newer-version.patch @@ -9,7 +9,7 @@ the game, immediately stop the server to prevent data corruption. You can override this functionality at your own peril. diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java -index 9a6f4c0bcfe8ce331ba7f6c92e527addcf65c911..03439b92297d8a2d73f21ddb57b3b2087f70907c 100644 +index 1267e93d1e315d55086a87670fd098db552c3afd..8866ded0567fee710aa301dbc89f4c45b7283447 100644 --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java @@ -109,9 +109,22 @@ public class ChunkSerializer { diff --git a/patches/server/0484-Brand-support.patch b/patches/server/0485-Brand-support.patch similarity index 100% rename from patches/server/0484-Brand-support.patch rename to patches/server/0485-Brand-support.patch diff --git a/patches/server/0485-Add-setMaxPlayers-API.patch b/patches/server/0486-Add-setMaxPlayers-API.patch similarity index 89% rename from patches/server/0485-Add-setMaxPlayers-API.patch rename to patches/server/0486-Add-setMaxPlayers-API.patch index aabc58837..8d7468426 100644 --- a/patches/server/0485-Add-setMaxPlayers-API.patch +++ b/patches/server/0486-Add-setMaxPlayers-API.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add #setMaxPlayers API diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index e655c806504d6e127e15dca479271d9b211975a3..5c829538a008f1a737380627f7b88c7a0914050f 100644 +index c75218775bb5e9745b863ef1db5280a4a3f2bed9..a1077445ab7d416dc61db85742e447193642b919 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -144,7 +144,7 @@ public abstract class PlayerList { @@ -18,7 +18,7 @@ index e655c806504d6e127e15dca479271d9b211975a3..5c829538a008f1a737380627f7b88c7a private int simulationDistance; private boolean allowCheatsForAllPlayers; diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index b1dfd1b13652807882e057ae4fb55f9a045d1a16..cd98fa713ecd0cb8d4bb2a9211ee9b9b89a04330 100644 +index 2208b4da8293fc3627d6330f5061757ab4fab52b..1ffadc1da10872655449a8d63590b9c4ca2df7ae 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -674,6 +674,13 @@ public final class CraftServer implements Server { diff --git a/patches/server/0486-Add-playPickupItemAnimation-to-LivingEntity.patch b/patches/server/0487-Add-playPickupItemAnimation-to-LivingEntity.patch similarity index 100% rename from patches/server/0486-Add-playPickupItemAnimation-to-LivingEntity.patch rename to patches/server/0487-Add-playPickupItemAnimation-to-LivingEntity.patch diff --git a/patches/server/0487-Don-t-require-FACING-data.patch b/patches/server/0488-Don-t-require-FACING-data.patch similarity index 100% rename from patches/server/0487-Don-t-require-FACING-data.patch rename to patches/server/0488-Don-t-require-FACING-data.patch diff --git a/patches/server/0488-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch b/patches/server/0489-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch similarity index 96% rename from patches/server/0488-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch rename to patches/server/0489-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch index ebac545e6..a6c1cc787 100644 --- a/patches/server/0488-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch +++ b/patches/server/0489-Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix SpawnChangeEvent not firing for all use-cases diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index d55d2627b7e0c847250c551989d438280bef9ab8..5c98b61c08464cc78be34d1567eff7005f6ab2df 100644 +index d21a910f2cca26adedab0732d04c8613e5afcd4f..ad4904aff037fd916ef5481dc5516781ad078330 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1720,6 +1720,7 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0489-Add-moon-phase-API.patch b/patches/server/0490-Add-moon-phase-API.patch similarity index 100% rename from patches/server/0489-Add-moon-phase-API.patch rename to patches/server/0490-Add-moon-phase-API.patch diff --git a/patches/server/0490-Improve-Chunk-Status-Transition-Speed.patch b/patches/server/0491-Improve-Chunk-Status-Transition-Speed.patch similarity index 97% rename from patches/server/0490-Improve-Chunk-Status-Transition-Speed.patch rename to patches/server/0491-Improve-Chunk-Status-Transition-Speed.patch index 9daba0d15..2430d60a9 100644 --- a/patches/server/0490-Improve-Chunk-Status-Transition-Speed.patch +++ b/patches/server/0491-Improve-Chunk-Status-Transition-Speed.patch @@ -54,7 +54,7 @@ index 87271552aa85626f22f7f8569c8fb48fe4b30bf3..80aae4303e011dad13ce818136f0383e public ChunkHolder(ChunkPos pos, int level, LevelHeightAccessor world, LevelLightEngine lightingProvider, ChunkHolder.LevelChangeListener levelUpdateListener, ChunkHolder.PlayerProvider playersWatchingChunkProvider) { this.futures = new AtomicReferenceArray(ChunkHolder.CHUNK_STATUSES.size()); diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index 849dbc24baa518145a63489e5616c9e11955955e..2bec5bf41fe25c00b68c1040b68b2e204e67cf44 100644 +index a81c53e3c03cf8e44e7c823a91a049b5ca66eb7b..ee2eeea6e0fb3103620f6a6b5704e259f44d27e3 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -674,7 +674,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider diff --git a/patches/server/0491-Prevent-headless-pistons-from-being-created.patch b/patches/server/0492-Prevent-headless-pistons-from-being-created.patch similarity index 100% rename from patches/server/0491-Prevent-headless-pistons-from-being-created.patch rename to patches/server/0492-Prevent-headless-pistons-from-being-created.patch diff --git a/patches/server/0492-Add-BellRingEvent.patch b/patches/server/0493-Add-BellRingEvent.patch similarity index 100% rename from patches/server/0492-Add-BellRingEvent.patch rename to patches/server/0493-Add-BellRingEvent.patch diff --git a/patches/server/0493-Add-zombie-targets-turtle-egg-config.patch b/patches/server/0494-Add-zombie-targets-turtle-egg-config.patch similarity index 92% rename from patches/server/0493-Add-zombie-targets-turtle-egg-config.patch rename to patches/server/0494-Add-zombie-targets-turtle-egg-config.patch index 8fd9834dc..eac9809b0 100644 --- a/patches/server/0493-Add-zombie-targets-turtle-egg-config.patch +++ b/patches/server/0494-Add-zombie-targets-turtle-egg-config.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add zombie targets turtle egg config diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index bf0c6e1b2b1934bc3fa5c17c414b3730c5ac0833..fc788071f01310647a227d12c81dc62a43e64ef5 100644 +index c8bc6c34859542bbb761f1adf8030087d2ae9adc..85afb6a6606b78570e53f7e46339eb5db299558f 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -56,6 +56,11 @@ public class PaperWorldConfig { +@@ -58,6 +58,11 @@ public class PaperWorldConfig { } } diff --git a/patches/server/0494-Buffer-joins-to-world.patch b/patches/server/0495-Buffer-joins-to-world.patch similarity index 100% rename from patches/server/0494-Buffer-joins-to-world.patch rename to patches/server/0495-Buffer-joins-to-world.patch diff --git a/patches/server/0495-Optimize-redstone-algorithm.patch b/patches/server/0496-Optimize-redstone-algorithm.patch similarity index 99% rename from patches/server/0495-Optimize-redstone-algorithm.patch rename to patches/server/0496-Optimize-redstone-algorithm.patch index 18f92de50..c87aad567 100644 --- a/patches/server/0495-Optimize-redstone-algorithm.patch +++ b/patches/server/0496-Optimize-redstone-algorithm.patch @@ -19,10 +19,10 @@ Aside from making the obvious class/function renames and obfhelpers I didn't nee Just added Bukkit's event system and took a few liberties with dead code and comment misspellings. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index fc788071f01310647a227d12c81dc62a43e64ef5..aee981e967bfb32a531d5d79213c5d165bb64ad0 100644 +index 85afb6a6606b78570e53f7e46339eb5db299558f..71427964707e164e2db9c33afcb0373e88783257 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -61,6 +61,16 @@ public class PaperWorldConfig { +@@ -63,6 +63,16 @@ public class PaperWorldConfig { zombiesTargetTurtleEggs = getBoolean("zombies-target-turtle-eggs", zombiesTargetTurtleEggs); } diff --git a/patches/server/0496-Fix-hex-colors-not-working-in-some-kick-messages.patch b/patches/server/0497-Fix-hex-colors-not-working-in-some-kick-messages.patch similarity index 100% rename from patches/server/0496-Fix-hex-colors-not-working-in-some-kick-messages.patch rename to patches/server/0497-Fix-hex-colors-not-working-in-some-kick-messages.patch diff --git a/patches/server/0497-PortalCreateEvent-needs-to-know-its-entity.patch b/patches/server/0498-PortalCreateEvent-needs-to-know-its-entity.patch similarity index 100% rename from patches/server/0497-PortalCreateEvent-needs-to-know-its-entity.patch rename to patches/server/0498-PortalCreateEvent-needs-to-know-its-entity.patch diff --git a/patches/server/0498-Fix-CraftTeam-null-check.patch b/patches/server/0499-Fix-CraftTeam-null-check.patch similarity index 100% rename from patches/server/0498-Fix-CraftTeam-null-check.patch rename to patches/server/0499-Fix-CraftTeam-null-check.patch diff --git a/patches/server/0499-Add-more-Evoker-API.patch b/patches/server/0500-Add-more-Evoker-API.patch similarity index 100% rename from patches/server/0499-Add-more-Evoker-API.patch rename to patches/server/0500-Add-more-Evoker-API.patch diff --git a/patches/server/0500-Add-methods-to-get-translation-keys.patch b/patches/server/0501-Add-methods-to-get-translation-keys.patch similarity index 100% rename from patches/server/0500-Add-methods-to-get-translation-keys.patch rename to patches/server/0501-Add-methods-to-get-translation-keys.patch diff --git a/patches/server/0501-Create-HoverEvent-from-ItemStack-Entity.patch b/patches/server/0502-Create-HoverEvent-from-ItemStack-Entity.patch similarity index 100% rename from patches/server/0501-Create-HoverEvent-from-ItemStack-Entity.patch rename to patches/server/0502-Create-HoverEvent-from-ItemStack-Entity.patch diff --git a/patches/server/0502-Cache-block-data-strings.patch b/patches/server/0503-Cache-block-data-strings.patch similarity index 100% rename from patches/server/0502-Cache-block-data-strings.patch rename to patches/server/0503-Cache-block-data-strings.patch diff --git a/patches/server/0503-Fix-Entity-Teleportation-and-cancel-velocity-if-tele.patch b/patches/server/0504-Fix-Entity-Teleportation-and-cancel-velocity-if-tele.patch similarity index 100% rename from patches/server/0503-Fix-Entity-Teleportation-and-cancel-velocity-if-tele.patch rename to patches/server/0504-Fix-Entity-Teleportation-and-cancel-velocity-if-tele.patch diff --git a/patches/server/0504-Add-additional-open-container-api-to-HumanEntity.patch b/patches/server/0505-Add-additional-open-container-api-to-HumanEntity.patch similarity index 100% rename from patches/server/0504-Add-additional-open-container-api-to-HumanEntity.patch rename to patches/server/0505-Add-additional-open-container-api-to-HumanEntity.patch diff --git a/patches/server/0505-Cache-DataFixerUpper-Rewrite-Rules-on-demand.patch b/patches/server/0506-Cache-DataFixerUpper-Rewrite-Rules-on-demand.patch similarity index 100% rename from patches/server/0505-Cache-DataFixerUpper-Rewrite-Rules-on-demand.patch rename to patches/server/0506-Cache-DataFixerUpper-Rewrite-Rules-on-demand.patch diff --git a/patches/server/0506-Extend-block-drop-capture-to-capture-all-items-added.patch b/patches/server/0507-Extend-block-drop-capture-to-capture-all-items-added.patch similarity index 90% rename from patches/server/0506-Extend-block-drop-capture-to-capture-all-items-added.patch rename to patches/server/0507-Extend-block-drop-capture-to-capture-all-items-added.patch index 16a20d8a7..7ee183392 100644 --- a/patches/server/0506-Extend-block-drop-capture-to-capture-all-items-added.patch +++ b/patches/server/0507-Extend-block-drop-capture-to-capture-all-items-added.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Extend block drop capture to capture all items added to the diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 5c98b61c08464cc78be34d1567eff7005f6ab2df..313a368eb5d09b0c4d45b5da34d72390d86332c5 100644 +index ad4904aff037fd916ef5481dc5516781ad078330..00a64168592ad2c8cecb2fc844d81e47610601ad 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1257,6 +1257,13 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -24,10 +24,10 @@ index 5c98b61c08464cc78be34d1567eff7005f6ab2df..313a368eb5d09b0c4d45b5da34d72390 return false; } diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -index f087f48ad9e0b28d9874f3a9c1e3988ce6b60d87..2ac2100b6ae006ab490742424b682395e7513156 100644 +index 4f1430c71aff4959b1db76200fe750a6c44cef68..01b19225193ef3a3f69291f0357c096fc9e71618 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -@@ -421,10 +421,12 @@ public class ServerPlayerGameMode { +@@ -423,10 +423,12 @@ public class ServerPlayerGameMode { // return true; // CraftBukkit } // CraftBukkit start diff --git a/patches/server/0507-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch b/patches/server/0508-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch similarity index 89% rename from patches/server/0507-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch rename to patches/server/0508-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch index be798e12c..e9cb39693 100644 --- a/patches/server/0507-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch +++ b/patches/server/0508-Don-t-mark-dirty-in-invalid-locations-SPIGOT-6086.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Don't mark dirty in invalid locations (SPIGOT-6086) diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java -index 5b9abfb7b8edd686f416a46851f12bd52bea7000..874c99cdb8ea57c7ba986dd1cbd43bedbff30260 100644 +index 80aae4303e011dad13ce818136f0383e12ab5c41..4b0d87c0534cddcab16d772c16307f3621fc30e9 100644 --- a/src/main/java/net/minecraft/server/level/ChunkHolder.java +++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java @@ -229,6 +229,7 @@ public class ChunkHolder { diff --git a/patches/server/0508-Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch b/patches/server/0509-Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch similarity index 100% rename from patches/server/0508-Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch rename to patches/server/0509-Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch diff --git a/patches/server/0509-Lazily-track-plugin-scoreboards-by-default.patch b/patches/server/0510-Lazily-track-plugin-scoreboards-by-default.patch similarity index 100% rename from patches/server/0509-Lazily-track-plugin-scoreboards-by-default.patch rename to patches/server/0510-Lazily-track-plugin-scoreboards-by-default.patch diff --git a/patches/server/0510-Entity-isTicking.patch b/patches/server/0511-Entity-isTicking.patch similarity index 100% rename from patches/server/0510-Entity-isTicking.patch rename to patches/server/0511-Entity-isTicking.patch diff --git a/patches/server/0511-Fix-deop-kicking-non-whitelisted-player-when-white-l.patch b/patches/server/0512-Fix-deop-kicking-non-whitelisted-player-when-white-l.patch similarity index 100% rename from patches/server/0511-Fix-deop-kicking-non-whitelisted-player-when-white-l.patch rename to patches/server/0512-Fix-deop-kicking-non-whitelisted-player-when-white-l.patch diff --git a/patches/server/0512-Fix-Concurrency-issue-in-WeightedList.patch b/patches/server/0513-Fix-Concurrency-issue-in-WeightedList.patch similarity index 100% rename from patches/server/0512-Fix-Concurrency-issue-in-WeightedList.patch rename to patches/server/0513-Fix-Concurrency-issue-in-WeightedList.patch diff --git a/patches/server/0513-Reset-Ender-Crystals-on-Dragon-Spawn.patch b/patches/server/0514-Reset-Ender-Crystals-on-Dragon-Spawn.patch similarity index 100% rename from patches/server/0513-Reset-Ender-Crystals-on-Dragon-Spawn.patch rename to patches/server/0514-Reset-Ender-Crystals-on-Dragon-Spawn.patch diff --git a/patches/server/0514-Fix-for-large-move-vectors-crashing-server.patch b/patches/server/0515-Fix-for-large-move-vectors-crashing-server.patch similarity index 100% rename from patches/server/0514-Fix-for-large-move-vectors-crashing-server.patch rename to patches/server/0515-Fix-for-large-move-vectors-crashing-server.patch diff --git a/patches/server/0515-Optimise-getType-calls.patch b/patches/server/0516-Optimise-getType-calls.patch similarity index 98% rename from patches/server/0515-Optimise-getType-calls.patch rename to patches/server/0516-Optimise-getType-calls.patch index 9ff04ac33..446484513 100644 --- a/patches/server/0515-Optimise-getType-calls.patch +++ b/patches/server/0516-Optimise-getType-calls.patch @@ -28,7 +28,7 @@ index 76133c77e8ebce7c9e5402e3e7cd50b30aa1c2e0..348a91a760bd728f8e732e1a35c86ab7 super(block, propertyMap, codec); } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java b/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java -index 10e65d6b9c0fe34414894e0debd17bab6f25d4f2..a37a7bd61df25408fef425cee941f75d0568fe31 100644 +index dc1b73816e0e02d3a35a64e02904a034fbaeb8c9..83f8c3ab5ed1f491902e86e4cf605cfa6b10ae52 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java @@ -80,7 +80,7 @@ public class CraftChunkSnapshot implements ChunkSnapshot { diff --git a/patches/server/0516-Villager-resetOffers.patch b/patches/server/0517-Villager-resetOffers.patch similarity index 100% rename from patches/server/0516-Villager-resetOffers.patch rename to patches/server/0517-Villager-resetOffers.patch diff --git a/patches/server/0517-Improve-inlinig-for-some-hot-IBlockData-methods.patch b/patches/server/0518-Improve-inlinig-for-some-hot-IBlockData-methods.patch similarity index 100% rename from patches/server/0517-Improve-inlinig-for-some-hot-IBlockData-methods.patch rename to patches/server/0518-Improve-inlinig-for-some-hot-IBlockData-methods.patch diff --git a/patches/server/0518-Retain-block-place-order-when-capturing-blockstates.patch b/patches/server/0519-Retain-block-place-order-when-capturing-blockstates.patch similarity index 93% rename from patches/server/0518-Retain-block-place-order-when-capturing-blockstates.patch rename to patches/server/0519-Retain-block-place-order-when-capturing-blockstates.patch index 5ee9bbec3..63e501727 100644 --- a/patches/server/0518-Retain-block-place-order-when-capturing-blockstates.patch +++ b/patches/server/0519-Retain-block-place-order-when-capturing-blockstates.patch @@ -10,7 +10,7 @@ In general, look at making this logic more robust (i.e properly handling cases where a captured entry is overriden) - but for now this will do. diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 0bcb14f1377d603c93c471ce206d2e38d0278b60..5ca6254d104fbd407a98daf732dd6ac119914ee3 100644 +index c7a69b84dada3fef89d798bd9c4cb151d61ee2de..0149e5c3618e1c35ec15230fe9838650429afeb9 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java @@ -149,7 +149,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { diff --git a/patches/server/0519-Reduce-blockpos-allocation-from-pathfinding.patch b/patches/server/0520-Reduce-blockpos-allocation-from-pathfinding.patch similarity index 100% rename from patches/server/0519-Reduce-blockpos-allocation-from-pathfinding.patch rename to patches/server/0520-Reduce-blockpos-allocation-from-pathfinding.patch diff --git a/patches/server/0520-Fix-item-locations-dropped-from-campfires.patch b/patches/server/0521-Fix-item-locations-dropped-from-campfires.patch similarity index 100% rename from patches/server/0520-Fix-item-locations-dropped-from-campfires.patch rename to patches/server/0521-Fix-item-locations-dropped-from-campfires.patch diff --git a/patches/server/0521-Player-elytra-boost-API.patch b/patches/server/0522-Player-elytra-boost-API.patch similarity index 94% rename from patches/server/0521-Player-elytra-boost-API.patch rename to patches/server/0522-Player-elytra-boost-API.patch index 7191ed321..65d6aa6f6 100644 --- a/patches/server/0521-Player-elytra-boost-API.patch +++ b/patches/server/0522-Player-elytra-boost-API.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Player elytra boost API diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index f89fdf2913fb7caf0526b6f144638294cc688af4..10435f34526b20e50737a0328b464d7f1236f4bd 100644 +index e0efff05f10d4b994fabaa45d39b616a6b231685..bd507525e3b5f5d632ed515f08942be9d08796f3 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -563,6 +563,20 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0522-Fixed-TileEntityBell-memory-leak.patch b/patches/server/0523-Fixed-TileEntityBell-memory-leak.patch similarity index 100% rename from patches/server/0522-Fixed-TileEntityBell-memory-leak.patch rename to patches/server/0523-Fixed-TileEntityBell-memory-leak.patch diff --git a/patches/server/0523-Avoid-error-bubbling-up-when-item-stack-is-empty-in-.patch b/patches/server/0524-Avoid-error-bubbling-up-when-item-stack-is-empty-in-.patch similarity index 100% rename from patches/server/0523-Avoid-error-bubbling-up-when-item-stack-is-empty-in-.patch rename to patches/server/0524-Avoid-error-bubbling-up-when-item-stack-is-empty-in-.patch diff --git a/patches/server/0524-Add-getOfflinePlayerIfCached-String.patch b/patches/server/0525-Add-getOfflinePlayerIfCached-String.patch similarity index 93% rename from patches/server/0524-Add-getOfflinePlayerIfCached-String.patch rename to patches/server/0525-Add-getOfflinePlayerIfCached-String.patch index 6b7a38b26..41c32cbec 100644 --- a/patches/server/0524-Add-getOfflinePlayerIfCached-String.patch +++ b/patches/server/0525-Add-getOfflinePlayerIfCached-String.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add getOfflinePlayerIfCached(String) diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index cd98fa713ecd0cb8d4bb2a9211ee9b9b89a04330..5c8dc52d012117ebf9721fb26d3c0e9d84a751f4 100644 +index 1ffadc1da10872655449a8d63590b9c4ca2df7ae..553a427810bda77adb972cb39504be5baff1474b 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -1808,6 +1808,28 @@ public final class CraftServer implements Server { diff --git a/patches/server/0525-Add-ignore-discounts-API.patch b/patches/server/0526-Add-ignore-discounts-API.patch similarity index 100% rename from patches/server/0525-Add-ignore-discounts-API.patch rename to patches/server/0526-Add-ignore-discounts-API.patch diff --git a/patches/server/0526-Toggle-for-removing-existing-dragon.patch b/patches/server/0527-Toggle-for-removing-existing-dragon.patch similarity index 92% rename from patches/server/0526-Toggle-for-removing-existing-dragon.patch rename to patches/server/0527-Toggle-for-removing-existing-dragon.patch index 796133333..1eba73554 100644 --- a/patches/server/0526-Toggle-for-removing-existing-dragon.patch +++ b/patches/server/0527-Toggle-for-removing-existing-dragon.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Toggle for removing existing dragon diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index aee981e967bfb32a531d5d79213c5d165bb64ad0..ffcfa631a519079f355cddb7bf10dbceb2496882 100644 +index 71427964707e164e2db9c33afcb0373e88783257..d70b0159a80e697d85d701234975423fca06c2a1 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -71,6 +71,14 @@ public class PaperWorldConfig { +@@ -73,6 +73,14 @@ public class PaperWorldConfig { } } diff --git a/patches/server/0527-Fix-client-lag-on-advancement-loading.patch b/patches/server/0528-Fix-client-lag-on-advancement-loading.patch similarity index 100% rename from patches/server/0527-Fix-client-lag-on-advancement-loading.patch rename to patches/server/0528-Fix-client-lag-on-advancement-loading.patch diff --git a/patches/server/0528-Item-no-age-no-player-pickup.patch b/patches/server/0529-Item-no-age-no-player-pickup.patch similarity index 100% rename from patches/server/0528-Item-no-age-no-player-pickup.patch rename to patches/server/0529-Item-no-age-no-player-pickup.patch diff --git a/patches/server/0529-Optimize-Pathfinder-Remove-Streams-Optimized-collect.patch b/patches/server/0530-Optimize-Pathfinder-Remove-Streams-Optimized-collect.patch similarity index 100% rename from patches/server/0529-Optimize-Pathfinder-Remove-Streams-Optimized-collect.patch rename to patches/server/0530-Optimize-Pathfinder-Remove-Streams-Optimized-collect.patch diff --git a/patches/server/0530-Beacon-API-custom-effect-ranges.patch b/patches/server/0531-Beacon-API-custom-effect-ranges.patch similarity index 100% rename from patches/server/0530-Beacon-API-custom-effect-ranges.patch rename to patches/server/0531-Beacon-API-custom-effect-ranges.patch diff --git a/patches/server/0531-Add-API-for-quit-reason.patch b/patches/server/0532-Add-API-for-quit-reason.patch similarity index 98% rename from patches/server/0531-Add-API-for-quit-reason.patch rename to patches/server/0532-Add-API-for-quit-reason.patch index 1c1706104..6ea301253 100644 --- a/patches/server/0531-Add-API-for-quit-reason.patch +++ b/patches/server/0532-Add-API-for-quit-reason.patch @@ -49,7 +49,7 @@ index 2dd47eab63cf9322a5844e748709e220272a8cfe..c0a685cfe62aeda3583763ecc1e4fa12 this.connection.disconnect(ichatbasecomponent); }); diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 5c829538a008f1a737380627f7b88c7a0914050f..d414a3abae7dea5b813e41758eccf98cd35bddc2 100644 +index a1077445ab7d416dc61db85742e447193642b919..38f0f98c2191bfe36c3547501e49680faef50403 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -596,7 +596,7 @@ public abstract class PlayerList { diff --git a/patches/server/0532-Add-Wandering-Trader-spawn-rate-config-options.patch b/patches/server/0533-Add-Wandering-Trader-spawn-rate-config-options.patch similarity index 97% rename from patches/server/0532-Add-Wandering-Trader-spawn-rate-config-options.patch rename to patches/server/0533-Add-Wandering-Trader-spawn-rate-config-options.patch index b2b1e8617..925d71a55 100644 --- a/patches/server/0532-Add-Wandering-Trader-spawn-rate-config-options.patch +++ b/patches/server/0533-Add-Wandering-Trader-spawn-rate-config-options.patch @@ -11,10 +11,10 @@ in IWorldServerData are removed as they were only used in certain places, with h values used in other places. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index ffcfa631a519079f355cddb7bf10dbceb2496882..7f4e963c1bb37f929321e0a862f76f42ab72b4c4 100644 +index d70b0159a80e697d85d701234975423fca06c2a1..94a795786d3e9f2563a026ef7b00e17658d30920 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -79,6 +79,19 @@ public class PaperWorldConfig { +@@ -81,6 +81,19 @@ public class PaperWorldConfig { } } diff --git a/patches/server/0533-Significantly-improve-performance-of-the-end-generat.patch b/patches/server/0534-Significantly-improve-performance-of-the-end-generat.patch similarity index 100% rename from patches/server/0533-Significantly-improve-performance-of-the-end-generat.patch rename to patches/server/0534-Significantly-improve-performance-of-the-end-generat.patch diff --git a/patches/server/0534-Expose-world-spawn-angle.patch b/patches/server/0535-Expose-world-spawn-angle.patch similarity index 95% rename from patches/server/0534-Expose-world-spawn-angle.patch rename to patches/server/0535-Expose-world-spawn-angle.patch index a8d03cfac..fcd5d2979 100644 --- a/patches/server/0534-Expose-world-spawn-angle.patch +++ b/patches/server/0535-Expose-world-spawn-angle.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Expose world spawn angle diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index d414a3abae7dea5b813e41758eccf98cd35bddc2..e7834772e38e61df405be406fe320a646778175a 100644 +index 38f0f98c2191bfe36c3547501e49680faef50403..1a52902d80d5abf2d914f7b49ab461cb3cda8d80 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -874,7 +874,7 @@ public abstract class PlayerList { diff --git a/patches/server/0535-Add-Destroy-Speed-API.patch b/patches/server/0536-Add-Destroy-Speed-API.patch similarity index 100% rename from patches/server/0535-Add-Destroy-Speed-API.patch rename to patches/server/0536-Add-Destroy-Speed-API.patch diff --git a/patches/server/0536-Fix-Player-spawnParticle-x-y-z-precision-loss.patch b/patches/server/0537-Fix-Player-spawnParticle-x-y-z-precision-loss.patch similarity index 100% rename from patches/server/0536-Fix-Player-spawnParticle-x-y-z-precision-loss.patch rename to patches/server/0537-Fix-Player-spawnParticle-x-y-z-precision-loss.patch diff --git a/patches/server/0537-Add-LivingEntity-clearActiveItem.patch b/patches/server/0538-Add-LivingEntity-clearActiveItem.patch similarity index 100% rename from patches/server/0537-Add-LivingEntity-clearActiveItem.patch rename to patches/server/0538-Add-LivingEntity-clearActiveItem.patch diff --git a/patches/server/0538-Add-PlayerItemCooldownEvent.patch b/patches/server/0539-Add-PlayerItemCooldownEvent.patch similarity index 100% rename from patches/server/0538-Add-PlayerItemCooldownEvent.patch rename to patches/server/0539-Add-PlayerItemCooldownEvent.patch diff --git a/patches/server/0539-More-lightning-API.patch b/patches/server/0540-More-lightning-API.patch similarity index 100% rename from patches/server/0539-More-lightning-API.patch rename to patches/server/0540-More-lightning-API.patch diff --git a/patches/server/0540-Climbing-should-not-bypass-cramming-gamerule.patch b/patches/server/0541-Climbing-should-not-bypass-cramming-gamerule.patch similarity index 98% rename from patches/server/0540-Climbing-should-not-bypass-cramming-gamerule.patch rename to patches/server/0541-Climbing-should-not-bypass-cramming-gamerule.patch index f5f3eba66..f40e61762 100644 --- a/patches/server/0540-Climbing-should-not-bypass-cramming-gamerule.patch +++ b/patches/server/0541-Climbing-should-not-bypass-cramming-gamerule.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Climbing should not bypass cramming gamerule diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 7f4e963c1bb37f929321e0a862f76f42ab72b4c4..9bc44cbe06bc7055c4fafff899c999b5929f468b 100644 +index 94a795786d3e9f2563a026ef7b00e17658d30920..562ecd1adc3097d86fa086010a572d1f6902dba8 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -92,6 +92,11 @@ public class PaperWorldConfig { +@@ -94,6 +94,11 @@ public class PaperWorldConfig { wanderingTraderSpawnChanceMax = getInt("wandering-trader.spawn-chance-max", wanderingTraderSpawnChanceMax); } diff --git a/patches/server/0541-Added-missing-default-perms-for-commands.patch b/patches/server/0542-Added-missing-default-perms-for-commands.patch similarity index 100% rename from patches/server/0541-Added-missing-default-perms-for-commands.patch rename to patches/server/0542-Added-missing-default-perms-for-commands.patch diff --git a/patches/server/0542-Add-PlayerShearBlockEvent.patch b/patches/server/0543-Add-PlayerShearBlockEvent.patch similarity index 100% rename from patches/server/0542-Add-PlayerShearBlockEvent.patch rename to patches/server/0543-Add-PlayerShearBlockEvent.patch diff --git a/patches/server/0543-Fix-curing-zombie-villager-discount-exploit.patch b/patches/server/0544-Fix-curing-zombie-villager-discount-exploit.patch similarity index 94% rename from patches/server/0543-Fix-curing-zombie-villager-discount-exploit.patch rename to patches/server/0544-Fix-curing-zombie-villager-discount-exploit.patch index 03542bbe1..7ba26bd75 100644 --- a/patches/server/0543-Fix-curing-zombie-villager-discount-exploit.patch +++ b/patches/server/0544-Fix-curing-zombie-villager-discount-exploit.patch @@ -8,10 +8,10 @@ and curing a villager on repeat by simply resetting the relevant part of the reputation when it is cured. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 9bc44cbe06bc7055c4fafff899c999b5929f468b..fb03c7c1c2f0e090f22964973c1499271ad3dad9 100644 +index 562ecd1adc3097d86fa086010a572d1f6902dba8..b3c716a5df2b4085903e0890f1a2146fa68742de 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -97,6 +97,11 @@ public class PaperWorldConfig { +@@ -99,6 +99,11 @@ public class PaperWorldConfig { fixClimbingBypassingCrammingRule = getBoolean("fix-climbing-bypassing-cramming-rule", fixClimbingBypassingCrammingRule); } diff --git a/patches/server/0544-Limit-recipe-packets.patch b/patches/server/0545-Limit-recipe-packets.patch similarity index 100% rename from patches/server/0544-Limit-recipe-packets.patch rename to patches/server/0545-Limit-recipe-packets.patch diff --git a/patches/server/0545-Fix-CraftSound-backwards-compatibility.patch b/patches/server/0546-Fix-CraftSound-backwards-compatibility.patch similarity index 100% rename from patches/server/0545-Fix-CraftSound-backwards-compatibility.patch rename to patches/server/0546-Fix-CraftSound-backwards-compatibility.patch diff --git a/patches/server/0546-MC-4-Fix-item-position-desync.patch b/patches/server/0547-MC-4-Fix-item-position-desync.patch similarity index 100% rename from patches/server/0546-MC-4-Fix-item-position-desync.patch rename to patches/server/0547-MC-4-Fix-item-position-desync.patch diff --git a/patches/server/0547-Player-Chunk-Load-Unload-Events.patch b/patches/server/0548-Player-Chunk-Load-Unload-Events.patch similarity index 100% rename from patches/server/0547-Player-Chunk-Load-Unload-Events.patch rename to patches/server/0548-Player-Chunk-Load-Unload-Events.patch diff --git a/patches/server/0548-Optimize-Dynamic-get-Missing-Keys.patch b/patches/server/0549-Optimize-Dynamic-get-Missing-Keys.patch similarity index 100% rename from patches/server/0548-Optimize-Dynamic-get-Missing-Keys.patch rename to patches/server/0549-Optimize-Dynamic-get-Missing-Keys.patch diff --git a/patches/server/0549-Expose-LivingEntity-hurt-direction.patch b/patches/server/0550-Expose-LivingEntity-hurt-direction.patch similarity index 100% rename from patches/server/0549-Expose-LivingEntity-hurt-direction.patch rename to patches/server/0550-Expose-LivingEntity-hurt-direction.patch diff --git a/patches/server/0550-Add-OBSTRUCTED-reason-to-BedEnterResult.patch b/patches/server/0551-Add-OBSTRUCTED-reason-to-BedEnterResult.patch similarity index 100% rename from patches/server/0550-Add-OBSTRUCTED-reason-to-BedEnterResult.patch rename to patches/server/0551-Add-OBSTRUCTED-reason-to-BedEnterResult.patch diff --git a/patches/server/0551-Do-not-crash-from-invalid-ingredient-lists-in-Villag.patch b/patches/server/0552-Do-not-crash-from-invalid-ingredient-lists-in-Villag.patch similarity index 100% rename from patches/server/0551-Do-not-crash-from-invalid-ingredient-lists-in-Villag.patch rename to patches/server/0552-Do-not-crash-from-invalid-ingredient-lists-in-Villag.patch diff --git a/patches/server/0552-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch b/patches/server/0553-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch similarity index 100% rename from patches/server/0552-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch rename to patches/server/0553-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch diff --git a/patches/server/0553-Implement-TargetHitEvent.patch b/patches/server/0554-Implement-TargetHitEvent.patch similarity index 100% rename from patches/server/0553-Implement-TargetHitEvent.patch rename to patches/server/0554-Implement-TargetHitEvent.patch diff --git a/patches/server/0554-Additional-Block-Material-API-s.patch b/patches/server/0555-Additional-Block-Material-API-s.patch similarity index 100% rename from patches/server/0554-Additional-Block-Material-API-s.patch rename to patches/server/0555-Additional-Block-Material-API-s.patch diff --git a/patches/server/0555-Fix-harming-potion-dupe.patch b/patches/server/0556-Fix-harming-potion-dupe.patch similarity index 100% rename from patches/server/0555-Fix-harming-potion-dupe.patch rename to patches/server/0556-Fix-harming-potion-dupe.patch diff --git a/patches/server/0556-Implement-API-to-get-Material-from-Boats-and-Minecar.patch b/patches/server/0557-Implement-API-to-get-Material-from-Boats-and-Minecar.patch similarity index 100% rename from patches/server/0556-Implement-API-to-get-Material-from-Boats-and-Minecar.patch rename to patches/server/0557-Implement-API-to-get-Material-from-Boats-and-Minecar.patch diff --git a/patches/server/0557-Cache-burn-durations.patch b/patches/server/0558-Cache-burn-durations.patch similarity index 100% rename from patches/server/0557-Cache-burn-durations.patch rename to patches/server/0558-Cache-burn-durations.patch diff --git a/patches/server/0558-Allow-disabling-mob-spawner-spawn-egg-transformation.patch b/patches/server/0559-Allow-disabling-mob-spawner-spawn-egg-transformation.patch similarity index 93% rename from patches/server/0558-Allow-disabling-mob-spawner-spawn-egg-transformation.patch rename to patches/server/0559-Allow-disabling-mob-spawner-spawn-egg-transformation.patch index 5109435f9..9f0e4045c 100644 --- a/patches/server/0558-Allow-disabling-mob-spawner-spawn-egg-transformation.patch +++ b/patches/server/0559-Allow-disabling-mob-spawner-spawn-egg-transformation.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Allow disabling mob spawner spawn egg transformation diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index fb03c7c1c2f0e090f22964973c1499271ad3dad9..3ad93abb830d307a0d2cf8cb4554bf3fa37cb91d 100644 +index b3c716a5df2b4085903e0890f1a2146fa68742de..eb6fa156690d50802b4ea1d26d930a0528a2d439 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -102,6 +102,11 @@ public class PaperWorldConfig { +@@ -104,6 +104,11 @@ public class PaperWorldConfig { fixCuringZombieVillagerDiscountExploit = getBoolean("game-mechanics.fix-curing-zombie-villager-discount-exploit", fixCuringZombieVillagerDiscountExploit); } diff --git a/patches/server/0559-Fix-Not-a-string-Map-Conversion-spam.patch b/patches/server/0560-Fix-Not-a-string-Map-Conversion-spam.patch similarity index 100% rename from patches/server/0559-Fix-Not-a-string-Map-Conversion-spam.patch rename to patches/server/0560-Fix-Not-a-string-Map-Conversion-spam.patch diff --git a/patches/server/0560-Implement-PlayerFlowerPotManipulateEvent.patch b/patches/server/0561-Implement-PlayerFlowerPotManipulateEvent.patch similarity index 100% rename from patches/server/0560-Implement-PlayerFlowerPotManipulateEvent.patch rename to patches/server/0561-Implement-PlayerFlowerPotManipulateEvent.patch diff --git a/patches/server/0561-Fix-interact-event-not-being-called-in-adventure.patch b/patches/server/0562-Fix-interact-event-not-being-called-in-adventure.patch similarity index 100% rename from patches/server/0561-Fix-interact-event-not-being-called-in-adventure.patch rename to patches/server/0562-Fix-interact-event-not-being-called-in-adventure.patch diff --git a/patches/server/0562-Zombie-API-breaking-doors.patch b/patches/server/0563-Zombie-API-breaking-doors.patch similarity index 100% rename from patches/server/0562-Zombie-API-breaking-doors.patch rename to patches/server/0563-Zombie-API-breaking-doors.patch diff --git a/patches/server/0563-Fix-nerfed-slime-when-splitting.patch b/patches/server/0564-Fix-nerfed-slime-when-splitting.patch similarity index 100% rename from patches/server/0563-Fix-nerfed-slime-when-splitting.patch rename to patches/server/0564-Fix-nerfed-slime-when-splitting.patch diff --git a/patches/server/0564-Add-EntityLoadCrossbowEvent.patch b/patches/server/0565-Add-EntityLoadCrossbowEvent.patch similarity index 100% rename from patches/server/0564-Add-EntityLoadCrossbowEvent.patch rename to patches/server/0565-Add-EntityLoadCrossbowEvent.patch diff --git a/patches/server/0565-Guardian-beam-workaround.patch b/patches/server/0566-Guardian-beam-workaround.patch similarity index 100% rename from patches/server/0565-Guardian-beam-workaround.patch rename to patches/server/0566-Guardian-beam-workaround.patch diff --git a/patches/server/0566-Added-WorldGameRuleChangeEvent.patch b/patches/server/0567-Added-WorldGameRuleChangeEvent.patch similarity index 100% rename from patches/server/0566-Added-WorldGameRuleChangeEvent.patch rename to patches/server/0567-Added-WorldGameRuleChangeEvent.patch diff --git a/patches/server/0567-Added-ServerResourcesReloadedEvent.patch b/patches/server/0568-Added-ServerResourcesReloadedEvent.patch similarity index 100% rename from patches/server/0567-Added-ServerResourcesReloadedEvent.patch rename to patches/server/0568-Added-ServerResourcesReloadedEvent.patch diff --git a/patches/server/0568-Added-world-settings-for-mobs-picking-up-loot.patch b/patches/server/0569-Added-world-settings-for-mobs-picking-up-loot.patch similarity index 95% rename from patches/server/0568-Added-world-settings-for-mobs-picking-up-loot.patch rename to patches/server/0569-Added-world-settings-for-mobs-picking-up-loot.patch index 536d06472..6192e96f3 100644 --- a/patches/server/0568-Added-world-settings-for-mobs-picking-up-loot.patch +++ b/patches/server/0569-Added-world-settings-for-mobs-picking-up-loot.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Added world settings for mobs picking up loot diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 3ad93abb830d307a0d2cf8cb4554bf3fa37cb91d..556bf08491466a061119338a05d6165d041e6668 100644 +index eb6fa156690d50802b4ea1d26d930a0528a2d439..abe8f8c91c7a6f4dbe8b8e08a8ddf6abf3c21255 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -688,6 +688,14 @@ public class PaperWorldConfig { +@@ -716,6 +716,14 @@ public class PaperWorldConfig { phantomOnlyAttackInsomniacs = getBoolean("phantoms-only-attack-insomniacs", phantomOnlyAttackInsomniacs); } diff --git a/patches/server/0569-Implemented-BlockFailedDispenseEvent.patch b/patches/server/0570-Implemented-BlockFailedDispenseEvent.patch similarity index 100% rename from patches/server/0569-Implemented-BlockFailedDispenseEvent.patch rename to patches/server/0570-Implemented-BlockFailedDispenseEvent.patch diff --git a/patches/server/0570-Added-PlayerLecternPageChangeEvent.patch b/patches/server/0571-Added-PlayerLecternPageChangeEvent.patch similarity index 100% rename from patches/server/0570-Added-PlayerLecternPageChangeEvent.patch rename to patches/server/0571-Added-PlayerLecternPageChangeEvent.patch diff --git a/patches/server/0571-Added-PlayerLoomPatternSelectEvent.patch b/patches/server/0572-Added-PlayerLoomPatternSelectEvent.patch similarity index 100% rename from patches/server/0571-Added-PlayerLoomPatternSelectEvent.patch rename to patches/server/0572-Added-PlayerLoomPatternSelectEvent.patch diff --git a/patches/server/0572-Configurable-door-breaking-difficulty.patch b/patches/server/0573-Configurable-door-breaking-difficulty.patch similarity index 73% rename from patches/server/0572-Configurable-door-breaking-difficulty.patch rename to patches/server/0573-Configurable-door-breaking-difficulty.patch index 4131ea9ff..bae980df6 100644 --- a/patches/server/0572-Configurable-door-breaking-difficulty.patch +++ b/patches/server/0573-Configurable-door-breaking-difficulty.patch @@ -5,39 +5,29 @@ Subject: [PATCH] Configurable door breaking difficulty diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 556bf08491466a061119338a05d6165d041e6668..79c8618eb1300239d457013c44d47277e2962904 100644 +index abe8f8c91c7a6f4dbe8b8e08a8ddf6abf3c21255..84dc0f57331ed619e0db76d4dfe18cfd2d2c06f8 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -6,6 +6,9 @@ import java.util.stream.Collectors; - import it.unimi.dsi.fastutil.objects.Reference2IntMap; - import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; - import net.minecraft.world.entity.MobCategory; -+import net.minecraft.world.Difficulty; -+import net.minecraft.world.entity.monster.Vindicator; -+import net.minecraft.world.entity.monster.Zombie; - import org.bukkit.Bukkit; - import org.bukkit.configuration.file.YamlConfiguration; - import org.spigotmc.SpigotWorldConfig; -@@ -107,6 +110,25 @@ public class PaperWorldConfig { +@@ -109,6 +109,25 @@ public class PaperWorldConfig { disableMobSpawnerSpawnEggTransformation = getBoolean("game-mechanics.disable-mob-spawner-spawn-egg-transformation", disableMobSpawnerSpawnEggTransformation); } -+ public List zombieBreakDoors; -+ public List vindicatorBreakDoors; ++ public List zombieBreakDoors; ++ public List vindicatorBreakDoors; + private void setupEntityBreakingDoors() { + zombieBreakDoors = getEnumList( + "door-breaking-difficulty.zombie", -+ java.util.Arrays.stream(Difficulty.values()) -+ .filter(Zombie.DOOR_BREAKING_PREDICATE) ++ java.util.Arrays.stream(net.minecraft.world.Difficulty.values()) ++ .filter(net.minecraft.world.entity.monster.Zombie.DOOR_BREAKING_PREDICATE) + .collect(Collectors.toList()), -+ Difficulty.class ++ net.minecraft.world.Difficulty.class + ); + vindicatorBreakDoors = getEnumList( + "door-breaking-difficulty.vindicator", -+ java.util.Arrays.stream(Difficulty.values()) -+ .filter(Vindicator.DOOR_BREAKING_PREDICATE) ++ java.util.Arrays.stream(net.minecraft.world.Difficulty.values()) ++ .filter(net.minecraft.world.entity.monster.Vindicator.DOOR_BREAKING_PREDICATE) + .collect(Collectors.toList()), -+ Difficulty.class ++ net.minecraft.world.Difficulty.class + ); + } + diff --git a/patches/server/0573-Empty-commands-shall-not-be-dispatched.patch b/patches/server/0574-Empty-commands-shall-not-be-dispatched.patch similarity index 100% rename from patches/server/0573-Empty-commands-shall-not-be-dispatched.patch rename to patches/server/0574-Empty-commands-shall-not-be-dispatched.patch diff --git a/patches/server/0574-Implement-API-to-expose-exact-interaction-point.patch b/patches/server/0575-Implement-API-to-expose-exact-interaction-point.patch similarity index 96% rename from patches/server/0574-Implement-API-to-expose-exact-interaction-point.patch rename to patches/server/0575-Implement-API-to-expose-exact-interaction-point.patch index 0ad239321..06bc7e440 100644 --- a/patches/server/0574-Implement-API-to-expose-exact-interaction-point.patch +++ b/patches/server/0575-Implement-API-to-expose-exact-interaction-point.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Implement API to expose exact interaction point diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -index 2ac2100b6ae006ab490742424b682395e7513156..9fbd88027933242348d9f4fea8b45e96fd01c343 100644 +index 01b19225193ef3a3f69291f0357c096fc9e71618..3a8e87f19aa03786b3bf60b793958b59284d31ac 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -@@ -497,7 +497,7 @@ public class ServerPlayerGameMode { +@@ -499,7 +499,7 @@ public class ServerPlayerGameMode { cancelledBlock = true; } diff --git a/patches/server/0575-Remove-stale-POIs.patch b/patches/server/0576-Remove-stale-POIs.patch similarity index 92% rename from patches/server/0575-Remove-stale-POIs.patch rename to patches/server/0576-Remove-stale-POIs.patch index 1de2e35ea..c7050f800 100644 --- a/patches/server/0575-Remove-stale-POIs.patch +++ b/patches/server/0576-Remove-stale-POIs.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Remove stale POIs diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 313a368eb5d09b0c4d45b5da34d72390d86332c5..2dddc0160c758decc257aeada11adeeaaad59629 100644 +index 00a64168592ad2c8cecb2fc844d81e47610601ad..6d635a02a12d3af0639d7afda19d5f71cf81ee44 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1800,6 +1800,11 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0576-Fix-villager-boat-exploit.patch b/patches/server/0577-Fix-villager-boat-exploit.patch similarity index 93% rename from patches/server/0576-Fix-villager-boat-exploit.patch rename to patches/server/0577-Fix-villager-boat-exploit.patch index 12ae3a8b8..68099d756 100644 --- a/patches/server/0576-Fix-villager-boat-exploit.patch +++ b/patches/server/0577-Fix-villager-boat-exploit.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix villager boat exploit diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index e7834772e38e61df405be406fe320a646778175a..236641fa4c325e455de0a5ad83541143f5bc18d1 100644 +index 1a52902d80d5abf2d914f7b49ab461cb3cda8d80..04e314761b09f7c13c94cb83a9a7da629fb16641 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -621,6 +621,14 @@ public abstract class PlayerList { diff --git a/patches/server/0577-Add-sendOpLevel-API.patch b/patches/server/0578-Add-sendOpLevel-API.patch similarity index 91% rename from patches/server/0577-Add-sendOpLevel-API.patch rename to patches/server/0578-Add-sendOpLevel-API.patch index d4b019c7e..8e722e560 100644 --- a/patches/server/0577-Add-sendOpLevel-API.patch +++ b/patches/server/0578-Add-sendOpLevel-API.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add sendOpLevel API diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 236641fa4c325e455de0a5ad83541143f5bc18d1..e04e4cf62d2a7dcf95ffee452dc2ee2e2a4fdf6f 100644 +index 04e314761b09f7c13c94cb83a9a7da629fb16641..52f8e91462b9f605aa529bc3ec4d55c9a006e472 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -1119,6 +1119,11 @@ public abstract class PlayerList { @@ -32,7 +32,7 @@ index 236641fa4c325e455de0a5ad83541143f5bc18d1..e04e4cf62d2a7dcf95ffee452dc2ee2e // Paper start diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index ef6c209221ad3a48ea9749d81a9f536443fb9403..eeaab3d50318dd06684bee3e484f6c7218259717 100644 +index 9499062a2d8d69764c314a791622c967641e3543..a68973595b9b08a636f5aeb11608b5b9499d8e16 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -577,6 +577,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0578-Add-StructureLocateEvent.patch b/patches/server/0579-Add-StructureLocateEvent.patch similarity index 100% rename from patches/server/0578-Add-StructureLocateEvent.patch rename to patches/server/0579-Add-StructureLocateEvent.patch diff --git a/patches/server/0579-Collision-option-for-requiring-a-player-participant.patch b/patches/server/0580-Collision-option-for-requiring-a-player-participant.patch similarity index 96% rename from patches/server/0579-Collision-option-for-requiring-a-player-participant.patch rename to patches/server/0580-Collision-option-for-requiring-a-player-participant.patch index ad984fbd2..fa8742bd6 100644 --- a/patches/server/0579-Collision-option-for-requiring-a-player-participant.patch +++ b/patches/server/0580-Collision-option-for-requiring-a-player-participant.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Collision option for requiring a player participant diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 79c8618eb1300239d457013c44d47277e2962904..a1c0b9770f4f9b84778db9b42c097af146485420 100644 +index 84dc0f57331ed619e0db76d4dfe18cfd2d2c06f8..03bd3c7bb978d908789e9a85695c9e5996191cb8 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -82,6 +82,18 @@ public class PaperWorldConfig { +@@ -81,6 +81,18 @@ public class PaperWorldConfig { } } diff --git a/patches/server/0580-Remove-ProjectileHitEvent-call-when-fireballs-dead.patch b/patches/server/0581-Remove-ProjectileHitEvent-call-when-fireballs-dead.patch similarity index 100% rename from patches/server/0580-Remove-ProjectileHitEvent-call-when-fireballs-dead.patch rename to patches/server/0581-Remove-ProjectileHitEvent-call-when-fireballs-dead.patch diff --git a/patches/server/0581-Return-chat-component-with-empty-text-instead-of-thr.patch b/patches/server/0582-Return-chat-component-with-empty-text-instead-of-thr.patch similarity index 100% rename from patches/server/0581-Return-chat-component-with-empty-text-instead-of-thr.patch rename to patches/server/0582-Return-chat-component-with-empty-text-instead-of-thr.patch diff --git a/patches/server/0582-Make-schedule-command-per-world.patch b/patches/server/0583-Make-schedule-command-per-world.patch similarity index 100% rename from patches/server/0582-Make-schedule-command-per-world.patch rename to patches/server/0583-Make-schedule-command-per-world.patch diff --git a/patches/server/0583-Configurable-max-leash-distance.patch b/patches/server/0584-Configurable-max-leash-distance.patch similarity index 94% rename from patches/server/0583-Configurable-max-leash-distance.patch rename to patches/server/0584-Configurable-max-leash-distance.patch index f434b74aa..6d7d6ce3b 100644 --- a/patches/server/0583-Configurable-max-leash-distance.patch +++ b/patches/server/0584-Configurable-max-leash-distance.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Configurable max leash distance diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index a1c0b9770f4f9b84778db9b42c097af146485420..e1bb630f2352a30e351c7e1535ff82fd93849609 100644 +index 03bd3c7bb978d908789e9a85695c9e5996191cb8..36135f32b1a3fb739317f6e44a0118adc6125012 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -302,6 +302,12 @@ public class PaperWorldConfig { +@@ -301,6 +301,12 @@ public class PaperWorldConfig { } } diff --git a/patches/server/0584-Implement-BlockPreDispenseEvent.patch b/patches/server/0585-Implement-BlockPreDispenseEvent.patch similarity index 100% rename from patches/server/0584-Implement-BlockPreDispenseEvent.patch rename to patches/server/0585-Implement-BlockPreDispenseEvent.patch diff --git a/patches/server/0585-added-Wither-API.patch b/patches/server/0586-added-Wither-API.patch similarity index 100% rename from patches/server/0585-added-Wither-API.patch rename to patches/server/0586-added-Wither-API.patch diff --git a/patches/server/0586-Added-firing-of-PlayerChangeBeaconEffectEvent.patch b/patches/server/0587-Added-firing-of-PlayerChangeBeaconEffectEvent.patch similarity index 100% rename from patches/server/0586-Added-firing-of-PlayerChangeBeaconEffectEvent.patch rename to patches/server/0587-Added-firing-of-PlayerChangeBeaconEffectEvent.patch diff --git a/patches/server/0587-Add-toggle-for-always-placing-the-dragon-egg.patch b/patches/server/0588-Add-toggle-for-always-placing-the-dragon-egg.patch similarity index 93% rename from patches/server/0587-Add-toggle-for-always-placing-the-dragon-egg.patch rename to patches/server/0588-Add-toggle-for-always-placing-the-dragon-egg.patch index 8df477f13..653c69957 100644 --- a/patches/server/0587-Add-toggle-for-always-placing-the-dragon-egg.patch +++ b/patches/server/0588-Add-toggle-for-always-placing-the-dragon-egg.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add toggle for always placing the dragon egg diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index e1bb630f2352a30e351c7e1535ff82fd93849609..d891a7d54688a10fe4fe16f2f5037a57a9c58e86 100644 +index 36135f32b1a3fb739317f6e44a0118adc6125012..28141062e404cb9ae993c9c0fb92a06bdfe511a7 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -721,6 +721,11 @@ public class PaperWorldConfig { +@@ -746,6 +746,11 @@ public class PaperWorldConfig { perPlayerMobSpawns = getBoolean("per-player-mob-spawns", true); } diff --git a/patches/server/0588-Added-PlayerStonecutterRecipeSelectEvent.patch b/patches/server/0589-Added-PlayerStonecutterRecipeSelectEvent.patch similarity index 100% rename from patches/server/0588-Added-PlayerStonecutterRecipeSelectEvent.patch rename to patches/server/0589-Added-PlayerStonecutterRecipeSelectEvent.patch diff --git a/patches/server/0589-Add-dropLeash-variable-to-EntityUnleashEvent.patch b/patches/server/0590-Add-dropLeash-variable-to-EntityUnleashEvent.patch similarity index 100% rename from patches/server/0589-Add-dropLeash-variable-to-EntityUnleashEvent.patch rename to patches/server/0590-Add-dropLeash-variable-to-EntityUnleashEvent.patch diff --git a/patches/server/0590-Skip-distance-map-update-when-spawning-disabled.patch b/patches/server/0591-Skip-distance-map-update-when-spawning-disabled.patch similarity index 92% rename from patches/server/0590-Skip-distance-map-update-when-spawning-disabled.patch rename to patches/server/0591-Skip-distance-map-update-when-spawning-disabled.patch index d41b951ef..248826735 100644 --- a/patches/server/0590-Skip-distance-map-update-when-spawning-disabled.patch +++ b/patches/server/0591-Skip-distance-map-update-when-spawning-disabled.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Skip distance map update when spawning disabled. diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 58c22ed8e37b22b3b304139b1746b5bc8ba6f45a..59d7f93c9364571edf2e7b613a57f8f28989cb56 100644 +index 364375f5da5a3daea200c97c5dca86cbb8be5fb9..f7abb67568cf1034dae3fe9e0adff9bcc36b96e7 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -966,7 +966,7 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0591-Reset-shield-blocking-on-dimension-change.patch b/patches/server/0592-Reset-shield-blocking-on-dimension-change.patch similarity index 100% rename from patches/server/0591-Reset-shield-blocking-on-dimension-change.patch rename to patches/server/0592-Reset-shield-blocking-on-dimension-change.patch diff --git a/patches/server/0592-add-DragonEggFormEvent.patch b/patches/server/0593-add-DragonEggFormEvent.patch similarity index 100% rename from patches/server/0592-add-DragonEggFormEvent.patch rename to patches/server/0593-add-DragonEggFormEvent.patch diff --git a/patches/server/0593-EntityMoveEvent.patch b/patches/server/0594-EntityMoveEvent.patch similarity index 97% rename from patches/server/0593-EntityMoveEvent.patch rename to patches/server/0594-EntityMoveEvent.patch index 092a5f300..72725055d 100644 --- a/patches/server/0593-EntityMoveEvent.patch +++ b/patches/server/0594-EntityMoveEvent.patch @@ -17,7 +17,7 @@ index 276795ef5b504bea56d6b533385ed55f7fd02ddb..2a0aabd4ca39ecada4d50de338421bc7 this.profiler.push(() -> { diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 2dddc0160c758decc257aeada11adeeaaad59629..f7bccad8b029133377f0e3ae81619ec72055d265 100644 +index 6d635a02a12d3af0639d7afda19d5f71cf81ee44..3a66376145f29e2330daed723ffccf98415b0540 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -205,6 +205,7 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0594-added-option-to-disable-pathfinding-updates-on-block.patch b/patches/server/0595-added-option-to-disable-pathfinding-updates-on-block.patch similarity index 89% rename from patches/server/0594-added-option-to-disable-pathfinding-updates-on-block.patch rename to patches/server/0595-added-option-to-disable-pathfinding-updates-on-block.patch index 554e8dd7f..805a944f7 100644 --- a/patches/server/0594-added-option-to-disable-pathfinding-updates-on-block.patch +++ b/patches/server/0595-added-option-to-disable-pathfinding-updates-on-block.patch @@ -5,10 +5,10 @@ Subject: [PATCH] added option to disable pathfinding updates on block changes diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index d891a7d54688a10fe4fe16f2f5037a57a9c58e86..84a3d8ee365d05fb2ab7c8550e4880fd5d332846 100644 +index 28141062e404cb9ae993c9c0fb92a06bdfe511a7..3ac3f8f8a6cc144c426409898abee3908c098b76 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -726,6 +726,11 @@ public class PaperWorldConfig { +@@ -751,6 +751,11 @@ public class PaperWorldConfig { enderDragonsDeathAlwaysPlacesDragonEgg = getBoolean("ender-dragons-death-always-places-dragon-egg", enderDragonsDeathAlwaysPlacesDragonEgg); } @@ -21,7 +21,7 @@ index d891a7d54688a10fe4fe16f2f5037a57a9c58e86..84a3d8ee365d05fb2ab7c8550e4880fd public boolean phantomOnlyAttackInsomniacs = true; private void phantomSettings() { diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index f7bccad8b029133377f0e3ae81619ec72055d265..955f1f14ba7dca04d928a35db83c9b55133caa85 100644 +index 3a66376145f29e2330daed723ffccf98415b0540..5b17b4c06d8da92d25048a4df72a328c90af76b6 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1391,6 +1391,7 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0595-Inline-shift-direction-fields.patch b/patches/server/0596-Inline-shift-direction-fields.patch similarity index 100% rename from patches/server/0595-Inline-shift-direction-fields.patch rename to patches/server/0596-Inline-shift-direction-fields.patch diff --git a/patches/server/0596-Allow-adding-items-to-BlockDropItemEvent.patch b/patches/server/0597-Allow-adding-items-to-BlockDropItemEvent.patch similarity index 100% rename from patches/server/0596-Allow-adding-items-to-BlockDropItemEvent.patch rename to patches/server/0597-Allow-adding-items-to-BlockDropItemEvent.patch diff --git a/patches/server/0597-Add-getMainThreadExecutor-to-BukkitScheduler.patch b/patches/server/0598-Add-getMainThreadExecutor-to-BukkitScheduler.patch similarity index 100% rename from patches/server/0597-Add-getMainThreadExecutor-to-BukkitScheduler.patch rename to patches/server/0598-Add-getMainThreadExecutor-to-BukkitScheduler.patch diff --git a/patches/server/0598-living-entity-allow-attribute-registration.patch b/patches/server/0599-living-entity-allow-attribute-registration.patch similarity index 100% rename from patches/server/0598-living-entity-allow-attribute-registration.patch rename to patches/server/0599-living-entity-allow-attribute-registration.patch diff --git a/patches/server/0599-fix-dead-slime-setSize-invincibility.patch b/patches/server/0600-fix-dead-slime-setSize-invincibility.patch similarity index 100% rename from patches/server/0599-fix-dead-slime-setSize-invincibility.patch rename to patches/server/0600-fix-dead-slime-setSize-invincibility.patch diff --git a/patches/server/0600-Merchant-getRecipes-should-return-an-immutable-list.patch b/patches/server/0601-Merchant-getRecipes-should-return-an-immutable-list.patch similarity index 100% rename from patches/server/0600-Merchant-getRecipes-should-return-an-immutable-list.patch rename to patches/server/0601-Merchant-getRecipes-should-return-an-immutable-list.patch diff --git a/patches/server/0601-Add-support-for-hex-color-codes-in-console.patch b/patches/server/0602-Add-support-for-hex-color-codes-in-console.patch similarity index 100% rename from patches/server/0601-Add-support-for-hex-color-codes-in-console.patch rename to patches/server/0602-Add-support-for-hex-color-codes-in-console.patch diff --git a/patches/server/0602-Expose-Tracked-Players.patch b/patches/server/0603-Expose-Tracked-Players.patch similarity index 100% rename from patches/server/0602-Expose-Tracked-Players.patch rename to patches/server/0603-Expose-Tracked-Players.patch diff --git a/patches/server/0603-Remove-streams-from-SensorNearest.patch b/patches/server/0604-Remove-streams-from-SensorNearest.patch similarity index 100% rename from patches/server/0603-Remove-streams-from-SensorNearest.patch rename to patches/server/0604-Remove-streams-from-SensorNearest.patch diff --git a/patches/server/0604-Throw-proper-exception-on-empty-JsonList-file.patch b/patches/server/0605-Throw-proper-exception-on-empty-JsonList-file.patch similarity index 100% rename from patches/server/0604-Throw-proper-exception-on-empty-JsonList-file.patch rename to patches/server/0605-Throw-proper-exception-on-empty-JsonList-file.patch diff --git a/patches/server/0605-Improve-ServerGUI.patch b/patches/server/0606-Improve-ServerGUI.patch similarity index 100% rename from patches/server/0605-Improve-ServerGUI.patch rename to patches/server/0606-Improve-ServerGUI.patch diff --git a/patches/server/0606-stop-firing-pressure-plate-EntityInteractEvent-for-i.patch b/patches/server/0607-stop-firing-pressure-plate-EntityInteractEvent-for-i.patch similarity index 100% rename from patches/server/0606-stop-firing-pressure-plate-EntityInteractEvent-for-i.patch rename to patches/server/0607-stop-firing-pressure-plate-EntityInteractEvent-for-i.patch diff --git a/patches/server/0607-fix-converting-txt-to-json-file.patch b/patches/server/0608-fix-converting-txt-to-json-file.patch similarity index 97% rename from patches/server/0607-fix-converting-txt-to-json-file.patch rename to patches/server/0608-fix-converting-txt-to-json-file.patch index 2f1dd0a23..de3c433c6 100644 --- a/patches/server/0607-fix-converting-txt-to-json-file.patch +++ b/patches/server/0608-fix-converting-txt-to-json-file.patch @@ -48,7 +48,7 @@ index e968b880e435b8753314d85b919a0abc4f35be25..02d7b16f81ebf9f902a36d4f31802b20 if (!OldUsersConverter.serverReadyAfterUserconversion(this)) { return false; diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index e04e4cf62d2a7dcf95ffee452dc2ee2e2a4fdf6f..5077991ca54f848a2e1a3e2f375f0957f68113bd 100644 +index 52f8e91462b9f605aa529bc3ec4d55c9a006e472..f4966251d35323d526479a8a9c1fb552ad1709e9 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -174,6 +174,7 @@ public abstract class PlayerList { diff --git a/patches/server/0608-Add-worldborder-events.patch b/patches/server/0609-Add-worldborder-events.patch similarity index 100% rename from patches/server/0608-Add-worldborder-events.patch rename to patches/server/0609-Add-worldborder-events.patch diff --git a/patches/server/0609-added-PlayerNameEntityEvent.patch b/patches/server/0610-added-PlayerNameEntityEvent.patch similarity index 100% rename from patches/server/0609-added-PlayerNameEntityEvent.patch rename to patches/server/0610-added-PlayerNameEntityEvent.patch diff --git a/patches/server/0610-Prevent-grindstones-from-overstacking-items.patch b/patches/server/0611-Prevent-grindstones-from-overstacking-items.patch similarity index 100% rename from patches/server/0610-Prevent-grindstones-from-overstacking-items.patch rename to patches/server/0611-Prevent-grindstones-from-overstacking-items.patch diff --git a/patches/server/0611-Add-recipe-to-cook-events.patch b/patches/server/0612-Add-recipe-to-cook-events.patch similarity index 100% rename from patches/server/0611-Add-recipe-to-cook-events.patch rename to patches/server/0612-Add-recipe-to-cook-events.patch diff --git a/patches/server/0612-Add-Block-isValidTool.patch b/patches/server/0613-Add-Block-isValidTool.patch similarity index 100% rename from patches/server/0612-Add-Block-isValidTool.patch rename to patches/server/0613-Add-Block-isValidTool.patch diff --git a/patches/server/0613-Allow-using-signs-inside-spawn-protection.patch b/patches/server/0614-Allow-using-signs-inside-spawn-protection.patch similarity index 89% rename from patches/server/0613-Allow-using-signs-inside-spawn-protection.patch rename to patches/server/0614-Allow-using-signs-inside-spawn-protection.patch index 4706835e3..83ba67caf 100644 --- a/patches/server/0613-Allow-using-signs-inside-spawn-protection.patch +++ b/patches/server/0614-Allow-using-signs-inside-spawn-protection.patch @@ -5,12 +5,12 @@ Subject: [PATCH] Allow using signs inside spawn protection diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 84a3d8ee365d05fb2ab7c8550e4880fd5d332846..9fc14f3102e2ceb10b80974fabb5c4513e17e63f 100644 +index 3ac3f8f8a6cc144c426409898abee3908c098b76..f1e4f8af50ef5ede030b35bda62ebc63d6982bae 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -751,4 +751,9 @@ public class PaperWorldConfig { - expMergeMaxValue = getInt("experience-merge-max-value", -1); - log("Experience Merge Max Value: " + expMergeMaxValue); +@@ -785,4 +785,9 @@ public class PaperWorldConfig { + delayChunkUnloadsBy *= 20; + } } + + public boolean allowUsingSignsInsideSpawnProtection = false; diff --git a/patches/server/0614-Implement-Keyed-on-World.patch b/patches/server/0615-Implement-Keyed-on-World.patch similarity index 96% rename from patches/server/0614-Implement-Keyed-on-World.patch rename to patches/server/0615-Implement-Keyed-on-World.patch index b6bdabe26..ddaaa9728 100644 --- a/patches/server/0614-Implement-Keyed-on-World.patch +++ b/patches/server/0615-Implement-Keyed-on-World.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Implement Keyed on World diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 5c8dc52d012117ebf9721fb26d3c0e9d84a751f4..9d77ecf330d93b3c2925d097b753c887838cb1ec 100644 +index 553a427810bda77adb972cb39504be5baff1474b..86816736595c269e3a2e8a849d67a0836a3f1593 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -1239,7 +1239,7 @@ public final class CraftServer implements Server { diff --git a/patches/server/0615-Add-fast-alternative-constructor-for-Rotations.patch b/patches/server/0616-Add-fast-alternative-constructor-for-Rotations.patch similarity index 100% rename from patches/server/0615-Add-fast-alternative-constructor-for-Rotations.patch rename to patches/server/0616-Add-fast-alternative-constructor-for-Rotations.patch diff --git a/patches/server/0616-Item-Rarity-API.patch b/patches/server/0617-Item-Rarity-API.patch similarity index 100% rename from patches/server/0616-Item-Rarity-API.patch rename to patches/server/0617-Item-Rarity-API.patch diff --git a/patches/server/0617-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch b/patches/server/0618-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch similarity index 100% rename from patches/server/0617-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch rename to patches/server/0618-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch diff --git a/patches/server/0618-copy-TESign-isEditable-from-snapshots.patch b/patches/server/0619-copy-TESign-isEditable-from-snapshots.patch similarity index 100% rename from patches/server/0618-copy-TESign-isEditable-from-snapshots.patch rename to patches/server/0619-copy-TESign-isEditable-from-snapshots.patch diff --git a/patches/server/0619-Drop-carried-item-when-player-has-disconnected.patch b/patches/server/0620-Drop-carried-item-when-player-has-disconnected.patch similarity index 92% rename from patches/server/0619-Drop-carried-item-when-player-has-disconnected.patch rename to patches/server/0620-Drop-carried-item-when-player-has-disconnected.patch index c4ba93637..ab409204f 100644 --- a/patches/server/0619-Drop-carried-item-when-player-has-disconnected.patch +++ b/patches/server/0620-Drop-carried-item-when-player-has-disconnected.patch @@ -7,7 +7,7 @@ Fixes disappearance of held items, when a player gets disconnected and PlayerDro Closes #5036 diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 5077991ca54f848a2e1a3e2f375f0957f68113bd..29864d3c25cea7bbb84a431a82e7b80f4af2966d 100644 +index f4966251d35323d526479a8a9c1fb552ad1709e9..19e6da4ab7d609470ef1597ac45ad3ab6a6a2825 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -614,6 +614,14 @@ public abstract class PlayerList { diff --git a/patches/server/0620-forced-whitelist-use-configurable-kick-message.patch b/patches/server/0621-forced-whitelist-use-configurable-kick-message.patch similarity index 100% rename from patches/server/0620-forced-whitelist-use-configurable-kick-message.patch rename to patches/server/0621-forced-whitelist-use-configurable-kick-message.patch diff --git a/patches/server/0621-Don-t-ignore-result-of-PlayerEditBookEvent.patch b/patches/server/0622-Don-t-ignore-result-of-PlayerEditBookEvent.patch similarity index 100% rename from patches/server/0621-Don-t-ignore-result-of-PlayerEditBookEvent.patch rename to patches/server/0622-Don-t-ignore-result-of-PlayerEditBookEvent.patch diff --git a/patches/server/0622-Entity-load-save-limit-per-chunk.patch b/patches/server/0623-Entity-load-save-limit-per-chunk.patch similarity index 88% rename from patches/server/0622-Entity-load-save-limit-per-chunk.patch rename to patches/server/0623-Entity-load-save-limit-per-chunk.patch index 2bdf1a9c3..0952bfa38 100644 --- a/patches/server/0622-Entity-load-save-limit-per-chunk.patch +++ b/patches/server/0623-Entity-load-save-limit-per-chunk.patch @@ -9,25 +9,23 @@ defaults are only included for certain entites, this allows setting limits for any entity type. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 9fc14f3102e2ceb10b80974fabb5c4513e17e63f..cc4c067ad70375f76ddede403b88e76f3c8f37da 100644 +index f1e4f8af50ef5ede030b35bda62ebc63d6982bae..ed833a289b99d4ae028b5b83752364d328d48c4b 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -6,7 +6,10 @@ import java.util.stream.Collectors; - import it.unimi.dsi.fastutil.objects.Reference2IntMap; +@@ -8,6 +8,8 @@ import it.unimi.dsi.fastutil.objects.Reference2IntMap; import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; import net.minecraft.world.entity.MobCategory; + import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode; +import java.util.HashMap; +import java.util.Map; - import net.minecraft.world.Difficulty; -+import net.minecraft.world.entity.EntityType; - import net.minecraft.world.entity.monster.Vindicator; - import net.minecraft.world.entity.monster.Zombie; import org.bukkit.Bukkit; -@@ -141,6 +144,38 @@ public class PaperWorldConfig { + import org.bukkit.configuration.file.YamlConfiguration; + import org.spigotmc.SpigotWorldConfig; +@@ -140,6 +142,38 @@ public class PaperWorldConfig { ); } -+ public Map, Integer> entityPerChunkSaveLimits = new HashMap<>(); ++ public Map, Integer> entityPerChunkSaveLimits = new HashMap<>(); + private void entityPerChunkSaveLimits() { + getInt("entity-per-chunk-save-limit.experience_orb", -1); + getInt("entity-per-chunk-save-limit.snowball", -1); @@ -40,13 +38,13 @@ index 9fc14f3102e2ceb10b80974fabb5c4513e17e63f..cc4c067ad70375f76ddede403b88e76f + addEntityPerChunkSaveLimitsFromSection(config.getConfigurationSection("world-settings." + worldName + ".entity-per-chunk-save-limit"), entityPerChunkSaveLimits); + } + -+ private static void addEntityPerChunkSaveLimitsFromSection(final org.bukkit.configuration.ConfigurationSection section, final Map, Integer> limitMap) { ++ private static void addEntityPerChunkSaveLimitsFromSection(final org.bukkit.configuration.ConfigurationSection section, final Map, Integer> limitMap) { + if (section == null) { + return; + } + for (final String key : section.getKeys(false)) { + final int value = section.getInt(key); -+ final EntityType type = EntityType.byString(key).orElse(null); ++ final net.minecraft.world.entity.EntityType type = net.minecraft.world.entity.EntityType.byString(key).orElse(null); + if (type == null) { + logError("Invalid entity-per-chunk-save-limit config, '" + key+ "' is not a valid entity type. Correct this in paper.yml."); + continue; diff --git a/patches/server/0623-fix-cancelling-block-falling-causing-client-desync.patch b/patches/server/0624-fix-cancelling-block-falling-causing-client-desync.patch similarity index 100% rename from patches/server/0623-fix-cancelling-block-falling-causing-client-desync.patch rename to patches/server/0624-fix-cancelling-block-falling-causing-client-desync.patch diff --git a/patches/server/0624-Expose-protocol-version.patch b/patches/server/0625-Expose-protocol-version.patch similarity index 100% rename from patches/server/0624-Expose-protocol-version.patch rename to patches/server/0625-Expose-protocol-version.patch diff --git a/patches/server/0625-Allow-for-Component-suggestion-tooltips-in-AsyncTabC.patch b/patches/server/0626-Allow-for-Component-suggestion-tooltips-in-AsyncTabC.patch similarity index 100% rename from patches/server/0625-Allow-for-Component-suggestion-tooltips-in-AsyncTabC.patch rename to patches/server/0626-Allow-for-Component-suggestion-tooltips-in-AsyncTabC.patch diff --git a/patches/server/0626-Enhance-console-tab-completions-for-brigadier-comman.patch b/patches/server/0627-Enhance-console-tab-completions-for-brigadier-comman.patch similarity index 100% rename from patches/server/0626-Enhance-console-tab-completions-for-brigadier-comman.patch rename to patches/server/0627-Enhance-console-tab-completions-for-brigadier-comman.patch diff --git a/patches/server/0627-Fix-PlayerItemConsumeEvent-cancelling-properly.patch b/patches/server/0628-Fix-PlayerItemConsumeEvent-cancelling-properly.patch similarity index 100% rename from patches/server/0627-Fix-PlayerItemConsumeEvent-cancelling-properly.patch rename to patches/server/0628-Fix-PlayerItemConsumeEvent-cancelling-properly.patch diff --git a/patches/server/0628-Add-bypass-host-check.patch b/patches/server/0629-Add-bypass-host-check.patch similarity index 100% rename from patches/server/0628-Add-bypass-host-check.patch rename to patches/server/0629-Add-bypass-host-check.patch diff --git a/patches/server/0629-Set-area-affect-cloud-rotation.patch b/patches/server/0630-Set-area-affect-cloud-rotation.patch similarity index 100% rename from patches/server/0629-Set-area-affect-cloud-rotation.patch rename to patches/server/0630-Set-area-affect-cloud-rotation.patch diff --git a/patches/server/0630-add-isDeeplySleeping-to-HumanEntity.patch b/patches/server/0631-add-isDeeplySleeping-to-HumanEntity.patch similarity index 100% rename from patches/server/0630-add-isDeeplySleeping-to-HumanEntity.patch rename to patches/server/0631-add-isDeeplySleeping-to-HumanEntity.patch diff --git a/patches/server/0631-Fix-duplicating-give-items-on-item-drop-cancel.patch b/patches/server/0632-Fix-duplicating-give-items-on-item-drop-cancel.patch similarity index 97% rename from patches/server/0631-Fix-duplicating-give-items-on-item-drop-cancel.patch rename to patches/server/0632-Fix-duplicating-give-items-on-item-drop-cancel.patch index 7b6dbe192..ee8bbaabe 100644 --- a/patches/server/0631-Fix-duplicating-give-items-on-item-drop-cancel.patch +++ b/patches/server/0632-Fix-duplicating-give-items-on-item-drop-cancel.patch @@ -42,7 +42,7 @@ index 58941830a4bd024fcdb97df47783c82062e9167f..a0dc380e90415de9068ea408d62a1605 itemEntity2.makeFakeItem(); } diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 869c765fba6b8b7f37f0699a05b74b312dfde30d..fad2c1206944c0dbca4317ed84be335f154d1a45 100644 +index 14bcc4642d7dd81e5bc30f40e3c9d8269d409d20..9c71fdcb68a865bfc9b3b081a904598dfab4105c 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -683,6 +683,13 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0632-add-consumeFuel-to-FurnaceBurnEvent.patch b/patches/server/0633-add-consumeFuel-to-FurnaceBurnEvent.patch similarity index 100% rename from patches/server/0632-add-consumeFuel-to-FurnaceBurnEvent.patch rename to patches/server/0633-add-consumeFuel-to-FurnaceBurnEvent.patch diff --git a/patches/server/0633-add-get-set-drop-chance-to-EntityEquipment.patch b/patches/server/0634-add-get-set-drop-chance-to-EntityEquipment.patch similarity index 100% rename from patches/server/0633-add-get-set-drop-chance-to-EntityEquipment.patch rename to patches/server/0634-add-get-set-drop-chance-to-EntityEquipment.patch diff --git a/patches/server/0634-fix-PigZombieAngerEvent-cancellation.patch b/patches/server/0635-fix-PigZombieAngerEvent-cancellation.patch similarity index 100% rename from patches/server/0634-fix-PigZombieAngerEvent-cancellation.patch rename to patches/server/0635-fix-PigZombieAngerEvent-cancellation.patch diff --git a/patches/server/0635-Fix-checkReach-check-for-Shulker-boxes.patch b/patches/server/0636-Fix-checkReach-check-for-Shulker-boxes.patch similarity index 100% rename from patches/server/0635-Fix-checkReach-check-for-Shulker-boxes.patch rename to patches/server/0636-Fix-checkReach-check-for-Shulker-boxes.patch diff --git a/patches/server/0636-fix-PlayerItemHeldEvent-firing-twice.patch b/patches/server/0637-fix-PlayerItemHeldEvent-firing-twice.patch similarity index 100% rename from patches/server/0636-fix-PlayerItemHeldEvent-firing-twice.patch rename to patches/server/0637-fix-PlayerItemHeldEvent-firing-twice.patch diff --git a/patches/server/0637-Added-PlayerDeepSleepEvent.patch b/patches/server/0638-Added-PlayerDeepSleepEvent.patch similarity index 91% rename from patches/server/0637-Added-PlayerDeepSleepEvent.patch rename to patches/server/0638-Added-PlayerDeepSleepEvent.patch index d45d9364e..b0434fe75 100644 --- a/patches/server/0637-Added-PlayerDeepSleepEvent.patch +++ b/patches/server/0638-Added-PlayerDeepSleepEvent.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Added PlayerDeepSleepEvent diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index fad2c1206944c0dbca4317ed84be335f154d1a45..6f406d8d945f3938961fe1a0df42f8cb558d8716 100644 +index 9c71fdcb68a865bfc9b3b081a904598dfab4105c..a67a04cbb94edd02918809d5654399952d2597a2 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -245,6 +245,11 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0638-More-World-API.patch b/patches/server/0639-More-World-API.patch similarity index 100% rename from patches/server/0638-More-World-API.patch rename to patches/server/0639-More-World-API.patch diff --git a/patches/server/0639-Added-PlayerBedFailEnterEvent.patch b/patches/server/0640-Added-PlayerBedFailEnterEvent.patch similarity index 100% rename from patches/server/0639-Added-PlayerBedFailEnterEvent.patch rename to patches/server/0640-Added-PlayerBedFailEnterEvent.patch diff --git a/patches/server/0640-Implement-methods-to-convert-between-Component-and-B.patch b/patches/server/0641-Implement-methods-to-convert-between-Component-and-B.patch similarity index 100% rename from patches/server/0640-Implement-methods-to-convert-between-Component-and-B.patch rename to patches/server/0641-Implement-methods-to-convert-between-Component-and-B.patch diff --git a/patches/server/0641-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch b/patches/server/0642-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch similarity index 95% rename from patches/server/0641-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch rename to patches/server/0642-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch index 5046cc4ab..e593462f2 100644 --- a/patches/server/0641-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch +++ b/patches/server/0642-Fix-anchor-respawn-acting-as-a-bed-respawn-from-the-.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Fix anchor respawn acting as a bed respawn from the end diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 29864d3c25cea7bbb84a431a82e7b80f4af2966d..5f099d45203f155abb23c9241b55d34e04f2aa7e 100644 +index 19e6da4ab7d609470ef1597ac45ad3ab6a6a2825..2edb28eddc740a13f1bcad1271f7f0163538846b 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -847,6 +847,7 @@ public abstract class PlayerList { diff --git a/patches/server/0642-Introduce-beacon-activation-deactivation-events.patch b/patches/server/0643-Introduce-beacon-activation-deactivation-events.patch similarity index 100% rename from patches/server/0642-Introduce-beacon-activation-deactivation-events.patch rename to patches/server/0643-Introduce-beacon-activation-deactivation-events.patch diff --git a/patches/server/0643-add-RespawnFlags-to-PlayerRespawnEvent.patch b/patches/server/0644-add-RespawnFlags-to-PlayerRespawnEvent.patch similarity index 97% rename from patches/server/0643-add-RespawnFlags-to-PlayerRespawnEvent.patch rename to patches/server/0644-add-RespawnFlags-to-PlayerRespawnEvent.patch index 187ae5be2..136369545 100644 --- a/patches/server/0643-add-RespawnFlags-to-PlayerRespawnEvent.patch +++ b/patches/server/0644-add-RespawnFlags-to-PlayerRespawnEvent.patch @@ -18,7 +18,7 @@ index eb811f9fcaf84edce3b59fc5f53cd72ffaf1506c..9daad376b7c837ac5dcda5f54d520e2a } else { if (this.player.getHealth() > 0.0F) { diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 5f099d45203f155abb23c9241b55d34e04f2aa7e..f61c31a028c286399f0921c516b5d94ad52f88b5 100644 +index 2edb28eddc740a13f1bcad1271f7f0163538846b..bc623b2e326f0241d8c86a37f231dd113a331583 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -806,6 +806,12 @@ public abstract class PlayerList { diff --git a/patches/server/0644-Add-Channel-initialization-listeners.patch b/patches/server/0645-Add-Channel-initialization-listeners.patch similarity index 100% rename from patches/server/0644-Add-Channel-initialization-listeners.patch rename to patches/server/0645-Add-Channel-initialization-listeners.patch diff --git a/patches/server/0645-Send-empty-commands-if-tab-completion-is-disabled.patch b/patches/server/0646-Send-empty-commands-if-tab-completion-is-disabled.patch similarity index 100% rename from patches/server/0645-Send-empty-commands-if-tab-completion-is-disabled.patch rename to patches/server/0646-Send-empty-commands-if-tab-completion-is-disabled.patch diff --git a/patches/server/0646-Add-more-WanderingTrader-API.patch b/patches/server/0647-Add-more-WanderingTrader-API.patch similarity index 100% rename from patches/server/0646-Add-more-WanderingTrader-API.patch rename to patches/server/0647-Add-more-WanderingTrader-API.patch diff --git a/patches/server/0647-Add-EntityBlockStorage-clearEntities.patch b/patches/server/0648-Add-EntityBlockStorage-clearEntities.patch similarity index 100% rename from patches/server/0647-Add-EntityBlockStorage-clearEntities.patch rename to patches/server/0648-Add-EntityBlockStorage-clearEntities.patch diff --git a/patches/server/0648-Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch b/patches/server/0649-Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch similarity index 100% rename from patches/server/0648-Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch rename to patches/server/0649-Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch diff --git a/patches/server/0649-Add-raw-address-to-AsyncPlayerPreLoginEvent.patch b/patches/server/0650-Add-raw-address-to-AsyncPlayerPreLoginEvent.patch similarity index 100% rename from patches/server/0649-Add-raw-address-to-AsyncPlayerPreLoginEvent.patch rename to patches/server/0650-Add-raw-address-to-AsyncPlayerPreLoginEvent.patch diff --git a/patches/server/0650-Inventory-close.patch b/patches/server/0651-Inventory-close.patch similarity index 100% rename from patches/server/0650-Inventory-close.patch rename to patches/server/0651-Inventory-close.patch diff --git a/patches/server/0651-call-PortalCreateEvent-players-and-end-platform.patch b/patches/server/0652-call-PortalCreateEvent-players-and-end-platform.patch similarity index 100% rename from patches/server/0651-call-PortalCreateEvent-players-and-end-platform.patch rename to patches/server/0652-call-PortalCreateEvent-players-and-end-platform.patch diff --git a/patches/server/0652-Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch b/patches/server/0653-Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch similarity index 100% rename from patches/server/0652-Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch rename to patches/server/0653-Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch diff --git a/patches/server/0653-Fix-CraftPotionBrewer-cache.patch b/patches/server/0654-Fix-CraftPotionBrewer-cache.patch similarity index 100% rename from patches/server/0653-Fix-CraftPotionBrewer-cache.patch rename to patches/server/0654-Fix-CraftPotionBrewer-cache.patch diff --git a/patches/server/0654-Add-basic-Datapack-API.patch b/patches/server/0655-Add-basic-Datapack-API.patch similarity index 98% rename from patches/server/0654-Add-basic-Datapack-API.patch rename to patches/server/0655-Add-basic-Datapack-API.patch index cf8ec9117..37c756662 100644 --- a/patches/server/0654-Add-basic-Datapack-API.patch +++ b/patches/server/0655-Add-basic-Datapack-API.patch @@ -92,7 +92,7 @@ index 0000000000000000000000000000000000000000..cf4374493c11057451a62a655514415c + } +} diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 9d77ecf330d93b3c2925d097b753c887838cb1ec..3d3913686727af7367377deaf35681de6900aa22 100644 +index 86816736595c269e3a2e8a849d67a0836a3f1593..c8e8db3052c1f16da0bc0858955fcdec0491c9af 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -292,6 +292,7 @@ public final class CraftServer implements Server { diff --git a/patches/server/0655-Add-environment-variable-to-disable-server-gui.patch b/patches/server/0656-Add-environment-variable-to-disable-server-gui.patch similarity index 100% rename from patches/server/0655-Add-environment-variable-to-disable-server-gui.patch rename to patches/server/0656-Add-environment-variable-to-disable-server-gui.patch diff --git a/patches/server/0656-additions-to-PlayerGameModeChangeEvent.patch b/patches/server/0657-additions-to-PlayerGameModeChangeEvent.patch similarity index 97% rename from patches/server/0656-additions-to-PlayerGameModeChangeEvent.patch rename to patches/server/0657-additions-to-PlayerGameModeChangeEvent.patch index 01cab80fa..df9de0084 100644 --- a/patches/server/0656-additions-to-PlayerGameModeChangeEvent.patch +++ b/patches/server/0657-additions-to-PlayerGameModeChangeEvent.patch @@ -93,7 +93,7 @@ index 670048f5114ec1dcb0d6e0bb6173ba9d657e6eb1..b6230ce81d50da84b2db9446232c83bd } diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -index 9fbd88027933242348d9f4fea8b45e96fd01c343..3ab74a721d9d9bec82a68a30bf523292a3038587 100644 +index 3a8e87f19aa03786b3bf60b793958b59284d31ac..92f5cb240e0cf52caa8e95302606baa79a0da0f9 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java @@ -72,18 +72,24 @@ public class ServerPlayerGameMode { @@ -139,7 +139,7 @@ index 9daad376b7c837ac5dcda5f54d520e2adfda0481..311df240858d4416306a795d893bdf7d } } diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index eeaab3d50318dd06684bee3e484f6c7218259717..edaf40cfe543ff7aeb356559dedc17620fd52056 100644 +index a68973595b9b08a636f5aeb11608b5b9499d8e16..11a9fbc696ed6c208cbb4f9dc2c161eed7fada77 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -1268,7 +1268,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0657-ItemStack-repair-check-API.patch b/patches/server/0658-ItemStack-repair-check-API.patch similarity index 100% rename from patches/server/0657-ItemStack-repair-check-API.patch rename to patches/server/0658-ItemStack-repair-check-API.patch diff --git a/patches/server/0658-More-Enchantment-API.patch b/patches/server/0659-More-Enchantment-API.patch similarity index 100% rename from patches/server/0658-More-Enchantment-API.patch rename to patches/server/0659-More-Enchantment-API.patch diff --git a/patches/server/0659-Fix-and-optimise-world-force-upgrading.patch b/patches/server/0660-Fix-and-optimise-world-force-upgrading.patch similarity index 97% rename from patches/server/0659-Fix-and-optimise-world-force-upgrading.patch rename to patches/server/0660-Fix-and-optimise-world-force-upgrading.patch index 83dd9f896..94b3eb0a6 100644 --- a/patches/server/0659-Fix-and-optimise-world-force-upgrading.patch +++ b/patches/server/0660-Fix-and-optimise-world-force-upgrading.patch @@ -274,7 +274,7 @@ index f685ab3cc6e4fd76e8dec3d2d3627a13715cda44..36a1d58dd238c835ce3cc9c2376a86a0 Main.LOGGER.info("Forcing world upgrade! {}", session.getLevelId()); // CraftBukkit WorldUpgrader worldupgrader = new WorldUpgrader(session, dataFixer, generatorOptions, eraseCache); diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 80e101301f148520a04dfc914caa58ea3a6653d2..6715920dcbc7cd895f8662d9c7b9dbb8b8790323 100644 +index 6a733008e0d94654dd9973a112e860b7af8b875c..c3e4c2634d11621000204b6deddd2dbe32202239 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -556,11 +556,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions public java.util.ArrayDeque redstoneUpdateInfos; // Paper - Move from Map in BlockRedstoneTorch to here @@ -326,7 +326,7 @@ index 5ca6254d104fbd407a98daf732dd6ac119914ee3..4def51a0b2a133cf1fb2358974db2533 return this.world; } diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java -index 91cf5878dc13e1abca0c301d1346248bda251cbf..0c5f5b2960f1a0d4bbd41c3c3baf101b4c388c43 100644 +index 2ee32657a49937418b352a138aca21fbb27857e6..7b4f3c30cfc4bf68cc872598726f7f7eab5f9830 100644 --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java @@ -32,6 +32,28 @@ public class RegionFileStorage implements AutoCloseable { @@ -359,7 +359,7 @@ index 91cf5878dc13e1abca0c301d1346248bda251cbf..0c5f5b2960f1a0d4bbd41c3c3baf101b return this.regionCache.getAndMoveToFirst(ChunkPos.asLong(chunkcoordintpair.getRegionX(), chunkcoordintpair.getRegionZ())); } diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 3d3913686727af7367377deaf35681de6900aa22..9f69e1874caa087778e1de637c93719b43ac5a23 100644 +index c8e8db3052c1f16da0bc0858955fcdec0491c9af..5bd8115430ceb8924460fe05294d7c96303cb7e8 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -1200,12 +1200,7 @@ public final class CraftServer implements Server { diff --git a/patches/server/0660-Add-Mob-lookAt-API.patch b/patches/server/0661-Add-Mob-lookAt-API.patch similarity index 100% rename from patches/server/0660-Add-Mob-lookAt-API.patch rename to patches/server/0661-Add-Mob-lookAt-API.patch diff --git a/patches/server/0661-Add-Unix-domain-socket-support.patch b/patches/server/0662-Add-Unix-domain-socket-support.patch similarity index 100% rename from patches/server/0661-Add-Unix-domain-socket-support.patch rename to patches/server/0662-Add-Unix-domain-socket-support.patch diff --git a/patches/server/0662-Add-EntityInsideBlockEvent.patch b/patches/server/0663-Add-EntityInsideBlockEvent.patch similarity index 100% rename from patches/server/0662-Add-EntityInsideBlockEvent.patch rename to patches/server/0663-Add-EntityInsideBlockEvent.patch diff --git a/patches/server/0663-Attributes-API-for-item-defaults.patch b/patches/server/0664-Attributes-API-for-item-defaults.patch similarity index 100% rename from patches/server/0663-Attributes-API-for-item-defaults.patch rename to patches/server/0664-Attributes-API-for-item-defaults.patch diff --git a/patches/server/0664-Add-cause-to-Weather-ThunderChangeEvents.patch b/patches/server/0665-Add-cause-to-Weather-ThunderChangeEvents.patch similarity index 98% rename from patches/server/0664-Add-cause-to-Weather-ThunderChangeEvents.patch rename to patches/server/0665-Add-cause-to-Weather-ThunderChangeEvents.patch index 2e9855972..7af83473e 100644 --- a/patches/server/0664-Add-cause-to-Weather-ThunderChangeEvents.patch +++ b/patches/server/0665-Add-cause-to-Weather-ThunderChangeEvents.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add cause to Weather/ThunderChangeEvents diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 955f1f14ba7dca04d928a35db83c9b55133caa85..ce2caf0dec4994d7361ba078f56bd4d6bc2bd751 100644 +index 5b17b4c06d8da92d25048a4df72a328c90af76b6..51e290adb44c9f7987ad79f22f158e5f93bedbbe 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -468,8 +468,8 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0665-More-Lidded-Block-API.patch b/patches/server/0666-More-Lidded-Block-API.patch similarity index 100% rename from patches/server/0665-More-Lidded-Block-API.patch rename to patches/server/0666-More-Lidded-Block-API.patch diff --git a/patches/server/0666-Limit-item-frame-cursors-on-maps.patch b/patches/server/0667-Limit-item-frame-cursors-on-maps.patch similarity index 93% rename from patches/server/0666-Limit-item-frame-cursors-on-maps.patch rename to patches/server/0667-Limit-item-frame-cursors-on-maps.patch index 29f729e93..e240a6f09 100644 --- a/patches/server/0666-Limit-item-frame-cursors-on-maps.patch +++ b/patches/server/0667-Limit-item-frame-cursors-on-maps.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Limit item frame cursors on maps diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index cc4c067ad70375f76ddede403b88e76f3c8f37da..7d79d4caa299961fd5c54ae924d7658ad37d464b 100644 +index ed833a289b99d4ae028b5b83752364d328d48c4b..01283b5f36063b337494cdc4a44f48397b5754e2 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -791,4 +791,9 @@ public class PaperWorldConfig { +@@ -824,4 +824,9 @@ public class PaperWorldConfig { private void allowUsingSignsInsideSpawnProtection() { allowUsingSignsInsideSpawnProtection = getBoolean("allow-using-signs-inside-spawn-protection", allowUsingSignsInsideSpawnProtection); } diff --git a/patches/server/0667-Add-PlayerKickEvent-causes.patch b/patches/server/0668-Add-PlayerKickEvent-causes.patch similarity index 99% rename from patches/server/0667-Add-PlayerKickEvent-causes.patch rename to patches/server/0668-Add-PlayerKickEvent-causes.patch index d2ce6a174..f5bd612f9 100644 --- a/patches/server/0667-Add-PlayerKickEvent-causes.patch +++ b/patches/server/0668-Add-PlayerKickEvent-causes.patch @@ -318,7 +318,7 @@ index 311df240858d4416306a795d893bdf7da403e90b..85e24920e774e84f9fa63a4fb088c07c } diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index f61c31a028c286399f0921c516b5d94ad52f88b5..13f68b8d241a0b2532a1bd9d9554d2e615780383 100644 +index bc623b2e326f0241d8c86a37f231dd113a331583..75ca1abe19c789fec020aa4b135d6df05abaec5c 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -715,7 +715,7 @@ public abstract class PlayerList { @@ -342,7 +342,7 @@ index f61c31a028c286399f0921c516b5d94ad52f88b5..13f68b8d241a0b2532a1bd9d9554d2e6 // CraftBukkit end diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index edaf40cfe543ff7aeb356559dedc17620fd52056..c4e979055c54f147dd7e01b120de00bb5338bede 100644 +index 11a9fbc696ed6c208cbb4f9dc2c161eed7fada77..9d8e48b859933a2b9412df78daf158129b430e8c 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -503,16 +503,21 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0668-Add-PufferFishStateChangeEvent.patch b/patches/server/0669-Add-PufferFishStateChangeEvent.patch similarity index 100% rename from patches/server/0668-Add-PufferFishStateChangeEvent.patch rename to patches/server/0669-Add-PufferFishStateChangeEvent.patch diff --git a/patches/server/0669-Fix-PlayerBucketEmptyEvent-result-itemstack.patch b/patches/server/0670-Fix-PlayerBucketEmptyEvent-result-itemstack.patch similarity index 100% rename from patches/server/0669-Fix-PlayerBucketEmptyEvent-result-itemstack.patch rename to patches/server/0670-Fix-PlayerBucketEmptyEvent-result-itemstack.patch diff --git a/patches/server/0670-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch b/patches/server/0671-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch similarity index 63% rename from patches/server/0670-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch rename to patches/server/0671-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch index 6fd4dcb05..df2a76b8a 100644 --- a/patches/server/0670-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch +++ b/patches/server/0671-Synchronize-PalettedContainer-instead-of-ReentrantLo.patch @@ -13,10 +13,10 @@ contention situations. And this is extremely a low contention situation. diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -index 71fbb476ad081424cc8807c01818f332887ae366..ec285516c2c403b65b2446f20b187628539d96a6 100644 +index cdd357a8dd82cfd2a8abd45c1b7937b409af4b05..5bbbb10a567963a451db8cf29d8d16f1cd013a16 100644 --- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -@@ -34,15 +34,15 @@ public class PalettedContainer implements PaletteResize { +@@ -35,17 +35,17 @@ public class PalettedContainer implements PaletteResize { private final ThreadingDetector threadingDetector = new ThreadingDetector("PalettedContainer"); public void acquire() { @@ -29,22 +29,24 @@ index 71fbb476ad081424cc8807c01818f332887ae366..ec285516c2c403b65b2446f20b187628 + // this.threadingDetector.checkAndUnlock(); // Paper - disable this } - public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object) { + // Paper start - Anti-Xray - Add preset values + @Deprecated public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object) { return PalettedContainer.codec(idList, entryCodec, provider, object, null); } // Notice for updates: Please make sure this function isn't used anywhere + public static Codec> codec(IdMap idList, Codec entryCodec, PalettedContainer.Strategy provider, T object, T[] presetValues) { - return RecordCodecBuilder.create((instance) -> { + return RecordCodecBuilder.>create((instance) -> { // Paper - decompile fixes return instance.group(entryCodec.mapResult(ExtraCodecs.orElsePartial(object)).listOf().fieldOf("palette").forGetter(PalettedContainer.DiscData::paletteEntries), Codec.LONG_STREAM.optionalFieldOf("data").forGetter(PalettedContainer.DiscData::storage)).apply(instance, PalettedContainer.DiscData::new); }).comapFlatMap((serialized) -> { - return read(idList, provider, serialized); -@@ -84,7 +84,7 @@ public class PalettedContainer implements PaletteResize { - return data2.palette.idFor(object); + return read(idList, provider, serialized, object, presetValues); +@@ -143,7 +143,7 @@ public class PalettedContainer implements PaletteResize { } + // Paper end - public T getAndSet(int x, int y, int z, T value) { + public synchronized T getAndSet(int x, int y, int z, T value) { // Paper - synchronize this.acquire(); Object var5; -@@ -107,7 +107,7 @@ public class PalettedContainer implements PaletteResize { +@@ -166,7 +166,7 @@ public class PalettedContainer implements PaletteResize { return this.data.palette.valueFor(j); } @@ -53,7 +55,7 @@ index 71fbb476ad081424cc8807c01818f332887ae366..ec285516c2c403b65b2446f20b187628 this.acquire(); try { -@@ -141,7 +141,7 @@ public class PalettedContainer implements PaletteResize { +@@ -200,7 +200,7 @@ public class PalettedContainer implements PaletteResize { }); } @@ -62,26 +64,26 @@ index 71fbb476ad081424cc8807c01818f332887ae366..ec285516c2c403b65b2446f20b187628 this.acquire(); try { -@@ -156,7 +156,7 @@ public class PalettedContainer implements PaletteResize { +@@ -218,7 +218,7 @@ public class PalettedContainer implements PaletteResize { - } - -- public void write(FriendlyByteBuf buf) { -+ public synchronized void write(FriendlyByteBuf buf) { // Paper - synchronize + // Paper start - Anti-Xray - Add chunk packet info + @Deprecated public void write(FriendlyByteBuf buf) { this.write(buf, null, 0); } // Notice for updates: Please make sure this method isn't used anywhere +- public void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo, int bottomBlockY) { ++ public synchronized void write(FriendlyByteBuf buf, com.destroystokyo.paper.antixray.ChunkPacketInfo chunkPacketInfo, int bottomBlockY) { // Paper - synchronize this.acquire(); try { -@@ -167,7 +167,7 @@ public class PalettedContainer implements PaletteResize { +@@ -236,7 +236,7 @@ public class PalettedContainer implements PaletteResize { } -- private static DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized) { -+ private static synchronized DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized) { // Paper - synchronize +- private static DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized, T defaultValue, T[] presetValues) { // Paper - Anti-Xray - Add preset values ++ private synchronized static DataResult> read(IdMap idList, PalettedContainer.Strategy provider, PalettedContainer.DiscData serialized, T defaultValue, T[] presetValues) { // Paper - Anti-Xray - Add preset values // Paper - synchronize List list = serialized.paletteEntries(); int i = provider.size(); int j = provider.calculateBitsForSerialization(idList, list.size()); -@@ -206,7 +206,7 @@ public class PalettedContainer implements PaletteResize { - return DataResult.success(new PalettedContainer<>(idList, provider, configuration, bitStorage, list)); +@@ -275,7 +275,7 @@ public class PalettedContainer implements PaletteResize { + return DataResult.success(new PalettedContainer<>(idList, provider, configuration, bitStorage, list, defaultValue, presetValues)); // Paper - Anti-Xray - Add preset values } - private PalettedContainer.DiscData write(IdMap idList, PalettedContainer.Strategy provider) { diff --git a/patches/server/0671-Add-option-to-fix-items-merging-through-walls.patch b/patches/server/0672-Add-option-to-fix-items-merging-through-walls.patch similarity index 93% rename from patches/server/0671-Add-option-to-fix-items-merging-through-walls.patch rename to patches/server/0672-Add-option-to-fix-items-merging-through-walls.patch index d1018af9a..e697c6942 100644 --- a/patches/server/0671-Add-option-to-fix-items-merging-through-walls.patch +++ b/patches/server/0672-Add-option-to-fix-items-merging-through-walls.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add option to fix items merging through walls diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 7d79d4caa299961fd5c54ae924d7658ad37d464b..8494e3147295f997e826025f13a6da29684f3c38 100644 +index 01283b5f36063b337494cdc4a44f48397b5754e2..a653e821343410e7faec39c51d32eeba223c829c 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -796,4 +796,9 @@ public class PaperWorldConfig { +@@ -829,4 +829,9 @@ public class PaperWorldConfig { private void mapItemFrameCursorLimit() { mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit); } diff --git a/patches/server/0672-Add-BellRevealRaiderEvent.patch b/patches/server/0673-Add-BellRevealRaiderEvent.patch similarity index 100% rename from patches/server/0672-Add-BellRevealRaiderEvent.patch rename to patches/server/0673-Add-BellRevealRaiderEvent.patch diff --git a/patches/server/0673-Fix-invulnerable-end-crystals.patch b/patches/server/0674-Fix-invulnerable-end-crystals.patch similarity index 96% rename from patches/server/0673-Fix-invulnerable-end-crystals.patch rename to patches/server/0674-Fix-invulnerable-end-crystals.patch index eb6660b92..8a83dcfe7 100644 --- a/patches/server/0673-Fix-invulnerable-end-crystals.patch +++ b/patches/server/0674-Fix-invulnerable-end-crystals.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Fix invulnerable end crystals MC-108513 diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 8494e3147295f997e826025f13a6da29684f3c38..83674565d280f5aa2504cdaee027386f3f377291 100644 +index a653e821343410e7faec39c51d32eeba223c829c..f6486a74ac205ef82e3a1e7023f6e818db8dab71 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -801,4 +801,9 @@ public class PaperWorldConfig { +@@ -834,4 +834,9 @@ public class PaperWorldConfig { private void fixItemsMergingThroughWalls() { fixItemsMergingThroughWalls = getBoolean("fix-items-merging-through-walls", fixItemsMergingThroughWalls); } diff --git a/patches/server/0674-Add-ElderGuardianAppearanceEvent.patch b/patches/server/0675-Add-ElderGuardianAppearanceEvent.patch similarity index 100% rename from patches/server/0674-Add-ElderGuardianAppearanceEvent.patch rename to patches/server/0675-Add-ElderGuardianAppearanceEvent.patch diff --git a/patches/server/0675-Fix-dangerous-end-portal-logic.patch b/patches/server/0676-Fix-dangerous-end-portal-logic.patch similarity index 100% rename from patches/server/0675-Fix-dangerous-end-portal-logic.patch rename to patches/server/0676-Fix-dangerous-end-portal-logic.patch diff --git a/patches/server/0676-Optimize-Biome-Mob-Lookups-for-Mob-Spawning.patch b/patches/server/0677-Optimize-Biome-Mob-Lookups-for-Mob-Spawning.patch similarity index 100% rename from patches/server/0676-Optimize-Biome-Mob-Lookups-for-Mob-Spawning.patch rename to patches/server/0677-Optimize-Biome-Mob-Lookups-for-Mob-Spawning.patch diff --git a/patches/server/0677-Make-item-validations-configurable.patch b/patches/server/0678-Make-item-validations-configurable.patch similarity index 100% rename from patches/server/0677-Make-item-validations-configurable.patch rename to patches/server/0678-Make-item-validations-configurable.patch diff --git a/patches/server/0678-Line-Of-Sight-Changes.patch b/patches/server/0679-Line-Of-Sight-Changes.patch similarity index 100% rename from patches/server/0678-Line-Of-Sight-Changes.patch rename to patches/server/0679-Line-Of-Sight-Changes.patch diff --git a/patches/server/0679-add-per-world-spawn-limits.patch b/patches/server/0680-add-per-world-spawn-limits.patch similarity index 82% rename from patches/server/0679-add-per-world-spawn-limits.patch rename to patches/server/0680-add-per-world-spawn-limits.patch index bf0a0dd34..5f911b99e 100644 --- a/patches/server/0679-add-per-world-spawn-limits.patch +++ b/patches/server/0680-add-per-world-spawn-limits.patch @@ -6,18 +6,10 @@ Subject: [PATCH] add per world spawn limits Taken from #2982. Credit to Chasewhip8 diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 83674565d280f5aa2504cdaee027386f3f377291..24f784209109f599fab11ba8c905f16c304dba3c 100644 +index f6486a74ac205ef82e3a1e7023f6e818db8dab71..75988ff014e40b248312d13d27f677882211d607 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -12,6 +12,7 @@ import net.minecraft.world.Difficulty; - import net.minecraft.world.entity.EntityType; - import net.minecraft.world.entity.monster.Vindicator; - import net.minecraft.world.entity.monster.Zombie; -+import net.minecraft.world.level.NaturalSpawner; - import org.bukkit.Bukkit; - import org.bukkit.configuration.file.YamlConfiguration; - import org.spigotmc.SpigotWorldConfig; -@@ -55,6 +56,11 @@ public class PaperWorldConfig { +@@ -53,6 +53,11 @@ public class PaperWorldConfig { set("despawn-ranges.soft", null); set("despawn-ranges.hard", null); @@ -29,11 +21,11 @@ index 83674565d280f5aa2504cdaee027386f3f377291..24f784209109f599fab11ba8c905f16c } if (needsSave) { -@@ -686,6 +692,21 @@ public class PaperWorldConfig { +@@ -684,6 +689,21 @@ public class PaperWorldConfig { zombieVillagerInfectionChance = getDouble("zombie-villager-infection-chance", zombieVillagerInfectionChance); } -+ public Reference2IntMap perWorldSpawnLimits = new Reference2IntOpenHashMap<>(NaturalSpawner.SPAWNING_CATEGORIES.length); ++ public Reference2IntMap perWorldSpawnLimits = new Reference2IntOpenHashMap<>(net.minecraft.world.level.NaturalSpawner.SPAWNING_CATEGORIES.length); + private void perWorldSpawnLimits() { + perWorldSpawnLimits.defaultReturnValue(-1); + if (PaperConfig.version < 24) { @@ -43,7 +35,7 @@ index 83674565d280f5aa2504cdaee027386f3f377291..24f784209109f599fab11ba8c905f16c + perWorldSpawnLimits.put(MobCategory.WATER_CREATURE, getInt("spawn-limits.water-animals", -1, false)); + perWorldSpawnLimits.put(MobCategory.WATER_AMBIENT, getInt("spawn-limits.water-ambient", -1, false)); + } -+ for (MobCategory value : NaturalSpawner.SPAWNING_CATEGORIES) { ++ for (MobCategory value : net.minecraft.world.level.NaturalSpawner.SPAWNING_CATEGORIES) { + perWorldSpawnLimits.put(value, getInt("spawn-limits." + value.getName(), perWorldSpawnLimits.getInt(value))); + } + } diff --git a/patches/server/0680-Fix-PotionSplashEvent-for-water-splash-potions.patch b/patches/server/0681-Fix-PotionSplashEvent-for-water-splash-potions.patch similarity index 100% rename from patches/server/0680-Fix-PotionSplashEvent-for-water-splash-potions.patch rename to patches/server/0681-Fix-PotionSplashEvent-for-water-splash-potions.patch diff --git a/patches/server/0681-Add-more-LimitedRegion-API.patch b/patches/server/0682-Add-more-LimitedRegion-API.patch similarity index 100% rename from patches/server/0681-Add-more-LimitedRegion-API.patch rename to patches/server/0682-Add-more-LimitedRegion-API.patch diff --git a/patches/server/0682-Fix-PlayerDropItemEvent-using-wrong-item.patch b/patches/server/0683-Fix-PlayerDropItemEvent-using-wrong-item.patch similarity index 94% rename from patches/server/0682-Fix-PlayerDropItemEvent-using-wrong-item.patch rename to patches/server/0683-Fix-PlayerDropItemEvent-using-wrong-item.patch index bbca49d9c..23cedb13c 100644 --- a/patches/server/0682-Fix-PlayerDropItemEvent-using-wrong-item.patch +++ b/patches/server/0683-Fix-PlayerDropItemEvent-using-wrong-item.patch @@ -18,7 +18,7 @@ index b6230ce81d50da84b2db9446232c83bde3632a91..df0b08628d736b7f75120f1b9840784f this.awardStat(Stats.DROP); diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 6f406d8d945f3938961fe1a0df42f8cb558d8716..44c2820a33ed40b4ef2ebd20708347d3cc2437ae 100644 +index a67a04cbb94edd02918809d5654399952d2597a2..56110f0022c99dad562e9398f4f34b993eda4923 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -703,6 +703,11 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0683-Missing-Entity-Behavior-API.patch b/patches/server/0684-Missing-Entity-Behavior-API.patch similarity index 100% rename from patches/server/0683-Missing-Entity-Behavior-API.patch rename to patches/server/0684-Missing-Entity-Behavior-API.patch diff --git a/patches/server/0684-Ensure-disconnect-for-book-edit-is-called-on-main.patch b/patches/server/0685-Ensure-disconnect-for-book-edit-is-called-on-main.patch similarity index 100% rename from patches/server/0684-Ensure-disconnect-for-book-edit-is-called-on-main.patch rename to patches/server/0685-Ensure-disconnect-for-book-edit-is-called-on-main.patch diff --git a/patches/server/0685-Fix-return-value-of-Block-applyBoneMeal-always-being.patch b/patches/server/0686-Fix-return-value-of-Block-applyBoneMeal-always-being.patch similarity index 100% rename from patches/server/0685-Fix-return-value-of-Block-applyBoneMeal-always-being.patch rename to patches/server/0686-Fix-return-value-of-Block-applyBoneMeal-always-being.patch diff --git a/patches/server/0686-Use-getChunkIfLoadedImmediately-in-places.patch b/patches/server/0687-Use-getChunkIfLoadedImmediately-in-places.patch similarity index 90% rename from patches/server/0686-Use-getChunkIfLoadedImmediately-in-places.patch rename to patches/server/0687-Use-getChunkIfLoadedImmediately-in-places.patch index 7277f2b04..d0296bb8d 100644 --- a/patches/server/0686-Use-getChunkIfLoadedImmediately-in-places.patch +++ b/patches/server/0687-Use-getChunkIfLoadedImmediately-in-places.patch @@ -8,7 +8,7 @@ ticket level 33 (yes getChunkIfLoaded will actually perform a chunk load in that case). diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index ce2caf0dec4994d7361ba078f56bd4d6bc2bd751..7dd99f16caac736ffb6b53b09695eede9cb7fbca 100644 +index 51e290adb44c9f7987ad79f22f158e5f93bedbbe..081c031f08c9817de6c4e1e6bf18b11efc3c668b 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -211,7 +211,7 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -34,10 +34,10 @@ index b0c319175b40b0f1ac87152eb64b6b60ddc36464..8705df3ca3df6b4aa77b38e1a0b6ad5f return; } diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 4def51a0b2a133cf1fb2358974db2533aae0a807..e5cb991543c695bc90256ef250a1d695ac5bc17d 100644 +index aaebbf265ba6ad98fc14d02d24b3db1a6fa904ba..7ac5755df29a82d053fdd3f9e83b0789cbdb0525 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -193,6 +193,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -194,6 +194,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable { return (CraftServer) Bukkit.getServer(); } @@ -50,8 +50,8 @@ index 4def51a0b2a133cf1fb2358974db2533aae0a807..e5cb991543c695bc90256ef250a1d695 + public abstract ResourceKey getTypeKey(); - protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env) { -@@ -1363,7 +1370,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor +@@ -1366,7 +1373,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { for (int l1 = j; l1 <= l; ++l1) { for (int i2 = k; i2 <= i1; ++i2) { diff --git a/patches/server/0687-Fix-commands-from-signs-not-firing-command-events.patch b/patches/server/0688-Fix-commands-from-signs-not-firing-command-events.patch similarity index 98% rename from patches/server/0687-Fix-commands-from-signs-not-firing-command-events.patch rename to patches/server/0688-Fix-commands-from-signs-not-firing-command-events.patch index 9d0fa730b..92242a76f 100644 --- a/patches/server/0687-Fix-commands-from-signs-not-firing-command-events.patch +++ b/patches/server/0688-Fix-commands-from-signs-not-firing-command-events.patch @@ -10,10 +10,10 @@ This patch changes sign command logic so that `run_command` click events: - sends failure messages to the player who clicked the sign diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 24f784209109f599fab11ba8c905f16c304dba3c..c4ee757e4c8e796b402a56803d4031e90a85d916 100644 +index 75988ff014e40b248312d13d27f677882211d607..449093429d0c15dedc2a135a49d570c104f2f563 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -827,4 +827,9 @@ public class PaperWorldConfig { +@@ -859,4 +859,9 @@ public class PaperWorldConfig { private void fixInvulnerableEndCrystalExploit() { fixInvulnerableEndCrystalExploit = getBoolean("unsupported-settings.fix-invulnerable-end-crystal-exploit", fixInvulnerableEndCrystalExploit); } diff --git a/patches/server/0688-Adds-PlayerArmSwingEvent.patch b/patches/server/0689-Adds-PlayerArmSwingEvent.patch similarity index 100% rename from patches/server/0688-Adds-PlayerArmSwingEvent.patch rename to patches/server/0689-Adds-PlayerArmSwingEvent.patch diff --git a/patches/server/0689-Fixes-kick-event-leave-message-not-being-sent.patch b/patches/server/0690-Fixes-kick-event-leave-message-not-being-sent.patch similarity index 98% rename from patches/server/0689-Fixes-kick-event-leave-message-not-being-sent.patch rename to patches/server/0690-Fixes-kick-event-leave-message-not-being-sent.patch index 209e2c1c7..c5876012b 100644 --- a/patches/server/0689-Fixes-kick-event-leave-message-not-being-sent.patch +++ b/patches/server/0690-Fixes-kick-event-leave-message-not-being-sent.patch @@ -39,7 +39,7 @@ index d66c9c09ae3874dd53ef298f94a0e5c6177f2b35..43cd0b67f31d0340893672c9bf5a0046 this.server.getPlayerList().broadcastMessage(PaperAdventure.asVanilla(quitMessage), ChatType.SYSTEM, Util.NIL_UUID); // Paper end diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 13f68b8d241a0b2532a1bd9d9554d2e615780383..932598d92e24521fed11d7236d87f34703b7bdd4 100644 +index 75ca1abe19c789fec020aa4b135d6df05abaec5c..2c3249359bf8f7e5e625ef4769c7e884cddd473c 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -587,6 +587,11 @@ public abstract class PlayerList { diff --git a/patches/server/0690-Add-config-for-mobs-immune-to-default-effects.patch b/patches/server/0691-Add-config-for-mobs-immune-to-default-effects.patch similarity index 97% rename from patches/server/0690-Add-config-for-mobs-immune-to-default-effects.patch rename to patches/server/0691-Add-config-for-mobs-immune-to-default-effects.patch index 5e4b53300..33f928674 100644 --- a/patches/server/0690-Add-config-for-mobs-immune-to-default-effects.patch +++ b/patches/server/0691-Add-config-for-mobs-immune-to-default-effects.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Add config for mobs immune to default effects diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index c4ee757e4c8e796b402a56803d4031e90a85d916..ed2b33afffdf975513c07ba8db6439810e444852 100644 +index 449093429d0c15dedc2a135a49d570c104f2f563..41534b2ee3360b79a1a119c69ea1ce3a0ad1a04b 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -682,6 +682,21 @@ public class PaperWorldConfig { +@@ -679,6 +679,21 @@ public class PaperWorldConfig { log("Hopper Ignore Occluding Blocks: " + (hoppersIgnoreOccludingBlocks ? "enabled" : "disabled")); } diff --git a/patches/server/0691-Fix-incorrect-message-for-outdated-client.patch b/patches/server/0692-Fix-incorrect-message-for-outdated-client.patch similarity index 100% rename from patches/server/0691-Fix-incorrect-message-for-outdated-client.patch rename to patches/server/0692-Fix-incorrect-message-for-outdated-client.patch diff --git a/patches/server/0692-Fix-MerchantOffer-BuyB-Only-AssertionError.patch b/patches/server/0693-Fix-MerchantOffer-BuyB-Only-AssertionError.patch similarity index 100% rename from patches/server/0692-Fix-MerchantOffer-BuyB-Only-AssertionError.patch rename to patches/server/0693-Fix-MerchantOffer-BuyB-Only-AssertionError.patch diff --git a/patches/server/0693-Don-t-apply-cramming-damage-to-players.patch b/patches/server/0694-Don-t-apply-cramming-damage-to-players.patch similarity index 93% rename from patches/server/0693-Don-t-apply-cramming-damage-to-players.patch rename to patches/server/0694-Don-t-apply-cramming-damage-to-players.patch index 40efb31ec..4302a597c 100644 --- a/patches/server/0693-Don-t-apply-cramming-damage-to-players.patch +++ b/patches/server/0694-Don-t-apply-cramming-damage-to-players.patch @@ -11,10 +11,10 @@ It does not make a lot of sense to damage players if they get crammed, For those who really want it a config option is provided. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index ed2b33afffdf975513c07ba8db6439810e444852..24a14b9f2d6e070fe9220bfb6e709f58368390f6 100644 +index 41534b2ee3360b79a1a119c69ea1ce3a0ad1a04b..1895fac6a0fd1545b46b7aebab5aeee7351b2a94 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -847,4 +847,9 @@ public class PaperWorldConfig { +@@ -879,4 +879,9 @@ public class PaperWorldConfig { private void showSignClickCommandFailureMessagesToPlayer() { showSignClickCommandFailureMessagesToPlayer = getBoolean("show-sign-click-command-failure-msgs-to-player", showSignClickCommandFailureMessagesToPlayer); } diff --git a/patches/server/0694-Rate-options-and-timings-for-sensors-and-behaviors.patch b/patches/server/0695-Rate-options-and-timings-for-sensors-and-behaviors.patch similarity index 90% rename from patches/server/0694-Rate-options-and-timings-for-sensors-and-behaviors.patch rename to patches/server/0695-Rate-options-and-timings-for-sensors-and-behaviors.patch index 1692e8e3e..09fc26f02 100644 --- a/patches/server/0694-Rate-options-and-timings-for-sensors-and-behaviors.patch +++ b/patches/server/0695-Rate-options-and-timings-for-sensors-and-behaviors.patch @@ -28,35 +28,27 @@ index b47b7dce26805badd422c1867733ff4bfd00e9f4..b27021a42cbed3f0648a8d0903d00d03 * Get a named timer for the specified tile entity type to track type specific timings. * @param entity diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 24a14b9f2d6e070fe9220bfb6e709f58368390f6..9a866ab0b887f2db1cf0e6802a44c2e8b0912b74 100644 +index 1895fac6a0fd1545b46b7aebab5aeee7351b2a94..8f358ed2d734ba63143c98bd044beb7e36a53aa5 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -7,13 +7,18 @@ import it.unimi.dsi.fastutil.objects.Reference2IntMap; - import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; +@@ -9,8 +9,10 @@ import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; import net.minecraft.world.entity.MobCategory; + import com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray.EngineMode; import java.util.HashMap; +import java.util.Locale; import java.util.Map; -+ -+import com.google.common.collect.HashBasedTable; -+import com.google.common.collect.Table; - import net.minecraft.world.Difficulty; - import net.minecraft.world.entity.EntityType; - import net.minecraft.world.entity.monster.Vindicator; - import net.minecraft.world.entity.monster.Zombie; - import net.minecraft.world.level.NaturalSpawner; import org.bukkit.Bukkit; +import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.YamlConfiguration; import org.spigotmc.SpigotWorldConfig; -@@ -852,4 +857,57 @@ public class PaperWorldConfig { +@@ -884,4 +886,57 @@ public class PaperWorldConfig { private void playerCrammingDamage() { allowPlayerCrammingDamage = getBoolean("allow-player-cramming-damage", allowPlayerCrammingDamage); } + -+ private Table sensorTickRates; -+ private Table behaviorTickRates; ++ private com.google.common.collect.Table sensorTickRates; ++ private com.google.common.collect.Table behaviorTickRates; + private void tickRates() { + config.addDefault("world-settings.default.tick-rates.sensor.villager.secondarypoisensor", 40); + config.addDefault("world-settings.default.tick-rates.behavior.villager.validatenearbypoi", -1); // Example @@ -65,9 +57,9 @@ index 24a14b9f2d6e070fe9220bfb6e709f58368390f6..9a866ab0b887f2db1cf0e6802a44c2e8 + behaviorTickRates = loadTickRates("behavior"); + } + -+ private Table loadTickRates(String type) { ++ private com.google.common.collect.Table loadTickRates(String type) { + log(" " + type + ":"); -+ Table table = HashBasedTable.create(); ++ com.google.common.collect.Table table = com.google.common.collect.HashBasedTable.create(); + + ConfigurationSection typeSection = config.getConfigurationSection("world-settings." + worldName + ".tick-rates." + type); + if (typeSection == null) { @@ -103,7 +95,7 @@ index 24a14b9f2d6e070fe9220bfb6e709f58368390f6..9a866ab0b887f2db1cf0e6802a44c2e8 + return getIntOrDefault(sensorTickRates, typeName, entityType, def); + } + -+ private int getIntOrDefault(Table table, String rowKey, String columnKey, int def) { ++ private int getIntOrDefault(com.google.common.collect.Table table, String rowKey, String columnKey, int def) { + Integer rate = table.get(columnKey, rowKey); + return rate != null && rate > -1 ? rate : def; + } diff --git a/patches/server/0695-Add-a-bunch-of-missing-forceDrop-toggles.patch b/patches/server/0696-Add-a-bunch-of-missing-forceDrop-toggles.patch similarity index 100% rename from patches/server/0695-Add-a-bunch-of-missing-forceDrop-toggles.patch rename to patches/server/0696-Add-a-bunch-of-missing-forceDrop-toggles.patch diff --git a/patches/server/0696-Stinger-API.patch b/patches/server/0697-Stinger-API.patch similarity index 100% rename from patches/server/0696-Stinger-API.patch rename to patches/server/0697-Stinger-API.patch diff --git a/patches/server/0697-Fix-incosistency-issue-with-empty-map-items-in-CB.patch b/patches/server/0698-Fix-incosistency-issue-with-empty-map-items-in-CB.patch similarity index 100% rename from patches/server/0697-Fix-incosistency-issue-with-empty-map-items-in-CB.patch rename to patches/server/0698-Fix-incosistency-issue-with-empty-map-items-in-CB.patch diff --git a/patches/server/0698-Add-System.out-err-catcher.patch b/patches/server/0699-Add-System.out-err-catcher.patch similarity index 98% rename from patches/server/0698-Add-System.out-err-catcher.patch rename to patches/server/0699-Add-System.out-err-catcher.patch index 0159e346b..ff3261501 100644 --- a/patches/server/0698-Add-System.out-err-catcher.patch +++ b/patches/server/0699-Add-System.out-err-catcher.patch @@ -105,7 +105,7 @@ index 0000000000000000000000000000000000000000..76d0d00cd6742991e3f3ec827a75ee87 + } +} diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java -index 9f69e1874caa087778e1de637c93719b43ac5a23..6b53310b37a502a677459bf2b777a2c450fb6482 100644 +index 5bd8115430ceb8924460fe05294d7c96303cb7e8..1d7d3dbf7f6857d9853112844b70692e92e9c89d 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java @@ -18,6 +18,7 @@ import com.mojang.serialization.Lifecycle; diff --git a/patches/server/0699-Fix-test-not-bootstrapping.patch b/patches/server/0700-Fix-test-not-bootstrapping.patch similarity index 100% rename from patches/server/0699-Fix-test-not-bootstrapping.patch rename to patches/server/0700-Fix-test-not-bootstrapping.patch diff --git a/patches/server/0700-Rewrite-LogEvents-to-contain-the-source-jars-in-stac.patch b/patches/server/0701-Rewrite-LogEvents-to-contain-the-source-jars-in-stac.patch similarity index 100% rename from patches/server/0700-Rewrite-LogEvents-to-contain-the-source-jars-in-stac.patch rename to patches/server/0701-Rewrite-LogEvents-to-contain-the-source-jars-in-stac.patch diff --git a/patches/server/0701-Improve-boat-collision-performance.patch b/patches/server/0702-Improve-boat-collision-performance.patch similarity index 100% rename from patches/server/0701-Improve-boat-collision-performance.patch rename to patches/server/0702-Improve-boat-collision-performance.patch diff --git a/patches/server/0702-Prevent-AFK-kick-while-watching-end-credits.patch b/patches/server/0703-Prevent-AFK-kick-while-watching-end-credits.patch similarity index 100% rename from patches/server/0702-Prevent-AFK-kick-while-watching-end-credits.patch rename to patches/server/0703-Prevent-AFK-kick-while-watching-end-credits.patch diff --git a/patches/server/0703-Allow-skipping-writing-of-comments-to-server.propert.patch b/patches/server/0704-Allow-skipping-writing-of-comments-to-server.propert.patch similarity index 100% rename from patches/server/0703-Allow-skipping-writing-of-comments-to-server.propert.patch rename to patches/server/0704-Allow-skipping-writing-of-comments-to-server.propert.patch diff --git a/patches/server/0704-Add-PlayerSetSpawnEvent.patch b/patches/server/0705-Add-PlayerSetSpawnEvent.patch similarity index 97% rename from patches/server/0704-Add-PlayerSetSpawnEvent.patch rename to patches/server/0705-Add-PlayerSetSpawnEvent.patch index 7e196e797..d14db0d90 100644 --- a/patches/server/0704-Add-PlayerSetSpawnEvent.patch +++ b/patches/server/0705-Add-PlayerSetSpawnEvent.patch @@ -67,7 +67,7 @@ index 2607dc36e0bd7a915afb0cc9e0f453a2b301c0bd..ea724b1781ea256c991fe47aa044183e this.respawnPosition = pos; diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 932598d92e24521fed11d7236d87f34703b7bdd4..92a3df6d2435d8800a8173e7be3ba11577f23b5a 100644 +index 2c3249359bf8f7e5e625ef4769c7e884cddd473c..8a74c1aa2add393f4706a7f943f0fd5d9f5175e1 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -891,7 +891,7 @@ public abstract class PlayerList { @@ -93,7 +93,7 @@ index d620f559cdd1bd0e161a99123ef6c6f64e3302df..07e893f1859abe3c2a765694c21309d6 return InteractionResult.SUCCESS; } diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java -index c4e979055c54f147dd7e01b120de00bb5338bede..2ebeb2ab175cd93f7adc9f4ed923831e37481b8f 100644 +index 9d8e48b859933a2b9412df78daf158129b430e8c..ad15c4c20ae9e1858a2b914b0a1aa91ec1d7a012 100644 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java @@ -1088,9 +1088,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player { diff --git a/patches/server/0705-Make-hoppers-respect-inventory-max-stack-size.patch b/patches/server/0706-Make-hoppers-respect-inventory-max-stack-size.patch similarity index 100% rename from patches/server/0705-Make-hoppers-respect-inventory-max-stack-size.patch rename to patches/server/0706-Make-hoppers-respect-inventory-max-stack-size.patch diff --git a/patches/server/0706-Optimize-entity-tracker-passenger-checks.patch b/patches/server/0707-Optimize-entity-tracker-passenger-checks.patch similarity index 100% rename from patches/server/0706-Optimize-entity-tracker-passenger-checks.patch rename to patches/server/0707-Optimize-entity-tracker-passenger-checks.patch diff --git a/patches/server/0707-Config-option-for-Piglins-guarding-chests.patch b/patches/server/0708-Config-option-for-Piglins-guarding-chests.patch similarity index 92% rename from patches/server/0707-Config-option-for-Piglins-guarding-chests.patch rename to patches/server/0708-Config-option-for-Piglins-guarding-chests.patch index 759c52cdb..ccc23188d 100644 --- a/patches/server/0707-Config-option-for-Piglins-guarding-chests.patch +++ b/patches/server/0708-Config-option-for-Piglins-guarding-chests.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Config option for Piglins guarding chests diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 9a866ab0b887f2db1cf0e6802a44c2e8b0912b74..10a52ee6177d5eb463a9a08302099b5dbc7b1a18 100644 +index 8f358ed2d734ba63143c98bd044beb7e36a53aa5..1ecc60ca4923e27f6015c00b4bd66ebbfb368be4 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -78,6 +78,11 @@ public class PaperWorldConfig { +@@ -72,6 +72,11 @@ public class PaperWorldConfig { zombiesTargetTurtleEggs = getBoolean("zombies-target-turtle-eggs", zombiesTargetTurtleEggs); } diff --git a/patches/server/0708-Added-EntityDamageItemEvent.patch b/patches/server/0709-Added-EntityDamageItemEvent.patch similarity index 100% rename from patches/server/0708-Added-EntityDamageItemEvent.patch rename to patches/server/0709-Added-EntityDamageItemEvent.patch diff --git a/patches/server/0709-Optimize-indirect-passenger-iteration.patch b/patches/server/0710-Optimize-indirect-passenger-iteration.patch similarity index 100% rename from patches/server/0709-Optimize-indirect-passenger-iteration.patch rename to patches/server/0710-Optimize-indirect-passenger-iteration.patch diff --git a/patches/server/0710-Fix-block-drops-position-losing-precision-millions-o.patch b/patches/server/0711-Fix-block-drops-position-losing-precision-millions-o.patch similarity index 100% rename from patches/server/0710-Fix-block-drops-position-losing-precision-millions-o.patch rename to patches/server/0711-Fix-block-drops-position-losing-precision-millions-o.patch diff --git a/patches/server/0711-Configurable-item-frame-map-cursor-update-interval.patch b/patches/server/0712-Configurable-item-frame-map-cursor-update-interval.patch similarity index 93% rename from patches/server/0711-Configurable-item-frame-map-cursor-update-interval.patch rename to patches/server/0712-Configurable-item-frame-map-cursor-update-interval.patch index bff9dd9df..0ba11a1e4 100644 --- a/patches/server/0711-Configurable-item-frame-map-cursor-update-interval.patch +++ b/patches/server/0712-Configurable-item-frame-map-cursor-update-interval.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Configurable item frame map cursor update interval diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 10a52ee6177d5eb463a9a08302099b5dbc7b1a18..4d85af9d021291e813daa3a44e8bae340fc568fb 100644 +index 1ecc60ca4923e27f6015c00b4bd66ebbfb368be4..1dab732cf5614be864cf8abfbd6709545b9ff0c8 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -843,6 +843,11 @@ public class PaperWorldConfig { +@@ -872,6 +872,11 @@ public class PaperWorldConfig { mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit); } diff --git a/patches/server/0712-Make-EntityUnleashEvent-cancellable.patch b/patches/server/0713-Make-EntityUnleashEvent-cancellable.patch similarity index 100% rename from patches/server/0712-Make-EntityUnleashEvent-cancellable.patch rename to patches/server/0713-Make-EntityUnleashEvent-cancellable.patch diff --git a/patches/server/0713-Clear-bucket-NBT-after-dispense.patch b/patches/server/0714-Clear-bucket-NBT-after-dispense.patch similarity index 100% rename from patches/server/0713-Clear-bucket-NBT-after-dispense.patch rename to patches/server/0714-Clear-bucket-NBT-after-dispense.patch diff --git a/patches/server/0714-Set-AsyncAppender-dispatch-thread-to-be-a-daemon-thr.patch b/patches/server/0715-Set-AsyncAppender-dispatch-thread-to-be-a-daemon-thr.patch similarity index 100% rename from patches/server/0714-Set-AsyncAppender-dispatch-thread-to-be-a-daemon-thr.patch rename to patches/server/0715-Set-AsyncAppender-dispatch-thread-to-be-a-daemon-thr.patch diff --git a/patches/server/0715-Respect-despawn-rate-in-item-merge-check.patch b/patches/server/0716-Respect-despawn-rate-in-item-merge-check.patch similarity index 100% rename from patches/server/0715-Respect-despawn-rate-in-item-merge-check.patch rename to patches/server/0716-Respect-despawn-rate-in-item-merge-check.patch diff --git a/patches/server/0716-Move-BlockPistonRetractEvent-to-fix-duplication.patch b/patches/server/0717-Move-BlockPistonRetractEvent-to-fix-duplication.patch similarity index 100% rename from patches/server/0716-Move-BlockPistonRetractEvent-to-fix-duplication.patch rename to patches/server/0717-Move-BlockPistonRetractEvent-to-fix-duplication.patch diff --git a/patches/server/0717-Change-EnderEye-target-without-changing-other-things.patch b/patches/server/0718-Change-EnderEye-target-without-changing-other-things.patch similarity index 100% rename from patches/server/0717-Change-EnderEye-target-without-changing-other-things.patch rename to patches/server/0718-Change-EnderEye-target-without-changing-other-things.patch diff --git a/patches/server/0718-Add-BlockBreakBlockEvent.patch b/patches/server/0719-Add-BlockBreakBlockEvent.patch similarity index 100% rename from patches/server/0718-Add-BlockBreakBlockEvent.patch rename to patches/server/0719-Add-BlockBreakBlockEvent.patch diff --git a/patches/server/0719-Option-to-prevent-NBT-copy-in-smithing-recipes.patch b/patches/server/0720-Option-to-prevent-NBT-copy-in-smithing-recipes.patch similarity index 100% rename from patches/server/0719-Option-to-prevent-NBT-copy-in-smithing-recipes.patch rename to patches/server/0720-Option-to-prevent-NBT-copy-in-smithing-recipes.patch diff --git a/patches/server/0720-More-CommandBlock-API.patch b/patches/server/0721-More-CommandBlock-API.patch similarity index 100% rename from patches/server/0720-More-CommandBlock-API.patch rename to patches/server/0721-More-CommandBlock-API.patch diff --git a/patches/server/0721-Add-missing-team-sidebar-display-slots.patch b/patches/server/0722-Add-missing-team-sidebar-display-slots.patch similarity index 100% rename from patches/server/0721-Add-missing-team-sidebar-display-slots.patch rename to patches/server/0722-Add-missing-team-sidebar-display-slots.patch diff --git a/patches/server/0722-Add-back-EntityPortalExitEvent.patch b/patches/server/0723-Add-back-EntityPortalExitEvent.patch similarity index 100% rename from patches/server/0722-Add-back-EntityPortalExitEvent.patch rename to patches/server/0723-Add-back-EntityPortalExitEvent.patch diff --git a/patches/server/0723-Add-methods-to-find-targets-for-lightning-strikes.patch b/patches/server/0724-Add-methods-to-find-targets-for-lightning-strikes.patch similarity index 96% rename from patches/server/0723-Add-methods-to-find-targets-for-lightning-strikes.patch rename to patches/server/0724-Add-methods-to-find-targets-for-lightning-strikes.patch index 1d1295829..da9b6f962 100644 --- a/patches/server/0723-Add-methods-to-find-targets-for-lightning-strikes.patch +++ b/patches/server/0724-Add-methods-to-find-targets-for-lightning-strikes.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Add methods to find targets for lightning strikes diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 7dd99f16caac736ffb6b53b09695eede9cb7fbca..2b3c54737a203401c6f03bba9c9d969e95102298 100644 +index 081c031f08c9817de6c4e1e6bf18b11efc3c668b..c2800bbcf4892ca4e8fdc22e9bf794aa5a60c0fc 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -748,6 +748,11 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0724-Get-entity-default-attributes.patch b/patches/server/0725-Get-entity-default-attributes.patch similarity index 100% rename from patches/server/0724-Get-entity-default-attributes.patch rename to patches/server/0725-Get-entity-default-attributes.patch diff --git a/patches/server/0725-Left-handed-API.patch b/patches/server/0726-Left-handed-API.patch similarity index 100% rename from patches/server/0725-Left-handed-API.patch rename to patches/server/0726-Left-handed-API.patch diff --git a/patches/server/0726-Add-advancement-display-API.patch b/patches/server/0727-Add-advancement-display-API.patch similarity index 100% rename from patches/server/0726-Add-advancement-display-API.patch rename to patches/server/0727-Add-advancement-display-API.patch diff --git a/patches/server/0727-Add-ItemFactory-getMonsterEgg-API.patch b/patches/server/0728-Add-ItemFactory-getMonsterEgg-API.patch similarity index 100% rename from patches/server/0727-Add-ItemFactory-getMonsterEgg-API.patch rename to patches/server/0728-Add-ItemFactory-getMonsterEgg-API.patch diff --git a/patches/server/0728-Add-critical-damage-API.patch b/patches/server/0729-Add-critical-damage-API.patch similarity index 98% rename from patches/server/0728-Add-critical-damage-API.patch rename to patches/server/0729-Add-critical-damage-API.patch index f94c86c98..dfd5229da 100644 --- a/patches/server/0728-Add-critical-damage-API.patch +++ b/patches/server/0729-Add-critical-damage-API.patch @@ -29,7 +29,7 @@ index 80d19af2ad423bd3de0e039c5bb8f97af536aaa9..a828cad27fcd39f8bfbaefa97052a2a3 public static DamageSource sting(LivingEntity attacker) { return new EntityDamageSource("sting", attacker); diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index 44c2820a33ed40b4ef2ebd20708347d3cc2437ae..b6f8e94df86c174569ccbc69cfd031cc08271dd3 100644 +index 56110f0022c99dad562e9398f4f34b993eda4923..8eafe216a942956d97ad36a2fe0dbaccd9aa87a5 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -1215,7 +1215,7 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0729-Fix-issues-with-mob-conversion.patch b/patches/server/0730-Fix-issues-with-mob-conversion.patch similarity index 100% rename from patches/server/0729-Fix-issues-with-mob-conversion.patch rename to patches/server/0730-Fix-issues-with-mob-conversion.patch diff --git a/patches/server/0730-Add-isCollidable-methods-to-various-places.patch b/patches/server/0731-Add-isCollidable-methods-to-various-places.patch similarity index 100% rename from patches/server/0730-Add-isCollidable-methods-to-various-places.patch rename to patches/server/0731-Add-isCollidable-methods-to-various-places.patch diff --git a/patches/server/0731-Goat-ram-API.patch b/patches/server/0732-Goat-ram-API.patch similarity index 100% rename from patches/server/0731-Goat-ram-API.patch rename to patches/server/0732-Goat-ram-API.patch diff --git a/patches/server/0732-Add-API-for-resetting-a-single-score.patch b/patches/server/0733-Add-API-for-resetting-a-single-score.patch similarity index 100% rename from patches/server/0732-Add-API-for-resetting-a-single-score.patch rename to patches/server/0733-Add-API-for-resetting-a-single-score.patch diff --git a/patches/server/0733-Add-Raw-Byte-Entity-Serialization.patch b/patches/server/0734-Add-Raw-Byte-Entity-Serialization.patch similarity index 100% rename from patches/server/0733-Add-Raw-Byte-Entity-Serialization.patch rename to patches/server/0734-Add-Raw-Byte-Entity-Serialization.patch diff --git a/patches/server/0734-Vanilla-command-permission-fixes.patch b/patches/server/0735-Vanilla-command-permission-fixes.patch similarity index 100% rename from patches/server/0734-Vanilla-command-permission-fixes.patch rename to patches/server/0735-Vanilla-command-permission-fixes.patch diff --git a/patches/server/0735-Make-CallbackExecutor-strict-again.patch b/patches/server/0736-Make-CallbackExecutor-strict-again.patch similarity index 95% rename from patches/server/0735-Make-CallbackExecutor-strict-again.patch rename to patches/server/0736-Make-CallbackExecutor-strict-again.patch index 4e4f0003f..862f9007c 100644 --- a/patches/server/0735-Make-CallbackExecutor-strict-again.patch +++ b/patches/server/0736-Make-CallbackExecutor-strict-again.patch @@ -10,7 +10,7 @@ schedules. Effectively, use the callback executor as a tool of finding issues rather than hiding these issues. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index d9f6d47629f2f4aa1db5a19b8cb7229a0905b75e..dec387e56928fa9b07a183e3055489dfe3dd94fe 100644 +index ee2eeea6e0fb3103620f6a6b5704e259f44d27e3..0bee0f348a6123a27b8bcf02d2a93df9b007b689 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -160,17 +160,28 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider diff --git a/patches/server/0736-Do-not-allow-the-server-to-unload-chunks-at-request-.patch b/patches/server/0737-Do-not-allow-the-server-to-unload-chunks-at-request-.patch similarity index 92% rename from patches/server/0736-Do-not-allow-the-server-to-unload-chunks-at-request-.patch rename to patches/server/0737-Do-not-allow-the-server-to-unload-chunks-at-request-.patch index 83aeeea37..eb5a3a65e 100644 --- a/patches/server/0736-Do-not-allow-the-server-to-unload-chunks-at-request-.patch +++ b/patches/server/0737-Do-not-allow-the-server-to-unload-chunks-at-request-.patch @@ -10,7 +10,7 @@ to be unloaded will simply be unloaded next tick, rather than immediately. diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 59d7f93c9364571edf2e7b613a57f8f28989cb56..804aaa62d9c39bc4340a83a9ed88ab7d04c47059 100644 +index f7abb67568cf1034dae3fe9e0adff9bcc36b96e7..2099769f54b53129f350856a227db4c475b4c903 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -884,6 +884,7 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0737-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch b/patches/server/0738-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch similarity index 95% rename from patches/server/0737-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch rename to patches/server/0738-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch index 067092397..7de4b588e 100644 --- a/patches/server/0737-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch +++ b/patches/server/0738-Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch @@ -9,7 +9,7 @@ chunk through it. This should also be OK from a leak prevention/ state desync POV because the TE is getting unloaded anyways. diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 2b3c54737a203401c6f03bba9c9d969e95102298..3748dae9bbb80e70bb9a0547868e02d91d9c85c6 100644 +index c2800bbcf4892ca4e8fdc22e9bf794aa5a60c0fc..132d87cc61f836cf5518e28f24374aa17173bd82 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1303,9 +1303,13 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -51,7 +51,7 @@ index ea724b1781ea256c991fe47aa044183e20ae4d82..5270a8b1ee2cc426b8e0b5d34db4d818 public void doCloseContainer() { this.containerMenu.removed(this); diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java -index b6f8e94df86c174569ccbc69cfd031cc08271dd3..4e6364bea8f464bef690b8cc8f25a80ee699ed5a 100644 +index 8eafe216a942956d97ad36a2fe0dbaccd9aa87a5..2c00a766130a7f682fc6c4c74321e10637ca7932 100644 --- a/src/main/java/net/minecraft/world/entity/player/Player.java +++ b/src/main/java/net/minecraft/world/entity/player/Player.java @@ -496,6 +496,11 @@ public abstract class Player extends LivingEntity { diff --git a/patches/server/0738-Correctly-handle-recursion-for-chunkholder-updates.patch b/patches/server/0739-Correctly-handle-recursion-for-chunkholder-updates.patch similarity index 95% rename from patches/server/0738-Correctly-handle-recursion-for-chunkholder-updates.patch rename to patches/server/0739-Correctly-handle-recursion-for-chunkholder-updates.patch index 3cfb006b2..8b0d0239c 100644 --- a/patches/server/0738-Correctly-handle-recursion-for-chunkholder-updates.patch +++ b/patches/server/0739-Correctly-handle-recursion-for-chunkholder-updates.patch @@ -8,7 +8,7 @@ cause a recursive call which would handle the increase but then the caller would think the chunk would be unloaded. diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java -index 874c99cdb8ea57c7ba986dd1cbd43bedbff30260..b6445778a023531774784f1a6e569849dda4c8ce 100644 +index 4b0d87c0534cddcab16d772c16307f3621fc30e9..634de60385923b3482f8a52138694b5c635c23b8 100644 --- a/src/main/java/net/minecraft/server/level/ChunkHolder.java +++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java @@ -438,8 +438,10 @@ public class ChunkHolder { diff --git a/patches/server/0739-Separate-lookup-locking-from-state-access-in-UserCac.patch b/patches/server/0740-Separate-lookup-locking-from-state-access-in-UserCac.patch similarity index 100% rename from patches/server/0739-Separate-lookup-locking-from-state-access-in-UserCac.patch rename to patches/server/0740-Separate-lookup-locking-from-state-access-in-UserCac.patch diff --git a/patches/server/0740-Fix-chunks-refusing-to-unload-at-low-TPS.patch b/patches/server/0741-Fix-chunks-refusing-to-unload-at-low-TPS.patch similarity index 92% rename from patches/server/0740-Fix-chunks-refusing-to-unload-at-low-TPS.patch rename to patches/server/0741-Fix-chunks-refusing-to-unload-at-low-TPS.patch index f4ea93a3a..b2ad0c10f 100644 --- a/patches/server/0740-Fix-chunks-refusing-to-unload-at-low-TPS.patch +++ b/patches/server/0741-Fix-chunks-refusing-to-unload-at-low-TPS.patch @@ -10,7 +10,7 @@ chunk future to complete. We can simply schedule to the immediate executor to get this effect, rather than the main mailbox. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index dec387e56928fa9b07a183e3055489dfe3dd94fe..e106583bbd3268e48b485019e5b6a80f36aa161e 100644 +index 0bee0f348a6123a27b8bcf02d2a93df9b007b689..52d0896356529d07ce43c0006423ab169cc3b068 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -1297,9 +1297,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider diff --git a/patches/server/0741-Do-not-allow-ticket-level-changes-while-unloading-pl.patch b/patches/server/0742-Do-not-allow-ticket-level-changes-while-unloading-pl.patch similarity index 95% rename from patches/server/0741-Do-not-allow-ticket-level-changes-while-unloading-pl.patch rename to patches/server/0742-Do-not-allow-ticket-level-changes-while-unloading-pl.patch index 476788236..59ad52883 100644 --- a/patches/server/0741-Do-not-allow-ticket-level-changes-while-unloading-pl.patch +++ b/patches/server/0742-Do-not-allow-ticket-level-changes-while-unloading-pl.patch @@ -8,7 +8,7 @@ Sync loading the chunk at this stage would cause it to load older data, as well as screwing our region state. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index e106583bbd3268e48b485019e5b6a80f36aa161e..ba7cd04b33fcaea7e7cea43b5929df56e130bf3f 100644 +index 52d0896356529d07ce43c0006423ab169cc3b068..bda3d88b9d99b18ba703a781a0a9c447fd147585 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -296,6 +296,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -49,7 +49,7 @@ index e106583bbd3268e48b485019e5b6a80f36aa161e..ba7cd04b33fcaea7e7cea43b5929df56 } }; diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 804aaa62d9c39bc4340a83a9ed88ab7d04c47059..7dfccd2e72ac5ec8b03b3439b034975ddadd759e 100644 +index 2099769f54b53129f350856a227db4c475b4c903..e13a8e3dc11292aed13ff12ee8e0f9d6a95f0c34 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -820,6 +820,7 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0742-Do-not-allow-ticket-level-changes-when-updating-chun.patch b/patches/server/0743-Do-not-allow-ticket-level-changes-when-updating-chun.patch similarity index 95% rename from patches/server/0742-Do-not-allow-ticket-level-changes-when-updating-chun.patch rename to patches/server/0743-Do-not-allow-ticket-level-changes-when-updating-chun.patch index 65687508d..e4d9eab54 100644 --- a/patches/server/0742-Do-not-allow-ticket-level-changes-when-updating-chun.patch +++ b/patches/server/0743-Do-not-allow-ticket-level-changes-when-updating-chun.patch @@ -8,7 +8,7 @@ This WILL cause state corruption if it happens. So, don't allow it. diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java -index b6445778a023531774784f1a6e569849dda4c8ce..c70e1018c5e5b65911ee430be123e38f03666df2 100644 +index 634de60385923b3482f8a52138694b5c635c23b8..bb411853cb9e0120bcaa82e878724ee17167057b 100644 --- a/src/main/java/net/minecraft/server/level/ChunkHolder.java +++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java @@ -418,7 +418,13 @@ public class ChunkHolder { diff --git a/patches/server/0743-Do-not-submit-profile-lookups-to-worldgen-threads.patch b/patches/server/0744-Do-not-submit-profile-lookups-to-worldgen-threads.patch similarity index 100% rename from patches/server/0743-Do-not-submit-profile-lookups-to-worldgen-threads.patch rename to patches/server/0744-Do-not-submit-profile-lookups-to-worldgen-threads.patch diff --git a/patches/server/0744-Log-when-the-async-catcher-is-tripped.patch b/patches/server/0745-Log-when-the-async-catcher-is-tripped.patch similarity index 100% rename from patches/server/0744-Log-when-the-async-catcher-is-tripped.patch rename to patches/server/0745-Log-when-the-async-catcher-is-tripped.patch diff --git a/patches/server/0745-Add-paper-mobcaps-and-paper-playermobcaps.patch b/patches/server/0746-Add-paper-mobcaps-and-paper-playermobcaps.patch similarity index 100% rename from patches/server/0745-Add-paper-mobcaps-and-paper-playermobcaps.patch rename to patches/server/0746-Add-paper-mobcaps-and-paper-playermobcaps.patch diff --git a/patches/server/0746-Sanitize-ResourceLocation-error-logging.patch b/patches/server/0747-Sanitize-ResourceLocation-error-logging.patch similarity index 100% rename from patches/server/0746-Sanitize-ResourceLocation-error-logging.patch rename to patches/server/0747-Sanitize-ResourceLocation-error-logging.patch diff --git a/patches/server/0747-Optimise-general-POI-access.patch b/patches/server/0748-Optimise-general-POI-access.patch similarity index 100% rename from patches/server/0747-Optimise-general-POI-access.patch rename to patches/server/0748-Optimise-general-POI-access.patch diff --git a/patches/server/0748-Allow-controlled-flushing-for-network-manager.patch b/patches/server/0749-Allow-controlled-flushing-for-network-manager.patch similarity index 100% rename from patches/server/0748-Allow-controlled-flushing-for-network-manager.patch rename to patches/server/0749-Allow-controlled-flushing-for-network-manager.patch diff --git a/patches/server/0749-Add-more-async-catchers.patch b/patches/server/0750-Add-more-async-catchers.patch similarity index 100% rename from patches/server/0749-Add-more-async-catchers.patch rename to patches/server/0750-Add-more-async-catchers.patch diff --git a/patches/server/0750-Rewrite-entity-bounding-box-lookup-calls.patch b/patches/server/0751-Rewrite-entity-bounding-box-lookup-calls.patch similarity index 98% rename from patches/server/0750-Rewrite-entity-bounding-box-lookup-calls.patch rename to patches/server/0751-Rewrite-entity-bounding-box-lookup-calls.patch index 6106353e6..2f7e4c540 100644 --- a/patches/server/0750-Rewrite-entity-bounding-box-lookup-calls.patch +++ b/patches/server/0751-Rewrite-entity-bounding-box-lookup-calls.patch @@ -914,7 +914,7 @@ index 0000000000000000000000000000000000000000..3ba094e640d7fe7803e2bbdab8ff3beb + } +} diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 3748dae9bbb80e70bb9a0547868e02d91d9c85c6..7a5b6bd84f1a7becdebe03b0bd07f8481eb27ecd 100644 +index 132d87cc61f836cf5518e28f24374aa17173bd82..2459b8bfbb73310be66e354112c39e0ded1db036 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -425,7 +425,7 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -1051,10 +1051,10 @@ index bc3bfe8d3c2f87e2e9f167b9ff34d9ca8a696391..30276959c0119813c27ee3f98e237c93 List getEntities(EntityTypeTest filter, AABB box, Predicate predicate); diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index e5cb991543c695bc90256ef250a1d695ac5bc17d..4484c455f4be73763f5aa1112be5969e18c092bc 100644 +index 7ac5755df29a82d053fdd3f9e83b0789cbdb0525..317f4ea838a2ba654d5bf36b416e67d897a12470 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -202,6 +202,48 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -203,6 +203,48 @@ public abstract class Level implements LevelAccessor, AutoCloseable { public abstract ResourceKey getTypeKey(); @@ -1100,18 +1100,18 @@ index e5cb991543c695bc90256ef250a1d695ac5bc17d..4484c455f4be73763f5aa1112be5969e + } + // Paper end + - protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env) { + protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName(), this.spigotConfig); // Paper -@@ -278,6 +320,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { - this.keepSpawnInMemory = this.paperConfig.keepSpawnInMemory; // Paper +@@ -280,6 +322,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { this.entityLimiter = new org.spigotmc.TickLimiter(spigotConfig.entityMaxTickTime); this.tileLimiter = new org.spigotmc.TickLimiter(spigotConfig.tileMaxTickTime); + this.chunkPacketBlockController = this.paperConfig.antiXray ? new com.destroystokyo.paper.antixray.ChunkPacketBlockControllerAntiXray(this, executor) : com.destroystokyo.paper.antixray.ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray + this.entitySliceManager = new io.papermc.paper.world.EntitySliceManager((ServerLevel)this); // Paper } // Paper start -@@ -987,26 +1030,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -990,26 +1033,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { public List getEntities(@Nullable Entity except, AABB box, Predicate predicate) { this.getProfiler().incrementCounter("getEntities"); List list = Lists.newArrayList(); @@ -1139,7 +1139,7 @@ index e5cb991543c695bc90256ef250a1d695ac5bc17d..4484c455f4be73763f5aa1112be5969e return list; } -@@ -1015,27 +1039,22 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -1018,27 +1042,22 @@ public abstract class Level implements LevelAccessor, AutoCloseable { this.getProfiler().incrementCounter("getEntities"); List list = Lists.newArrayList(); @@ -1231,7 +1231,7 @@ index aa3217425a64fdd691f255dcc5529a29b8c2c86b..a0c66689c954823e7c20664594557dc2 Visibility visibility = PersistentEntitySectionManager.getEffectiveStatus(this.entity, this.currentSection.getStatus()); diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java -index 7bc1219523eeb0880493e6fb42692f1fdb30c110..4bf4d48fe7f511c4d41b030f0bfb6a198211a657 100644 +index d6efa18ba9c032858071f6c87f1bdc0ce2ddb20f..d51833b1ad40ab234e2a2b2a61f093628ee1ea40 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java @@ -132,9 +132,7 @@ public class CraftChunk implements Chunk { diff --git a/patches/server/0751-Execute-chunk-tasks-mid-tick.patch b/patches/server/0752-Execute-chunk-tasks-mid-tick.patch similarity index 95% rename from patches/server/0751-Execute-chunk-tasks-mid-tick.patch rename to patches/server/0752-Execute-chunk-tasks-mid-tick.patch index e4a4e1884..ef13dfd33 100644 --- a/patches/server/0751-Execute-chunk-tasks-mid-tick.patch +++ b/patches/server/0752-Execute-chunk-tasks-mid-tick.patch @@ -19,7 +19,7 @@ index b27021a42cbed3f0648a8d0903d00d03922ae221..eada966d7f108a6081be7a848f5c1dfc private MinecraftTimings() {} diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index ad92755203d62bb76d259d4c1eba960c04d90a1e..743dd0253e9dffddee28c142d8b5ebdc2a8e670a 100644 +index 5af9607665cfa3283b781eb037fa3f7b0eaff46b..72dd906395679cc52f1b5ba5b03c1fd7a86e51c1 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -331,6 +331,76 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop void guardEntityTick(Consumer tickConsumer, T entity) { try { tickConsumer.accept(entity); diff --git a/patches/server/0752-Do-not-copy-visible-chunks.patch b/patches/server/0753-Do-not-copy-visible-chunks.patch similarity index 99% rename from patches/server/0752-Do-not-copy-visible-chunks.patch rename to patches/server/0753-Do-not-copy-visible-chunks.patch index 368ea2117..0f7e67079 100644 --- a/patches/server/0752-Do-not-copy-visible-chunks.patch +++ b/patches/server/0753-Do-not-copy-visible-chunks.patch @@ -35,7 +35,7 @@ index 35949e9c15eb998aa89842d34d0999cd973590e0..15f0c85ba9f4f9666e94e67dde43eb2e List allChunks = new ArrayList<>(visibleChunks.values()); List players = world.players; diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index ba7cd04b33fcaea7e7cea43b5929df56e130bf3f..72c769d627779224091660c44ccd2ba40796bb58 100644 +index bda3d88b9d99b18ba703a781a0a9c447fd147585..b50c2c6fec4dc4a6672e2220b7fdf488d7b68c0f 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -120,9 +120,11 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider diff --git a/patches/server/0753-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch b/patches/server/0754-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch similarity index 99% rename from patches/server/0753-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch rename to patches/server/0754-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch index 14c56b557..48436825c 100644 --- a/patches/server/0753-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch +++ b/patches/server/0754-Attempt-to-recalculate-regionfile-header-if-it-is-co.patch @@ -10,7 +10,7 @@ hoping that at least then we don't swap chunks, and maybe recover them all. diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java -index 5cbcd113385e6bef3eddd969841ee4ac2a8a8923..859e23a182e97afa179419973485208bb0aa84ca 100644 +index 8866ded0567fee710aa301dbc89f4c45b7283447..cf042295fe250d74c67a04f8f0d2b233860d4d1d 100644 --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java @@ -66,6 +66,12 @@ import org.apache.logging.log4j.LogManager; @@ -24,9 +24,9 @@ index 5cbcd113385e6bef3eddd969841ee4ac2a8a8923..859e23a182e97afa179419973485208b + } + // Paper end - public static final Codec> BLOCK_STATE_CODEC = PalettedContainer.codec(Block.BLOCK_STATE_REGISTRY, BlockState.CODEC, PalettedContainer.Strategy.SECTION_STATES, Blocks.AIR.defaultBlockState()); + public static final Codec> BLOCK_STATE_CODEC = PalettedContainer.codec(Block.BLOCK_STATE_REGISTRY, BlockState.CODEC, PalettedContainer.Strategy.SECTION_STATES, Blocks.AIR.defaultBlockState(), null); // Paper - Anti-Xray - Add preset block states private static final Logger LOGGER = LogManager.getLogger(); -@@ -450,7 +456,7 @@ public class ChunkSerializer { +@@ -454,7 +460,7 @@ public class ChunkSerializer { nbttagcompound.putInt("xPos", chunkcoordintpair.x); nbttagcompound.putInt("yPos", chunk.getMinSection()); nbttagcompound.putInt("zPos", chunkcoordintpair.z); diff --git a/patches/server/0754-Custom-table-implementation-for-blockstate-state-loo.patch b/patches/server/0755-Custom-table-implementation-for-blockstate-state-loo.patch similarity index 100% rename from patches/server/0754-Custom-table-implementation-for-blockstate-state-loo.patch rename to patches/server/0755-Custom-table-implementation-for-blockstate-state-loo.patch diff --git a/patches/server/0755-Detail-more-information-in-watchdog-dumps.patch b/patches/server/0756-Detail-more-information-in-watchdog-dumps.patch similarity index 99% rename from patches/server/0755-Detail-more-information-in-watchdog-dumps.patch rename to patches/server/0756-Detail-more-information-in-watchdog-dumps.patch index 6d7c6f69c..0c33109e1 100644 --- a/patches/server/0755-Detail-more-information-in-watchdog-dumps.patch +++ b/patches/server/0756-Detail-more-information-in-watchdog-dumps.patch @@ -77,7 +77,7 @@ index bcf53ec07b8eeec7a88fb67e6fb908362e6f51b0..acc12307f61e1e055896b68fe16654c9 }); throw RunningOnDifferentThreadException.RUNNING_ON_DIFFERENT_THREAD; diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index f9f1e2f9eb1a682b3c4c50b5ab4839bf595b0a73..f31d84f0eb65c2754b8622997f404b8cd5ee845d 100644 +index f4b61f719c422028a5d8bc63c29f7a1c44fd2a6c..a1b4a9c92b2b602b2de97424eefbb0677a80dede 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -973,7 +973,26 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0756-Manually-inline-methods-in-BlockPosition.patch b/patches/server/0757-Manually-inline-methods-in-BlockPosition.patch similarity index 100% rename from patches/server/0756-Manually-inline-methods-in-BlockPosition.patch rename to patches/server/0757-Manually-inline-methods-in-BlockPosition.patch diff --git a/patches/server/0757-Distance-manager-tick-timings.patch b/patches/server/0758-Distance-manager-tick-timings.patch similarity index 96% rename from patches/server/0757-Distance-manager-tick-timings.patch rename to patches/server/0758-Distance-manager-tick-timings.patch index 5e47c52af..eb2ae8684 100644 --- a/patches/server/0757-Distance-manager-tick-timings.patch +++ b/patches/server/0758-Distance-manager-tick-timings.patch @@ -19,7 +19,7 @@ index eada966d7f108a6081be7a848f5c1dfcb1eed676..a977f7483f37df473096b2234dc1308b public static final Timing midTickChunkTasks = Timings.ofSafe("Mid Tick Chunk Tasks"); diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java -index 45700b146ac3f1b7df153c096a03651ae771378d..1c03c4eb5e70a502bb3b9136f2582969ed16f5dd 100644 +index e13a8e3dc11292aed13ff12ee8e0f9d6a95f0c34..660ce57b008985d9064271b1ef861f4291d7e09f 100644 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java @@ -821,6 +821,7 @@ public class ServerChunkCache extends ChunkSource { diff --git a/patches/server/0758-Name-craft-scheduler-threads-according-to-the-plugin.patch b/patches/server/0759-Name-craft-scheduler-threads-according-to-the-plugin.patch similarity index 100% rename from patches/server/0758-Name-craft-scheduler-threads-according-to-the-plugin.patch rename to patches/server/0759-Name-craft-scheduler-threads-according-to-the-plugin.patch diff --git a/patches/server/0759-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch b/patches/server/0760-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch similarity index 90% rename from patches/server/0759-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch rename to patches/server/0760-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch index 7ceb975f8..ff97803f3 100644 --- a/patches/server/0759-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch +++ b/patches/server/0760-Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch @@ -13,10 +13,10 @@ Paper recently reverted this optimisation, so it's been reintroduced here. diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 9cc34ff8ec5db5a87faf0afb574543f01c8381c2..367c932ae6abfbc73a42afaa143cefcedea52ffb 100644 +index 93e607aae3e64b6a04fd56b25748283535ce5aac..79a231c6a2387e8b6bf1b32d02f0d3e0e1393756 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -395,6 +395,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -397,6 +397,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable { @Override public final LevelChunk getChunk(int chunkX, int chunkZ) { // Paper - final to help inline diff --git a/patches/server/0760-Add-packet-limiter-config.patch b/patches/server/0761-Add-packet-limiter-config.patch similarity index 100% rename from patches/server/0760-Add-packet-limiter-config.patch rename to patches/server/0761-Add-packet-limiter-config.patch diff --git a/patches/server/0761-Lag-compensate-block-breaking.patch b/patches/server/0762-Lag-compensate-block-breaking.patch similarity index 98% rename from patches/server/0761-Lag-compensate-block-breaking.patch rename to patches/server/0762-Lag-compensate-block-breaking.patch index b3dc9addc..9ab1776b2 100644 --- a/patches/server/0761-Lag-compensate-block-breaking.patch +++ b/patches/server/0762-Lag-compensate-block-breaking.patch @@ -21,7 +21,7 @@ index aafb87e80ff2cbc7f46fc102dd5b1d828206ecc8..f34ae86812b13a96b509724591a75c1a + } } diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java -index 3ab74a721d9d9bec82a68a30bf523292a3038587..17a59fba538f8a7bdd96964c6acda94b33655d27 100644 +index 92f5cb240e0cf52caa8e95302606baa79a0da0f9..dd92cc53f0e6247508c6ce494dd45b4829344b2a 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java @@ -54,14 +54,28 @@ public class ServerPlayerGameMode { @@ -139,7 +139,7 @@ index 3ab74a721d9d9bec82a68a30bf523292a3038587..17a59fba538f8a7bdd96964c6acda94b } } -@@ -324,7 +350,13 @@ public class ServerPlayerGameMode { +@@ -326,7 +352,13 @@ public class ServerPlayerGameMode { public void destroyAndAck(BlockPos pos, ServerboundPlayerActionPacket.Action action, String reason) { if (this.destroyBlock(pos)) { diff --git a/patches/server/0762-Use-correct-LevelStem-registry-when-loading-default-.patch b/patches/server/0763-Use-correct-LevelStem-registry-when-loading-default-.patch similarity index 93% rename from patches/server/0762-Use-correct-LevelStem-registry-when-loading-default-.patch rename to patches/server/0763-Use-correct-LevelStem-registry-when-loading-default-.patch index 77e7bdc58..c769a8f3b 100644 --- a/patches/server/0762-Use-correct-LevelStem-registry-when-loading-default-.patch +++ b/patches/server/0763-Use-correct-LevelStem-registry-when-loading-default-.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Use correct LevelStem registry when loading default diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java -index 743dd0253e9dffddee28c142d8b5ebdc2a8e670a..519806cee3a45eaaedefa83b7237b073c9bbc332 100644 +index 72dd906395679cc52f1b5ba5b03c1fd7a86e51c1..893badbe321fa974cb82f5f11ab590bb3827f8b8 100644 --- a/src/main/java/net/minecraft/server/MinecraftServer.java +++ b/src/main/java/net/minecraft/server/MinecraftServer.java @@ -634,7 +634,14 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop blockStateContainer, PalettedContainer biomeContainer) { this.bottomBlockY = LevelChunkSection.getBottomBlockY(chunkPos); -@@ -79,6 +80,9 @@ public class LevelChunkSection { +@@ -82,6 +83,9 @@ public class LevelChunkSection { --this.nonEmptyBlockCount; if (iblockdata1.isRandomlyTicking()) { --this.tickingBlockCount; @@ -342,7 +342,7 @@ index f9e871cff9318e6fea92d5b7a7035b3bfa259bca..c579be24944b310151738d375c53e2d5 } } -@@ -90,6 +94,9 @@ public class LevelChunkSection { +@@ -93,6 +97,9 @@ public class LevelChunkSection { ++this.nonEmptyBlockCount; if (state.isRandomlyTicking()) { ++this.tickingBlockCount; @@ -352,7 +352,7 @@ index f9e871cff9318e6fea92d5b7a7035b3bfa259bca..c579be24944b310151738d375c53e2d5 } } -@@ -121,23 +128,29 @@ public class LevelChunkSection { +@@ -124,23 +131,29 @@ public class LevelChunkSection { } public void recalcBlockCounts() { @@ -388,10 +388,10 @@ index f9e871cff9318e6fea92d5b7a7035b3bfa259bca..c579be24944b310151738d375c53e2d5 } diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -index ec285516c2c403b65b2446f20b187628539d96a6..dea80ddba894453a0229888adfa235638cc9f659 100644 +index 5bbbb10a567963a451db8cf29d8d16f1cd013a16..d850cae1ec024a557e62cd561fbca137dc2be96c 100644 --- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -@@ -286,6 +286,14 @@ public class PalettedContainer implements PaletteResize { +@@ -355,6 +355,14 @@ public class PalettedContainer implements PaletteResize { } } diff --git a/patches/server/0773-Optimise-non-flush-packet-sending.patch b/patches/server/0774-Optimise-non-flush-packet-sending.patch similarity index 100% rename from patches/server/0773-Optimise-non-flush-packet-sending.patch rename to patches/server/0774-Optimise-non-flush-packet-sending.patch diff --git a/patches/server/0774-Optimise-nearby-player-lookups.patch b/patches/server/0775-Optimise-nearby-player-lookups.patch similarity index 97% rename from patches/server/0774-Optimise-nearby-player-lookups.patch rename to patches/server/0775-Optimise-nearby-player-lookups.patch index c23c08abe..ca59b4611 100644 --- a/patches/server/0774-Optimise-nearby-player-lookups.patch +++ b/patches/server/0775-Optimise-nearby-player-lookups.patch @@ -26,7 +26,7 @@ index bb411853cb9e0120bcaa82e878724ee17167057b..7f663523b8c43b356763d6d5249e1aec // Paper end - optimise anyPlayerCloseEnoughForSpawning long lastAutoSaveTime; // Paper - incremental autosave diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index 05fd5f8bd0f88fe8e8cd1492c2d4a6e3ad90374c..2da01d9b3f371ec992d1114c0c1501fa2f09adbd 100644 +index 06a66be037e5a32e2216b661048f40fec30a81a5..462f94b439749e86d860d02014dca96e154b3756 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -159,6 +159,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -92,7 +92,7 @@ index 05fd5f8bd0f88fe8e8cd1492c2d4a6e3ad90374c..2da01d9b3f371ec992d1114c0c1501fa protected ChunkGenerator generator() { diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 96548781eefb60c0d0c5c4d242de687481a5faf0..7cc142f8d2fe8d0443d5822137ebec1dfac2a54c 100644 +index 0e8bfceeb2eae9b465e8810c67073e11ff882ea7..c525d8aed8f0671ad6cfef67cadaeb311a4d5e97 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -396,6 +396,83 @@ public class ServerLevel extends Level implements WorldGenLevel { @@ -213,10 +213,10 @@ index 697c2663c4deeb8f2ad603c979ab0884ac027930..0b46066d35d9bb38d98a9d6e5ca8dbdc if (entityhuman != null) { double d0 = entityhuman.distanceToSqr((Entity) this); diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java -index 6be462975523dae9ff436ba1643b2042ec66e554..929f48675a10fdd64cb351305389d680a16963fb 100644 +index 02a240a3925008152ea93059db47122e7f1a40d9..c2220d5157d3065a256cd17410760c6aedf24987 100644 --- a/src/main/java/net/minecraft/world/level/Level.java +++ b/src/main/java/net/minecraft/world/level/Level.java -@@ -243,6 +243,69 @@ public abstract class Level implements LevelAccessor, AutoCloseable { +@@ -244,6 +244,69 @@ public abstract class Level implements LevelAccessor, AutoCloseable { return ret; } // Paper end @@ -284,7 +284,7 @@ index 6be462975523dae9ff436ba1643b2042ec66e554..929f48675a10fdd64cb351305389d680 + } + // Paper end - optimise checkDespawn - protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env) { + protected Level(WritableLevelData worlddatamutable, ResourceKey resourcekey, final DimensionType dimensionmanager, Supplier supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java index 928025438af179711c42381fc3eaeac74cd20c59..c48d0773e7f1af4bc247d777eccc8a42c7e17601 100644 @@ -309,7 +309,7 @@ index 928025438af179711c42381fc3eaeac74cd20c59..c48d0773e7f1af4bc247d777eccc8a42 private static Boolean isValidSpawnPostitionForType(ServerLevel world, MobCategory group, StructureFeatureManager structureAccessor, ChunkGenerator chunkGenerator, MobSpawnSettings.SpawnerData spawnEntry, BlockPos.MutableBlockPos pos, double squaredDistance) { // Paper 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 a8bc174d0b5016cf595267d2727ab06d90f2c794..b64272b8353cceb2489bc33e36585155347b7d58 100644 +index b641bf5b2d02bfc1443a84af3cb98aff0dc7a575..c9cd9121e0ca7402c812e803ffd417c1887a4823 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -235,6 +235,93 @@ public class LevelChunk extends ChunkAccess { diff --git a/patches/server/0775-Optimise-WorldServer-notify.patch b/patches/server/0776-Optimise-WorldServer-notify.patch similarity index 98% rename from patches/server/0775-Optimise-WorldServer-notify.patch rename to patches/server/0776-Optimise-WorldServer-notify.patch index 4dd1785af..76533e831 100644 --- a/patches/server/0775-Optimise-WorldServer-notify.patch +++ b/patches/server/0776-Optimise-WorldServer-notify.patch @@ -8,7 +8,7 @@ Instead, only iterate over navigators in the current region that are eligible for repathing. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index f6d5bf3474dbf37095778cd8d774b58338d53877..a3f3015f9eba9a2eccbc3f1f64bca4c66d52b9f2 100644 +index 462f94b439749e86d860d02014dca96e154b3756..d19961f0b62173c661de3204f03fdcc603486e7b 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -283,15 +283,81 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -110,7 +110,7 @@ index f6d5bf3474dbf37095778cd8d774b58338d53877..a3f3015f9eba9a2eccbc3f1f64bca4c6 } diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index d47b21b5edc2734cdd45ed3282df98babe0045c0..3b5dd838bc8759bd849f5dd2ee0f260a65d17adb 100644 +index c525d8aed8f0671ad6cfef67cadaeb311a4d5e97..0cf1c9203addc602f3ed0cf7a3c439b98bc73e9b 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -1090,6 +1090,7 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0776-Remove-streams-for-villager-AI.patch b/patches/server/0777-Remove-streams-for-villager-AI.patch similarity index 100% rename from patches/server/0776-Remove-streams-for-villager-AI.patch rename to patches/server/0777-Remove-streams-for-villager-AI.patch diff --git a/patches/server/0777-Rewrite-dataconverter-system.patch b/patches/server/0778-Rewrite-dataconverter-system.patch similarity index 100% rename from patches/server/0777-Rewrite-dataconverter-system.patch rename to patches/server/0778-Rewrite-dataconverter-system.patch diff --git a/patches/server/0778-Use-Velocity-compression-and-cipher-natives.patch b/patches/server/0779-Use-Velocity-compression-and-cipher-natives.patch similarity index 100% rename from patches/server/0778-Use-Velocity-compression-and-cipher-natives.patch rename to patches/server/0779-Use-Velocity-compression-and-cipher-natives.patch diff --git a/patches/server/0779-Reduce-worldgen-thread-worker-count-for-low-core-cou.patch b/patches/server/0780-Reduce-worldgen-thread-worker-count-for-low-core-cou.patch similarity index 100% rename from patches/server/0779-Reduce-worldgen-thread-worker-count-for-low-core-cou.patch rename to patches/server/0780-Reduce-worldgen-thread-worker-count-for-low-core-cou.patch diff --git a/patches/server/0780-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch b/patches/server/0781-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch similarity index 97% rename from patches/server/0780-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch rename to patches/server/0781-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch index 73cf66a59..ddc57c0d3 100644 --- a/patches/server/0780-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch +++ b/patches/server/0781-Do-not-process-entity-loads-in-CraftChunk-getEntitie.patch @@ -16,7 +16,7 @@ of a chance that we're about to eat a dirtload of chunk load callbacks, thus making this issue much more of an issue diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java -index 4bf4d48fe7f511c4d41b030f0bfb6a198211a657..6f6956ceed3ec5ca3a41ebc36865d0a32c6f80f6 100644 +index d51833b1ad40ab234e2a2b2a61f093628ee1ea40..db344e5b9f96f317a232304587e6b1673fc6067d 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java @@ -128,46 +128,6 @@ public class CraftChunk implements Chunk { diff --git a/patches/server/0781-Async-catch-modifications-to-critical-entity-state.patch b/patches/server/0782-Async-catch-modifications-to-critical-entity-state.patch similarity index 100% rename from patches/server/0781-Async-catch-modifications-to-critical-entity-state.patch rename to patches/server/0782-Async-catch-modifications-to-critical-entity-state.patch diff --git a/patches/server/0782-Fix-Bukkit-NamespacedKey-shenanigans.patch b/patches/server/0783-Fix-Bukkit-NamespacedKey-shenanigans.patch similarity index 100% rename from patches/server/0782-Fix-Bukkit-NamespacedKey-shenanigans.patch rename to patches/server/0783-Fix-Bukkit-NamespacedKey-shenanigans.patch diff --git a/patches/server/0783-Fix-merchant-inventory-not-closing-on-entity-removal.patch b/patches/server/0784-Fix-merchant-inventory-not-closing-on-entity-removal.patch similarity index 93% rename from patches/server/0783-Fix-merchant-inventory-not-closing-on-entity-removal.patch rename to patches/server/0784-Fix-merchant-inventory-not-closing-on-entity-removal.patch index b586f3f4d..d50214bb2 100644 --- a/patches/server/0783-Fix-merchant-inventory-not-closing-on-entity-removal.patch +++ b/patches/server/0784-Fix-merchant-inventory-not-closing-on-entity-removal.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Fix merchant inventory not closing on entity removal diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java -index 3b5dd838bc8759bd849f5dd2ee0f260a65d17adb..53c3b1abc1acf0b847fa2e52b9941bd003971342 100644 +index 0cf1c9203addc602f3ed0cf7a3c439b98bc73e9b..f055d25394d20afb208e8612fb31d77af141876b 100644 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java @@ -2440,6 +2440,11 @@ public class ServerLevel extends Level implements WorldGenLevel { diff --git a/patches/server/0784-Check-requirement-before-suggesting-root-nodes.patch b/patches/server/0785-Check-requirement-before-suggesting-root-nodes.patch similarity index 100% rename from patches/server/0784-Check-requirement-before-suggesting-root-nodes.patch rename to patches/server/0785-Check-requirement-before-suggesting-root-nodes.patch diff --git a/patches/server/0785-Don-t-respond-to-ServerboundCommandSuggestionPacket-.patch b/patches/server/0786-Don-t-respond-to-ServerboundCommandSuggestionPacket-.patch similarity index 100% rename from patches/server/0785-Don-t-respond-to-ServerboundCommandSuggestionPacket-.patch rename to patches/server/0786-Don-t-respond-to-ServerboundCommandSuggestionPacket-.patch diff --git a/patches/server/0786-Fix-setPatternColor-on-tropical-fish-bucket-meta.patch b/patches/server/0787-Fix-setPatternColor-on-tropical-fish-bucket-meta.patch similarity index 100% rename from patches/server/0786-Fix-setPatternColor-on-tropical-fish-bucket-meta.patch rename to patches/server/0787-Fix-setPatternColor-on-tropical-fish-bucket-meta.patch diff --git a/patches/server/0787-Ensure-valid-vehicle-status.patch b/patches/server/0788-Ensure-valid-vehicle-status.patch similarity index 100% rename from patches/server/0787-Ensure-valid-vehicle-status.patch rename to patches/server/0788-Ensure-valid-vehicle-status.patch diff --git a/patches/server/0788-Prevent-softlocked-end-exit-portal-generation.patch b/patches/server/0789-Prevent-softlocked-end-exit-portal-generation.patch similarity index 100% rename from patches/server/0788-Prevent-softlocked-end-exit-portal-generation.patch rename to patches/server/0789-Prevent-softlocked-end-exit-portal-generation.patch diff --git a/patches/server/0789-Fix-CocaoDecorator-causing-a-crash-when-trying-to-ge.patch b/patches/server/0790-Fix-CocaoDecorator-causing-a-crash-when-trying-to-ge.patch similarity index 100% rename from patches/server/0789-Fix-CocaoDecorator-causing-a-crash-when-trying-to-ge.patch rename to patches/server/0790-Fix-CocaoDecorator-causing-a-crash-when-trying-to-ge.patch diff --git a/patches/server/0790-Don-t-log-debug-logging-being-disabled.patch b/patches/server/0791-Don-t-log-debug-logging-being-disabled.patch similarity index 100% rename from patches/server/0790-Don-t-log-debug-logging-being-disabled.patch rename to patches/server/0791-Don-t-log-debug-logging-being-disabled.patch diff --git a/patches/server/0791-Mark-fish-and-axolotls-from-buckets-as-persistent.patch b/patches/server/0792-Mark-fish-and-axolotls-from-buckets-as-persistent.patch similarity index 100% rename from patches/server/0791-Mark-fish-and-axolotls-from-buckets-as-persistent.patch rename to patches/server/0792-Mark-fish-and-axolotls-from-buckets-as-persistent.patch diff --git a/patches/server/0792-fix-various-menus-with-empty-level-accesses.patch b/patches/server/0793-fix-various-menus-with-empty-level-accesses.patch similarity index 100% rename from patches/server/0792-fix-various-menus-with-empty-level-accesses.patch rename to patches/server/0793-fix-various-menus-with-empty-level-accesses.patch diff --git a/patches/server/0793-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch b/patches/server/0794-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch similarity index 95% rename from patches/server/0793-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch rename to patches/server/0794-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch index 443f7b493..77f453411 100644 --- a/patches/server/0793-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch +++ b/patches/server/0794-Do-not-overload-I-O-threads-with-chunk-data-while-fl.patch @@ -12,7 +12,7 @@ time to save, as flush saving performs a full flush at the end anyways. diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index a3f3015f9eba9a2eccbc3f1f64bca4c66d52b9f2..7c4154b1b5ccc53af5f5fb186c2a5d1ff88c7af1 100644 +index d19961f0b62173c661de3204f03fdcc603486e7b..9a19263d6cfbcc7f0f94a6bc04a43f8200431e62 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -910,6 +910,16 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider diff --git a/patches/server/0794-Preserve-overstacked-loot.patch b/patches/server/0795-Preserve-overstacked-loot.patch similarity index 92% rename from patches/server/0794-Preserve-overstacked-loot.patch rename to patches/server/0795-Preserve-overstacked-loot.patch index b3b8f80f1..f25f684b1 100644 --- a/patches/server/0794-Preserve-overstacked-loot.patch +++ b/patches/server/0795-Preserve-overstacked-loot.patch @@ -10,10 +10,10 @@ chunk bans via the large amount of NBT created by unstacking the items. Fixes GH-5140 and GH-4748. diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index 4d85af9d021291e813daa3a44e8bae340fc568fb..dd3a0903f9a26986edca4d1d6a78d0404069e990 100644 +index 1dab732cf5614be864cf8abfbd6709545b9ff0c8..b20422f847d8f06d658950af8dcc95998bd5ac6c 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -868,6 +868,11 @@ public class PaperWorldConfig { +@@ -897,6 +897,11 @@ public class PaperWorldConfig { allowPlayerCrammingDamage = getBoolean("allow-player-cramming-damage", allowPlayerCrammingDamage); } @@ -22,8 +22,8 @@ index 4d85af9d021291e813daa3a44e8bae340fc568fb..dd3a0903f9a26986edca4d1d6a78d040 + splitOverstackedLoot = getBoolean("split-overstacked-loot", splitOverstackedLoot); + } + - private Table sensorTickRates; - private Table behaviorTickRates; + private com.google.common.collect.Table sensorTickRates; + private com.google.common.collect.Table behaviorTickRates; private void tickRates() { diff --git a/src/main/java/net/minecraft/world/level/storage/loot/LootTable.java b/src/main/java/net/minecraft/world/level/storage/loot/LootTable.java index 276c444a0fddb6962818635d5fc7721a56b30784..4f240fc74fb9551d752855dcdf2a376ff30f536b 100644 diff --git a/patches/server/0795-Update-head-rotation-in-missing-places.patch b/patches/server/0796-Update-head-rotation-in-missing-places.patch similarity index 100% rename from patches/server/0795-Update-head-rotation-in-missing-places.patch rename to patches/server/0796-Update-head-rotation-in-missing-places.patch diff --git a/patches/server/0796-prevent-unintended-light-block-manipulation.patch b/patches/server/0797-prevent-unintended-light-block-manipulation.patch similarity index 100% rename from patches/server/0796-prevent-unintended-light-block-manipulation.patch rename to patches/server/0797-prevent-unintended-light-block-manipulation.patch diff --git a/patches/server/0797-Dont-count-named-piglins-and-hoglins-towards-mob-cap.patch b/patches/server/0798-Dont-count-named-piglins-and-hoglins-towards-mob-cap.patch similarity index 100% rename from patches/server/0797-Dont-count-named-piglins-and-hoglins-towards-mob-cap.patch rename to patches/server/0798-Dont-count-named-piglins-and-hoglins-towards-mob-cap.patch diff --git a/patches/server/0798-Fix-CraftCriteria-defaults-map.patch b/patches/server/0799-Fix-CraftCriteria-defaults-map.patch similarity index 100% rename from patches/server/0798-Fix-CraftCriteria-defaults-map.patch rename to patches/server/0799-Fix-CraftCriteria-defaults-map.patch diff --git a/patches/server/0799-Fix-upstreams-block-state-factories.patch b/patches/server/0800-Fix-upstreams-block-state-factories.patch similarity index 100% rename from patches/server/0799-Fix-upstreams-block-state-factories.patch rename to patches/server/0800-Fix-upstreams-block-state-factories.patch diff --git a/patches/server/0800-Add-config-option-for-logging-player-ip-addresses.patch b/patches/server/0801-Add-config-option-for-logging-player-ip-addresses.patch similarity index 98% rename from patches/server/0800-Add-config-option-for-logging-player-ip-addresses.patch rename to patches/server/0801-Add-config-option-for-logging-player-ip-addresses.patch index 0048c1a38..fdf4ff8ea 100644 --- a/patches/server/0800-Add-config-option-for-logging-player-ip-addresses.patch +++ b/patches/server/0801-Add-config-option-for-logging-player-ip-addresses.patch @@ -81,7 +81,7 @@ index d2dd8b802ecea7fd2efe5f07fcef65c26e1adfbc..33a29890435d6065a2cc4f8e8bf8209c @Override diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java -index 92a3df6d2435d8800a8173e7be3ba11577f23b5a..24111c47145b296c442982affdbfe045c52386e1 100644 +index 8a74c1aa2add393f4706a7f943f0fd5d9f5175e1..40d55cade76d0e8f39f91a322bc8a821877efa2c 100644 --- a/src/main/java/net/minecraft/server/players/PlayerList.java +++ b/src/main/java/net/minecraft/server/players/PlayerList.java @@ -237,7 +237,7 @@ public abstract class PlayerList { diff --git a/patches/server/0801-Configurable-feature-seeds.patch b/patches/server/0802-Configurable-feature-seeds.patch similarity index 97% rename from patches/server/0801-Configurable-feature-seeds.patch rename to patches/server/0802-Configurable-feature-seeds.patch index 5384fb04f..d23c9aca5 100644 --- a/patches/server/0801-Configurable-feature-seeds.patch +++ b/patches/server/0802-Configurable-feature-seeds.patch @@ -19,10 +19,10 @@ index ee53453440177537fc653ea156785d7591498614..5e3b7fb2e0b7608610555cd23e7ad25a } final Object val = config.get(key); diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -index dd3a0903f9a26986edca4d1d6a78d0404069e990..82a6b481c745cc6f70e2afa922b6c362161069fa 100644 +index b20422f847d8f06d658950af8dcc95998bd5ac6c..b64fbce003c00a6371a849d4835632c18ad730bb 100644 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java -@@ -913,6 +913,55 @@ public class PaperWorldConfig { +@@ -942,6 +942,55 @@ public class PaperWorldConfig { return table; } diff --git a/patches/server/0802-VanillaCommandWrapper-didnt-account-for-entity-sende.patch b/patches/server/0803-VanillaCommandWrapper-didnt-account-for-entity-sende.patch similarity index 100% rename from patches/server/0802-VanillaCommandWrapper-didnt-account-for-entity-sende.patch rename to patches/server/0803-VanillaCommandWrapper-didnt-account-for-entity-sende.patch diff --git a/patches/server/0803-Add-root-admin-user-detection.patch b/patches/server/0804-Add-root-admin-user-detection.patch similarity index 100% rename from patches/server/0803-Add-root-admin-user-detection.patch rename to patches/server/0804-Add-root-admin-user-detection.patch diff --git a/patches/server/0804-Always-allow-item-changing-in-Fireball.patch b/patches/server/0805-Always-allow-item-changing-in-Fireball.patch similarity index 100% rename from patches/server/0804-Always-allow-item-changing-in-Fireball.patch rename to patches/server/0805-Always-allow-item-changing-in-Fireball.patch diff --git a/patches/server/0805-don-t-attempt-to-teleport-dead-entities.patch b/patches/server/0806-don-t-attempt-to-teleport-dead-entities.patch similarity index 100% rename from patches/server/0805-don-t-attempt-to-teleport-dead-entities.patch rename to patches/server/0806-don-t-attempt-to-teleport-dead-entities.patch diff --git a/patches/server/0806-Call-onRemove-logic-for-breakNaturally.patch b/patches/server/0807-Call-onRemove-logic-for-breakNaturally.patch similarity index 100% rename from patches/server/0806-Call-onRemove-logic-for-breakNaturally.patch rename to patches/server/0807-Call-onRemove-logic-for-breakNaturally.patch diff --git a/patches/server/0807-Fix-anvil-prepare-event-not-working-with-zero-xp.patch b/patches/server/0808-Fix-anvil-prepare-event-not-working-with-zero-xp.patch similarity index 100% rename from patches/server/0807-Fix-anvil-prepare-event-not-working-with-zero-xp.patch rename to patches/server/0808-Fix-anvil-prepare-event-not-working-with-zero-xp.patch diff --git a/patches/server/0808-Prevent-excessive-velocity-through-repeated-crits.patch b/patches/server/0809-Prevent-excessive-velocity-through-repeated-crits.patch similarity index 100% rename from patches/server/0808-Prevent-excessive-velocity-through-repeated-crits.patch rename to patches/server/0809-Prevent-excessive-velocity-through-repeated-crits.patch diff --git a/patches/server/0809-Remove-client-side-code-using-deprecated-for-removal.patch b/patches/server/0810-Remove-client-side-code-using-deprecated-for-removal.patch similarity index 100% rename from patches/server/0809-Remove-client-side-code-using-deprecated-for-removal.patch rename to patches/server/0810-Remove-client-side-code-using-deprecated-for-removal.patch diff --git a/patches/server/0810-Rewrite-the-light-engine.patch b/patches/server/0811-Rewrite-the-light-engine.patch similarity index 99% rename from patches/server/0810-Rewrite-the-light-engine.patch rename to patches/server/0811-Rewrite-the-light-engine.patch index 1963b2174..71cbac333 100644 --- a/patches/server/0810-Rewrite-the-light-engine.patch +++ b/patches/server/0811-Rewrite-the-light-engine.patch @@ -4418,7 +4418,7 @@ index 7f663523b8c43b356763d6d5249e1aec416de37c..873a9767687ee78a852e2392d12bafa2 private final DebugBuffer chunkToSaveHistory; public int oldTicketLevel; diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java -index 8f5e443c49ce2dd1319d3fcb2dee1f6104c367fb..dad9553cd47731cffbf0a10865e54f584ad794c7 100644 +index 9a19263d6cfbcc7f0f94a6bc04a43f8200431e62..42b4292152d4b17c49c9cc1f488abf892a4883a5 100644 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java @@ -130,7 +130,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider @@ -4797,7 +4797,7 @@ index ce4848bdd00c091b9eb5fa2d47b03378d43c91b2..1831588b275f11aff37573fead835f6d } diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java -index 5093e34dddbea0f0d5c26f25c257b85bdf841a47..f932cd79e58e472e76aaf36382494c2ad3206311 100644 +index e3a92021b32aa74a37287504e0e539af5ec8216f..57f13937c3ed47c0764ac5292c58d4dc1ce93780 100644 --- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java +++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java @@ -81,6 +81,47 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom @@ -4945,13 +4945,13 @@ index 7c5b3acd299c5b021bd20f17ff0b89c8208a6623..d29739c3a67e60741a06fb25bcaf7705 super(wrapped.getPos(), UpgradeData.EMPTY, wrapped.levelHeightAccessor, wrapped.getLevel().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), wrapped.getBlendingData()); this.wrapped = wrapped; 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 b64272b8353cceb2489bc33e36585155347b7d58..86875d7593598850ab08003820895771e1ba2e2b 100644 +index c9cd9121e0ca7402c812e803ffd417c1887a4823..f310678e18a7bb217cb5760a1af1c5a8a1f7e8cd 100644 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java @@ -100,6 +100,10 @@ public class LevelChunk extends ChunkAccess { public LevelChunk(Level world, ChunkPos pos, UpgradeData upgradeData, LevelChunkTicks blockTickScheduler, LevelChunkTicks fluidTickScheduler, long inhabitedTime, @Nullable LevelChunkSection[] sectionArrayInitializer, @Nullable LevelChunk.PostLoadProcessor entityLoader, @Nullable BlendingData blendingData) { - super(pos, upgradeData, world, world.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), inhabitedTime, sectionArrayInitializer, blendingData); + super(pos, upgradeData, world, net.minecraft.server.MinecraftServer.getServer().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), inhabitedTime, sectionArrayInitializer, blendingData); // Paper - Anti-Xray - The world isnt ready yet, use server singleton for registry + // Paper start - rewrite light engine + this.setBlockNibbles(ca.spottedleaf.starlight.common.light.StarLightEngine.getFilledEmptyLight(world)); + this.setSkyNibbles(ca.spottedleaf.starlight.common.light.StarLightEngine.getFilledEmptyLight(world)); @@ -4973,10 +4973,10 @@ index b64272b8353cceb2489bc33e36585155347b7d58..86875d7593598850ab08003820895771 while (iterator.hasNext()) { diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -index a7048235cdbca6970590d50c959782069169b4fa..6eebd1a7675bac3406536e80301fadf19a61cc1e 100644 +index d850cae1ec024a557e62cd561fbca137dc2be96c..eef1b58cfaf3cfa90f3786785dd94d050dfdd4c2 100644 --- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java -@@ -127,7 +127,7 @@ public class PalettedContainer implements PaletteResize { +@@ -186,7 +186,7 @@ public class PalettedContainer implements PaletteResize { return this.get(this.strategy.getIndex(x, y, z)); } @@ -5003,7 +5003,7 @@ index 568dc3c9cbf009a3892766cacdd00667556e27c5..e7676e86c08affa8e730c13f11d4b269 this.fluidTicks = fluidTickScheduler; } diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java -index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686db684fdb 100644 +index cf042295fe250d74c67a04f8f0d2b233860d4d1d..e54376b463b017d5e371f8d3204a37993b0e78e7 100644 --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java @@ -79,6 +79,14 @@ public class ChunkSerializer { @@ -5052,7 +5052,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 byte b0 = nbttagcompound1.getByte("Y"); int k = world.getSectionIndexFromSectionY(b0); -@@ -199,23 +214,29 @@ public class ChunkSerializer { +@@ -203,23 +218,29 @@ public class ChunkSerializer { } if (flag) { @@ -5096,7 +5096,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 } } -@@ -244,6 +265,8 @@ public class ChunkSerializer { +@@ -248,6 +269,8 @@ public class ChunkSerializer { }, chunkPos); object = new LevelChunk(world.getLevel(), chunkPos, chunkconverter, levelchunkticks, levelchunkticks1, l, achunksection, ChunkSerializer.postLoadChunk(world, nbt), blendingdata); @@ -5105,7 +5105,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 } else { ProtoChunkTicks protochunkticklist = ProtoChunkTicks.load(nbt.getList("block_ticks", 10), (s) -> { return Registry.BLOCK.getOptional(ResourceLocation.tryParse(s)); -@@ -252,6 +275,8 @@ public class ChunkSerializer { +@@ -256,6 +279,8 @@ public class ChunkSerializer { return Registry.FLUID.getOptional(ResourceLocation.tryParse(s)); }, chunkPos); ProtoChunk protochunk = new ProtoChunk(chunkPos, chunkconverter, achunksection, protochunkticklist, protochunkticklist1, world, iregistry, blendingdata); @@ -5114,7 +5114,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 object = protochunk; protochunk.setInhabitedTime(l); -@@ -397,7 +422,7 @@ public class ChunkSerializer { +@@ -401,7 +426,7 @@ public class ChunkSerializer { DataLayer[] blockLight = new DataLayer[lightenginethreaded.getMaxLightSection() - lightenginethreaded.getMinLightSection()]; DataLayer[] skyLight = new DataLayer[lightenginethreaded.getMaxLightSection() - lightenginethreaded.getMinLightSection()]; @@ -5123,7 +5123,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 DataLayer blockArray = lightenginethreaded.getLayerListener(LightLayer.BLOCK).getDataLayerData(SectionPos.of(chunkPos, i)); DataLayer skyArray = lightenginethreaded.getLayerListener(LightLayer.SKY).getDataLayerData(SectionPos.of(chunkPos, i)); -@@ -449,6 +474,12 @@ public class ChunkSerializer { +@@ -453,6 +478,12 @@ public class ChunkSerializer { } public static CompoundTag saveChunk(ServerLevel world, ChunkAccess chunk, @org.checkerframework.checker.nullness.qual.Nullable AsyncSaveData asyncsavedata) { // Paper end @@ -5136,7 +5136,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 ChunkPos chunkcoordintpair = chunk.getPos(); CompoundTag nbttagcompound = new CompoundTag(); -@@ -499,20 +530,14 @@ public class ChunkSerializer { +@@ -503,20 +534,14 @@ public class ChunkSerializer { for (int i = lightenginethreaded.getMinLightSection(); i < lightenginethreaded.getMaxLightSection(); ++i) { int j = chunk.getSectionIndexFromSectionY(i); boolean flag1 = j >= 0 && j < achunksection.length; @@ -5164,7 +5164,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 if (flag1) { LevelChunkSection chunksection = achunksection[j]; -@@ -527,13 +552,27 @@ public class ChunkSerializer { +@@ -531,13 +556,27 @@ public class ChunkSerializer { nbttagcompound1.put("biomes", (Tag) dataresult1.getOrThrow(false, logger1::error)); } @@ -5196,7 +5196,7 @@ index 859e23a182e97afa179419973485208bb0aa84ca..d81a2e74cadccebeb5242b34f4550686 if (!nbttagcompound1.isEmpty()) { nbttagcompound1.putByte("Y", (byte) i); -@@ -544,7 +583,8 @@ public class ChunkSerializer { +@@ -548,7 +587,8 @@ public class ChunkSerializer { nbttagcompound.put("sections", nbttaglist); if (flag) {