more patches

patches/server/Add-phantom-creative-and-insomniac-controls.patch

@@ -34,10 +34,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
 @@ -0,0 +0,0 @@ public class PhantomSpawner implements CustomSpawner {
                      while (iterator.hasNext()) {
-                         Player entityhuman = (Player) iterator.next();
+                         ServerPlayer entityplayer = (ServerPlayer) iterator.next();
  
--                        if (!entityhuman.isSpectator()) {
-+                        if (!entityhuman.isSpectator() && (!world.paperConfig().entities.behavior.phantomsDoNotSpawnOnCreativePlayers || !entityhuman.isCreative())) { // Paper
-                             BlockPos blockposition = entityhuman.blockPosition();
+-                        if (!entityplayer.isSpectator()) {
++                        if (!entityplayer.isSpectator() && (!world.paperConfig().entities.behavior.phantomsDoNotSpawnOnCreativePlayers || !entityplayer.isCreative())) { // Paper
+                             BlockPos blockposition = entityplayer.blockPosition();
  
                              if (!world.dimensionType().hasSkyLight() || blockposition.getY() >= world.getSeaLevel() && world.canSeeSky(blockposition)) {

patches/server/Do-not-allow-bees-to-load-chunks-for-beehives.patch

@@ -12,31 +12,31 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.hivePos == null) {
              return false;
          } else {
-+            if (!this.level.isLoadedAndInBounds(hivePos)) return false; // Paper
-             BlockEntity tileentity = this.level.getBlockEntity(this.hivePos);
++            if (!this.level().isLoadedAndInBounds(this.hivePos)) return false; // Paper
+             BlockEntity tileentity = this.level().getBlockEntity(this.hivePos);
  
              return tileentity instanceof BeehiveBlockEntity && ((BeehiveBlockEntity) tileentity).isFireNearby();
 @@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
      }
  
      private boolean doesHiveHaveSpace(BlockPos pos) {
-+        if (!this.level.isLoadedAndInBounds(pos)) return false; // Paper
-         BlockEntity tileentity = this.level.getBlockEntity(pos);
++        if (!this.level().isLoadedAndInBounds(pos)) return false; // Paper
+         BlockEntity tileentity = this.level().getBlockEntity(pos);
  
          return tileentity instanceof BeehiveBlockEntity ? !((BeehiveBlockEntity) tileentity).isFull() : false;
 @@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
          @Override
          public boolean canBeeUse() {
              if (Bee.this.hasHive() && Bee.this.wantsToEnterHive() && Bee.this.hivePos.closerToCenterThan(Bee.this.position(), 2.0D)) {
-+                if (!Bee.this.level.isLoadedAndInBounds(Bee.this.hivePos)) return false; // Paper
-                 BlockEntity tileentity = Bee.this.level.getBlockEntity(Bee.this.hivePos);
++                if (!Bee.this.level().isLoadedAndInBounds(Bee.this.hivePos)) return false; // Paper
+                 BlockEntity tileentity = Bee.this.level().getBlockEntity(Bee.this.hivePos);
  
                  if (tileentity instanceof BeehiveBlockEntity) {
 @@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
  
          @Override
          public void start() {
-+            if (!Bee.this.level.isLoadedAndInBounds(Bee.this.hivePos)) return; // Paper
-             BlockEntity tileentity = Bee.this.level.getBlockEntity(Bee.this.hivePos);
++            if (!Bee.this.level().isLoadedAndInBounds(Bee.this.hivePos)) return; // Paper
+             BlockEntity tileentity = Bee.this.level().getBlockEntity(Bee.this.hivePos);
  
              if (tileentity instanceof BeehiveBlockEntity) {

patches/server/Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch

@@ -20,4 +20,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (objectset == null || objectset.isEmpty()) { // Paper
              this.playersPerChunk.remove(i);
              this.naturalSpawnChunkCounter.update(i, Integer.MAX_VALUE, false);
-             //this.playerTicketManager.update(i, Integer.MAX_VALUE, false); // Paper - no longer used
+             this.playerTicketManager.update(i, Integer.MAX_VALUE, false);

patches/server/Don-t-move-existing-players-to-world-spawn.patch

@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
                  position = Vec3.atCenterOf(world.getSharedSpawnPos());
              }
-             this.level = world;
+             this.setLevel(world);
 -            this.setPos(position);
 +            this.setPosRaw(position.x(), position.y(), position.z()); // Paper - don't register to chunks yet
          }
@@ -45,4 +45,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            player.fudgeSpawnLocation(worldserver1); // only move to spawn on first login, otherwise, stay where you are....
          }
          // Paper end
-         player.setLevel(worldserver1);
+         player.setServerLevel(worldserver1);

patches/server/Don-t-run-entity-collision-code-if-not-needed.patch

@@ -16,8 +16,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         if (this.level.isClientSide()) {
-             this.level.getEntities(EntityTypeTest.forClass(net.minecraft.world.entity.player.Player.class), this.getBoundingBox(), EntitySelector.pushableBy(this)).forEach(this::doPush);
+         if (this.level().isClientSide()) {
+             this.level().getEntities(EntityTypeTest.forClass(net.minecraft.world.entity.player.Player.class), this.getBoundingBox(), EntitySelector.pushableBy(this)).forEach(this::doPush);
          } else {
 +            // Paper start - don't run getEntities if we're not going to use its result
 +            if (!this.isPushable()) {
@@ -28,15 +28,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return;
 +            }
 +
-+            int i = this.level.getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
-+            if (i <= 0 && level.paperConfig().collisions.maxEntityCollisions <= 0) {
++            int i = this.level().getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
++            if (i <= 0 && this.level().paperConfig().collisions.maxEntityCollisions <= 0) {
 +                return;
 +            }
 +            // Paper end - don't run getEntities if we're not going to use its result
-             List<Entity> list = this.level.getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushableBy(this));
+             List<Entity> list = this.level().getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushableBy(this));
  
              if (!list.isEmpty()) {
--                int i = this.level.getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
+-                int i = this.level().getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
 +                // Paper - moved up
                  int j;
  

patches/server/Fix-numerous-item-duplication-issues-and-teleport-is.patch

@@ -28,8 +28,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  return null;
              }
              // CraftBukkit end
--            ItemEntity entityitem = new ItemEntity(this.level, this.getX(), this.getY() + (double) yOffset, this.getZ(), stack);
-+            ItemEntity entityitem = new ItemEntity(this.level, this.getX(), this.getY() + (double) yOffset, this.getZ(), stack.copy()); // Paper - clone so we can destroy original
+-            ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) yOffset, this.getZ(), stack);
++            ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) yOffset, this.getZ(), stack.copy()); // Paper - copy so we can destroy original
 +            stack.setCount(0); // Paper - destroy this item - if this ever leaks due to game bugs, ensure it doesn't dupe
  
              entityitem.setDefaultPickUpDelay();
@@ -39,18 +39,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public Entity teleportTo(ServerLevel worldserver, PositionImpl location) {
          // CraftBukkit end
 +        // Paper start - fix bad state entities causing dupes
-+        if (!isAlive() || !valid) {
++        if (!this.isAlive() || !this.valid) {
 +            LOGGER.warn("Illegal Entity Teleport " + this + " to " + worldserver + ":" + location, new Throwable());
 +            return null;
 +        }
 +        // Paper end
-         if (this.level instanceof ServerLevel && !this.isRemoved()) {
-             this.level.getProfiler().push("changeDimension");
+         if (this.level() instanceof ServerLevel && !this.isRemoved()) {
+             this.level().getProfiler().push("changeDimension");
              // CraftBukkit start
 @@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
                  // CraftBukkit end
  
-                 this.level.getProfiler().popPush("reloading");
+                 this.level().getProfiler().popPush("reloading");
 +                // Paper start - Change lead drop timing to prevent dupe
 +                if (this instanceof Mob) {
 +                    ((Mob) this).dropLeash(true, true); // Paper drop lead

patches/server/Improved-Watchdog-Support.patch

@@ -92,7 +92,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
          AtomicReference<S> atomicreference = new AtomicReference();
-         Thread thread = new io.papermc.paper.util.TickThread(() -> { // Paper - rewrite chunk system
+         Thread thread = new Thread(() -> {
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      // CraftBukkit start
@@ -122,12 +122,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.metricsRecorder.isRecording()) {
              this.cancelRecordingMetrics();
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.getProfileCache().save(false); // Paper
          }
          // Spigot end
+ 
 +        // Paper start - move final shutdown items here
 +        LOGGER.info("Flushing Chunk IO");
-         io.papermc.paper.chunk.system.io.RegionFileIOThread.close(true); // Paper // Paper - rewrite chunk system
++       // io.papermc.paper.chunk.system.io.RegionFileIOThread.close(true); // Paper // Paper - rewrite chunk system
 +        LOGGER.info("Closing Thread Pool");
 +        Util.shutdownExecutors(); // Paper
 +        LOGGER.info("Closing Server");
@@ -303,7 +303,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } catch (Throwable throwable) {
 +            if (throwable instanceof ThreadDeath) throw throwable; // Paper
              // Paper start - Prevent tile entity and entity crashes
-             final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level.getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
+             final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level().getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
              MinecraftServer.LOGGER.error(msg, throwable);
 diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -475,14 +475,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/spigotmc/WatchdogThread.java
 +++ b/src/main/java/org/spigotmc/WatchdogThread.java
 @@ -0,0 +0,0 @@ import org.bukkit.Bukkit;
- public final class WatchdogThread extends io.papermc.paper.util.TickThread // Paper - rewrite chunk system
+ public class WatchdogThread extends Thread
  {
  
 +    public static final boolean DISABLE_WATCHDOG = Boolean.getBoolean("disable.watchdog"); // Paper
      private static WatchdogThread instance;
      private long timeoutTime;
      private boolean restart;
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
      {
          if ( WatchdogThread.instance == null )
          {
@@ -490,7 +490,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              WatchdogThread.instance = new WatchdogThread( timeoutTime * 1000L, restart );
              WatchdogThread.instance.start();
          } else
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
              // Paper start
              Logger log = Bukkit.getServer().getLogger();
              long currentTime = WatchdogThread.monotonicMillis();
@@ -507,7 +507,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  lastEarlyWarning = currentTime;
                  if (isLongTimeout) {
                  // Paper end
-@@ -0,0 +0,0 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
  
                  if ( isLongTimeout )
                  {

patches/server/Optimize-Collision-to-not-load-chunks.patch

@@ -41,8 +41,8 @@ diff --git a/src/main/java/net/minecraft/world/level/BlockCollisions.java b/src/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/BlockCollisions.java
 +++ b/src/main/java/net/minecraft/world/level/BlockCollisions.java
-@@ -0,0 +0,0 @@ public class BlockCollisions extends AbstractIterator<VoxelShape> {
-     protected VoxelShape computeNext() {
+@@ -0,0 +0,0 @@ public class BlockCollisions<T> extends AbstractIterator<T> {
+     protected T computeNext() {
          while(true) {
              if (this.cursor.advance()) {
 -                int i = this.cursor.nextX();

patches/server/Prevent-opening-inventories-when-frozen.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-             containerUpdateDelay = level.paperConfig().tickRates.containerUpdate;
+             containerUpdateDelay = this.level().paperConfig().tickRates.containerUpdate;
          }
          // Paper end
--        if (!this.level.isClientSide && !this.containerMenu.stillValid(this)) {
-+        if (!this.level.isClientSide && this.containerMenu != this.inventoryMenu && (isImmobile() || !this.containerMenu.stillValid(this))) { // Paper - auto close while frozen
+-        if (!this.level().isClientSide && !this.containerMenu.stillValid(this)) {
++        if (!this.level().isClientSide && this.containerMenu != this.inventoryMenu && (this.isImmobile() || !this.containerMenu.stillValid(this))) { // Paper - auto close while frozen
              this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper
              this.containerMenu = this.inventoryMenu;
          }
@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  // CraftBukkit start
                  this.containerMenu = container;
 -                this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle()));
-+                if (!isImmobile()) this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle())); // Paper
++                if (!this.isImmobile()) this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle())); // Paper
                  // CraftBukkit end
                  this.initMenu(container);
                  return OptionalInt.of(this.containerCounter);