more patches

patches/server/Add-EntityInsideBlockEvent.patch

@@ -28,6 +28,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!world.isClientSide) {
              int i = this.getSignalForState(state);
  
+diff --git a/src/main/java/net/minecraft/world/level/block/BigDripleafBlock.java b/src/main/java/net/minecraft/world/level/block/BigDripleafBlock.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/block/BigDripleafBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/BigDripleafBlock.java
+@@ -0,0 +0,0 @@ public class BigDripleafBlock extends HorizontalDirectionalBlock implements Bone
+ 
+     @Override
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!world.isClientSide) {
+             if (state.getValue(BigDripleafBlock.TILT) == Tilt.NONE && BigDripleafBlock.canEntityTilt(pos, entity) && !world.hasNeighborSignal(pos)) {
+                 // CraftBukkit start - tilt dripleaf
 diff --git a/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java b/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/BubbleColumnBlock.java
@@ -110,7 +122,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
          if (world instanceof ServerLevel && !entity.isPassenger() && !entity.isVehicle() && entity.canChangeDimensions() && Shapes.joinIsNotEmpty(Shapes.create(entity.getBoundingBox().move((double) (-pos.getX()), (double) (-pos.getY()), (double) (-pos.getZ()))), state.getShape(world, pos), BooleanOp.AND)) {
-             ResourceKey<Level> resourcekey = world.getTypeKey() == DimensionType.END_LOCATION ? Level.OVERWORLD : Level.END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
+             ResourceKey<Level> resourcekey = world.getTypeKey() == LevelStem.END ? Level.OVERWORLD : Level.END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
              ServerLevel worldserver = ((ServerLevel) world).getServer().getLevel(resourcekey);
 diff --git a/src/main/java/net/minecraft/world/level/block/HoneyBlock.java b/src/main/java/net/minecraft/world/level/block/HoneyBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Add-cause-to-Weather-ThunderChangeEvents.patch

@@ -32,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.oThunderLevel = this.thunderLevel;
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
  
-     private void stopWeather() {
+     private void resetWeatherCycle() {
          // CraftBukkit start
 -        this.serverLevelData.setRaining(false);
 +        this.serverLevelData.setRaining(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - when passing the night
@@ -58,29 +58,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start
 +        this.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.UNKNOWN);
 +    }
-+    public void setThundering(boolean flag, org.bukkit.event.weather.ThunderChangeEvent.Cause cause) {
++    public void setThundering(boolean thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause cause) {
 +        // Paper end
          // CraftBukkit start
--        if (this.thundering == thundering) {
-+        if (this.thundering == flag) {
+         if (this.thundering == thundering) {
              return;
-         }
+@@ -0,0 +0,0 @@ public class PrimaryLevelData implements ServerLevelData, WorldData {
  
          org.bukkit.World world = Bukkit.getWorld(this.getLevelName());
          if (world != null) {
 -            ThunderChangeEvent thunder = new ThunderChangeEvent(world, thundering);
-+            ThunderChangeEvent thunder = new ThunderChangeEvent(world, flag, cause); // Paper
++            ThunderChangeEvent thunder = new ThunderChangeEvent(world, thundering, cause); // Paper
              Bukkit.getServer().getPluginManager().callEvent(thunder);
              if (thunder.isCancelled()) {
                  return;
-             }
-         }
-         // CraftBukkit end
--        this.thundering = thundering;
-+        this.thundering = flag;
-     }
- 
-     @Override
 @@ -0,0 +0,0 @@ public class PrimaryLevelData implements ServerLevelData, WorldData {
  
      @Override

patches/server/Fix-and-optimise-world-force-upgrading.patch

@@ -37,15 +37,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package io.papermc.paper.world;
 +
 +import com.mojang.datafixers.DataFixer;
++import com.mojang.serialization.Codec;
 +import net.minecraft.SharedConstants;
 +import net.minecraft.nbt.CompoundTag;
 +import net.minecraft.resources.ResourceKey;
 +import net.minecraft.util.worldupdate.WorldUpgrader;
 +import net.minecraft.world.level.ChunkPos;
++import net.minecraft.world.level.Level;
++import net.minecraft.world.level.chunk.ChunkGenerator;
 +import net.minecraft.world.level.chunk.storage.ChunkStorage;
 +import net.minecraft.world.level.chunk.storage.RegionFileStorage;
 +import net.minecraft.world.level.dimension.DimensionType;
 +import net.minecraft.world.level.dimension.LevelStem;
++import net.minecraft.world.level.levelgen.WorldGenSettings;
 +import net.minecraft.world.level.storage.DimensionDataStorage;
 +import net.minecraft.world.level.storage.LevelStorageSource;
 +import org.apache.logging.log4j.LogManager;
@@ -53,6 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import java.io.File;
 +import java.io.IOException;
 +import java.text.DecimalFormat;
++import java.util.Optional;
 +import java.util.concurrent.ExecutorService;
 +import java.util.concurrent.Executors;
 +import java.util.concurrent.ThreadFactory;
@@ -70,10 +75,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final File worldDir;
 +    private final ExecutorService threadPool;
 +    private final DataFixer dataFixer;
++    private final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey;
 +    private final boolean removeCaches;
 +
 +    public ThreadedWorldUpgrader(final ResourceKey<LevelStem> dimensionType, final ResourceKey<DimensionType> worldKey, final String worldName, final File worldDir, final int threads,
-+                                 final DataFixer dataFixer, final boolean removeCaches) {
++                                 final DataFixer dataFixer, final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey, final boolean removeCaches) {
 +        this.dimensionType = dimensionType;
 +        this.worldKey = worldKey;
 +        this.worldName = worldName;
@@ -94,11 +100,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +        });
 +        this.dataFixer = dataFixer;
++        this.generatorKey = generatorKey;
 +        this.removeCaches = removeCaches;
 +    }
 +
 +    public void convert() {
-+        final File worldFolder = LevelStorageSource.getFolder(this.worldDir, this.dimensionType);
++        final File worldFolder = LevelStorageSource.getStorageFolder(this.worldDir.toPath(), this.dimensionType).toFile();
 +        final DimensionDataStorage worldPersistentData = new DimensionDataStorage(new File(worldFolder, "data"), this.dataFixer);
 +
 +        final File regionFolder = new File(worldFolder, "region");
@@ -116,12 +123,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        LOGGER.info("Starting conversion now for world " + this.worldName);
 +
 +        final WorldInfo info = new WorldInfo(() -> worldPersistentData,
-+                new ChunkStorage(regionFolder, this.dataFixer, false), this.removeCaches, this.worldKey);
++                new ChunkStorage(regionFolder.toPath(), this.dataFixer, false), this.removeCaches, this.dimensionType, this.generatorKey);
 +
 +        long expectedChunks = (long)regionFiles.length * (32L * 32L);
 +
 +        for (final File regionFile : regionFiles) {
-+            final ChunkPos regionPos = RegionFileStorage.getRegionFileCoordinates(regionFile);
++            final ChunkPos regionPos = RegionFileStorage.getRegionFileCoordinates(regionFile.toPath());
 +            if (regionPos == null) {
 +                expectedChunks -= (32L * 32L);
 +                continue;
@@ -161,16 +168,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        public final Supplier<DimensionDataStorage> persistentDataSupplier;
 +        public final ChunkStorage loader;
 +        public final boolean removeCaches;
-+        public final ResourceKey<DimensionType> worldKey;
++        public final ResourceKey<LevelStem> worldKey;
++        public final Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey;
 +        public final AtomicLong convertedChunks = new AtomicLong();
 +        public final AtomicLong modifiedChunks = new AtomicLong();
 +
 +        private WorldInfo(final Supplier<DimensionDataStorage> persistentDataSupplier, final ChunkStorage loader, final boolean removeCaches,
-+                          final ResourceKey<DimensionType> worldKey) {
++                          final ResourceKey<LevelStem> worldKey, Optional<ResourceKey<Codec<? extends ChunkGenerator>>> generatorKey) {
 +            this.persistentDataSupplier = persistentDataSupplier;
 +            this.loader = loader;
 +            this.removeCaches = removeCaches;
 +            this.worldKey = worldKey;
++            this.generatorKey = generatorKey;
 +        }
 +    }
 +
@@ -194,7 +203,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            final Supplier<DimensionDataStorage> persistentDataSupplier = this.worldInfo.persistentDataSupplier;
 +            final ChunkStorage loader = this.worldInfo.loader;
 +            final boolean removeCaches = this.worldInfo.removeCaches;
-+            final ResourceKey<DimensionType> worldKey = this.worldInfo.worldKey;
++            final ResourceKey<LevelStem> worldKey = this.worldInfo.worldKey;
 +
 +            for (int cz = regionCZ; cz < (regionCZ + 32); ++cz) {
 +                for (int cx = regionCX; cx < (regionCX + 32); ++cx) {
@@ -210,7 +219,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +                        final int versionBefore = ChunkStorage.getVersion(chunkNBT);
 +
-+                        chunkNBT = loader.getChunkData(worldKey, persistentDataSupplier, chunkNBT, chunkPos, null);
++                        chunkNBT = loader.upgradeChunkTag(worldKey, persistentDataSupplier, chunkNBT, this.worldInfo.generatorKey, chunkPos, null);
 +
 +                        boolean modified = versionBefore < SharedConstants.getCurrentVersion().getWorldVersion();
 +
@@ -253,17 +262,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // Paper end
  
 +    // Paper start - fix and optimise world upgrading
-+    public static void convertWorldButItWorks(ResourceKey<LevelStem> dimensionType, ResourceKey<DimensionType> worldKey, net.minecraft.world.level.storage.LevelStorageSource.LevelStorageAccess worldSession,
-+                                              DataFixer dataFixer, boolean removeCaches) {
++    public static void convertWorldButItWorks(net.minecraft.resources.ResourceKey<net.minecraft.world.level.dimension.LevelStem> dimensionType, net.minecraft.resources.ResourceKey<net.minecraft.world.level.dimension.DimensionType> worldKey, net.minecraft.world.level.storage.LevelStorageSource.LevelStorageAccess worldSession,
++                                              DataFixer dataFixer, Optional<net.minecraft.resources.ResourceKey<com.mojang.serialization.Codec<? extends net.minecraft.world.level.chunk.ChunkGenerator>>> generatorKey, boolean removeCaches) {
 +        int threads = Runtime.getRuntime().availableProcessors() * 3 / 8;
-+        final ThreadedWorldUpgrader worldUpgrader = new ThreadedWorldUpgrader(dimensionType, worldKey, worldSession.getLevelId(), worldSession.levelPath.toFile(), threads, dataFixer, removeCaches);
++        final ThreadedWorldUpgrader worldUpgrader = new ThreadedWorldUpgrader(dimensionType, worldKey, worldSession.getLevelId(), worldSession.levelPath.toFile(), threads, dataFixer, generatorKey, removeCaches);
 +        worldUpgrader.convert();
 +    }
 +    // Paper end - fix and optimise world upgrading
 +
-     public static void forceUpgrade(LevelStorageSource.LevelStorageAccess session, DataFixer dataFixer, boolean eraseCache, BooleanSupplier booleansupplier, ImmutableSet<ResourceKey<DimensionType>> worlds) { // CraftBukkit
+     public static void forceUpgrade(LevelStorageSource.LevelStorageAccess session, DataFixer dataFixer, boolean eraseCache, BooleanSupplier continueCheck, WorldGenSettings generatorOptions) {
          Main.LOGGER.info("Forcing world upgrade! {}", session.getLevelId()); // CraftBukkit
-         WorldUpgrader worldupgrader = new WorldUpgrader(session, dataFixer, worlds, eraseCache);
+         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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -275,9 +284,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            if (this.options.has("forceUpgrade")) {
 -                net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), this.options.has("eraseCache"), () -> {
 -                    return true;
--                }, worlddata.worldGenSettings().dimensions().entrySet().stream().map((entry1) -> {
--                    return ResourceKey.create(Registry.DIMENSION_TYPE_REGISTRY, ((ResourceKey) entry1.getKey()).location());
--                }).collect(ImmutableSet.toImmutableSet()));
+-                }, worlddata.worldGenSettings());
 -            }
 +            // Paper - move down
  
@@ -290,7 +297,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper start - fix and optimise world upgrading
 +            if (options.has("forceUpgrade")) {
 +                net.minecraft.server.Main.convertWorldButItWorks(
-+                        dimensionKey, Level.getDimensionKey(dimensionmanager), worldSession, DataFixers.getDataFixer(), options.has("eraseCache")
++                        dimensionKey, Level.getDimensionKey(dimensionmanager), worldSession, DataFixers.getDataFixer(), chunkgenerator.getTypeNameForDataFixer(), options.has("eraseCache")
 +                );
 +            }
 +            // Paper end - fix and optimise world upgrading
@@ -326,8 +333,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      // Paper start
-+    public static ChunkPos getRegionFileCoordinates(File file) {
-+        String fileName = file.getName();
++    public static @Nullable ChunkPos getRegionFileCoordinates(Path file) {
++        String fileName = file.getFileName().toString();
 +        if (!fileName.startsWith("r.") || !fileName.endsWith(".mca")) {
 +            return null;
 +        }
@@ -358,14 +365,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
          }
          worlddata.checkName(name);
-         worlddata.setModdedInfo(this.console.getServerModName(), this.console.getModdedStatus().isPresent());
+         worlddata.setModdedInfo(this.console.getServerModName(), this.console.getModdedStatus().shouldReportAsModified());
 -
 -        if (console.options.has("forceUpgrade")) {
 -            net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), console.options.has("eraseCache"), () -> {
 -                return true;
--            }, worlddata.worldGenSettings().dimensions().entrySet().stream().map((entry) -> {
--                return ResourceKey.create(Registry.DIMENSION_TYPE_REGISTRY, ((ResourceKey) entry.getKey()).location());
--            }).collect(ImmutableSet.toImmutableSet()));
+-            }, worlddata.worldGenSettings());
 -        }
 +        // Paper - move down
  
@@ -378,7 +383,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start - fix and optimise world upgrading
 +        if (console.options.has("forceUpgrade")) {
 +            net.minecraft.server.Main.convertWorldButItWorks(
-+                actualDimension, net.minecraft.world.level.Level.getDimensionKey(dimensionmanager), worldSession, DataFixers.getDataFixer(), console.options.has("eraseCache")
++                actualDimension, net.minecraft.world.level.Level.getDimensionKey(dimensionmanager), worldSession, DataFixers.getDataFixer(), chunkgenerator.getTypeNameForDataFixer(), console.options.has("eraseCache")
 +            );
 +        }
 +        // Paper end - fix and optimise world upgrading

patches/server/Limit-item-frame-cursors-on-maps.patch

@@ -18,7 +18,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit);
 +    }
  }
- 
 diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java

patches/server/additions-to-PlayerGameModeChangeEvent.patch

@@ -55,11 +55,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if (!this.gameMode.changeGameModeForPlayer(gameMode)) {
 -            return false;
 +        // Paper start - Add cause and nullable message to event
-+        PlayerGameModeChangeEvent event = this.setGameMode(gameMode, org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.UNKNOWN, null);
++        org.bukkit.event.player.PlayerGameModeChangeEvent event = this.setGameMode(gameMode, org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.UNKNOWN, null);
 +        return event == null ? false : event.isCancelled();
 +    }
-+    public PlayerGameModeChangeEvent setGameMode(GameType gameMode, PlayerGameModeChangeEvent.Cause cause, net.kyori.adventure.text.Component message) {
-+        PlayerGameModeChangeEvent event = this.gameMode.changeGameModeForPlayer(gameMode, cause, message);
++    public org.bukkit.event.player.PlayerGameModeChangeEvent setGameMode(GameType gameMode, org.bukkit.event.player.PlayerGameModeChangeEvent.Cause cause, net.kyori.adventure.text.Component message) {
++        org.bukkit.event.player.PlayerGameModeChangeEvent event = this.gameMode.changeGameModeForPlayer(gameMode, cause, message);
 +        if (event == null || event.isCancelled()) {
 +            // Paper end
 +            return null;
@@ -81,7 +81,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void loadGameTypes(@Nullable CompoundTag nbt) {
 +        // Paper start
 +        if (this.server.getForcedGameType() != null && this.server.getForcedGameType() != ServerPlayer.readPlayerMode(nbt, "playerGameType")) {
-+            if (new PlayerGameModeChangeEvent(this.getBukkitEntity(), GameMode.getByValue(this.server.getDefaultGameType().getId()), org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.DEFAULT_GAMEMODE, null).callEvent()) {
++            if (new org.bukkit.event.player.PlayerGameModeChangeEvent(this.getBukkitEntity(), org.bukkit.GameMode.getByValue(this.server.getDefaultGameType().getId()), org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.DEFAULT_GAMEMODE, null).callEvent()) {
 +                this.gameMode.setGameModeForPlayer(this.server.getForcedGameType(), GameType.DEFAULT_MODE);
 +            } else {
 +                this.gameMode.setGameModeForPlayer(ServerPlayer.readPlayerMode(nbt,"playerGameType"), ServerPlayer.readPlayerMode(nbt, "previousPlayerGameType"));