Skip Improve-exact-choice-recipe-ingredients for now

patches/server/Add-LivingEntity-getTargetEntity.patch

@@ -8,19 +8,11 @@ diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.storage.loot.LootTable;
- import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets;
- import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
- import net.minecraft.world.phys.AABB;
-+import net.minecraft.world.phys.EntityHitResult;
- import net.minecraft.world.phys.HitResult;
- import net.minecraft.world.phys.Vec3;
- import net.minecraft.world.scores.PlayerTeam;
 @@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return this.level().clip(raytrace);
      }
  
-+    public @Nullable EntityHitResult getTargetEntity(int maxDistance) {
++    public @Nullable net.minecraft.world.phys.EntityHitResult getTargetEntity(int maxDistance) {
 +        if (maxDistance < 1 || maxDistance > 120) {
 +            throw new IllegalArgumentException("maxDistance must be between 1-120");
 +        }
@@ -32,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        List<Entity> entityList = this.level().getEntities(this, getBoundingBox().expandTowards(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance).inflate(1.0D, 1.0D, 1.0D), EntitySelector.NO_SPECTATORS.and(Entity::isPickable));
 +
 +        double distance = 0.0D;
-+        EntityHitResult result = null;
++        net.minecraft.world.phys.EntityHitResult result = null;
 +
 +        for (Entity entity : entityList) {
 +            final double inflationAmount = (double) entity.getPickRadius();
@@ -43,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                Vec3 rayTrace = rayTraceResult.get();
 +                double distanceTo = start.distanceToSqr(rayTrace);
 +                if (distanceTo < distance || distance == 0.0D) {
-+                    result = new EntityHitResult(entity, rayTrace);
++                    result = new net.minecraft.world.phys.EntityHitResult(entity, rayTrace);
 +                    distance = distanceTo;
 +                }
 +            }
@@ -59,13 +51,6 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@
- package org.bukkit.craftbukkit.entity;
- 
-+import com.destroystokyo.paper.entity.TargetEntityInfo;
- import com.google.common.base.Preconditions;
- import com.google.common.collect.Sets;
- import java.util.ArrayList;
 @@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
          }
          return null;
@@ -76,9 +61,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return rayTrace == null ? null : rayTrace.getEntity().getBukkitEntity();
 +    }
 +
-+    public TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks) {
++    public com.destroystokyo.paper.entity.TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks) {
 +        net.minecraft.world.phys.EntityHitResult rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : new TargetEntityInfo(rayTrace.getEntity().getBukkitEntity(), new org.bukkit.util.Vector(rayTrace.getLocation().x, rayTrace.getLocation().y, rayTrace.getLocation().z));
++        return rayTrace == null ? null : new com.destroystokyo.paper.entity.TargetEntityInfo(rayTrace.getEntity().getBukkitEntity(), new org.bukkit.util.Vector(rayTrace.getLocation().x, rayTrace.getLocation().y, rayTrace.getLocation().z));
 +    }
 +
 +    @Override

patches/server/Add-more-Zombie-API.patch

@@ -46,8 +46,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper end - Add more Zombie API
 +
      @Override
