More more more more more work

build-data/dev-imports.txt

@@ -8,3 +8,4 @@
 # To import classes from the vanilla Minecraft jar use `minecraft` as the artifactId:
 #     minecraft net.minecraft.world.level.entity.LevelEntityGetterAdapter
 #     minecraft net/minecraft/world/level/entity/LevelEntityGetter.java
+

patches/server/API-to-get-a-BlockState-without-a-snapshot.patch

@@ -16,15 +16,15 @@ diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
+@@ -0,0 +0,0 @@ public abstract class BlockEntity implements io.papermc.paper.util.KeyedObject {
          this.type = type;
          this.worldPosition = pos.immutable();
          this.blockState = state;
 +        this.persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY); // Paper - always init
      }
  
-     // Paper start
-@@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
+     public static BlockPos getPosFromTag(CompoundTag nbt) {
+@@ -0,0 +0,0 @@ public abstract class BlockEntity implements io.papermc.paper.util.KeyedObject {
  
      // CraftBukkit start - read container
      public void load(CompoundTag nbt) {
@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          net.minecraft.nbt.Tag persistentDataTag = nbt.get("PublicBukkitValues");
          if (persistentDataTag instanceof CompoundTag) {
-@@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
+@@ -0,0 +0,0 @@ public abstract class BlockEntity implements io.papermc.paper.util.KeyedObject {
  
      // CraftBukkit start - add method
      public InventoryHolder getOwner() {

patches/server/Ability-to-apply-mending-to-XP-API.patch

@@ -31,21 +31,6 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.server.network.ServerGamePacketListenerImpl;
- import net.minecraft.server.players.UserWhiteListEntry;
- import net.minecraft.world.entity.Entity;
-+import net.minecraft.world.entity.ExperienceOrb;
- import net.minecraft.world.entity.LivingEntity;
- import net.minecraft.world.entity.ai.attributes.AttributeInstance;
- import net.minecraft.world.entity.ai.attributes.AttributeMap;
- import net.minecraft.world.entity.ai.attributes.Attributes;
- import net.minecraft.world.inventory.AbstractContainerMenu;
-+import net.minecraft.world.item.enchantment.EnchantmentHelper;
-+import net.minecraft.world.item.enchantment.Enchantments;
- import net.minecraft.world.level.GameType;
- import net.minecraft.world.level.block.Blocks;
- import net.minecraft.world.level.block.entity.SignBlockEntity;
 @@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
          return GameMode.getByValue(this.getHandle().gameMode.getGameModeForPlayer().getId());
      }
@@ -55,10 +40,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public int applyMending(int amount) {
 +        ServerPlayer handle = getHandle();
 +        // Logic copied from EntityExperienceOrb and remapped to unobfuscated methods/properties
-+        net.minecraft.world.item.ItemStack itemstack = EnchantmentHelper.getRandomEquippedItemWithEnchant(Enchantments.MENDING, handle);
++        net.minecraft.world.item.ItemStack itemstack = net.minecraft.world.item.enchantment.EnchantmentHelper
++            .getRandomEquippedItemWithEnchant(net.minecraft.world.item.enchantment.Enchantments.MENDING, handle);
 +        if (!itemstack.isEmpty() && itemstack.getItem().canBeDepleted()) {
-+
-+            ExperienceOrb orb = net.minecraft.world.entity.EntityType.EXPERIENCE_ORB.create(handle.level);
++            net.minecraft.world.entity.ExperienceOrb orb = net.minecraft.world.entity.EntityType.EXPERIENCE_ORB.create(handle.level);
 +            orb.value = amount;
 +            orb.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM;
 +            orb.setPosRaw(handle.getX(), handle.getY(), handle.getZ());

patches/server/Basic-PlayerProfile-API.patch

@@ -332,7 +332,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final Environment environment;
 +    public PaperAuthenticationService(Proxy proxy) {
 +        super(proxy);
-+        this.environment = (Environment)EnvironmentParser.getEnvironmentFromProperties().orElse(YggdrasilEnvironment.PROD);;
++        this.environment = EnvironmentParser.getEnvironmentFromProperties().orElse(YggdrasilEnvironment.PROD.getEnvironment());
 +    }
 +
 +    @Override

patches/server/Configurable-Grass-Spread-Tick-Rate.patch

@@ -35,9 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public void randomTick(BlockState state, ServerLevel world, BlockPos pos, Random random) {
--        if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
 +        if (this instanceof GrassBlock && world.paperConfig.grassUpdateRate != 1 && (world.paperConfig.grassUpdateRate < 1 || (MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig.grassUpdateRate != 0)) { return; } // Paper
-+        if (!SpreadingSnowyDirtBlock.canBeGrass(state, (LevelReader) world, pos)) {
+         if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
              // CraftBukkit start
              if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {
-                 return;

patches/server/Entity-fromMobSpawner.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
      public final org.spigotmc.ActivationRange.ActivationType activationType = org.spigotmc.ActivationRange.initializeEntityActivationType(this);
      public final boolean defaultActivationState;
      public long activatedTick = Integer.MIN_VALUE;
@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      protected int numCollisions = 0; // Paper
      public void inactiveTick() { }
      // Spigot end
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
                  }
                  nbt.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
              }
@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // Paper end
              return nbt;
          } catch (Throwable throwable) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
                  this.originWorld = originWorld;
                  origin = new org.bukkit.util.Vector(originTag.getDouble(0), originTag.getDouble(1), originTag.getDouble(2));
              }

patches/server/Fix-MC-117075-TE-Unload-Lag-Spike.patch

@@ -32,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                this.blockEntityTickers.remove(this.tileTickPosition--);
 +                toRemove.add(tickingblockentity); // Paper - use removeAll
                  // Spigot end
-             } else {
+             } else if (this.shouldTickBlocksAt(ChunkPos.asLong(tickingblockentity.getPos()))) {
                  tickingblockentity.tick();
              }
          }

patches/server/Fix-this-stupid-bullshit.patch

@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/Main.java
 @@ -0,0 +0,0 @@ public class Main {
                      Calendar deadline = Calendar.getInstance();
-                     deadline.add(Calendar.DAY_OF_YEAR, -28);
+                     deadline.add(Calendar.DAY_OF_YEAR, -7);
                      if (buildDate.before(deadline.getTime())) {
 -                        System.err.println("*** Error, this build is outdated ***");
 +                        // Paper start - This is some stupid bullshit

patches/server/Handle-plugin-prefixes-using-Log4J-configuration.patch

@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    implementation("org.apache.logging.log4j:log4j-core:2.14.1") // Paper - implementation
      // Paper end
      implementation("org.apache.logging.log4j:log4j-iostreams:2.14.1") // Paper
-     implementation("org.apache.logging.log4j:log4j-api:2.14.1") // Paper
+     implementation("org.ow2.asm:asm:9.2")
 diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/spigotmc/SpigotConfig.java

patches/server/Implement-extended-PaperServerListPingEvent.patch

@@ -204,14 +204,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import com.google.common.collect.Maps;
  import com.google.common.collect.Sets;
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         if (i - this.lastServerStatus >= 5000000000L) {
              this.lastServerStatus = i;
              this.status.setPlayers(new ServerStatus.Players(this.getMaxPlayers(), this.getPlayerCount()));
--            GameProfile[] agameprofile = new GameProfile[Math.min(this.getPlayerCount(), 12)];
-+            GameProfile[] agameprofile = new GameProfile[Math.min(this.getPlayerCount(), org.spigotmc.SpigotConfig.playerSample)]; // Paper
-             int j = Mth.nextInt(this.random, 0, this.getPlayerCount() - agameprofile.length);
+             if (!this.hidesOnlinePlayers()) {
+-                GameProfile[] agameprofile = new GameProfile[Math.min(this.getPlayerCount(), 12)];
++                GameProfile[] agameprofile = new GameProfile[Math.min(this.getPlayerCount(), org.spigotmc.SpigotConfig.playerSample)]; // Paper
+                 int j = Mth.nextInt(this.random, 0, this.getPlayerCount() - agameprofile.length);
  
-             for (int k = 0; k < agameprofile.length; ++k) {
+                 for (int k = 0; k < agameprofile.length; ++k) {
 diff --git a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
@@ -226,15 +226,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // this.networkManager.sendPacket(new PacketStatusOutServerInfo(this.minecraftServer.getServerPing()));
              final Object[] players = this.server.getPlayerList().players.toArray();
 @@ -0,0 +0,0 @@ public class ServerStatusPacketListenerImpl implements ServerStatusPacketListene
-             ping.setVersion(new ServerStatus.Version(this.server.getServerModName() + " " + this.server.getServerVersion(), version));
  
              this.connection.send(new ClientboundStatusResponsePacket(ping));
+             // CraftBukkit end
 +            */
 +            com.destroystokyo.paper.network.StandardPaperServerListPingEventImpl.processRequest(this.server, this.connection);
 +            // Paper end
          }
-         // CraftBukkit end
      }
+ 
 diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/spigotmc/SpigotConfig.java

patches/server/Ocelot-despawns-should-honor-nametags-and-leash.patch

@@ -12,8 +12,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public boolean removeWhenFarAway(double distanceSquared) {
--        return !this.isTrusting() /*&& this.ticksLived > 2400*/; // CraftBukkit
-+        return !this.isTrusting() && !this.hasCustomName() && !this.isLeashed() /*&& this.ticksLived > 2400*/; // CraftBukkit // Paper - honor name and leash
+-        return !this.isTrusting() /*&& this.tickCount > 2400*/; // CraftBukkit
++        return !this.isTrusting() && !this.hasCustomName() && !this.isLeashed() /*&& this.tickCount > 2400*/; // CraftBukkit // Paper - honor name and leash
      }
  
      public static AttributeSupplier.Builder createAttributes() {

patches/server/Only-send-Dragon-Wither-Death-sounds-to-same-world.patch

@@ -30,8 +30,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      // CraftBukkit start - Use relative location for far away sounds
                      // this.world.globalLevelEvent(1023, new BlockPosition(this), 0);
 -                    int viewDistance = ((ServerLevel) this.level).getCraftServer().getViewDistance() * 16;
+-                    for (ServerPlayer player : (List<ServerPlayer>) MinecraftServer.getServer().getPlayerList().players) {
 +                    //int viewDistance = ((ServerLevel) this.level).getCraftServer().getViewDistance() * 16; // Paper - updated to use worlds actual view distance incase we have to uncomment this due to removal of player view distance API
-                     for (ServerPlayer player : (List<ServerPlayer>) MinecraftServer.getServer().getPlayerList().players) {
++                    for (ServerPlayer player : (List<ServerPlayer>)this.level.players()) { // Paper
 +                        final int viewDistance = player.getViewDistance(); // TODO apply view distance api patch
                          double deltaX = this.getX() - player.getX();
                          double deltaZ = this.getZ() - player.getZ();

patches/server/Player.setPlayerProfile-API.patch

@@ -42,8 +42,8 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.item.enchantment.EnchantmentHelper;
- import net.minecraft.world.item.enchantment.Enchantments;
+@@ -0,0 +0,0 @@ import net.minecraft.world.entity.ai.attributes.Attributes;
+ import net.minecraft.world.inventory.AbstractContainerMenu;
  import net.minecraft.world.level.GameType;
  import net.minecraft.world.level.block.Blocks;
 +import net.minecraft.world.level.biome.BiomeManager;

patches/server/PlayerAttemptPickupItemEvent.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -0,0 +0,0 @@ import net.minecraft.stats.Stats;
+@@ -0,0 +0,0 @@ import net.minecraft.util.Mth;
  import org.bukkit.event.entity.EntityPickupItemEvent;
  import org.bukkit.event.player.PlayerPickupItemEvent;
  // CraftBukkit end

patches/server/PlayerNaturallySpawnCreaturesEvent.patch

@@ -19,30 +19,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        double blockRange = (reducedRange) ? Math.pow(chunkRange << 4, 2) : 16384.0D;
 +        final int finalChunkRange = chunkRange; // Paper for lambda below
 +        //double blockRange = (reducedRange) ? Math.pow(chunkRange << 4, 2) : 16384.0D; // Paper - use from event
++        double blockRange = 16384.0D; // Paper
          // Spigot end
          long i = chunkcoordintpair.toLong();
  
-         return !this.distanceManager.hasPlayersNearby(i) ? true : this.playerMap.getPlayers(i).noneMatch((entityplayer) -> {
-+            // Paper start - add PlayerNaturallySpawnCreaturesEvent
-+            com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent event;
-+            double blockRange = 16384.0D;
-+            if (reducedRange) {
-+                event = entityplayer.playerNaturallySpawnedEvent;
-+                if (event == null || event.isCancelled()) return false;
-+                blockRange = (double) ((event.getSpawnRadius() << 4) * (event.getSpawnRadius() << 4));
-+            }
-+            // Paper end
-             return !entityplayer.isSpectator() && ChunkMap.euclideanDistanceSquared(chunkcoordintpair, (Entity) entityplayer) < blockRange; // Spigot
-         });
-     }
+@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 }
+ 
+                 entityplayer = (ServerPlayer) iterator.next();
++                // Paper start - add PlayerNaturallySpawnCreaturesEvent
++                com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent event;
++                blockRange = 16384.0D;
++                if (reducedRange) {
++                    event = entityplayer.playerNaturallySpawnedEvent;
++                    if (event == null || event.isCancelled()) return false;
++                    blockRange = (double) ((event.getSpawnRadius() << 4) * (event.getSpawnRadius() << 4));
++                }
++                // Paper end
+             } while (!this.playerIsCloseEnoughForSpawning(entityplayer, chunkcoordintpair, blockRange)); // Spigot
+ 
+             return true;
 diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
 +++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
 @@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-             List<ChunkHolder> list = Lists.newArrayList(this.chunkMap.getChunks());
+             boolean flag2 = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit
  
-             Collections.shuffle(list);
+             //Collections.shuffle(list); // Paper - no... just no...
 +            // Paper start - call player naturally spawn event
 +            int chunkRange = level.spigotConfig.mobSpawnRange;
 +            chunkRange = (chunkRange > level.spigotConfig.viewDistance) ? (byte) level.spigotConfig.viewDistance : chunkRange;
@@ -52,9 +56,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                entityPlayer.playerNaturallySpawnedEvent.callEvent();
 +            };
 +            // Paper end
-             this.level.timings.chunkTicks.startTiming(); // Paper
-             list.forEach((playerchunk) -> {
-                 Optional<LevelChunk> optional = ((Either) playerchunk.getTickingChunkFuture().getNow(ChunkHolder.UNLOADED_LEVEL_CHUNK)).left();
+             Iterator iterator1 = list.iterator();
+ 
+             while (iterator1.hasNext()) {
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java

patches/server/PreCreatureSpawnEvent.patch

@@ -21,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityType<T extends Entity> implements EntityTypeTest<Entity, T> {
  
      @Nullable
-     public T spawnCreature(ServerLevel worldserver, @Nullable CompoundTag nbttagcompound, @Nullable Component ichatbasecomponent, @Nullable Player entityhuman, BlockPos blockposition, MobSpawnType enummobspawn, boolean flag, boolean flag1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason) {
+     public T spawn(ServerLevel worldserver, @Nullable CompoundTag nbttagcompound, @Nullable Component ichatbasecomponent, @Nullable Player entityhuman, BlockPos blockposition, MobSpawnType enummobspawn, boolean flag, boolean flag1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason) {
 +        // Paper start - Call PreCreatureSpawnEvent
 +        org.bukkit.entity.EntityType type = org.bukkit.entity.EntityType.fromName(EntityType.getKey(this).getPath());
 +        if (type != null) {
@@ -70,9 +70,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
 +++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
 @@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-                     double d2 = j >= 3 ? nbttaglist.getDouble(2) : (double) pos.getZ() + (world.random.nextDouble() - world.random.nextDouble()) * (double) this.spawnRange + 0.5D;
- 
-                     if (world.noCollision(((EntityType) optional.get()).getAABB(d0, d1, d2)) && SpawnPlacements.checkSpawnRules((EntityType) optional.get(), world, MobSpawnType.SPAWNER, new BlockPos(d0, d1, d2), world.getRandom())) {
+                         } else if (!SpawnPlacements.checkSpawnRules((EntityType) optional.get(), world, MobSpawnType.SPAWNER, blockposition1, world.getRandom())) {
+                             continue;
+                         }
 +                        // Paper start
 +                        EntityType<?> entityType = optional.get();
 +                        String key = EntityType.getKey(entityType).getPath();
@@ -94,9 +94,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            }
 +                        }
 +                        // Paper end
+ 
                          Entity entity = EntityType.loadEntityRecursive(nbttagcompound, world, (entity1) -> {
                              entity1.moveTo(d0, d1, d2, entity1.getYRot(), entity1.getXRot());
-                             return entity1;
 diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java

patches/server/Send-attack-SoundEffects-only-to-players-who-can-see.patch

@@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import net.minecraft.network.syncher.EntityDataSerializers;
  import net.minecraft.network.syncher.SynchedEntityData;
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                     int i = b0 + EnchantmentHelper.getKnockbackBonus((LivingEntity) this);
+                     int i = b0 + EnchantmentHelper.getKnockbackBonus(this);
  
                      if (this.isSprinting() && flag) {
 -                        this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_KNOCKBACK, this.getSoundSource(), 1.0F, 1.0F);
@@ -56,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
  
-                         this.applyExhaustion(level.spigotConfig.combatExhaustion, EntityExhaustionEvent.ExhaustionReason.ATTACK); // CraftBukkit - EntityExhaustionEvent // Spigot - Change to use configurable value
+                         this.causeFoodExhaustion(level.spigotConfig.combatExhaustion, EntityExhaustionEvent.ExhaustionReason.ATTACK); // CraftBukkit - EntityExhaustionEvent // Spigot - Change to use configurable value
                      } else {
 -                        this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_NODAMAGE, this.getSoundSource(), 1.0F, 1.0F);
 +                        sendSoundEffect(this, this.getX(), this.getY(), this.getZ(), SoundEvents.PLAYER_ATTACK_NODAMAGE, this.getSoundSource(), 1.0F, 1.0F); // Paper - send while respecting visibility

patches/server/Shoulder-Entities-Release-API.patch

@@ -43,11 +43,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
  
                  entity.setPos(this.getX(), this.getY() + 0.699999988079071D, this.getZ());
--                return ((ServerLevel) this.level).addEntitySerialized(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
+-                return ((ServerLevel) this.level).addWithUUID(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
 -            }).orElse(true); // CraftBukkit
-+                boolean addedToWorld = ((ServerLevel) this.level).addEntitySerialized(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
++                boolean addedToWorld = ((ServerLevel) this.level).addWithUUID(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
 +                return addedToWorld ? entity : null;
-+            }).orElse(null); // CraftBukkit // Paper - false -> null
++            }).orElse(null); // CraftBukkit // Paper - true -> null
          }
  
 -        return true; // CraftBukkit

patches/server/revert-serverside-behavior-of-keepalives.patch

@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private boolean keepAlivePending;
 +    private long keepAliveChallenge;
      // CraftBukkit start - multithreaded fields
-     private AtomicInteger chatSpamTickCount = new AtomicInteger();
+     private final AtomicInteger chatSpamTickCount = new AtomicInteger();
      // CraftBukkit end
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
      private int aboveGroundVehicleTickCount;

patches/unapplied/Make-max-squid-spawn-height-configurable.patch

@@ -3,6 +3,7 @@ From: Zach Brown <1254957+zachbr@users.noreply.github.com>
 Date: Thu, 11 Jan 2018 16:47:28 -0600
 Subject: [PATCH] Make max squid spawn height configurable
 
+#NOTE: Spigot removed the min option, Vanilla now has the same spawn rule for all ambient water animals
 I don't know why upstream made only the minimum height configurable but
 whatever
 
@@ -25,12 +26,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
 @@ -0,0 +0,0 @@ public class Squid extends WaterAnimal {
+     public void travel(Vec3 movementInput) {
+         this.move(MoverType.SELF, this.getDeltaMovement());
      }
- 
-     public static boolean checkSquidSpawnRules(EntityType<Squid> type, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) {
--        return pos.getY() > world.getMinecraftWorld().spigotConfig.squidSpawnRangeMin && pos.getY() < world.getSeaLevel(); // Spigot
-+        final double maxHeight = world.getMinecraftWorld().paperConfig.squidMaxSpawnHeight > 0 ? world.getMinecraftWorld().paperConfig.squidMaxSpawnHeight : world.getSeaLevel(); // Paper
-+        return pos.getY() > world.getMinecraftWorld().spigotConfig.squidSpawnRangeMin && pos.getY() < maxHeight; // Spigot // Paper
-     }
- 
+-
++// AAA
      @Override
+     public void handleEntityEvent(byte status) {
+         if (status == 19) {

patches/unapplied/Make-targetSize-more-aggressive-in-the-chunk-unload-.patch

@@ -3,6 +3,8 @@ From: Brokkonaut <hannos17@gmx.de>
 Date: Tue, 7 Feb 2017 16:55:35 -0600
 Subject: [PATCH] Make targetSize more aggressive in the chunk unload queue
 
+#NOTE: Vanilla now does incremental chunk saves
+
 
 diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

todo.txt

@@ -1,2 +1,3 @@
 Add Timings to LevelTicks and EntityTickList
 Check IBlockDataList#GLOBAL_PALETTE
+Check if PlayerNaturallySpawnedEvent is called correctly