Repackage patches

By: md_5 <git@md-5.net>

paper-server/nms-patches/net/minecraft/world/level/storage/Convertable.patch

@@ -0,0 +1,79 @@
+--- a/net/minecraft/server/Convertable.java
++++ b/net/minecraft/server/Convertable.java
+@@ -73,21 +73,21 @@
+             Logger logger1 = Convertable.LOGGER;
+ 
+             logger1.getClass();
+-            IRegistry<DimensionManager> iregistry = (IRegistry) dataresult1.resultOrPartial(SystemUtils.a("Dimension type registry: ", logger1::error)).orElseThrow(() -> {
++            IRegistry<DimensionManager> iregistry = (IRegistry) ((DataResult<IRegistry<DimensionManager>>) dataresult1).resultOrPartial(SystemUtils.a("Dimension type registry: ", logger1::error)).orElseThrow(() -> { // CraftBukkit - decompile error
+                 return new IllegalStateException("Failed to get dimension registry");
+             });
+ 
+             dataresult1 = RegistryLookupCodec.a(IRegistry.ay).codec().parse(dynamic2);
+             logger1 = Convertable.LOGGER;
+             logger1.getClass();
+-            IRegistry<BiomeBase> iregistry1 = (IRegistry) dataresult1.resultOrPartial(SystemUtils.a("Biome registry: ", logger1::error)).orElseThrow(() -> {
++            IRegistry<BiomeBase> iregistry1 = (IRegistry) ((DataResult<IRegistry<BiomeBase>>) dataresult1).resultOrPartial(SystemUtils.a("Biome registry: ", logger1::error)).orElseThrow(() -> { // CraftBukkit - decompile error
+                 return new IllegalStateException("Failed to get biome registry");
+             });
+ 
+             dataresult1 = RegistryLookupCodec.a(IRegistry.ar).codec().parse(dynamic2);
+             logger1 = Convertable.LOGGER;
+             logger1.getClass();
+-            IRegistry<GeneratorSettingBase> iregistry2 = (IRegistry) dataresult1.resultOrPartial(SystemUtils.a("Noise settings registry: ", logger1::error)).orElseThrow(() -> {
++            IRegistry<GeneratorSettingBase> iregistry2 = (IRegistry) ((DataResult<IRegistry<GeneratorSettingBase>>) dataresult1).resultOrPartial(SystemUtils.a("Noise settings registry: ", logger1::error)).orElseThrow(() -> { // CraftBukkit - decompile error
+                 return new IllegalStateException("Failed to get noise settings registry");
+             });
+ 
+@@ -195,8 +195,10 @@
+         };
+     }
+ 
+-    public Convertable.ConversionSession c(String s) throws IOException {
+-        return new Convertable.ConversionSession(s);
++    // CraftBukkit start
++    public Convertable.ConversionSession c(String s, ResourceKey<WorldDimension> dimensionType) throws IOException {
++        return new Convertable.ConversionSession(s, dimensionType);
++        // CraftBukkit end
+     }
+ 
+     public class ConversionSession implements AutoCloseable {
+@@ -205,8 +207,12 @@
+         public final java.nio.file.Path folder;
+         private final String levelName;
+         private final Map<SavedFile, java.nio.file.Path> e = Maps.newHashMap();
++        // CraftBukkit start
++        private final ResourceKey<WorldDimension> dimensionType;
+ 
+-        public ConversionSession(String s) throws IOException {
++        public ConversionSession(String s, ResourceKey<WorldDimension> dimensionType) throws IOException {
++            this.dimensionType = dimensionType;
++            // CraftBukkit end
+             this.levelName = s;
+             this.folder = Convertable.this.universe.resolve(s);
+             this.lock = SessionLock.a(this.folder);
+@@ -223,9 +229,23 @@
+         }
+ 
+         public File a(ResourceKey<World> resourcekey) {
+-            return DimensionManager.a(resourcekey, this.folder.toFile());
++            // CraftBukkit start
++            return this.getFolder(this.folder.toFile());
+         }
+ 
++        private File getFolder(File file) {
++            if (dimensionType == WorldDimension.OVERWORLD) {
++                return file;
++            } else if (dimensionType == WorldDimension.THE_NETHER) {
++                return new File(file, "DIM-1");
++            } else if (dimensionType == WorldDimension.THE_END) {
++                return new File(file, "DIM1");
++            } else {
++                throw new IllegalArgumentException("Unknwon dimension " + this.dimensionType);
++            }
++        }
++        // CraftBukkit end
++
+         private void checkSession() {
+             if (!this.lock.a()) {
+                 throw new IllegalStateException("Lock is no longer valid");

paper-server/nms-patches/net/minecraft/world/level/storage/WorldDataServer.patch

@@ -0,0 +1,123 @@
+--- a/net/minecraft/server/WorldDataServer.java
++++ b/net/minecraft/server/WorldDataServer.java
+@@ -14,10 +14,16 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++// CraftBukkit start
++import org.bukkit.Bukkit;
++import org.bukkit.event.weather.ThunderChangeEvent;
++import org.bukkit.event.weather.WeatherChangeEvent;
++// CraftBukkit end
++
+ public class WorldDataServer implements IWorldDataServer, SaveData {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+-    private WorldSettings b;
++    public WorldSettings b;
+     private final GeneratorSettings c;
+     private final Lifecycle d;
+     private int e;
+@@ -51,6 +57,7 @@
+     private final Set<String> C;
+     private boolean D;
+     private final CustomFunctionCallbackTimerQueue<MinecraftServer> E;
++    public WorldServer world; // CraftBukkit
+ 
+     private WorldDataServer(@Nullable DataFixer datafixer, int i, @Nullable NBTTagCompound nbttagcompound, boolean flag, int j, int k, int l, float f, long i1, long j1, int k1, int l1, int i2, boolean flag1, int j2, boolean flag2, boolean flag3, boolean flag4, WorldBorder.c worldborder_c, int k2, int l2, @Nullable UUID uuid, LinkedHashSet<String> linkedhashset, CustomFunctionCallbackTimerQueue<MinecraftServer> customfunctioncallbacktimerqueue, @Nullable NBTTagCompound nbttagcompound1, NBTTagCompound nbttagcompound2, WorldSettings worldsettings, GeneratorSettings generatorsettings, Lifecycle lifecycle) {
+         this.k = datafixer;
+@@ -94,7 +101,8 @@
+             return (NBTBase) dynamic.get("DimensionData").get("1").get("DragonFight").orElseEmptyMap().getValue();
+         });
+ 
+-        return new WorldDataServer(datafixer, i, nbttagcompound, dynamic.get("WasModded").asBoolean(false), dynamic.get("SpawnX").asInt(0), dynamic.get("SpawnY").asInt(0), dynamic.get("SpawnZ").asInt(0), dynamic.get("SpawnAngle").asFloat(0.0F), j, dynamic.get("DayTime").asLong(j), levelversion.a(), dynamic.get("clearWeatherTime").asInt(0), dynamic.get("rainTime").asInt(0), dynamic.get("raining").asBoolean(false), dynamic.get("thunderTime").asInt(0), dynamic.get("thundering").asBoolean(false), dynamic.get("initialized").asBoolean(true), dynamic.get("DifficultyLocked").asBoolean(false), WorldBorder.c.a(dynamic, WorldBorder.c), dynamic.get("WanderingTraderSpawnDelay").asInt(0), dynamic.get("WanderingTraderSpawnChance").asInt(0), (UUID) dynamic.get("WanderingTraderId").read(MinecraftSerializableUUID.a).result().orElse((Object) null), (LinkedHashSet) dynamic.get("ServerBrands").asStream().flatMap((dynamic1) -> {
++        // CraftBukkit - decompile error
++        return new WorldDataServer(datafixer, i, nbttagcompound, dynamic.get("WasModded").asBoolean(false), dynamic.get("SpawnX").asInt(0), dynamic.get("SpawnY").asInt(0), dynamic.get("SpawnZ").asInt(0), dynamic.get("SpawnAngle").asFloat(0.0F), j, dynamic.get("DayTime").asLong(j), levelversion.a(), dynamic.get("clearWeatherTime").asInt(0), dynamic.get("rainTime").asInt(0), dynamic.get("raining").asBoolean(false), dynamic.get("thunderTime").asInt(0), dynamic.get("thundering").asBoolean(false), dynamic.get("initialized").asBoolean(true), dynamic.get("DifficultyLocked").asBoolean(false), WorldBorder.c.a(dynamic, WorldBorder.c), dynamic.get("WanderingTraderSpawnDelay").asInt(0), dynamic.get("WanderingTraderSpawnChance").asInt(0), (UUID) dynamic.get("WanderingTraderId").read(MinecraftSerializableUUID.a).result().orElse(null), (LinkedHashSet) dynamic.get("ServerBrands").asStream().flatMap((dynamic1) -> {
+             return SystemUtils.a(dynamic1.asString().result());
+         }).collect(Collectors.toCollection(Sets::newLinkedHashSet)), new CustomFunctionCallbackTimerQueue<>(CustomFunctionCallbackTimers.a, dynamic.get("ScheduledEvents").asStream()), (NBTTagCompound) dynamic.get("CustomBossEvents").orElseEmptyMap().getValue(), nbttagcompound1, worldsettings, generatorsettings, lifecycle);
+     }
+@@ -126,7 +134,7 @@
+         nbttagcompound.set("Version", nbttagcompound2);
+         nbttagcompound.setInt("DataVersion", SharedConstants.getGameVersion().getWorldVersion());
+         RegistryWriteOps<NBTBase> registrywriteops = RegistryWriteOps.a(DynamicOpsNBT.a, iregistrycustom);
+-        DataResult dataresult = GeneratorSettings.a.encodeStart(registrywriteops, this.c);
++        DataResult<NBTBase> dataresult = GeneratorSettings.a.encodeStart(registrywriteops, this.c); // CraftBukkit - decompile error
+         Logger logger = WorldDataServer.LOGGER;
+ 
+         logger.getClass();
+@@ -174,6 +182,7 @@
+             nbttagcompound.a("WanderingTraderId", this.B);
+         }
+ 
++        nbttagcompound.setString("Bukkit.Version", Bukkit.getName() + "/" + Bukkit.getVersion() + "/" + Bukkit.getBukkitVersion()); // CraftBukkit
+     }
+ 
+     @Override
+@@ -291,6 +300,20 @@
+ 
+     @Override
+     public void setThundering(boolean flag) {
++        // CraftBukkit start
++        if (this.thundering == flag) {
++            return;
++        }
++
++        org.bukkit.World world = Bukkit.getWorld(getName());
++        if (world != null) {
++            ThunderChangeEvent thunder = new ThunderChangeEvent(world, flag);
++            Bukkit.getServer().getPluginManager().callEvent(thunder);
++            if (thunder.isCancelled()) {
++                return;
++            }
++        }
++        // CraftBukkit end
+         this.thundering = flag;
+     }
+ 
+@@ -311,6 +334,20 @@
+ 
+     @Override
+     public void setStorm(boolean flag) {
++        // CraftBukkit start
++        if (this.raining == flag) {
++            return;
++        }
++
++        org.bukkit.World world = Bukkit.getWorld(getName());
++        if (world != null) {
++            WeatherChangeEvent weather = new WeatherChangeEvent(world, flag);
++            Bukkit.getServer().getPluginManager().callEvent(weather);
++            if (weather.isCancelled()) {
++                return;
++            }
++        }
++        // CraftBukkit end
+         this.raining = flag;
+     }
+ 
+@@ -377,6 +414,12 @@
+     @Override
+     public void setDifficulty(EnumDifficulty enumdifficulty) {
+         this.b = this.b.a(enumdifficulty);
++        // CraftBukkit start
++        PacketPlayOutServerDifficulty packet = new PacketPlayOutServerDifficulty(this.getDifficulty(), this.isDifficultyLocked());
++        for (EntityPlayer player : (java.util.List<EntityPlayer>) (java.util.List) world.getPlayers()) {
++            player.playerConnection.sendPacket(packet);
++        }
++        // CraftBukkit end
+     }
+ 
+     @Override
+@@ -481,4 +524,12 @@
+     public IWorldDataServer H() {
+         return this;
+     }
++
++    // CraftBukkit start - Check if the name stored in NBT is the correct one
++    public void checkName(String name) {
++        if (!this.b.levelName.equals(name)) {
++            this.b.levelName = name;
++        }
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/storage/WorldNBTStorage.patch

@@ -0,0 +1,66 @@
+--- a/net/minecraft/server/WorldNBTStorage.java
++++ b/net/minecraft/server/WorldNBTStorage.java
+@@ -6,6 +6,12 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++// CraftBukkit start
++import java.io.FileInputStream;
++import java.io.InputStream;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++// CraftBukkit end
++
+ public class WorldNBTStorage {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+@@ -49,6 +55,16 @@
+         }
+ 
+         if (nbttagcompound != null) {
++            // CraftBukkit start
++            if (entityhuman instanceof EntityPlayer) {
++                CraftPlayer player = (CraftPlayer) entityhuman.getBukkitEntity();
++                // Only update first played if it is older than the one we have
++                long modified = new File(this.playerDir, entityhuman.getUniqueID().toString() + ".dat").lastModified();
++                if (modified < player.getFirstPlayed()) {
++                    player.setFirstPlayed(modified);
++                }
++            }
++            // CraftBukkit end
+             int i = nbttagcompound.hasKeyOfType("DataVersion", 3) ? nbttagcompound.getInt("DataVersion") : -1;
+ 
+             entityhuman.load(GameProfileSerializer.a(this.a, DataFixTypes.PLAYER, nbttagcompound, i));
+@@ -57,6 +73,22 @@
+         return nbttagcompound;
+     }
+ 
++    // CraftBukkit start
++    public NBTTagCompound getPlayerData(String s) {
++        try {
++            File file1 = new File(this.playerDir, s + ".dat");
++
++            if (file1.exists()) {
++                return NBTCompressedStreamTools.a((InputStream) (new FileInputStream(file1)));
++            }
++        } catch (Exception exception) {
++            LOGGER.warn("Failed to load player data for " + s);
++        }
++
++        return null;
++    }
++    // CraftBukkit end
++
+     public String[] getSeenPlayers() {
+         String[] astring = this.playerDir.list();
+ 
+@@ -72,4 +104,10 @@
+ 
+         return astring;
+     }
++
++    // CraftBukkit start
++    public File getPlayerDir() {
++        return playerDir;
++    }
++    // CraftBukkit end
+ }

paper-server/nms-patches/net/minecraft/world/level/storage/loot/LootTable.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/LootTable.java
++++ b/net/minecraft/server/LootTable.java
+@@ -19,6 +19,13 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.Logger;
+ 
++// CraftBukkit start
++import java.util.stream.Collectors;
++import org.bukkit.craftbukkit.event.CraftEventFactory;
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.event.world.LootGenerateEvent;
++// CraftBukkit end
++
+ public class LootTable {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+@@ -103,8 +110,21 @@
+     }
+ 
+     public void fillInventory(IInventory iinventory, LootTableInfo loottableinfo) {
++        // CraftBukkit start
++        this.fillInventory(iinventory, loottableinfo, false);
++    }
++
++    public void fillInventory(IInventory iinventory, LootTableInfo loottableinfo, boolean plugin) {
++        // CraftBukkit end
+         List<ItemStack> list = this.populateLoot(loottableinfo);
+         Random random = loottableinfo.a();
++        // CraftBukkit start
++        LootGenerateEvent event = CraftEventFactory.callLootGenerateEvent(iinventory, this, loottableinfo, list, plugin);
++        if (event.isCancelled()) {
++            return;
++        }
++        list = event.getLoot().stream().map(CraftItemStack::asNMSCopy).collect(Collectors.toList());
++        // CraftBukkit end
+         List<Integer> list1 = this.a(iinventory, random);
+ 
+         this.a(list, list1.size(), random);

paper-server/nms-patches/net/minecraft/world/level/storage/loot/LootTableRegistry.patch

@@ -0,0 +1,31 @@
+--- a/net/minecraft/server/LootTableRegistry.java
++++ b/net/minecraft/server/LootTableRegistry.java
+@@ -15,6 +15,7 @@
+     private static final Logger LOGGER = LogManager.getLogger();
+     private static final Gson b = LootSerialization.c().create();
+     private Map<MinecraftKey, LootTable> keyToLootTable = ImmutableMap.of();
++    public Map<LootTable, MinecraftKey> lootTableToKey = ImmutableMap.of(); // CraftBukkit
+     private final LootPredicateManager d;
+ 
+     public LootTableRegistry(LootPredicateManager lootpredicatemanager) {
+@@ -50,7 +51,7 @@
+         LootPredicateManager lootpredicatemanager = this.d;
+ 
+         this.d.getClass();
+-        Function function = lootpredicatemanager::a;
++        Function<MinecraftKey, LootItemCondition> function = lootpredicatemanager::a; // CraftBukkit - decompile error
+ 
+         immutablemap.getClass();
+         LootCollector lootcollector = new LootCollector(lootcontextparameterset, function, immutablemap::get);
+@@ -62,6 +63,11 @@
+             LootTableRegistry.LOGGER.warn("Found validation problem in " + s + ": " + s1);
+         });
+         this.keyToLootTable = immutablemap;
++        // CraftBukkit start - build a reversed registry map
++        ImmutableMap.Builder<LootTable, MinecraftKey> lootTableToKeyBuilder = ImmutableMap.builder();
++        this.keyToLootTable.forEach((lootTable, key) -> lootTableToKeyBuilder.put(key, lootTable)); // PAIL rename keyToLootTable
++        this.lootTableToKey = lootTableToKeyBuilder.build();
++        // CraftBukkit end
+     }
+ 
+     public static void a(LootCollector lootcollector, MinecraftKey minecraftkey, LootTable loottable) {

paper-server/nms-patches/net/minecraft/world/level/storage/loot/entries/LootEntryAbstract.patch

@@ -0,0 +1,20 @@
+--- a/net/minecraft/server/LootEntryAbstract.java
++++ b/net/minecraft/server/LootEntryAbstract.java
+@@ -34,7 +34,16 @@
+ 
+         public Serializer() {}
+ 
+-        public final void serializeType(JsonObject jsonobject, T t0, JsonSerializationContext jsonserializationcontext) {}
++        // CraftBukkit start
++        @Override
++        public final void a(JsonObject jsonobject, T t0, JsonSerializationContext jsonserializationcontext) {
++            if (!org.apache.commons.lang3.ArrayUtils.isEmpty(t0.d)) {
++                jsonobject.add("conditions", jsonserializationcontext.serialize(t0.d));
++            }
++
++            this.serializeType(jsonobject, t0, jsonserializationcontext);
++        }
++        // CraftBukkit end
+ 
+         @Override
+         public final T a(JsonObject jsonobject, JsonDeserializationContext jsondeserializationcontext) {

paper-server/nms-patches/net/minecraft/world/level/storage/loot/functions/LootEnchantFunction.patch

@@ -0,0 +1,26 @@
+--- a/net/minecraft/server/LootEnchantFunction.java
++++ b/net/minecraft/server/LootEnchantFunction.java
+@@ -37,8 +37,13 @@
+ 
+         if (entity instanceof EntityLiving) {
+             int i = EnchantmentManager.g((EntityLiving) entity);
++            // CraftBukkit start - use lootingModifier if set by plugin
++            if (loottableinfo.hasContextParameter(LootContextParameters.LOOTING_MOD)) {
++                i = loottableinfo.getContextParameter(LootContextParameters.LOOTING_MOD);
++            }
++            // CraftBukkit end
+ 
+-            if (i == 0) {
++            if (i <= 0) { // CraftBukkit - account for possible negative looting values from Bukkit
+                 return itemstack;
+             }
+ 
+@@ -62,7 +67,7 @@
+         public b() {}
+ 
+         public void a(JsonObject jsonobject, LootEnchantFunction lootenchantfunction, JsonSerializationContext jsonserializationcontext) {
+-            super.a(jsonobject, (LootItemFunctionConditional) lootenchantfunction, jsonserializationcontext);
++            super.a(jsonobject, lootenchantfunction, jsonserializationcontext); // CraftBukkit - decompile error
+             jsonobject.add("count", jsonserializationcontext.serialize(lootenchantfunction.a));
+             if (lootenchantfunction.c()) {
+                 jsonobject.add("limit", jsonserializationcontext.serialize(lootenchantfunction.b));

paper-server/nms-patches/net/minecraft/world/level/storage/loot/parameters/LootContextParameters.patch

@@ -0,0 +1,10 @@
+--- a/net/minecraft/server/LootContextParameters.java
++++ b/net/minecraft/server/LootContextParameters.java
+@@ -12,6 +12,7 @@
+     public static final LootContextParameter<TileEntity> BLOCK_ENTITY = a("block_entity");
+     public static final LootContextParameter<ItemStack> TOOL = a("tool");
+     public static final LootContextParameter<Float> EXPLOSION_RADIUS = a("explosion_radius");
++    public static final LootContextParameter<Integer> LOOTING_MOD = new LootContextParameter<>(new MinecraftKey("bukkit:looting_mod")); // CraftBukkit
+ 
+     private static <T> LootContextParameter<T> a(String s) {
+         return new LootContextParameter<>(new MinecraftKey(s));

paper-server/nms-patches/net/minecraft/world/level/storage/loot/predicates/LootItemConditionRandomChanceWithLooting.patch

@@ -0,0 +1,14 @@
+--- a/net/minecraft/server/LootItemConditionRandomChanceWithLooting.java
++++ b/net/minecraft/server/LootItemConditionRandomChanceWithLooting.java
+@@ -33,6 +33,11 @@
+         if (entity instanceof EntityLiving) {
+             i = EnchantmentManager.g((EntityLiving) entity);
+         }
++        // CraftBukkit start - only use lootingModifier if set by Bukkit
++        if (loottableinfo.hasContextParameter(LootContextParameters.LOOTING_MOD)) {
++            i = loottableinfo.getContextParameter(LootContextParameters.LOOTING_MOD);
++        }
++        // CraftBukkit end
+ 
+         return loottableinfo.a().nextFloat() < this.a + (float) i * this.b;
+     }

paper-server/nms-patches/net/minecraft/world/level/storage/loot/predicates/LootItemConditionSurvivesExplosion.patch

@@ -0,0 +1,12 @@
+--- a/net/minecraft/server/LootItemConditionSurvivesExplosion.java
++++ b/net/minecraft/server/LootItemConditionSurvivesExplosion.java
+@@ -30,7 +30,8 @@
+             Random random = loottableinfo.a();
+             float f = 1.0F / ofloat;
+ 
+-            return random.nextFloat() <= f;
++            // CraftBukkit - <= to < to allow for plugins to completely disable block drops from explosions
++            return random.nextFloat() < f;
+         } else {
+             return true;
+         }