-     public boolean hurt(DamageSource source, float amount) {
-         if (!super.hurt(source, amount)) {
+     public boolean hurtServer(ServerLevel world, DamageSource source, float amount) {
+         if (!super.hurtServer(world, source, amount)) {
 @@ -0,0 +0,0 @@ public class Zombie extends Monster {
          nbt.putBoolean("CanBreakDoors", this.canBreakDoors());
          nbt.putInt("InWaterTime", this.isInWater() ? this.inWaterTime : -1);

patches/server/Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -58,10 +58,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                                  }
 +                                // Paper start - Prevent moving into unloaded chunks
 +                                if (this.player.level().paperConfig().chunks.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
-+                                    this.internalTeleport(this.player.getX(), this.player.getY(), this.player.getZ(), this.player.getYRot(), this.player.getXRot(), Collections.emptySet());
++                                    this.internalTeleport(PositionMoveRotation.of(this.player), Collections.emptySet());
 +                                    return;
 +                                }
 +                                // Paper end - Prevent moving into unloaded chunks
  
-                                 if (!this.player.isChangingDimension() && (!this.player.level().getGameRules().getBoolean(GameRules.RULE_DISABLE_ELYTRA_MOVEMENT_CHECK) || !flag)) {
+                                 if (this.shouldCheckPlayerMovement(flag)) {
                                      float f2 = flag ? 300.0F : 100.0F;

patches/server/Book-size-limits.patch

@@ -5,22 +5,6 @@ Subject: [PATCH] Book size limits
 
 Puts some limits on the size of books.
 
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ServerboundEditBookPacket.java b/src/main/java/net/minecraft/network/protocol/game/ServerboundEditBookPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ServerboundEditBookPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ServerboundEditBookPacket.java
-@@ -0,0 +0,0 @@ public record ServerboundEditBookPacket(int slot, List<String> pages, Optional<S
-     public static final StreamCodec<FriendlyByteBuf, ServerboundEditBookPacket> STREAM_CODEC = StreamCodec.composite(
-         ByteBufCodecs.VAR_INT,
-         ServerboundEditBookPacket::slot,
--        ByteBufCodecs.stringUtf8(8192).apply(ByteBufCodecs.list(200)),
-+        ByteBufCodecs.stringUtf8(net.minecraft.world.item.component.WritableBookContent.PAGE_EDIT_LENGTH).apply(ByteBufCodecs.list(net.minecraft.world.item.component.WritableBookContent.MAX_PAGES)), // Paper - limit books
-         ServerboundEditBookPacket::pages,
--        ByteBufCodecs.stringUtf8(128).apply(ByteBufCodecs::optional),
-+        ByteBufCodecs.stringUtf8(net.minecraft.world.item.component.WrittenBookContent.TITLE_MAX_LENGTH).apply(ByteBufCodecs::optional), // Paper - limit books
-         ServerboundEditBookPacket::title,
-         ServerboundEditBookPacket::new
-     );
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java

patches/server/Check-Drowned-for-Villager-Aggression-Config.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
 @@ -0,0 +0,0 @@ public class Drowned extends Zombie implements RangedAttackMob {
-         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0D));
-         this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[]{Drowned.class})).setAlertOthers(ZombifiedPiglin.class));
-         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::okTarget));
+         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0));
+         this.targetSelector.addGoal(1, new HurtByTargetGoal(this, Drowned.class).setAlertOthers(ZombifiedPiglin.class));
+         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, (target, world) -> this.okTarget(target)));
 -        this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false));
-+        if (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Paper - Check drowned for villager aggression config
++        if (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false));  // Paper - Check drowned for villager aggression config
          this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
          this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Axolotl.class, true, false));
          this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR));

patches/server/Don-t-allow-digging-into-unloaded-chunks.patch

@@ -40,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!this.player.canInteractWithBlock(pos, 1.0D)) {
 +            if (true) return; // Paper - Don't allow digging into unloaded chunks; Don't notify if unreasonably far away
              this.debugLogging(pos, false, sequence, "too far");
-         } else if (pos.getY() >= worldHeight) {
+         } else if (pos.getY() > worldHeight) {
              this.player.connection.send(new ClientboundBlockUpdatePacket(pos, this.level.getBlockState(pos)));
 @@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
                  this.debugLogging(pos, true, sequence, "stopped destroying");
@@ -72,6 +72,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    return;
 +                }
 +                // Paper end - Don't allow digging into unloaded chunks
-                 this.player.gameMode.handleBlockBreakAction(blockposition, packetplayinblockdig_enumplayerdigtype, packet.getDirection(), this.player.level().getMaxBuildHeight(), packet.getSequence());
+                 this.player.gameMode.handleBlockBreakAction(blockposition, packetplayinblockdig_enumplayerdigtype, packet.getDirection(), this.player.level().getMaxY(), packet.getSequence());
                  this.player.connection.ackBlockChangesUpTo(packet.getSequence());
                  return;

patches/server/Improve-Server-Thread-Pool-and-Thread-Priorities.patch

@@ -45,18 +45,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private static final int DEFAULT_MAX_THREADS = 255;
      private static final int DEFAULT_SAFE_FILE_OPERATION_RETRIES = 10;
      private static final String MAX_THREADS_SYSTEM_PROPERTY = "max.bg.threads";
