More patchidy patched patches

patches/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
-@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal {
+@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
                      DyeColor enumcolor = ((DyeItem) item).getDyeColor();
  
                      if (enumcolor != this.getCollarColor()) {

patches/server/Add-GameEvent-tags.patch

@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-                     return (org.bukkit.Tag<T>) new CraftEntityTag(net.minecraft.core.Registry.ENTITY_TYPE, entityTagKey);
+                     return (org.bukkit.Tag<T>) new CraftEntityTag(BuiltInRegistries.ENTITY_TYPE, entityTagKey);
                  }
              }
 +            // Paper start
@@ -65,7 +65,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-                 net.minecraft.core.Registry<EntityType<?>> entityTags = net.minecraft.core.Registry.ENTITY_TYPE;
+                 net.minecraft.core.Registry<EntityType<?>> entityTags = BuiltInRegistries.ENTITY_TYPE;
                  return entityTags.getTags().map(pair -> (org.bukkit.Tag<T>) new CraftEntityTag(entityTags, pair.getFirst())).collect(ImmutableList.toImmutableList());
              }
 +            // Paper start

patches/server/Added-getHostname-to-AsyncPlayerPreLoginEvent.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListene
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements TickablePacketListener, Se
+@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
  
                          // Paper start
                          com.destroystokyo.paper.profile.PlayerProfile profile = com.destroystokyo.paper.profile.CraftPlayerProfile.asBukkitMirror(ServerLoginPacketListenerImpl.this.gameProfile);

patches/server/Allow-delegation-to-vanilla-chunk-gen.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         return new OldCraftChunkData(world.getMinHeight(), world.getMaxHeight(), handle.registryAccess().registryOrThrow(net.minecraft.core.Registry.BIOME_REGISTRY), world); // Paper - Anti-Xray - Add parameters
+         return new OldCraftChunkData(world.getMinHeight(), world.getMaxHeight(), handle.registryAccess().registryOrThrow(Registries.BIOME), world); // Paper - Anti-Xray - Add parameters
      }
  
 +    // Paper start

patches/server/Custom-Potion-Mixes.patch

@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.worldData.setDataPackConfig(MinecraftServer.getSelectedPacks(this.packRepository));
+             this.worldData.setDataConfiguration(worlddataconfiguration);
              this.resources.managers.updateRegistryTags(this.registryAccess());
              io.papermc.paper.registry.PaperRegistry.clearCaches(); // Paper
 +            net.minecraft.world.item.alchemy.PotionBrewing.reload(); // Paper

patches/server/Expose-vanilla-BiomeProvider-from-WorldInfo.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             }
+             List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(iworlddataserver));
-             // Paper end
+             LevelStem worlddimension = (LevelStem) dimensions.get(dimensionKey);
  
--            org.bukkit.generator.WorldInfo worldInfo = new org.bukkit.craftbukkit.generator.CraftWorldInfo(iworlddataserver, worldSession, org.bukkit.World.Environment.getEnvironment(dimension), worlddimension.typeHolder().value());
+-            org.bukkit.generator.WorldInfo worldInfo = new org.bukkit.craftbukkit.generator.CraftWorldInfo(iworlddataserver, worldSession, org.bukkit.World.Environment.getEnvironment(dimension), worlddimension.type().value());
-+            org.bukkit.generator.WorldInfo worldInfo = new org.bukkit.craftbukkit.generator.CraftWorldInfo(iworlddataserver, worldSession, org.bukkit.World.Environment.getEnvironment(dimension), worlddimension.typeHolder().value(), worlddimension.generator(), this.registryAccess()); // Paper
++            org.bukkit.generator.WorldInfo worldInfo = new org.bukkit.craftbukkit.generator.CraftWorldInfo(iworlddataserver, worldSession, org.bukkit.World.Environment.getEnvironment(dimension), worlddimension.type().value(), worlddimension.generator(), this.registryAccess()); // Paper
              if (biomeProvider == null && gen != null) {
                  biomeProvider = gen.getDefaultBiomeProvider(worldInfo);
              }
@@ -22,11 +22,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         net.minecraft.core.Registry<LevelStem> iregistry = worlddata.worldGenSettings().dimensions();
+         List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(worlddata));
          LevelStem worlddimension = (LevelStem) iregistry.get(actualDimension);
  
--        WorldInfo worldInfo = new CraftWorldInfo(worlddata, worldSession, creator.environment(), worlddimension.typeHolder().value());
+-        WorldInfo worldInfo = new CraftWorldInfo(worlddata, worldSession, creator.environment(), worlddimension.type().value());
-+        WorldInfo worldInfo = new CraftWorldInfo(worlddata, worldSession, creator.environment(), worlddimension.typeHolder().value(), worlddimension.generator(), this.getHandle().getServer().registryAccess()); // Paper
++        WorldInfo worldInfo = new CraftWorldInfo(worlddata, worldSession, creator.environment(), worlddimension.type().value(), worlddimension.generator(), this.getHandle().getServer().registryAccess()); // Paper
          if (biomeProvider == null && generator != null) {
              biomeProvider = generator.getDefaultBiomeProvider(worldInfo);
          }

