Rewrite chunk system (#8177)

Patch documentation to come

Issues with the old system that are fixed now:
- World generation does not scale with cpu cores effectively.
- Relies on the main thread for scheduling and maintaining chunk state, dropping chunk load/generate rates at lower tps.
- Unreliable prioritisation of chunk gen/load calls that block the main thread.
- Shutdown logic is utterly unreliable, as it has to wait for all chunks to unload - is it guaranteed that the chunk system is in a state on shutdown that it can reliably do this? Watchdog shutdown also typically failed due to thread checks, which is now resolved.
- Saving of data is not unified (i.e can save chunk data without saving entity data, poses problems for desync if shutdown is really abnormal.
- Entities are not loaded with chunks. This caused quite a bit of headache for Chunk#getEntities API, but now the new chunk system loads entities with chunks so that they are ready whenever the chunk loads in. Effectively brings the behavior back to 1.16 era, but still storing entities in their own separate regionfiles.

The above list is not complete. The patch documentation will complete it.

New chunk system hard relies on starlight and dataconverter, and most importantly the new concurrent utilities in ConcurrentUtil.

Some of the old async chunk i/o interface (i.e the old file io thread reroutes _some_ calls to the new file io thread) is kept for plugin compat reasons. It will be removed in the next major version of minecraft.

The old legacy chunk system patches have been moved to the removed folder in case we need them again.

1 files changed, 251 insertions, 0 deletions

diff --git a/patches/server/0529-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch b/patches/server/0529-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch
new file mode 100644
index 0000000000..339a34391b
--- /dev/null
+++ b/patches/server/0529-Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch
@@ -0,0 +1,251 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <[email protected]>
+Date: Thu, 2 Jul 2020 16:12:10 -0700
+Subject: [PATCH] Add PlayerTradeEvent and PlayerPurchaseEvent
+
+Co-authored-by: Alexander <[email protected]>
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java b/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
+index 0c585354ba459ceb6badbf60dcf7b068bfa108b6..5eab7d50734551d96128dfebee126a1da4c51375 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
++++ b/src/main/java/net/minecraft/world/entity/npc/AbstractVillager.java
+@@ -138,11 +138,24 @@ public abstract class AbstractVillager extends AgeableMob implements InventoryCa
+     @Override
+     public void overrideXp(int experience) {}
+ 
++    // Paper start
++    @Override
++    public void processTrade(MerchantOffer recipe, @Nullable io.papermc.paper.event.player.PlayerPurchaseEvent event) { // The MerchantRecipe passed in here is the one set by the PlayerPurchaseEvent
++        if (event == null || event.willIncreaseTradeUses()) {
++            recipe.increaseUses();
++        }
++        if (event == null || event.isRewardingExp()) {
++            this.rewardTradeXp(recipe);
++        }
++        this.notifyTrade(recipe);
++    }
++    // Paper end
++
+     @Override
+     public void notifyTrade(MerchantOffer offer) {
+-        offer.increaseUses();
++        // offer.increaseUses(); // Paper - handled in processTrade
+         this.ambientSoundTime = -this.getAmbientSoundInterval();
+-        this.rewardTradeXp(offer);
++        // this.rewardTradeXp(offer); // Paper - handled in processTrade
+         if (this.tradingPlayer instanceof ServerPlayer) {
+             CriteriaTriggers.TRADE.trigger((ServerPlayer) this.tradingPlayer, this, offer.getResult());
+         }
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index 66261330157cef50dfabb7f92e9ece6dcd280951..823ead0fd1942db0219968cd383439b324b16f6e 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
++++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -751,6 +751,14 @@ public abstract class AbstractContainerMenu {
+     public abstract boolean stillValid(Player player);
+ 
+     protected boolean moveItemStackTo(ItemStack stack, int startIndex, int endIndex, boolean fromLast) {
++        // Paper start
++        return this.moveItemStackTo(stack, startIndex, endIndex, fromLast, false);
++    }
++    protected boolean moveItemStackTo(ItemStack stack, int startIndex, int endIndex, boolean fromLast, boolean isCheck) {
++        if (isCheck) {
++            stack = stack.copy();
++        }
++        // Paper end
+         boolean flag1 = false;
+         int k = startIndex;
+ 
+@@ -773,18 +781,27 @@ public abstract class AbstractContainerMenu {
+ 
+                 slot = (Slot) this.slots.get(k);
+                 itemstack1 = slot.getItem();
++                // Paper start - clone if only a check
++                if (isCheck) {
++                    itemstack1 = itemstack1.copy();
++                }
++                // Paper end
+                 if (!itemstack1.isEmpty() && ItemStack.isSameItemSameTags(stack, itemstack1)) {
+                     int l = itemstack1.getCount() + stack.getCount();
+ 
+                     if (l <= stack.getMaxStackSize()) {
+                         stack.setCount(0);
+                         itemstack1.setCount(l);
++                        if (!isCheck) { // Paper - dont update if only a check
+                         slot.setChanged();
++                        } // Paper
+                         flag1 = true;
+                     } else if (itemstack1.getCount() < stack.getMaxStackSize()) {
+                         stack.shrink(stack.getMaxStackSize() - itemstack1.getCount());
+                         itemstack1.setCount(stack.getMaxStackSize());
++                        if (!isCheck) { // Paper - dont update if only a check
+                         slot.setChanged();
++                        } // Paper
+                         flag1 = true;
+                     }
+                 }
+@@ -815,14 +832,33 @@ public abstract class AbstractContainerMenu {
+ 
+                 slot = (Slot) this.slots.get(k);
+                 itemstack1 = slot.getItem();
++                // Paper start - clone if only a check
++                if (isCheck) {
++                    itemstack1 = itemstack1.copy();
++                }
++                // Paper end
+                 if (itemstack1.isEmpty() && slot.mayPlace(stack)) {
+                     if (stack.getCount() > slot.getMaxStackSize()) {
++                        // Paper start - dont set slot if only check
++                        if (isCheck) {
++                            stack.shrink(slot.getMaxStackSize());
++                        } else {
++                        // Paper end
+                         slot.set(stack.split(slot.getMaxStackSize()));
++                        } // Paper
+                     } else {
++                        // Paper start - dont set slot if only check
++                        if (isCheck) {
++                            stack.shrink(stack.getCount());
++                        } else {
++                        // Paper end
+                         slot.set(stack.split(stack.getCount()));
++                        } // Paper
+                     }
+ 
++                    if (!isCheck) { // Paper - dont update if only check
+                     slot.setChanged();
++                    } // Paper
+                     flag1 = true;
+                     break;
+                 }
+diff --git a/src/main/java/net/minecraft/world/inventory/MerchantMenu.java b/src/main/java/net/minecraft/world/inventory/MerchantMenu.java
+index 0d3002c5b13cbac0e021e8cdcf7d0685b256268a..3e3dfbe30fc5357e144aa176bc5df1b8a7ae6d64 100644
+--- a/src/main/java/net/minecraft/world/inventory/MerchantMenu.java
++++ b/src/main/java/net/minecraft/world/inventory/MerchantMenu.java
+@@ -134,12 +134,12 @@ public class MerchantMenu extends AbstractContainerMenu {
+ 
+             itemstack = itemstack1.copy();
+             if (index == 2) {
+-                if (!this.moveItemStackTo(itemstack1, 3, 39, true)) {
++                if (!this.moveItemStackTo(itemstack1, 3, 39, true, true)) { // Paper
+                     return ItemStack.EMPTY;
+                 }
+ 
+-                slot.onQuickCraft(itemstack1, itemstack);
+-                this.playTradeSound();
++                // slot.onQuickCraft(itemstack1, itemstack); // Paper - moved to after the non-check moveItemStackTo call
++                // this.playTradeSound();
+             } else if (index != 0 && index != 1) {
+                 if (index >= 3 && index < 30) {
+                     if (!this.moveItemStackTo(itemstack1, 30, 39, false)) {
+@@ -152,6 +152,7 @@ public class MerchantMenu extends AbstractContainerMenu {
+                 return ItemStack.EMPTY;
+             }
+ 
++            if (index != 2) { // Paper - moved down for slot 2
+             if (itemstack1.isEmpty()) {
+                 slot.set(ItemStack.EMPTY);
+             } else {
+@@ -163,6 +164,21 @@ public class MerchantMenu extends AbstractContainerMenu {
+             }
+ 
+             slot.onTake(player, itemstack1);
++            } // Paper start - handle slot 2
++            if (index == 2) { // is merchant result slot
++                slot.onTake(player, itemstack1);
++                if (itemstack1.isEmpty()) {
++                    slot.set(ItemStack.EMPTY);
++                    return ItemStack.EMPTY;
++                }
++
++                this.moveItemStackTo(itemstack1, 3, 39, true, false); // This should always succeed because it's checked above
++
++                slot.onQuickCraft(itemstack1, itemstack);
++                this.playTradeSound();
++                slot.set(ItemStack.EMPTY); // itemstack1 should ALWAYS be empty
++            }
++            // Paper end
+         }
+ 
+         return itemstack;
+diff --git a/src/main/java/net/minecraft/world/inventory/MerchantResultSlot.java b/src/main/java/net/minecraft/world/inventory/MerchantResultSlot.java
+index 74b28315197b81f80334ae6023113904e4fac4c3..7acf5ab9339e0134819aab5f270e99e927cc7a62 100644
+--- a/src/main/java/net/minecraft/world/inventory/MerchantResultSlot.java
++++ b/src/main/java/net/minecraft/world/inventory/MerchantResultSlot.java
+@@ -47,13 +47,32 @@ public class MerchantResultSlot extends Slot {
+ 
+     @Override
+     public void onTake(Player player, ItemStack stack) {
+-        this.checkTakeAchievements(stack);
++        // this.checkTakeAchievements(stack); // Paper - move to after event is called and not cancelled
+         MerchantOffer merchantOffer = this.slots.getActiveOffer();
++        // Paper start
++        io.papermc.paper.event.player.PlayerPurchaseEvent event = null;
++        if (merchantOffer != null && player instanceof net.minecraft.server.level.ServerPlayer serverPlayer) {
++            if (this.merchant instanceof net.minecraft.world.entity.npc.AbstractVillager abstractVillager) {
++                event = new io.papermc.paper.event.player.PlayerTradeEvent(serverPlayer.getBukkitEntity(), (org.bukkit.entity.AbstractVillager) abstractVillager.getBukkitEntity(), merchantOffer.asBukkit(), true, true);
++            } else if (this.merchant instanceof org.bukkit.craftbukkit.inventory.CraftMerchantCustom.MinecraftMerchant) {
++                event = new io.papermc.paper.event.player.PlayerPurchaseEvent(serverPlayer.getBukkitEntity(), merchantOffer.asBukkit(), false, true);
++            }
++            if (event != null) {
++                if (!event.callEvent()) {
++                    stack.setCount(0);
++                    event.getPlayer().updateInventory();
++                    return;
++                }
++                merchantOffer = org.bukkit.craftbukkit.inventory.CraftMerchantRecipe.fromBukkit(event.getTrade()).toMinecraft();
++            }
++        }
++        this.checkTakeAchievements(stack);
++        // Paper end
+         if (merchantOffer != null) {
+             ItemStack itemStack = this.slots.getItem(0);
+             ItemStack itemStack2 = this.slots.getItem(1);
+             if (merchantOffer.take(itemStack, itemStack2) || merchantOffer.take(itemStack2, itemStack)) {
+-                this.merchant.notifyTrade(merchantOffer);
++                this.merchant.processTrade(merchantOffer, event); // Paper
+                 player.awardStat(Stats.TRADED_WITH_VILLAGER);
+                 this.slots.setItem(0, itemStack);
+                 this.slots.setItem(1, itemStack2);
+diff --git a/src/main/java/net/minecraft/world/item/trading/Merchant.java b/src/main/java/net/minecraft/world/item/trading/Merchant.java
+index d41f44ed2e497ba3373d170c08488b49e88334c4..d3a99ba6f3085ad12b67ddc94cc4ab393ec7ecbe 100644
+--- a/src/main/java/net/minecraft/world/item/trading/Merchant.java
++++ b/src/main/java/net/minecraft/world/item/trading/Merchant.java
+@@ -20,6 +20,7 @@ public interface Merchant {
+ 
+     void overrideOffers(MerchantOffers offers);
+ 
++    default void processTrade(MerchantOffer merchantRecipe, @Nullable io.papermc.paper.event.player.PlayerPurchaseEvent event) { this.notifyTrade(merchantRecipe); } // Paper
+     void notifyTrade(MerchantOffer offer);
+ 
+     void notifyTradeUpdated(ItemStack stack);
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java
+index 257776a12ca26c1e75be22a67c94b0aa012fd687..5074e8b2259b3fb969bd0ff99c296b7537920273 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantCustom.java
+@@ -74,10 +74,25 @@ public class CraftMerchantCustom extends CraftMerchant {
+             return this.trades;
+         }
+ 
++        // Paper start
++        @Override
++        public void processTrade(MerchantOffer merchantRecipe, @javax.annotation.Nullable io.papermc.paper.event.player.PlayerPurchaseEvent event) { // The MerchantRecipe passed in here is the one set by the PlayerPurchaseEvent
++            /** Based on {@link net.minecraft.world.entity.npc.AbstractVillager#processTrade(MerchantOffer, io.papermc.paper.event.player.PlayerPurchaseEvent)} */
++            if (getTradingPlayer() instanceof net.minecraft.server.level.ServerPlayer) {
++                if (event == null || event.willIncreaseTradeUses()) {
++                    merchantRecipe.increaseUses();
++                }
++                if (event == null || event.isRewardingExp()) {
++                    this.tradingPlayer.level.addFreshEntity(new net.minecraft.world.entity.ExperienceOrb(tradingPlayer.level, tradingPlayer.getX(), tradingPlayer.getY(), tradingPlayer.getZ(), merchantRecipe.getXp(), org.bukkit.entity.ExperienceOrb.SpawnReason.VILLAGER_TRADE, this.tradingPlayer, null));
++                }
++            }
++            this.notifyTrade(merchantRecipe);
++        }
++        // Paper end
+         @Override
+         public void notifyTrade(MerchantOffer offer) {
+             // increase recipe's uses
+-            offer.increaseUses();
++            // offer.increaseUses(); // Paper - handled above in processTrade
+         }
+ 
+         @Override