--    private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main");
-+    private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main", -1); // Paper - Perf: add priority
-     private static final ExecutorService IO_POOL = makeIoExecutor("IO-Worker-", false);
-     private static final ExecutorService DOWNLOAD_POOL = makeIoExecutor("Download-", true);
+-    private static final TracingExecutor BACKGROUND_EXECUTOR = makeExecutor("Main");
++    private static final TracingExecutor BACKGROUND_EXECUTOR = makeExecutor("Main", -1); // Paper - Perf: add priority
+     private static final TracingExecutor IO_POOL = makeIoExecutor("IO-Worker-", false);
+     private static final TracingExecutor DOWNLOAD_POOL = makeIoExecutor("Download-", true);
      // Paper start - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
 @@ -0,0 +0,0 @@ public class Util {
          return FILENAME_DATE_TIME_FORMATTER.format(ZonedDateTime.now());
      }
  
--    private static ExecutorService makeExecutor(String name) {
+-    private static TracingExecutor makeExecutor(String name) {
 -        int i = Mth.clamp(Runtime.getRuntime().availableProcessors() - 1, 1, getMaxThreads());
-+    private static ExecutorService makeExecutor(String s, int priorityModifier) { // Paper - Perf: add priority
++    private static TracingExecutor makeExecutor(String s, final int priorityModifier) { // Paper - Perf: add priority
 +        // Paper start - Perf: use simpler thread pool that allows 1 thread and reduce worldgen thread worker count for low core count CPUs
 +        int cpus = Runtime.getRuntime().availableProcessors() / 2;
 +        int i;
@@ -70,26 +70,28 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        i = Math.min(8, i);
 +        i = Integer.getInteger("Paper.WorkerThreadCount", i);
++
          ExecutorService executorService;
          if (i <= 0) {
              executorService = MoreExecutors.newDirectExecutorService();
          } else {
 -            AtomicInteger atomicInteger = new AtomicInteger(1);
 -            executorService = new ForkJoinPool(i, pool -> {
--                ForkJoinWorkerThread forkJoinWorkerThread = new ForkJoinWorkerThread(pool) {
+-                final String string2 = "Worker-" + name + "-" + atomicInteger.getAndIncrement();
 +            executorService = new java.util.concurrent.ThreadPoolExecutor(i, i,0L, TimeUnit.MILLISECONDS, new java.util.concurrent.LinkedBlockingQueue<>(), target -> new io.papermc.paper.util.ServerWorkerThread(target, s, priorityModifier));
 +        }
-+        /*
++        /*      final String string2 = "Worker-" + name + "-" + atomicInteger.getAndIncrement();
+                 ForkJoinWorkerThread forkJoinWorkerThread = new ForkJoinWorkerThread(pool) {
                      @Override
-                     protected void onTermination(Throwable throwable) {
-                         if (throwable != null) {
+                     protected void onStart() {
 @@ -0,0 +0,0 @@ public class Util {
+                 forkJoinWorkerThread.setName(string2);
                  return forkJoinWorkerThread;
              }, Util::onThreadException, true);
-         }
-+        }*/ // Paper end - Perf: use simpler thread pool
+-        }
++        }*/
  
-         return executorService;
+         return new TracingExecutor(executorService);
      }
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Optimize-World-Time-Updates.patch

@@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if (this.tickCount % 20 == 0) {
 -            for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
 -                ServerPlayer entityplayer = (ServerPlayer) this.getPlayerList().players.get(i);
--                entityplayer.connection.send(new ClientboundSetTimePacket(entityplayer.level().getGameTime(), entityplayer.getPlayerTime(), entityplayer.level().getGameRules().getBoolean(GameRules.RULE_DAYLIGHT))); // Add support for per player time
+-                entityplayer.connection.send(new ClientboundSetTimePacket(entityplayer.level().getGameTime(), entityplayer.getPlayerTime(), entityplayer.serverLevel().getGameRules().getBoolean(GameRules.RULE_DAYLIGHT))); // Add support for per player time
 +        // Paper start - Perf: Optimize time updates
 +        for (final ServerLevel level : this.getAllLevels()) {
 +            final boolean doDaylight = level.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT);

patches/server/Reset-players-airTicks-on-respawn.patch

@@ -15,4 +15,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.setAirSupply(this.getMaxAirSupply()); // Paper - Reset players airTicks on respawn
          this.setRemainingFireTicks(0);
          this.fallDistance = 0;
-         this.foodData = new FoodData(this);
+         this.foodData = new FoodData();