patches/server/Fix-ChunkSnapshot-isSectionEmpty-int-and-optimize-Pa.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
          PalettedContainerRO<Holder<Biome>>[] biome = (includeBiome || includeBiomeTempRain) ? new PalettedContainer[cs.length] : null;
  
-         Registry<Biome> iregistry = this.worldServer.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY);
+         Registry<Biome> iregistry = this.worldServer.registryAccess().registryOrThrow(Registries.BIOME);
 -        Codec<PalettedContainerRO<Holder<Biome>>> biomeCodec = PalettedContainer.codecRO(iregistry.asHolderIdMap(), iregistry.holderByNameCodec(), PalettedContainer.Strategy.SECTION_BIOMES, iregistry.getHolderOrThrow(Biomes.PLAINS));
  
          for (int i = 0; i < cs.length; i++) {

patches/server/Fix-NotePlayEvent.patch

@@ -11,36 +11,45 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/NoteBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
 @@ -0,0 +0,0 @@ public class NoteBlock extends Block {
-     private void playNote(@Nullable Entity entity, Level world, BlockPos blockposition, BlockState data) { // CraftBukkit
+     private void playNote(@Nullable Entity entity, BlockState state, Level world, BlockPos pos) {
-         if (world.getBlockState(blockposition.above()).isAir()) {
+         if (!((NoteBlockInstrument) state.getValue(NoteBlock.INSTRUMENT)).requiresAirAbove() || world.getBlockState(pos.above()).isAir()) {
              // CraftBukkit start
--            org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, data.getValue(NoteBlock.INSTRUMENT), data.getValue(NoteBlock.NOTE));
+-            org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, pos, state.getValue(NoteBlock.INSTRUMENT), state.getValue(NoteBlock.NOTE));
 -            if (event.isCancelled()) {
 -                return;
 -            }
-+            // org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, data.getValue(NoteBlock.INSTRUMENT), data.getValue(NoteBlock.NOTE)); // Paper - move event into block event handler
++            // org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, pos, state.getValue(NoteBlock.INSTRUMENT), state.getValue(NoteBlock.NOTE));
 +            // if (event.isCancelled()) {
 +            //     return;
 +            // }
              // CraftBukkit end
 +            // Paper - TODO any way to cancel the game event?
-             world.blockEvent(blockposition, this, 0, 0);
+             world.blockEvent(pos, this, 0, 0);
-             world.gameEvent(entity, GameEvent.NOTE_BLOCK_PLAY, blockposition);
+             world.gameEvent(entity, GameEvent.NOTE_BLOCK_PLAY, pos);
          }
 @@ -0,0 +0,0 @@ public class NoteBlock extends Block {
  
      @Override
      public boolean triggerEvent(BlockState state, Level world, BlockPos pos, int type, int data) {
--        int k = (Integer) state.getValue(NoteBlock.NOTE);
 +        // Paper start - move NotePlayEvent call to fix instrument/note changes
 +        org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, pos, state.getValue(INSTRUMENT), state.getValue(NOTE));
 +        if (event.isCancelled()) return false;
-+        int k = event.getNote().getId();
-         float f = (float) Math.pow(2.0D, (double) (k - 12) / 12.0D);
- 
--        world.playSound((Player) null, pos, ((NoteBlockInstrument) state.getValue(NoteBlock.INSTRUMENT)).getSoundEvent(), SoundSource.RECORDS, 3.0F, f);
-+        world.playSound(null, pos, org.bukkit.craftbukkit.block.data.CraftBlockData.toNMS(event.getInstrument(), NoteBlockInstrument.class).getSoundEvent(), SoundSource.RECORDS, 3.0F, f);
 +        // Paper end
-         world.addParticle(ParticleTypes.NOTE, (double) pos.getX() + 0.5D, (double) pos.getY() + 1.2D, (double) pos.getZ() + 0.5D, (double) k / 24.0D, 0.0D, 0.0D);
+         NoteBlockInstrument blockpropertyinstrument = (NoteBlockInstrument) state.getValue(NoteBlock.INSTRUMENT);
+         float f;
+ 
+         if (blockpropertyinstrument.isTunable()) {
+-            int k = (Integer) state.getValue(NoteBlock.NOTE);
++            int k = event.getNote().getId(); // Paper
+ 
+             f = (float) Math.pow(2.0D, (double) (k - 12) / 12.0D);
+             world.addParticle(ParticleTypes.NOTE, (double) pos.getX() + 0.5D, (double) pos.getY() + 1.2D, (double) pos.getZ() + 0.5D, (double) k / 24.0D, 0.0D, 0.0D);
+@@ -0,0 +0,0 @@ public class NoteBlock extends Block {
+             holder = blockpropertyinstrument.getSoundEvent();
+         }
+ 
+-        world.playSeededSound((Player) null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, holder, SoundSource.RECORDS, 3.0F, f, world.random.nextLong());
++        world.playSeededSound((Player) null, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, org.bukkit.craftbukkit.block.data.CraftBlockData.toNMS(event.getInstrument(), NoteBlockInstrument.class).getSoundEvent(), SoundSource.RECORDS, 3.0F, f, world.random.nextLong()); // Paper
          return true;
      }
+ 

patches/server/Fix-StructureGrowEvent-species-for-RED_MUSHROOM.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/MushroomBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/MushroomBlock.java
 @@ -0,0 +0,0 @@ public class MushroomBlock extends BushBlock implements BonemealableBlock {
- 
+             return false;
-     public boolean growMushroom(ServerLevel world, BlockPos pos, BlockState state, RandomSource random) {
-         world.removeBlock(pos, false);
--        SaplingBlock.treeType = (this == Blocks.BROWN_MUSHROOM) ? TreeType.BROWN_MUSHROOM : TreeType.BROWN_MUSHROOM; // CraftBukkit
-+        SaplingBlock.treeType = (this == Blocks.BROWN_MUSHROOM) ? TreeType.BROWN_MUSHROOM : TreeType.RED_MUSHROOM; // CraftBukkit // Paper
-         if (((ConfiguredFeature) ((Holder) this.featureSupplier.get()).value()).place(world, world.getChunkSource().getGenerator(), random, pos)) {
-             return true;
          } else {
+             world.removeBlock(pos, false);
+-            SaplingBlock.treeType = (this == Blocks.BROWN_MUSHROOM) ? TreeType.BROWN_MUSHROOM : TreeType.BROWN_MUSHROOM; // CraftBukkit
++            SaplingBlock.treeType = (this == Blocks.BROWN_MUSHROOM) ? TreeType.BROWN_MUSHROOM : TreeType.RED_MUSHROOM; // CraftBukkit // Paper
+             if (((ConfiguredFeature) ((Holder) optional.get()).value()).place(world, world.getChunkSource().getGenerator(), random, pos)) {
+                 return true;
+             } else {

patches/server/Fix-entity-type-tags-suggestions-in-selectors.patch

@@ -123,9 +123,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntitySelectorOptions {
  
                      if (reader.isTag()) {
-                         TagKey<EntityType<?>> tagKey = TagKey.create(Registry.ENTITY_TYPE_REGISTRY, ResourceLocation.read(reader.getReader()));
+                         TagKey<EntityType<?>> tagKey = TagKey.create(Registries.ENTITY_TYPE, ResourceLocation.read(reader.getReader()));
 +                        // Paper start - throw error if invalid entity tag (only on suggestions to keep cmd success behavior)
-+                        if (reader.parsingEntityArgumentSuggestions && io.papermc.paper.configuration.GlobalConfiguration.get().commands.fixTargetSelectorTagCompletion && !Registry.ENTITY_TYPE.isKnownTagName(tagKey)) {
++                        if (reader.parsingEntityArgumentSuggestions && io.papermc.paper.configuration.GlobalConfiguration.get().commands.fixTargetSelectorTagCompletion && net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getTag(tagKey).isEmpty()) {
 +                            reader.getReader().setCursor(i);
 +                            throw ERROR_ENTITY_TAG_INVALID.createWithContext(reader.getReader(), tagKey);
 +                        }

patches/server/Fix-swamp-hut-cat-generation-deadlock.patch

@@ -13,13 +13,13 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
-@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal {
+@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
          });
          ServerLevel worldserver = world.getLevel();
  
 -        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK).isValid()) {
 +        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK, world).isValid()) { // Paper - fix deadlock
-             this.setCatVariant(CatVariant.ALL_BLACK);
+             this.setVariant((CatVariant) BuiltInRegistries.CAT_VARIANT.getOrThrow(CatVariant.ALL_BLACK));
              this.setPersistenceRequired();
          }
 diff --git a/src/main/java/net/minecraft/world/level/StructureManager.java b/src/main/java/net/minecraft/world/level/StructureManager.java
@@ -49,11 +49,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> structureTag, @Nullable ServerLevelAccessor levelAccessor) {
 +        // Paper end
-         Registry<Structure> registry = this.registryAccess().registryOrThrow(Registry.STRUCTURE_REGISTRY);
+         Registry<Structure> registry = this.registryAccess().registryOrThrow(Registries.STRUCTURE);
  
          for(StructureStart structureStart : this.startsForStructure(new ChunkPos(pos), (structure) -> {
-             return registry.getHolder(registry.getId(structure)).map((holder) -> {
+             return registry.getHolder(registry.getId(structure)).map((reference) -> {
-                 return holder.is(structureTag);
+                 return reference.is(structureTag);
              }).orElse(false);
 -        })) {
 +        }, levelAccessor)) { // Paper

patches/server/Hide-unnecessary-itemmeta-from-clients.patch

@@ -22,16 +22,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                                 // Refresh the current entity metadata
+                                 entity.getEntityData().refresh(player);
+                                 // SPIGOT-7136 - Allays
+-                                if (entity instanceof Allay) {
+-                                    ServerGamePacketListenerImpl.this.send(new ClientboundSetEquipmentPacket(entity.getId(), Arrays.stream(net.minecraft.world.entity.EquipmentSlot.values()).map((slot) -> Pair.of(slot, ((LivingEntity) entity).getItemBySlot(slot).copy())).collect(Collectors.toList())));
++                                if (entity instanceof Allay allay) { // Paper
++                                    ServerGamePacketListenerImpl.this.send(new ClientboundSetEquipmentPacket(entity.getId(), Arrays.stream(net.minecraft.world.entity.EquipmentSlot.values()).map((slot) -> Pair.of(slot, allay.stripMeta(allay.getItemBySlot(slot), true))).collect(Collectors.toList()))); // Paper - remove unnecessary item meta
+                                     player.containerMenu.sendAllDataToRemote();
+                                 }
                              }
-                             // Paper end
-                             // SPIGOT-7136 - Allays
--                            if (entity instanceof Allay) {
--                                ServerGamePacketListenerImpl.this.send(new ClientboundSetEquipmentPacket(entity.getId(), Arrays.stream(net.minecraft.world.entity.EquipmentSlot.values()).map((slot) -> Pair.of(slot, ((LivingEntity) entity).getItemBySlot(slot).copy())).collect(Collectors.toList())));
-+                            if (entity instanceof Allay allay) { // Paper
-+                                ServerGamePacketListenerImpl.this.send(new ClientboundSetEquipmentPacket(entity.getId(), Arrays.stream(net.minecraft.world.entity.EquipmentSlot.values()).map((slot) -> Pair.of(slot, allay.stripMeta(allay.getItemBySlot(slot), true))).collect(Collectors.toList()))); // Paper - remove unnecessary item meta
-                                 player.containerMenu.sendAllDataToRemote();
-                             }
-                         }
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java

patches/server/Highly-optimise-single-and-multi-AABB-VoxelShapes-an.patch

@@ -1213,7 +1213,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        while (avoidSuffocation && !worldserver1.noCollision(entityplayer1, entityplayer1.getBoundingBox(), true) && entityplayer1.getY() < (double) worldserver1.getMaxBuildHeight()) { // Paper - make sure this loads chunks, we default to NOT loading now
              entityplayer1.setPos(entityplayer1.getX(), entityplayer1.getY() + 1.0D, entityplayer1.getZ());
          }
-         // CraftBukkit start
+ 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -1496,11 +1496,10 @@ diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
 +++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
-@@ -0,0 +0,0 @@ public abstract class BlockBehaviour {
+@@ -0,0 +0,0 @@ public abstract class BlockBehaviour implements FeatureElement {
-         protected boolean isTicking;
+             return this.conditionallyFullOpaque;
-         protected FluidState fluid;
+         }
-         // Paper end
+         // Paper end - starlight
-+        // Paper start
 +        private long blockCollisionBehavior = io.papermc.paper.util.CollisionUtil.KNOWN_SPECIAL_BLOCK;
 +
 +        public final long getBlockCollisionBehavior() {
@@ -1509,8 +1508,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end
  
          public void initCache() {
-             this.fluid = this.getBlock().getFluidState(this.asState()); // Paper - moved from getFluid()
+             this.fluidState = ((Block) this.owner).getFluidState(this.asState());
-@@ -0,0 +0,0 @@ public abstract class BlockBehaviour {
+@@ -0,0 +0,0 @@ public abstract class BlockBehaviour implements FeatureElement {
              this.shapeExceedsCube = this.cache == null || this.cache.largeCollisionShape; // Paper - moved from actual method to here
              this.opacityIfCached = this.cache == null || this.isConditionallyFullOpaque() ? -1 : this.cache.lightBlock; // Paper - starlight - cache opacity for light
  

patches/server/Implement-getComputedBiome-API.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
 @@ -0,0 +0,0 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
-         return CraftBlock.biomeBaseToBiome(this.getHandle().registryAccess().registryOrThrow(Registry.BIOME_REGISTRY), this.getHandle().getNoiseBiome(x >> 2, y >> 2, z >> 2));
+         return CraftBlock.biomeBaseToBiome(this.getHandle().registryAccess().registryOrThrow(Registries.BIOME), this.getHandle().getNoiseBiome(x >> 2, y >> 2, z >> 2));
      }
  
 +    // Paper start

patches/server/Kick-on-main-for-illegal-chat.patch

@@ -18,8 +18,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.disconnect(Component.translatable("multiplayer.disconnect.illegal_characters"), org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_CHARACTERS); // Paper - add cause
 +            }); // Paper - push to main for event firing
          } else {
-             if (this.tryHandleChat(packet.message(), packet.timeStamp(), packet.lastSeenMessages())) {
+             Optional<LastSeenMessages> optional = this.tryHandleChat(packet.message(), packet.timeStamp(), packet.lastSeenMessages());
-                 // this.server.submit(() -> { // CraftBukkit - async chat
+ 
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
      @Override
      public void handleChatCommand(ServerboundChatCommandPacket packet) {
@@ -28,15 +28,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.disconnect(Component.translatable("multiplayer.disconnect.illegal_characters"), org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_CHARACTERS); // Paper
 +            }); // Paper - push to main for event firing
          } else {
-             if (this.tryHandleChat(packet.command(), packet.timeStamp(), packet.lastSeenMessages())) {
+             Optional<LastSeenMessages> optional = this.tryHandleChat(packet.command(), packet.timeStamp(), packet.lastSeenMessages());
-                 this.server.submit(() -> {
+ 
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
-     private boolean tryHandleChat(String message, Instant timestamp, LastSeenMessages.Update acknowledgment) {
+     private Optional<LastSeenMessages> tryHandleChat(String message, Instant timestamp, LastSeenMessages.Update acknowledgment) {
          if (!this.updateChatOrder(timestamp)) {
              ServerGamePacketListenerImpl.LOGGER.warn("{} sent out-of-order chat: '{}'", this.player.getName().getString(), message);
 +            this.server.scheduleOnMain(() -> { // Paper - push to main
-             this.disconnect(Component.translatable("multiplayer.disconnect.out_of_order_chat"), org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event cause
+             this.disconnect(Component.translatable("multiplayer.disconnect.out_of_order_chat"), org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event ca
 +            }); // Paper - push to main
-             return false;
+             return Optional.empty();
          } else if (this.player.isRemoved() || this.player.getChatVisibility() == ChatVisiblity.HIDDEN) { // CraftBukkit - dead men tell no tales
              this.send(new ClientboundSystemChatPacket(Component.translatable("chat.disabled.options").withStyle(ChatFormatting.RED), false));

patches/server/Optimise-collision-checking-in-player-move-packet-ha.patch

@@ -138,8 +138,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            }
 +                            if (!this.player.noPhysics && !this.player.isSleeping() && teleportBack) { // Paper end - optimise out extra getCubes
                                  this.internalTeleport(d3, d4, d5, f, f1, Collections.emptySet(), false); // CraftBukkit - SPIGOT-1807: Don't call teleport event, when the client thinks the player is falling, because the chunks are not loaded on the client yet.
+                                 this.player.doCheckFallDamage(this.player.getY() - d6, packet.isOnGround());
                              } else {
-                                 // CraftBukkit start - fire PlayerMoveEvent
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
          }
      }

patches/server/Put-world-into-worldlist-before-initing-the-world.patch

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              worlddata.setModdedInfo(this.getServerModName(), this.getModdedStatus().shouldReportAsModified());
 +            this.addLevel(world); // Paper - move up
-             this.initWorld(world, worlddata, worldData, worlddata.worldGenSettings());
+             this.initWorld(world, worlddata, worldData, worldoptions);
  
 -            this.addLevel(world);
 +            // Paper - move up
@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 +        this.console.addLevel(internal); // Paper - move up
-         this.console.initWorld(internal, worlddata, worlddata, worlddata.worldGenSettings());
+         this.console.initWorld(internal, worlddata, worlddata, worlddata.worldGenOptions());
  
          internal.setSpawnSettings(true, true);
 -        this.console.addLevel(internal);

patches/server/Validate-usernames.patch

@@ -8,16 +8,16 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListene
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements TickablePacketListener, Se
+@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-     private ServerPlayer delayedAcceptPlayer;
+     private final String serverId;
      @Nullable
-     private ProfilePublicKey.Data profilePublicKeyData;
+     private ServerPlayer delayedAcceptPlayer;
 +    public boolean iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation = false; // Paper - username validation overriding
  
      public ServerLoginPacketListenerImpl(MinecraftServer server, Connection connection) {
          this.state = ServerLoginPacketListenerImpl.State.HELLO;
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements TickablePacketListener, Se
+@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-         }
+         // Paper end
      }
  
 +    // Paper start - validate usernames
@@ -52,9 +52,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +        }
 +        // Paper end - validate usernames
-         this.profilePublicKeyData = (ProfilePublicKey.Data) packet.publicKey().orElse(null); // CraftBukkit - decompile error
          GameProfile gameprofile = this.server.getSingleplayerProfile();
  
+         if (gameprofile != null && packet.name().equalsIgnoreCase(gameprofile.getName())) {
 diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/players/PlayerList.java

patches/server/cache-resource-keys.patch

@@ -18,8 +18,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return null;
          }
  
--        return registry.getHolderOrThrow(ResourceKey.create(net.minecraft.core.Registry.BIOME_REGISTRY, CraftNamespacedKey.toMinecraft(bio.getKey())));
+-        return registry.getHolderOrThrow(ResourceKey.create(Registries.BIOME, CraftNamespacedKey.toMinecraft(bio.getKey())));
-+        return registry.getHolderOrThrow(BIOME_KEY_CACHE.computeIfAbsent(bio, b -> ResourceKey.create(net.minecraft.core.Registry.BIOME_REGISTRY, CraftNamespacedKey.toMinecraft(b.getKey())))); // Paper - cache key
++        return registry.getHolderOrThrow(BIOME_KEY_CACHE.computeIfAbsent(bio, b -> ResourceKey.create(Registries.BIOME, CraftNamespacedKey.toMinecraft(b.getKey())))); // Paper - cache key
      }
  
      @Override
@@ -31,11 +31,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super(registry, tag);
      }
  
-+    private static final java.util.Map<org.bukkit.entity.EntityType, net.minecraft.resources.ResourceKey<net.minecraft.world.entity.EntityType<?>>> KEY_CACHE = Collections.synchronizedMap(new java.util.EnumMap<>(EntityType.class)); // Paper
++    private static final java.util.Map<org.bukkit.entity.EntityType, net.minecraft.resources.ResourceKey<net.minecraft.world.entity.EntityType<?>>> KEY_CACHE = java.util.Collections.synchronizedMap(new java.util.EnumMap<>(EntityType.class)); // Paper
      @Override
      public boolean isTagged(EntityType entity) {
--        return registry.getHolderOrThrow(ResourceKey.create(net.minecraft.core.Registry.ENTITY_TYPE_REGISTRY, CraftNamespacedKey.toMinecraft(entity.getKey()))).is(tag);
+-        return registry.getHolderOrThrow(ResourceKey.create(Registries.ENTITY_TYPE, CraftNamespacedKey.toMinecraft(entity.getKey()))).is(tag);
-+        return registry.getHolderOrThrow(KEY_CACHE.computeIfAbsent(entity, type -> ResourceKey.create(net.minecraft.core.Registry.ENTITY_TYPE_REGISTRY, CraftNamespacedKey.toMinecraft(type.getKey())))).is(tag); // Paper - cache key
++        return registry.getHolderOrThrow(KEY_CACHE.computeIfAbsent(entity, type -> ResourceKey.create(Registries.ENTITY_TYPE, CraftNamespacedKey.toMinecraft(type.getKey())))).is(tag); // Paper - cache key
      }
  
      @Override

patches/unapplied/server/Add-missing-structure-set-seed-configs.patch

@@ -1,197 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Thu, 13 Jan 2022 23:05:53 -0800
-Subject: [PATCH] Add missing structure set seed configs
-
-The 4 missing structure set seed configs are strongholds, mineshafts,
-buried treasure, and ancient cities.
-
-Strongholds use a ring placement scheme which isn't random so they
-utilize the world seed by default, this adds a config to override it
-for just generating the ring positions.
-
-Mineshafts and Buried Treasure structure sets are special cases
-where the "salt" that can be defined for them via datapacks has 0
-effect because the difference between the spacing and separation is 1
-which is used as the upper bound in the random with salt. So the random
-always returns the same int (0) so the salt has no effect. This adds
-seeds/salts to the frequency reducer which has a similar effect.
-
-Co-authored-by: William Blake Galbreath <blake.galbreath@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
-     // Spigot start
-     private Stream<StructureSet> possibleStructureSetsSpigot() {
-         return this.possibleStructureSets().map(Holder::value).map((structureset) -> {
--            if (structureset.placement() instanceof RandomSpreadStructurePlacement randomConfig) {
-+            if (structureset.placement() instanceof RandomSpreadStructurePlacement randomConfig && this.structureSets.getKey(structureset).getNamespace().equals(net.minecraft.resources.ResourceLocation.DEFAULT_NAMESPACE)) { // Paper - check namespace cause datapacks could add structure sets with the same path
-                 String name = this.structureSets.getKey(structureset).getPath();
-                 int seed = randomConfig.salt;
- 
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
-                     case "villages":
-                         seed = conf.villageSeed;
-                         break;
-+                        // Paper start
-+                    case "ancient_cities":
-+                        seed = conf.ancientCitySeed;
-+                        break;
-+                        // Paper end
-                 }
- 
-                 structureset = new StructureSet(structureset.structures(), new RandomSpreadStructurePlacement(randomConfig.locateOffset, randomConfig.frequencyReductionMethod, randomConfig.frequency, seed, randomConfig.exclusionZone, randomConfig.spacing(), randomConfig.separation(), randomConfig.spreadType()));
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
-             HolderSet<Biome> holderset = concentricringsstructureplacement.preferredBiomes();
-             RandomSource randomsource = RandomSource.create();
- 
-+            // Paper start
-+            if (this.conf.strongholdSeed != null && this.structureSets.getResourceKey(holder).orElse(null) == net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS) {
-+                randomsource.setSeed(this.conf.strongholdSeed);
-+            } else {
-             randomsource.setSeed(this instanceof FlatLevelSource ? 0L : randomstate.legacyLevelSeed());
-+            }
-+            // Paper end
-             double d0 = randomsource.nextDouble() * 3.141592653589793D * 2.0D;
-             int l = 0;
-             int i1 = 0;
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
- 
-             for (int i1 = chunkX - chunkRange; i1 <= chunkX + chunkRange; ++i1) {
-                 for (int j1 = chunkZ - chunkRange; j1 <= chunkZ + chunkRange; ++j1) {
--                    if (structureplacement.isStructureChunk(this, noiseConfig, seed, i1, j1)) {
-+                    if (structureplacement.isStructureChunk(this, noiseConfig, seed, i1, j1, structureSet.unwrapKey().map(ResourceKey::location).orElse(null))) { // Paper
-                         return true;
-                     }
-                 }
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
-                 }
-             }
- 
--            if (structureplacement.isStructureChunk(this, noiseConfig, seed, chunkcoordintpair.x, chunkcoordintpair.z)) {
-+            if (structureplacement.isStructureChunk(this, noiseConfig, seed, chunkcoordintpair.x, chunkcoordintpair.z, this.structureSets.getResourceKey(holder).map(ResourceKey::location).orElse(null))) { // Paper
-                 if (list.size() == 1) {
-                     this.tryGenerateStructure((StructureSet.StructureSelectionEntry) list.get(0), structureAccessor, registryManager, noiseConfig, structureTemplateManager, seed, chunk, chunkcoordintpair, sectionposition);
-                 } else {
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
-@@ -0,0 +0,0 @@ public abstract class StructurePlacement {
-         return this.exclusionZone;
-     }
- 
-+    @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper
-     public boolean isStructureChunk(ChunkGenerator chunkGenerator, RandomState noiseConfig, long seed, int chunkX, int chunkZ) {
-+        // Paper start - add missing structure set configs
-+        return this.isStructureChunk(chunkGenerator, noiseConfig, seed, chunkX, chunkZ, null);
-+    }
-+    public boolean isStructureChunk(ChunkGenerator chunkGenerator, RandomState noiseConfig, long seed, int chunkX, int chunkZ, @org.jetbrains.annotations.Nullable net.minecraft.resources.ResourceLocation structureSetKey) {
-+        Integer saltOverride = null;
-+        if (net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.MINESHAFTS.location().equals(structureSetKey)) {
-+            saltOverride = chunkGenerator.conf.mineshaftSeed;
-+        } else if (net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.BURIED_TREASURES.location().equals(structureSetKey)) {
-+            saltOverride = chunkGenerator.conf.buriedTreasureSeed;
-+        }
-+        // Paper end
-         if (!this.isPlacementChunk(chunkGenerator, noiseConfig, seed, chunkX, chunkZ)) {
-             return false;
--        } else if (this.frequency < 1.0F && !this.frequencyReductionMethod.shouldGenerate(seed, this.salt, chunkX, chunkZ, this.frequency)) {
-+        } else if (this.frequency < 1.0F && !this.frequencyReductionMethod.shouldGenerate(seed, this.salt, chunkX, chunkZ, this.frequency, saltOverride)) { // Paper
-             return false;
-         } else {
-             return !this.exclusionZone.isPresent() || !this.exclusionZone.get().isPlacementForbidden(chunkGenerator, noiseConfig, seed, chunkX, chunkZ);
-@@ -0,0 +0,0 @@ public abstract class StructurePlacement {
- 
-     public abstract StructurePlacementType<?> type();
- 
--    private static boolean probabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency) {
-+    private static boolean probabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - ignore here
-         WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
-         worldgenRandom.setLargeFeatureWithSalt(seed, salt, chunkX, chunkZ);
-         return worldgenRandom.nextFloat() < frequency;
-     }
- 
--    private static boolean legacyProbabilityReducerWithDouble(long seed, int salt, int chunkX, int chunkZ, float frequency) {
-+    private static boolean legacyProbabilityReducerWithDouble(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper
-         WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
-+        if (saltOverride == null) { // Paper
-         worldgenRandom.setLargeFeatureSeed(seed, chunkX, chunkZ);
-+        // Paper start
-+        } else {
-+            worldgenRandom.setLargeFeatureWithSalt(seed, chunkX, chunkZ, saltOverride);
-+        }
-+        // Paper end
-         return worldgenRandom.nextDouble() < (double)frequency;
-     }
- 
--    private static boolean legacyArbitrarySaltProbabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency) {
-+    private static boolean legacyArbitrarySaltProbabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper
-         WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
--        worldgenRandom.setLargeFeatureWithSalt(seed, chunkX, chunkZ, 10387320);
-+        worldgenRandom.setLargeFeatureWithSalt(seed, chunkX, chunkZ, saltOverride != null ? saltOverride : 10387320); // Paper
-         return worldgenRandom.nextFloat() < frequency;
-     }
- 
--    private static boolean legacyPillagerOutpostReducer(long seed, int salt, int chunkX, int chunkZ, float frequency) {
-+    private static boolean legacyPillagerOutpostReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - ignore here
-         int i = chunkX >> 4;
-         int j = chunkZ >> 4;
-         WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
-@@ -0,0 +0,0 @@ public abstract class StructurePlacement {
- 
-     @FunctionalInterface
-     public interface FrequencyReducer {
--        boolean shouldGenerate(long seed, int salt, int chunkX, int chunkZ, float chance);
-+        boolean shouldGenerate(long seed, int salt, int chunkX, int chunkZ, float chance, @org.jetbrains.annotations.Nullable Integer saltOverride); // Paper
-     }
- 
-     public static enum FrequencyReductionMethod implements StringRepresentable {
-@@ -0,0 +0,0 @@ public abstract class StructurePlacement {
-             this.reducer = generationPredicate;
-         }
- 
--        public boolean shouldGenerate(long seed, int salt, int chunkX, int chunkZ, float chance) {
--            return this.reducer.shouldGenerate(seed, salt, chunkX, chunkZ, chance);
-+        public boolean shouldGenerate(long seed, int salt, int chunkX, int chunkZ, float chance, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper
-+            return this.reducer.shouldGenerate(seed, salt, chunkX, chunkZ, chance, saltOverride); // Paper
-         }
- 
-         @Override
-diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-@@ -0,0 +0,0 @@ public class SpigotWorldConfig
-     public int mansionSeed;
-     public int fossilSeed;
-     public int portalSeed;
-+    // Paper start - add missing structure set configs
-+    public int ancientCitySeed;
-+    public int buriedTreasureSeed;
-+    public Integer mineshaftSeed;
-+    public Long strongholdSeed;
-+    private <N extends Number> N getSeed(String path, java.util.function.Function<String, N> toNumberFunc) {
-+        final String value = this.getString(path, "default");
-+        return org.apache.commons.lang3.math.NumberUtils.isParsable(value) ? toNumberFunc.apply(value) : null;
-+    }
-+    // Paper end
-     private void initWorldGenSeeds()
-     {
-         this.villageSeed = this.getInt( "seed-village", 10387312 );
-@@ -0,0 +0,0 @@ public class SpigotWorldConfig
-         this.mansionSeed = this.getInt( "seed-mansion", 10387319 );
-         this.fossilSeed = this.getInt( "seed-fossil", 14357921 );
-         this.portalSeed = this.getInt( "seed-portal", 34222645 );
-+        // Paper start - add missing structure set configs
-+        this.ancientCitySeed = this.getInt("seed-ancientcity", 20083232);
-+        this.buriedTreasureSeed = this.getInt("seed-buriedtreasure", 10387320); // StructurePlacement#HIGHLY_ARBITRARY_RANDOM_SALT
-+        this.mineshaftSeed = this.getSeed("seed-mineshaft", Integer::parseInt);
-+        this.strongholdSeed = this.getSeed("seed-stronghold", Long::parseLong);
-+        // Paper end
-         this.log( "Custom Map Seeds:  Village: " + this.villageSeed + " Desert: " + this.desertSeed + " Igloo: " + this.iglooSeed + " Jungle: " + this.jungleSeed + " Swamp: " + this.swampSeed + " Monument: " + this.monumentSeed
-                 + " Ocean: " + this.oceanSeed + " Shipwreck: " + this.shipwreckSeed + " End City: " + this.endCitySeed + " Slime: " + this.slimeSeed + " Nether: " + this.netherSeed + " Mansion: " + this.mansionSeed + " Fossil: " + this.fossilSeed + " Portal: " + this.portalSeed );
-     }

patches/unapplied/server/Update-Log4j.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: darbyjack <admin@glaremasters.me>
-Date: Thu, 9 Dec 2021 19:17:02 -0600
-Subject: [PATCH] Update Log4j
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -0,0 +0,0 @@ dependencies {
-           all its classes to check if they are plugins.
-           Scanning takes about 1-2 seconds so adding this speeds up the server start.
-      */
--    implementation("org.apache.logging.log4j:log4j-core:2.14.1") // Paper - implementation
--    annotationProcessor("org.apache.logging.log4j:log4j-core:2.14.1") // Paper - Needed to generate meta for our Log4j plugins
-+    implementation("org.apache.logging.log4j:log4j-core:2.17.1") // Paper - implementation
-+    annotationProcessor("org.apache.logging.log4j:log4j-core:2.17.1") // Paper - Needed to generate meta for our Log4j plugins
-     // Paper end
-     implementation("org.apache.logging.log4j:log4j-iostreams:2.17.1") // Paper
-+    implementation("org.apache.logging.log4j:log4j-slf4j18-impl:2.17.1") // Paper
-     implementation("org.ow2.asm:asm:9.3")
-     implementation("org.ow2.asm:asm-commons:9.3") // Paper - ASM event executor generation
-     implementation("org.spongepowered:configurate-yaml:4.1.2") // Paper - config files