Release 4.18.0

this allows for plugin extension, for example to implement anvils.

CONTRIBUTING.md

@@ -21,21 +21,22 @@ Larger contributions like feature additions should be preceded by a [Change Prop
 ## Choosing a target branch
 PocketMine-MP has three primary branches of development.
 
-| Type of change | `stable` | `minor-next` | `major-next` |
-|:---------------|:--------:|:------------:|:------------:|
-| Bug fixes | ✔️ | ✔️ | ✔️ |
-| Improvements to API docs | ✔️ | ✔️ | ✔️ |
-| Cleaning up code | ❌ | ✔️ | ✔️ |
-| Changing code formatting or style | ❌ | ✔️ | ✔️ |
-| Addition of new core features | ❌ | 🟡 Only if non-disruptive | ✔️ |
-| Changing core behaviour (e.g. making something use threads) | ❌ | ✔️ | ✔️ |
-| Addition of new configuration options | ❌ | 🟡 Only if optional | ✔️ |
-| Addition of new API classes, methods or constants | ❌ | ✔️ | ✔️ |
-| Deprecating API classes, methods or constants | ❌ | ✔️ | ✔️ |
-| Adding optional parameters to an API method | ❌ | ✔️ | ✔️ |
-| Changing API behaviour | ❌ | 🟡 Only if backwards-compatible | ✔️ |
-| Removal of API | ❌ | ❌ | ✔️ |
-| Backwards-incompatible API change (e.g. renaming a method) | ❌ | ❌ | ✔️ |
+| Type of change                                                                              | `stable` |          `minor-next`           | `major-next` |
+|:--------------------------------------------------------------------------------------------|:--------:|:-------------------------------:|:------------:|
+| Bug fixes                                                                                   |    ✔️    |               ✔️                |      ✔️      |
+| Improvements to API docs                                                                    |    ✔️    |               ✔️                |      ✔️      |
+| Cleaning up code                                                                            |    ❌     |               ✔️                |      ✔️      |
+| Changing code formatting or style                                                           |    ❌     |               ✔️                |      ✔️      |
+| Addition of new core features                                                               |    ❌     |    🟡 Only if non-disruptive    |      ✔️      |
+| Changing core behaviour (e.g. making something use threads)                                 |    ❌     |               ✔️                |      ✔️      |
+| Addition of new configuration options                                                       |    ❌     |       🟡 Only if optional       |      ✔️      |
+| Addition of new API classes, methods or constants                                           |    ❌     |               ✔️                |      ✔️      |
+| Deprecating API classes, methods or constants                                               |    ❌     |               ✔️                |      ✔️      |
+| Adding optional parameters to an API method                                                 |    ❌     |               ✔️                |      ✔️      |
+| Changing API behaviour                                                                      |    ❌     | 🟡 Only if backwards-compatible |      ✔️      |
+| Removal of API                                                                              |    ❌     |                ❌                |      ✔️      |
+| Backwards-incompatible API change (e.g. renaming a method)                                  |    ❌     |                ❌                |      ✔️      |
+| Backwards-incompatible internals change (e.g. changing things in `pocketmine\network\mcpe`) |    ❌     |               ✔️                |      ✔️      |
 
 ### Notes
 - **Non-disruptive** means that usage should not be significantly altered by the change.
@@ -43,6 +44,10 @@ PocketMine-MP has three primary branches of development.
   - Examples of **disruptive** changes include changing the way the server is run, world format changes (since those require downtime for the user to convert their world).
 - **API** includes all public and protected classes, functions and constants (unless marked as `@internal`).
   - Private members are not part of the API, **unless in a trait**.
+  - The `pocketmine\network\mcpe` package is considered implicitly `@internal` in its entirety (see its [README](src/network/mcpe/README.md) for more details).
+- Minecraft's protocol changes are considered necessary internal changes, and are **not** subject to the same rules.
+  - Protocol changes must always be released in a new minor version, since they disrupt user experience by requiring a client update.
+- BC-breaking changes to the internal network API are allowed, but only in new minor versions. This ensures that plugins which use the internal network API will not break (though they shouldn't use such API anyway).
 
 ## Making a pull request
 The basic procedure to create a pull request is:

changelogs/4.18-alpha.md

@@ -0,0 +1,91 @@
+**For Minecraft: Bedrock Edition 1.19.70**
+
+### Note about API versions
+Plugins which don't touch the `pocketmine\network\mcpe` namespace are compatible with any previous 4.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+### Alpha release warning
+Alpha releases are **experimental**. Features introduced in these releases are subject to change or removal.
+
+APIs which existed **prior** to this version will continue to work as normal, so plugins which use them will continue to work.
+
+### Highlights
+This version makes changes to the internal network system to improve server performance and reduce memory usage.
+
+While these changes don't affect non-internal API, they are still significant enough to warrant a new minor version, as they may break plugins which use the internal network API (not recommended).
+
+# 4.18.0-ALPHA1
+Released 16th March 2023.
+
+## General
+- Improved server performance in congested areas of the world (lots of players and/or entities in the same area).
+
+## API
+### `pocketmine\event\server`
+- The following new classes have been added:
+  - `DataPacketDecodeEvent` - called before a packet is decoded by a `NetworkSession`; useful to mitigate DoS attacks if PocketMine-MP hasn't been patched against new bugs yet
+
+## Internals
+- Introduced new system for broadcasting entity events to network sessions.
+  - This change improves performance when lots of players and/or entities are in the same area.
+  - New interface `EntityEventBroadcaster` and class `StandardEntityEventBroadcaster` have been added to implement this.
+  - All entity-specific `on*()` and `sync*()` methods have been removed from `NetworkSession` (BC break).
+  - `NetworkSession` now accepts an `EntityEventBroadcaster` instance in its constructor.
+  - `NetworkBroadcastUtils::broadcastEntityEvent()` can be used to efficiently broadcast events to unique broadcasters shared by several network sessions.
+- All network sessions now share the same `PacketSerializerContext` and `PacketBroadcaster` by default.
+  - Previously, every session had its own context, meaning that broadcast optimisations were not used, causing significant performance losses compared to 3.x.
+  - This change improves performance in congested areas by allowing reuse of previously encoded packet buffers for all sessions sharing the same context.
+  - Packet broadcasts are automatically encoded separately per unique `PacketSerializerContext` instance. This allows, for example, a multi-version fork to have a separate context for each protocol version, to ensure maximum broadcast efficiency while encoding different packets for different versions.
+  - `PacketSerializerContext` is now passed in `NetworkSession::__construct()`, instead of being created by the session.
+- `StandardPacketBroadcaster` is now locked to a single `PacketSerializer` context, reducing complexity.
+- Introduced `NetworkBroadcastUtils::broadcastPackets()`, replacing `Server->broadcastPackets()`.
+- `Server->broadcastPackets()` has been deprecated. It will be removed in a future version.
+
+# 4.18.0-ALPHA2
+Released 21st March 2023.
+
+## General
+- Included more sections of the network system in Player Network Send timings.
+- Changed the names of some timings to make them more user-friendly.
+- Removed packet IDs from `receivePacket` and `sendPacket` timings, as they were not very useful.
+- Added new specialized timers for the following:
+  - Item entity base ticking (merging)
+  - Player movement processing
+  - Entity movement processing (collision checking section)
+  - Projectile movement (all)
+  - Projectile movement processing (ray tracing section)
+
+## API
+### `pocketmine\crafting`
+- The following new API methods have been added:
+  - `CraftingManager->getCraftingRecipeIndex() : array<int, CraftingRecipe>` - returns a list of all crafting recipes
+  - `CraftingManager->getCraftingRecipeFromIndex(int $index) : ?CraftingRecipe` - returns the crafting recipe at the given index, or null if it doesn't exist
+
+### `pocketmine\inventory\transaction`
+- The following API methods have changed signatures:
+  - `CraftingTransaction->__construct()` now accepts additional arguments `?CraftingRecipe $recipe = null, ?int $repetitions = null`
+- The following new API methods have been added:
+  - `TransactionBuilderInventory->getActualInventory() : Inventory` - returns the actual inventory that this inventory is a proxy for
+
+## Internals
+### Network
+- Introduced support for the `ItemStackRequest` Minecraft: Bedrock network protocol.
+  - This fixes a large number of inventory- and crafting-related bugs.
+  - This also improves server security by closing off many code pathways that might have been used for exploits. `TypeConverter->netItemStackToCore()` is no longer used in server code, and remains for tool usage only.
+  - This system is also significantly more bandwidth-efficient and has lower overhead than the legacy system.
+  - This now opens the gateway to easily implement lots of gameplay features which have been missing for a long time, such as enchanting, anvils, looms, and more.
+  - Significant changes have been made to `pocketmine\network\mcpe\InventoryManager` internals. These shouldn't affect plugins, but may affect plugins which use internal network API.
+  - **No changes have been made to the plugin `InventoryTransaction` API**.
+    - This system has been implemented as a shim for the existing PocketMine-MP transaction system to preserve plugin compatibility. Plugins using `InventoryTransactionEvent` should continue to work seamlessly.
+    - The `InventoryTransaction` API will be redesigned in a future major version to make use of the new information provided by the `ItemStackRequest` system.
+  - `InventoryTransactionPacket` is no longer sent by the client for "regular" inventory actions. However, it is still sent when dropping items, interacting with blocks, and using items.
+- Inventory slot and content syncing is now buffered until the end of the tick. This reduces outbound network usage when the client performs multiple transactions in a single tick (e.g. crafting a stack of items).
+- Renamed some `InventoryManager` internal properties to make them easier to understand.
+- `TypeConverter->createInventoryAction()` has been removed.
+- Packet batch limit has been lowered to `100` packets. With the introduction of `ItemStackRequest`, this is more than sufficient for normal gameplay.
+
+### Other
+- Use `Vector3::zero()` instead of `new Vector3()` in some places.

changelogs/4.18.md

@@ -0,0 +1,80 @@
+**For Minecraft: Bedrock Edition 1.19.70**
+
+### Note about API versions
+Plugins which don't touch the `pocketmine\network\mcpe` namespace are compatible with any previous 4.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+### Highlights
+This version significantly improves server performance with many players and/or entities by making changes to the internal network system.
+
+It also introduces support for the newer `ItemStackRequest` protocol, which fixes many bugs and improves server security.
+
+While these changes don't affect non-internal API, they are still significant enough to warrant a new minor version, as they may break plugins which use the internal network API (not recommended).
+
+# 4.18.0
+Released 25th March 2023.
+
+## General
+- Significantly improved server performance in congested areas of the world (lots of players and/or entities in the same area).
+- Included more sections of the network system in `Player Network Send` performance timings.
+- Changed the names of some performance timings to make them more user-friendly.
+- Removed packet IDs from `receivePacket` and `sendPacket` performance timings, as they were not very useful.
+- Added new specialized performance timings for the following:
+  - Item entity base ticking (merging)
+  - Player movement processing
+  - Entity movement processing (collision checking section)
+  - Projectile movement (all)
+  - Projectile movement processing (ray tracing section)
+
+## API
+### `pocketmine\crafting`
+- The following new API methods have been added:
+  - `CraftingManager->getCraftingRecipeIndex() : array<int, CraftingRecipe>` - returns a list of all crafting recipes
+  - `CraftingManager->getCraftingRecipeFromIndex(int $index) : ?CraftingRecipe` - returns the crafting recipe at the given index, or null if it doesn't exist
+
+### `pocketmine\event\server`
+- The following new classes have been added:
+  - `DataPacketDecodeEvent` - called before a packet is decoded by a `NetworkSession`; useful to mitigate DoS attacks if PocketMine-MP hasn't been patched against new bugs yet
+
+### `pocketmine\inventory\transaction`
+- The following API methods have changed signatures:
+  - `CraftingTransaction->__construct()` now accepts additional arguments `?CraftingRecipe $recipe = null, ?int $repetitions = null`
+- The following new API methods have been added:
+  - `TransactionBuilderInventory->getActualInventory() : Inventory` - returns the actual inventory that this inventory is a proxy for
+
+## Internals
+### Network
+- Introduced new system for broadcasting entity events to network sessions.
+  - This change improves performance when lots of players and/or entities are in the same area.
+  - New interface `EntityEventBroadcaster` and class `StandardEntityEventBroadcaster` have been added to implement this.
+  - All entity-specific `on*()` and `sync*()` methods have been removed from `NetworkSession` (internals backwards compatibility break, not covered by API version guarantee).
+  - `NetworkSession` now accepts an `EntityEventBroadcaster` instance in its constructor.
+  - `NetworkBroadcastUtils::broadcastEntityEvent()` can be used to efficiently broadcast events to unique broadcasters shared by several network sessions.
+- All network sessions now share the same `PacketSerializerContext` and `PacketBroadcaster` by default.
+  - Previously, every session had its own context, meaning that broadcast optimisations were not used, causing significant performance losses compared to 3.x.
+  - This change improves performance in congested areas by allowing reuse of previously encoded packet buffers for all sessions sharing the same context.
+  - Packet broadcasts are automatically encoded separately per unique `PacketSerializerContext` instance. This allows, for example, a multi-version fork to have a separate context for each protocol version, to ensure maximum broadcast efficiency while encoding different packets for different versions.
+  - `PacketSerializerContext` is now passed in `NetworkSession::__construct()`, instead of being created by the session.
+- `StandardPacketBroadcaster` is now locked to a single `PacketSerializer` context, reducing complexity.
+- Introduced `NetworkBroadcastUtils::broadcastPackets()`, replacing `Server->broadcastPackets()`.
+- `Server->broadcastPackets()` has been deprecated. It will be removed in a future version.
+- Introduced support for the `ItemStackRequest` Minecraft: Bedrock network protocol.
+  - This fixes a large number of inventory- and crafting-related bugs.
+  - This also improves server security by closing off many code pathways that might have been used for exploits. `TypeConverter->netItemStackToCore()` is no longer used in server code, and remains for tool usage only.
+  - This system is also significantly more bandwidth-efficient and has lower overhead than the legacy system.
+  - This now opens the gateway to easily implement lots of gameplay features which have been missing for a long time, such as enchanting, anvils, looms, and more.
+  - Significant changes have been made to `pocketmine\network\mcpe\InventoryManager` internals. These shouldn't affect plugins, but may affect plugins which use internal network API.
+  - **No changes have been made to the plugin `InventoryTransaction` API**.
+    - This system has been implemented as a shim for the existing PocketMine-MP transaction system to preserve plugin compatibility. Plugins using `InventoryTransactionEvent` should continue to work seamlessly.
+    - The `InventoryTransaction` API will be redesigned in a future major version to make use of the new information provided by the `ItemStackRequest` system.
+  - `InventoryTransactionPacket` is no longer sent by the client for "regular" inventory actions. However, it is still sent when dropping items, interacting with blocks, and using items.
+- Inventory slot and content syncing is now buffered until the end of the tick. This reduces outbound network usage when the client performs multiple transactions in a single tick (e.g. crafting a stack of items).
+- Renamed some `InventoryManager` internal properties to make them easier to understand.
+- `TypeConverter->createInventoryAction()` has been removed.
+- Packet batch limit has been lowered to `100` packets. With the introduction of `ItemStackRequest`, this is more than sufficient for normal gameplay.
+
+### Other
+- Use `Vector3::zero()` instead of `new Vector3()` in some places.

composer.json

@@ -37,7 +37,7 @@
       "pocketmine/bedrock-block-upgrade-schema": "~1.1.1+bedrock-1.19.70",
       "pocketmine/bedrock-data": "~2.1.1+bedrock-1.19.70",
       "pocketmine/bedrock-item-upgrade-schema": "~1.1.0+bedrock-1.19.70",
-      "pocketmine/bedrock-protocol": "~20.0.0+bedrock-1.19.70",
+      "pocketmine/bedrock-protocol": "~20.1.0+bedrock-1.19.70",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/classloader": "^0.2.0",

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "7c02da0a4bfc5f59effdf8e55b085c08",
+    "content-hash": "956553d402f9c522cfcfe19260af2d2b",
     "packages": [
         {
             "name": "adhocore/json-comment",
@@ -328,16 +328,16 @@
         },
         {
             "name": "pocketmine/bedrock-protocol",
-            "version": "20.0.0+bedrock-1.19.70",
+            "version": "20.1.0+bedrock-1.19.70",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pmmp/BedrockProtocol.git",
-                "reference": "4892a5020187da805d7b46ab522d8185b0283726"
+                "reference": "91d67c8b1bced3c82d0841b1041c0c1f4e93eb68"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pmmp/BedrockProtocol/zipball/4892a5020187da805d7b46ab522d8185b0283726",
-                "reference": "4892a5020187da805d7b46ab522d8185b0283726",
+                "url": "https://api.github.com/repos/pmmp/BedrockProtocol/zipball/91d67c8b1bced3c82d0841b1041c0c1f4e93eb68",
+                "reference": "91d67c8b1bced3c82d0841b1041c0c1f4e93eb68",
                 "shasum": ""
             },
             "require": {
@@ -351,7 +351,7 @@
                 "ramsey/uuid": "^4.1"
             },
             "require-dev": {
-                "phpstan/phpstan": "1.10.1",
+                "phpstan/phpstan": "1.10.7",
                 "phpstan/phpstan-phpunit": "^1.0.0",
                 "phpstan/phpstan-strict-rules": "^1.0.0",
                 "phpunit/phpunit": "^9.5"
@@ -369,9 +369,9 @@
             "description": "An implementation of the Minecraft: Bedrock Edition protocol in PHP",
             "support": {
                 "issues": "https://github.com/pmmp/BedrockProtocol/issues",
-                "source": "https://github.com/pmmp/BedrockProtocol/tree/20.0.0+bedrock-1.19.70"
+                "source": "https://github.com/pmmp/BedrockProtocol/tree/20.1.0+bedrock-1.19.70"
             },
-            "time": "2023-03-14T17:06:38+00:00"
+            "time": "2023-03-20T01:17:00+00:00"
         },
         {
             "name": "pocketmine/binaryutils",
@@ -1946,16 +1946,16 @@
         },
         {
             "name": "phpstan/phpstan-phpunit",
-            "version": "1.3.10",
+            "version": "1.3.11",
             "source": {
                 "type": "git",
                 "url": "https://github.com/phpstan/phpstan-phpunit.git",
-                "reference": "4cc5c6cc38e56bce7ea47c4091814e516d172dc3"
+                "reference": "9e1b9de6d260461f6e99b6a8f2dbb0bbb98b579c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan-phpunit/zipball/4cc5c6cc38e56bce7ea47c4091814e516d172dc3",
-                "reference": "4cc5c6cc38e56bce7ea47c4091814e516d172dc3",
+                "url": "https://api.github.com/repos/phpstan/phpstan-phpunit/zipball/9e1b9de6d260461f6e99b6a8f2dbb0bbb98b579c",
+                "reference": "9e1b9de6d260461f6e99b6a8f2dbb0bbb98b579c",
                 "shasum": ""
             },
             "require": {
@@ -1992,9 +1992,9 @@
             "description": "PHPUnit extensions and rules for PHPStan",
             "support": {
                 "issues": "https://github.com/phpstan/phpstan-phpunit/issues",
-                "source": "https://github.com/phpstan/phpstan-phpunit/tree/1.3.10"
+                "source": "https://github.com/phpstan/phpstan-phpunit/tree/1.3.11"
             },
-            "time": "2023-03-02T10:25:13+00:00"
+            "time": "2023-03-25T19:42:13+00:00"
         },
         {
             "name": "phpstan/phpstan-strict-rules",

src/Server.php

@@ -43,7 +43,6 @@ use pocketmine\event\player\PlayerCreationEvent;
 use pocketmine\event\player\PlayerDataSaveEvent;
 use pocketmine\event\player\PlayerLoginEvent;
 use pocketmine\event\server\CommandEvent;
-use pocketmine\event\server\DataPacketSendEvent;
 use pocketmine\event\server\QueryRegenerateEvent;
 use pocketmine\lang\KnownTranslationFactory;
 use pocketmine\lang\Language;
@@ -54,13 +53,19 @@ use pocketmine\network\mcpe\compression\CompressBatchPromise;
 use pocketmine\network\mcpe\compression\CompressBatchTask;
 use pocketmine\network\mcpe\compression\Compressor;
 use pocketmine\network\mcpe\compression\ZlibCompressor;
+use pocketmine\network\mcpe\convert\GlobalItemTypeDictionary;
 use pocketmine\network\mcpe\encryption\EncryptionContext;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\NetworkSession;
 use pocketmine\network\mcpe\PacketBroadcaster;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
 use pocketmine\network\mcpe\protocol\serializer\PacketBatch;
+use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
 use pocketmine\network\mcpe\raklib\RakLibInterface;
+use pocketmine\network\mcpe\StandardEntityEventBroadcaster;
+use pocketmine\network\mcpe\StandardPacketBroadcaster;
 use pocketmine\network\Network;
 use pocketmine\network\NetworkInterfaceStartException;
 use pocketmine\network\query\DedicatedQueryNetworkInterface;
@@ -1169,10 +1174,18 @@ class Server{
 		return !$anyWorldFailedToLoad;
 	}
 
-	private function startupPrepareConnectableNetworkInterfaces(string $ip, int $port, bool $ipV6, bool $useQuery) : bool{
+	private function startupPrepareConnectableNetworkInterfaces(
+		string $ip,
+		int $port,
+		bool $ipV6,
+		bool $useQuery,
+		PacketBroadcaster $packetBroadcaster,
+		EntityEventBroadcaster $entityEventBroadcaster,
+		PacketSerializerContext $packetSerializerContext
+	) : bool{
 		$prettyIp = $ipV6 ? "[$ip]" : $ip;
 		try{
-			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6));
+			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext));
 		}catch(NetworkInterfaceStartException $e){
 			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_networkStartFailed(
 				$ip,
@@ -1198,11 +1211,15 @@ class Server{
 	private function startupPrepareNetworkInterfaces() : bool{
 		$useQuery = $this->configGroup->getConfigBool("enable-query", true);
 
+		$packetSerializerContext = new PacketSerializerContext(GlobalItemTypeDictionary::getInstance()->getDictionary());
+		$packetBroadcaster = new StandardPacketBroadcaster($this, $packetSerializerContext);
+		$entityEventBroadcaster = new StandardEntityEventBroadcaster($packetBroadcaster);
+
 		if(
-			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery) ||
+			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext) ||
 			(
 				$this->configGroup->getConfigBool("enable-ipv6", true) &&
-				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery)
+				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext)
 			)
 		){
 			return false;
@@ -1334,46 +1351,10 @@ class Server{
 	/**
 	 * @param Player[]            $players
 	 * @param ClientboundPacket[] $packets
+	 * @deprecated
 	 */
 	public function broadcastPackets(array $players, array $packets) : bool{
-		if(count($packets) === 0){
-			throw new \InvalidArgumentException("Cannot broadcast empty list of packets");
-		}
-
-		return Timings::$broadcastPackets->time(function() use ($players, $packets) : bool{
-			/** @var NetworkSession[] $recipients */
-			$recipients = [];
-			foreach($players as $player){
-				if($player->isConnected()){
-					$recipients[] = $player->getNetworkSession();
-				}
-			}
-			if(count($recipients) === 0){
-				return false;
-			}
-
-			$ev = new DataPacketSendEvent($recipients, $packets);
-			$ev->call();
-			if($ev->isCancelled()){
-				return false;
-			}
-			$recipients = $ev->getTargets();
-
-			/** @var PacketBroadcaster[] $broadcasters */
-			$broadcasters = [];
-			/** @var NetworkSession[][] $broadcasterTargets */
-			$broadcasterTargets = [];
-			foreach($recipients as $recipient){
-				$broadcaster = $recipient->getBroadcaster();
-				$broadcasters[spl_object_id($broadcaster)] = $broadcaster;
-				$broadcasterTargets[spl_object_id($broadcaster)][] = $recipient;
-			}
-			foreach($broadcasters as $broadcaster){
-				$broadcaster->broadcastPackets($broadcasterTargets[spl_object_id($broadcaster)], $packets);
-			}
-
-			return true;
-		});
+		return NetworkBroadcastUtils::broadcastPackets($players, $packets);
 	}
 
 	/**

src/VersionInfo.php

@@ -31,7 +31,7 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "4.17.1";
+	public const BASE_VERSION = "4.18.0";
 	public const IS_DEVELOPMENT_BUILD = false;
 	public const BUILD_CHANNEL = "stable";
 

src/crafting/CraftingManager.php

@@ -45,6 +45,12 @@ class CraftingManager{
 	 */
 	protected $shapelessRecipes = [];
 
+	/**
+	 * @var CraftingRecipe[]
+	 * @phpstan-var array<int, CraftingRecipe>
+	 */
+	private array $craftingRecipeIndex = [];
+
 	/**
 	 * @var FurnaceRecipeManager[]
 	 * @phpstan-var array<int, FurnaceRecipeManager>
@@ -153,6 +159,18 @@ class CraftingManager{
 		return $this->shapedRecipes;
 	}
 
+	/**
+	 * @return CraftingRecipe[]
+	 * @phpstan-return array<int, CraftingRecipe>
+	 */
+	public function getCraftingRecipeIndex() : array{
+		return $this->craftingRecipeIndex;
+	}
+
+	public function getCraftingRecipeFromIndex(int $index) : ?CraftingRecipe{
+		return $this->craftingRecipeIndex[$index] ?? null;
+	}
+
 	public function getFurnaceRecipeManager(FurnaceType $furnaceType) : FurnaceRecipeManager{
 		return $this->furnaceRecipeManagers[$furnaceType->id()];
 	}
@@ -175,6 +193,7 @@ class CraftingManager{
 
 	public function registerShapedRecipe(ShapedRecipe $recipe) : void{
 		$this->shapedRecipes[self::hashOutputs($recipe->getResults())][] = $recipe;
+		$this->craftingRecipeIndex[] = $recipe;
 
 		foreach($this->recipeRegisteredCallbacks as $callback){
 			$callback();
@@ -183,6 +202,7 @@ class CraftingManager{
 
 	public function registerShapelessRecipe(ShapelessRecipe $recipe) : void{
 		$this->shapelessRecipes[self::hashOutputs($recipe->getResults())][] = $recipe;
+		$this->craftingRecipeIndex[] = $recipe;
 
 		foreach($this->recipeRegisteredCallbacks as $callback){
 			$callback();

src/entity/Entity.php

@@ -44,6 +44,8 @@ use pocketmine\nbt\tag\DoubleTag;
 use pocketmine\nbt\tag\FloatTag;
 use pocketmine\nbt\tag\ListTag;
 use pocketmine\nbt\tag\StringTag;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\AddActorPacket;
 use pocketmine\network\mcpe\protocol\MoveActorAbsolutePacket;
 use pocketmine\network\mcpe\protocol\SetActorMotionPacket;
@@ -244,7 +246,7 @@ abstract class Entity{
 		if($nbt !== null){
 			$this->motion = EntityDataHelper::parseVec3($nbt, self::TAG_MOTION, true);
 		}else{
-			$this->motion = new Vector3(0, 0, 0);
+			$this->motion = Vector3::zero();
 		}
 
 		$this->resetLastMovements();
@@ -785,7 +787,7 @@ abstract class Entity{
 				$this->spawnTo($player);
 			}
 		}else{
-			$this->server->broadcastPackets($this->hasSpawned, [MoveActorAbsolutePacket::create(
+			NetworkBroadcastUtils::broadcastPackets($this->hasSpawned, [MoveActorAbsolutePacket::create(
 				$this->id,
 				$this->getOffsetPosition($this->location),
 				$this->location->pitch,
@@ -800,7 +802,7 @@ abstract class Entity{
 	}
 
 	protected function broadcastMotion() : void{
-		$this->server->broadcastPackets($this->hasSpawned, [SetActorMotionPacket::create($this->id, $this->getMotion())]);
+		NetworkBroadcastUtils::broadcastPackets($this->hasSpawned, [SetActorMotionPacket::create($this->id, $this->getMotion())]);
 	}
 
 	public function getGravity() : float{
@@ -1137,6 +1139,7 @@ abstract class Entity{
 		$this->blocksAround = null;
 
 		Timings::$entityMove->startTiming();
+		Timings::$entityMoveCollision->startTiming();
 
 		$wantedX = $dx;
 		$wantedY = $dy;
@@ -1221,6 +1224,7 @@ abstract class Entity{
 
 			$this->boundingBox = $moveBB;
 		}
+		Timings::$entityMoveCollision->stopTiming();
 
 		$this->location = new Location(
 			($this->boundingBox->minX + $this->boundingBox->maxX) / 2,
@@ -1537,7 +1541,7 @@ abstract class Entity{
 		$id = spl_object_id($player);
 		if(isset($this->hasSpawned[$id])){
 			if($send){
-				$player->getNetworkSession()->onEntityRemoved($this);
+				$player->getNetworkSession()->getEntityEventBroadcaster()->onEntityRemoved([$player->getNetworkSession()], $this);
 			}
 			unset($this->hasSpawned[$id]);
 		}
@@ -1548,9 +1552,11 @@ abstract class Entity{
 	 * player moves, viewers will once again be able to see the entity.
 	 */
 	public function despawnFromAll() : void{
-		foreach($this->hasSpawned as $player){
-			$this->despawnFrom($player);
-		}
+		NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->hasSpawned,
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onEntityRemoved($recipients, $this)
+		);
+		$this->hasSpawned = [];
 	}
 
 	/**
@@ -1624,9 +1630,7 @@ abstract class Entity{
 		$targets = $targets ?? $this->hasSpawned;
 		$data = $data ?? $this->getAllNetworkData();
 
-		foreach($targets as $p){
-			$p->getNetworkSession()->syncActorData($this, $data);
-		}
+		NetworkBroadcastUtils::broadcastEntityEvent($targets, fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->syncActorData($recipients, $this, $data));
 	}
 
 	/**
@@ -1680,7 +1684,7 @@ abstract class Entity{
 	 * @param Player[]|null $targets
 	 */
 	public function broadcastAnimation(Animation $animation, ?array $targets = null) : void{
-		$this->server->broadcastPackets($targets ?? $this->getViewers(), $animation->encode());
+		NetworkBroadcastUtils::broadcastPackets($targets ?? $this->getViewers(), $animation->encode());
 	}
 
 	/**
@@ -1689,7 +1693,7 @@ abstract class Entity{
 	 */
 	public function broadcastSound(Sound $sound, ?array $targets = null) : void{
 		if(!$this->silent){
-			$this->server->broadcastPackets($targets ?? $this->getViewers(), $sound->encode($this->location));
+			NetworkBroadcastUtils::broadcastPackets($targets ?? $this->getViewers(), $sound->encode($this->location));
 		}
 	}
 

src/entity/EntityDataHelper.php

@@ -80,7 +80,7 @@ final class EntityDataHelper{
 	public static function parseVec3(CompoundTag $nbt, string $tagName, bool $optional) : Vector3{
 		$pos = $nbt->getTag($tagName);
 		if($pos === null && $optional){
-			return new Vector3(0, 0, 0);
+			return Vector3::zero();
 		}
 		if(!($pos instanceof ListTag) || ($pos->getTagType() !== NBT::TAG_Double && $pos->getTagType() !== NBT::TAG_Float)){
 			throw new SavedDataLoadingException("'$tagName' should be a List<Double> or List<Float>");

src/entity/Human.php

@@ -47,6 +47,8 @@ use pocketmine\nbt\tag\ListTag;
 use pocketmine\nbt\tag\StringTag;
 use pocketmine\network\mcpe\convert\SkinAdapterSingleton;
 use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\AddPlayerPacket;
 use pocketmine\network\mcpe\protocol\PlayerListPacket;
 use pocketmine\network\mcpe\protocol\PlayerSkinPacket;
@@ -174,7 +176,7 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 	 * @param Player[]|null $targets
 	 */
 	public function sendSkin(?array $targets = null) : void{
-		$this->server->broadcastPackets($targets ?? $this->hasSpawned, [
+		NetworkBroadcastUtils::broadcastPackets($targets ?? $this->hasSpawned, [
 			PlayerSkinPacket::create($this->getUniqueId(), "", "", SkinAdapterSingleton::get()->toSkinData($this->skin))
 		]);
 	}
@@ -189,9 +191,10 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 	}
 
 	public function emote(string $emoteId) : void{
-		foreach($this->getViewers() as $player){
-			$player->getNetworkSession()->onEmote($this, $emoteId);
-		}
+		NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onEmote($recipients, $this, $emoteId)
+		);
 	}
 
 	public function getHungerManager() : HungerManager{
@@ -270,11 +273,10 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 		$this->xpManager = new ExperienceManager($this);
 
 		$this->inventory = new PlayerInventory($this);
-		$syncHeldItem = function() : void{
-			foreach($this->getViewers() as $viewer){
-				$viewer->getNetworkSession()->onMobMainHandItemChange($this);
-			}
-		};
+		$syncHeldItem = fn() => NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onMobMainHandItemChange($recipients, $this)
+		);
 		$this->inventory->getListeners()->add(new CallbackInventoryListener(
 			function(Inventory $unused, int $slot, Item $unused2) use ($syncHeldItem) : void{
 				if($slot === $this->inventory->getHeldItemIndex()){
@@ -315,11 +317,10 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 		if($offHand !== null){
 			$this->offHandInventory->setItem(0, Item::nbtDeserialize($offHand));
 		}
-		$this->offHandInventory->getListeners()->add(CallbackInventoryListener::onAnyChange(function() : void{
-			foreach($this->getViewers() as $viewer){
-				$viewer->getNetworkSession()->onMobOffHandItemChange($this);
-			}
-		}));
+		$this->offHandInventory->getListeners()->add(CallbackInventoryListener::onAnyChange(fn() => NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onMobOffHandItemChange($recipients, $this)
+		)));
 
 		$enderChestInventoryTag = $nbt->getListTag(self::TAG_ENDER_CHEST_INVENTORY);
 		if($enderChestInventoryTag !== null){
@@ -333,11 +334,10 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 		}
 
 		$this->inventory->setHeldItemIndex($nbt->getInt(self::TAG_SELECTED_INVENTORY_SLOT, 0));
-		$this->inventory->getHeldItemIndexChangeListeners()->add(function(int $oldIndex) : void{
-			foreach($this->getViewers() as $viewer){
-				$viewer->getNetworkSession()->onMobMainHandItemChange($this);
-			}
-		});
+		$this->inventory->getHeldItemIndexChangeListeners()->add(fn() => NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onMobMainHandItemChange($recipients, $this)
+		));
 
 		$this->hungerManager->setFood((float) $nbt->getInt(self::TAG_FOOD_LEVEL, (int) $this->hungerManager->getFood()));
 		$this->hungerManager->setExhaustion($nbt->getFloat(self::TAG_FOOD_EXHAUSTION_LEVEL, $this->hungerManager->getExhaustion()));
@@ -490,11 +490,12 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 	}
 
 	protected function sendSpawnPacket(Player $player) : void{
+		$networkSession = $player->getNetworkSession();
 		if(!($this instanceof Player)){
-			$player->getNetworkSession()->sendDataPacket(PlayerListPacket::add([PlayerListEntry::createAdditionEntry($this->uuid, $this->id, $this->getName(), SkinAdapterSingleton::get()->toSkinData($this->skin))]));
+			$networkSession->sendDataPacket(PlayerListPacket::add([PlayerListEntry::createAdditionEntry($this->uuid, $this->id, $this->getName(), SkinAdapterSingleton::get()->toSkinData($this->skin))]));
 		}
 
-		$player->getNetworkSession()->sendDataPacket(AddPlayerPacket::create(
+		$networkSession->sendDataPacket(AddPlayerPacket::create(
 			$this->getUniqueId(),
 			$this->getName(),
 			$this->getId(),
@@ -524,11 +525,12 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 		//TODO: Hack for MCPE 1.2.13: DATA_NAMETAG is useless in AddPlayerPacket, so it has to be sent separately
 		$this->sendData([$player], [EntityMetadataProperties::NAMETAG => new StringMetadataProperty($this->getNameTag())]);
 
-		$player->getNetworkSession()->onMobArmorChange($this);
-		$player->getNetworkSession()->onMobOffHandItemChange($this);
+		$entityEventBroadcaster = $networkSession->getEntityEventBroadcaster();
+		$entityEventBroadcaster->onMobArmorChange([$networkSession], $this);
+		$entityEventBroadcaster->onMobOffHandItemChange([$networkSession], $this);
 
 		if(!($this instanceof Player)){
-			$player->getNetworkSession()->sendDataPacket(PlayerListPacket::remove([PlayerListEntry::createRemovalEntry($this->uuid)]));
+			$networkSession->sendDataPacket(PlayerListPacket::remove([PlayerListEntry::createRemovalEntry($this->uuid)]));
 		}
 	}
 

src/entity/Living.php

@@ -50,6 +50,8 @@ use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\nbt\tag\FloatTag;
 use pocketmine\nbt\tag\ListTag;
 use pocketmine\nbt\tag\ShortTag;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataCollection;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataFlags;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataProperties;
@@ -143,13 +145,10 @@ abstract class Living extends Entity{
 
 		$this->armorInventory = new ArmorInventory($this);
 		//TODO: load/save armor inventory contents
-		$this->armorInventory->getListeners()->add(CallbackInventoryListener::onAnyChange(
-			function(Inventory $unused) : void{
-				foreach($this->getViewers() as $viewer){
-					$viewer->getNetworkSession()->onMobArmorChange($this);
-				}
-			}
-		));
+		$this->armorInventory->getListeners()->add(CallbackInventoryListener::onAnyChange(fn() => NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onMobArmorChange($recipients, $this)
+		)));
 
 		$health = $this->getMaxHealth();
 
@@ -850,7 +849,8 @@ abstract class Living extends Entity{
 	protected function sendSpawnPacket(Player $player) : void{
 		parent::sendSpawnPacket($player);
 
-		$player->getNetworkSession()->onMobArmorChange($this);
+		$networkSession = $player->getNetworkSession();
+		$networkSession->getEntityEventBroadcaster()->onMobArmorChange([$networkSession], $this);
 	}
 
 	protected function syncNetworkData(EntityMetadataCollection $properties) : void{

src/entity/object/ItemEntity.php

@@ -35,10 +35,13 @@ use pocketmine\item\Item;
 use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\AddItemActorPacket;
 use pocketmine\network\mcpe\protocol\types\entity\EntityIds;
 use pocketmine\network\mcpe\protocol\types\inventory\ItemStackWrapper;
 use pocketmine\player\Player;
+use pocketmine\timings\Timings;
 use function max;
 
 class ItemEntity extends Entity{
@@ -111,57 +114,63 @@ class ItemEntity extends Entity{
 			return false;
 		}
 
-		$hasUpdate = parent::entityBaseTick($tickDiff);
+		Timings::$itemEntityBaseTick->startTiming();
+		try{
 
-		if($this->isFlaggedForDespawn()){
-			return $hasUpdate;
-		}
+			$hasUpdate = parent::entityBaseTick($tickDiff);
 
-		if($this->pickupDelay !== self::NEVER_DESPAWN && $this->pickupDelay > 0){ //Infinite delay
-			$hasUpdate = true;
-			$this->pickupDelay -= $tickDiff;
-			if($this->pickupDelay < 0){
-				$this->pickupDelay = 0;
+			if($this->isFlaggedForDespawn()){
+				return $hasUpdate;
 			}
-		}
 
-		if($this->hasMovementUpdate() && $this->despawnDelay % self::MERGE_CHECK_PERIOD === 0){
-			$mergeable = [$this]; //in case the merge target ends up not being this
-			$mergeTarget = $this;
-			foreach($this->getWorld()->getNearbyEntities($this->boundingBox->expandedCopy(0.5, 0.5, 0.5), $this) as $entity){
-				if(!$entity instanceof ItemEntity || $entity->isFlaggedForDespawn()){
-					continue;
+			if($this->pickupDelay !== self::NEVER_DESPAWN && $this->pickupDelay > 0){ //Infinite delay
+				$hasUpdate = true;
+				$this->pickupDelay -= $tickDiff;
+				if($this->pickupDelay < 0){
+					$this->pickupDelay = 0;
 				}
+			}
 
-				if($entity->isMergeable($this)){
-					$mergeable[] = $entity;
-					if($entity->item->getCount() > $mergeTarget->item->getCount()){
-						$mergeTarget = $entity;
+			if($this->hasMovementUpdate() && $this->despawnDelay % self::MERGE_CHECK_PERIOD === 0){
+				$mergeable = [$this]; //in case the merge target ends up not being this
+				$mergeTarget = $this;
+				foreach($this->getWorld()->getNearbyEntities($this->boundingBox->expandedCopy(0.5, 0.5, 0.5), $this) as $entity){
+					if(!$entity instanceof ItemEntity || $entity->isFlaggedForDespawn()){
+						continue;
+					}
+
+					if($entity->isMergeable($this)){
+						$mergeable[] = $entity;
+						if($entity->item->getCount() > $mergeTarget->item->getCount()){
+							$mergeTarget = $entity;
+						}
+					}
+				}
+				foreach($mergeable as $itemEntity){
+					if($itemEntity !== $mergeTarget){
+						$itemEntity->tryMergeInto($mergeTarget);
 					}
 				}
 			}
-			foreach($mergeable as $itemEntity){
-				if($itemEntity !== $mergeTarget){
-					$itemEntity->tryMergeInto($mergeTarget);
+
+			if(!$this->isFlaggedForDespawn() && $this->despawnDelay !== self::NEVER_DESPAWN){
+				$hasUpdate = true;
+				$this->despawnDelay -= $tickDiff;
+				if($this->despawnDelay <= 0){
+					$ev = new ItemDespawnEvent($this);
+					$ev->call();
+					if($ev->isCancelled()){
+						$this->despawnDelay = self::DEFAULT_DESPAWN_DELAY;
+					}else{
+						$this->flagForDespawn();
+					}
 				}
 			}
-		}
 
-		if(!$this->isFlaggedForDespawn() && $this->despawnDelay !== self::NEVER_DESPAWN){
-			$hasUpdate = true;
-			$this->despawnDelay -= $tickDiff;
-			if($this->despawnDelay <= 0){
-				$ev = new ItemDespawnEvent($this);
-				$ev->call();
-				if($ev->isCancelled()){
-					$this->despawnDelay = self::DEFAULT_DESPAWN_DELAY;
-				}else{
-					$this->flagForDespawn();
-				}
-			}
+			return $hasUpdate;
+		}finally{
+			Timings::$itemEntityBaseTick->stopTiming();
 		}
-
-		return $hasUpdate;
 	}
 
 	/**
@@ -328,9 +337,10 @@ class ItemEntity extends Entity{
 			return;
 		}
 
-		foreach($this->getViewers() as $viewer){
-			$viewer->getNetworkSession()->onPlayerPickUpItem($player, $this);
-		}
+		NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onPickUpItem($recipients, $player, $this)
+		);
 
 		$inventory = $ev->getInventory();
 		if($inventory !== null){

src/entity/projectile/Arrow.php

@@ -33,6 +33,8 @@ use pocketmine\event\entity\ProjectileHitEvent;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\RayTraceResult;
 use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\types\entity\EntityIds;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataCollection;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataFlags;
@@ -196,9 +198,10 @@ class Arrow extends Projectile{
 			return;
 		}
 
-		foreach($this->getViewers() as $viewer){
-			$viewer->getNetworkSession()->onPlayerPickUpItem($player, $this);
-		}
+		NetworkBroadcastUtils::broadcastEntityEvent(
+			$this->getViewers(),
+			fn(EntityEventBroadcaster $broadcaster, array $recipients) => $broadcaster->onPickUpItem($recipients, $player, $this)
+		);
 
 		$ev->getInventory()?->addItem($ev->getItem());
 		$this->flagForDespawn();

src/entity/projectile/Projectile.php

@@ -175,7 +175,8 @@ abstract class Projectile extends Entity{
 	protected function move(float $dx, float $dy, float $dz) : void{
 		$this->blocksAround = null;
 
-		Timings::$entityMove->startTiming();
+		Timings::$projectileMove->startTiming();
+		Timings::$projectileMoveRayTrace->startTiming();
 
 		$start = $this->location->asVector3();
 		$end = $start->add($dx, $dy, $dz);
@@ -221,6 +222,8 @@ abstract class Projectile extends Entity{
 			}
 		}
 
+		Timings::$projectileMoveRayTrace->stopTiming();
+
 		$this->location = Location::fromObject(
 			$end,
 			$this->location->world,
@@ -252,7 +255,7 @@ abstract class Projectile extends Entity{
 			}
 
 			$this->isCollided = $this->onGround = true;
-			$this->motion = new Vector3(0, 0, 0);
+			$this->motion = Vector3::zero();
 		}else{
 			$this->isCollided = $this->onGround = false;
 			$this->blockHit = null;
@@ -268,7 +271,7 @@ abstract class Projectile extends Entity{
 		$this->getWorld()->onEntityMoved($this);
 		$this->checkBlockIntersections();
 
-		Timings::$entityMove->stopTiming();
+		Timings::$projectileMove->stopTiming();
 	}
 
 	/**

src/event/player/PlayerInteractEvent.php

@@ -59,7 +59,7 @@ class PlayerInteractEvent extends PlayerEvent implements Cancellable{
 		$this->player = $player;
 		$this->item = $item;
 		$this->blockTouched = $block;
-		$this->touchVector = $touchVector ?? new Vector3(0, 0, 0);
+		$this->touchVector = $touchVector ?? Vector3::zero();
 		$this->blockFace = $face;
 		$this->action = $action;
 	}

src/event/server/DataPacketDecodeEvent.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\event\server;
+
+use pocketmine\event\Cancellable;
+use pocketmine\event\CancellableTrait;
+use pocketmine\network\mcpe\NetworkSession;
+
+/**
+ * Called before a packet is decoded and handled by the network session.
+ * Cancelling this event will drop the packet without decoding it, minimizing wasted CPU time.
+ */
+class DataPacketDecodeEvent extends ServerEvent implements Cancellable{
+	use CancellableTrait;
+
+	public function __construct(
+		private NetworkSession $origin,
+		private int $packetId,
+		private string $packetBuffer
+	){}
+
+	public function getOrigin() : NetworkSession{
+		return $this->origin;
+	}
+
+	public function getPacketId() : int{
+		return $this->packetId;
+	}
+
+	public function getPacketBuffer() : string{
+		return $this->packetBuffer;
+	}
+}

src/inventory/BaseInventory.php

@@ -348,7 +348,7 @@ abstract class BaseInventory implements Inventory{
 			if($invManager === null){
 				continue;
 			}
-			$invManager->syncSlot($this, $index);
+			$invManager->onSlotChange($this, $index);
 		}
 	}
 

src/inventory/transaction/CraftingTransaction.php

@@ -60,9 +60,11 @@ class CraftingTransaction extends InventoryTransaction{
 
 	private CraftingManager $craftingManager;
 
-	public function __construct(Player $source, CraftingManager $craftingManager, array $actions = []){
+	public function __construct(Player $source, CraftingManager $craftingManager, array $actions = [], ?CraftingRecipe $recipe = null, ?int $repetitions = null){
 		parent::__construct($source, $actions);
 		$this->craftingManager = $craftingManager;
+		$this->recipe = $recipe;
+		$this->repetitions = $repetitions;
 	}
 
 	/**
@@ -123,6 +125,18 @@ class CraftingTransaction extends InventoryTransaction{
 		return $iterations;
 	}
 
+	private function validateRecipe(CraftingRecipe $recipe, ?int $expectedRepetitions) : int{
+		//compute number of times recipe was crafted
+		$repetitions = $this->matchRecipeItems($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()), false);
+		if($expectedRepetitions !== null && $repetitions !== $expectedRepetitions){
+			throw new TransactionValidationException("Expected $expectedRepetitions repetitions, got $repetitions");
+		}
+		//assert that $repetitions x recipe ingredients should be consumed
+		$this->matchRecipeItems($this->inputs, $recipe->getIngredientList(), true, $repetitions);
+
+		return $repetitions;
+	}
+
 	public function validate() : void{
 		$this->squashDuplicateSlotChanges();
 		if(count($this->actions) < 1){
@@ -131,25 +145,24 @@ class CraftingTransaction extends InventoryTransaction{
 
 		$this->matchItems($this->outputs, $this->inputs);
 
-		$failed = 0;
-		foreach($this->craftingManager->matchRecipeByOutputs($this->outputs) as $recipe){
-			try{
-				//compute number of times recipe was crafted
-				$this->repetitions = $this->matchRecipeItems($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()), false);
-				//assert that $repetitions x recipe ingredients should be consumed
-				$this->matchRecipeItems($this->inputs, $recipe->getIngredientList(), true, $this->repetitions);
-
-				//Success!
-				$this->recipe = $recipe;
-				break;
-			}catch(TransactionValidationException $e){
-				//failed
-				++$failed;
-			}
-		}
-
 		if($this->recipe === null){
-			throw new TransactionValidationException("Unable to match a recipe to transaction (tried to match against $failed recipes)");
+			$failed = 0;
+			foreach($this->craftingManager->matchRecipeByOutputs($this->outputs) as $recipe){
+				try{
+					$this->repetitions = $this->validateRecipe($recipe, $this->repetitions);
+					$this->recipe = $recipe;
+					break;
+				}catch(TransactionValidationException $e){
+					//failed
+					++$failed;
+				}
+			}
+
+			if($this->recipe === null){
+				throw new TransactionValidationException("Unable to match a recipe to transaction (tried to match against $failed recipes)");
+			}
+		}else{
+			$this->repetitions = $this->validateRecipe($this->recipe, $this->repetitions);
 		}
 	}
 

src/inventory/transaction/TransactionBuilderInventory.php

@@ -50,6 +50,10 @@ final class TransactionBuilderInventory extends BaseInventory{
 		$this->changedSlots = new \SplFixedArray($this->actualInventory->getSize());
 	}
 
+	public function getActualInventory() : Inventory{
+		return $this->actualInventory;
+	}
+
 	protected function internalSetContents(array $items) : void{
 		for($i = 0, $size = $this->getSize(); $i < $size; ++$i){
 			if(!isset($items[$i])){

src/network/mcpe/ComplexInventoryMapEntry.php

@@ -25,7 +25,7 @@ namespace pocketmine\network\mcpe;
 
 use pocketmine\inventory\Inventory;
 
-final class ComplexWindowMapEntry{
+final class ComplexInventoryMapEntry{
 
 	/**
 	 * @var int[]

src/network/mcpe/EntityEventBroadcaster.php

@@ -0,0 +1,93 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe;
+
+use pocketmine\entity\Attribute;
+use pocketmine\entity\effect\EffectInstance;
+use pocketmine\entity\Entity;
+use pocketmine\entity\Human;
+use pocketmine\entity\Living;
+use pocketmine\network\mcpe\protocol\types\entity\MetadataProperty;
+
+/**
+ * This class allows broadcasting entity events to many viewers on the server network.
+ */
+interface EntityEventBroadcaster{
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 * @param Attribute[]      $attributes
+	 */
+	public function syncAttributes(array $recipients, Living $entity, array $attributes) : void;
+
+	/**
+	 * @param NetworkSession[]   $recipients
+	 * @param MetadataProperty[] $properties
+	 *
+	 * @phpstan-param array<int, MetadataProperty> $properties
+	 */
+	public function syncActorData(array $recipients, Entity $entity, array $properties) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onEntityEffectAdded(array $recipients, Living $entity, EffectInstance $effect, bool $replacesOldEffect) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onEntityEffectRemoved(array $recipients, Living $entity, EffectInstance $effect) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onEntityRemoved(array $recipients, Entity $entity) : void;
+
+	/**
+	 * TODO: expand this to more than just humans
+	 *
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onMobMainHandItemChange(array $recipients,Human $mob) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onMobOffHandItemChange(array $recipients, Human $mob) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onMobArmorChange(array $recipients, Living $mob) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onPickUpItem(array $recipients, Entity $collector, Entity $pickedUp) : void;
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	public function onEmote(array $recipients, Human $from, string $emoteId) : void;
+}

src/network/mcpe/InventoryManager.php

@@ -38,7 +38,6 @@ use pocketmine\inventory\Inventory;
 use pocketmine\inventory\transaction\action\SlotChangeAction;
 use pocketmine\inventory\transaction\InventoryTransaction;
 use pocketmine\item\Item;
-use pocketmine\network\mcpe\convert\TypeConversionException;
 use pocketmine\network\mcpe\convert\TypeConverter;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\ContainerClosePacket;
@@ -51,6 +50,7 @@ use pocketmine\network\mcpe\protocol\MobEquipmentPacket;
 use pocketmine\network\mcpe\protocol\types\BlockPosition;
 use pocketmine\network\mcpe\protocol\types\inventory\ContainerIds;
 use pocketmine\network\mcpe\protocol\types\inventory\CreativeContentEntry;
+use pocketmine\network\mcpe\protocol\types\inventory\ItemStack;
 use pocketmine\network\mcpe\protocol\types\inventory\ItemStackWrapper;
 use pocketmine\network\mcpe\protocol\types\inventory\NetworkInventoryAction;
 use pocketmine\network\mcpe\protocol\types\inventory\UIInventorySlotOffset;
@@ -59,9 +59,11 @@ use pocketmine\network\PacketHandlingException;
 use pocketmine\player\Player;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\ObjectSet;
-use function array_map;
+use function array_keys;
 use function array_search;
+use function count;
 use function get_class;
+use function implode;
 use function is_int;
 use function max;
 use function spl_object_id;
@@ -70,26 +72,25 @@ use function spl_object_id;
  * @phpstan-type ContainerOpenClosure \Closure(int $id, Inventory $inventory) : (list<ClientboundPacket>|null)
  */
 class InventoryManager{
-	/** @var Inventory[] */
-	private array $windowMap = [];
 	/**
-	 * @var ComplexWindowMapEntry[]
-	 * @phpstan-var array<int, ComplexWindowMapEntry>
+	 * @var InventoryManagerEntry[] spl_object_id(Inventory) => InventoryManagerEntry
+	 * @phpstan-var array<int, InventoryManagerEntry>
 	 */
-	private array $complexWindows = [];
+	private array $inventories = [];
+
 	/**
-	 * @var ComplexWindowMapEntry[]
-	 * @phpstan-var array<int, ComplexWindowMapEntry>
+	 * @var Inventory[] network window ID => Inventory
+	 * @phpstan-var array<int, Inventory>
 	 */
-	private array $complexSlotToWindowMap = [];
+	private array $networkIdToInventoryMap = [];
+	/**
+	 * @var ComplexInventoryMapEntry[] net slot ID => ComplexWindowMapEntry
+	 * @phpstan-var array<int, ComplexInventoryMapEntry>
+	 */
+	private array $complexSlotToInventoryMap = [];
 
 	private int $lastInventoryNetworkId = ContainerIds::FIRST;
 
-	/**
-	 * @var Item[][]
-	 * @phpstan-var array<int, array<int, Item>>
-	 */
-	private array $initiatedSlotChanges = [];
 	private int $clientSelectedHotbarSlot = -1;
 
 	/** @phpstan-var ObjectSet<ContainerOpenClosure> */
@@ -99,6 +100,11 @@ class InventoryManager{
 	/** @phpstan-var \Closure() : void */
 	private ?\Closure $pendingOpenWindowCallback = null;
 
+	private int $nextItemStackId = 1;
+	private ?int $currentItemStackRequestId = null;
+
+	private bool $fullSyncRequested = false;
+
 	public function __construct(
 		private Player $player,
 		private NetworkSession $session
@@ -117,14 +123,27 @@ class InventoryManager{
 		});
 	}
 
+	private function associateIdWithInventory(int $id, Inventory $inventory) : void{
+		$this->networkIdToInventoryMap[$id] = $inventory;
+	}
+
+	private function getNewWindowId() : int{
+		$this->lastInventoryNetworkId = max(ContainerIds::FIRST, ($this->lastInventoryNetworkId + 1) % ContainerIds::LAST);
+		return $this->lastInventoryNetworkId;
+	}
+
 	private function add(int $id, Inventory $inventory) : void{
-		$this->windowMap[$id] = $inventory;
+		if(isset($this->inventories[spl_object_id($inventory)])){
+			throw new \InvalidArgumentException("Inventory " . get_class($inventory) . " is already tracked");
+		}
+		$this->inventories[spl_object_id($inventory)] = new InventoryManagerEntry($inventory);
+		$this->associateIdWithInventory($id, $inventory);
 	}
 
 	private function addDynamic(Inventory $inventory) : int{
-		$this->lastInventoryNetworkId = max(ContainerIds::FIRST, ($this->lastInventoryNetworkId + 1) % ContainerIds::LAST);
-		$this->add($this->lastInventoryNetworkId, $inventory);
-		return $this->lastInventoryNetworkId;
+		$id = $this->getNewWindowId();
+		$this->add($id, $inventory);
+		return $id;
 	}
 
 	/**
@@ -132,26 +151,45 @@ class InventoryManager{
 	 * @phpstan-param array<int, int>|int $slotMap
 	 */
 	private function addComplex(array|int $slotMap, Inventory $inventory) : void{
-		$entry = new ComplexWindowMapEntry($inventory, is_int($slotMap) ? [$slotMap => 0] : $slotMap);
-		$this->complexWindows[spl_object_id($inventory)] = $entry;
-		foreach($entry->getSlotMap() as $netSlot => $coreSlot){
-			$this->complexSlotToWindowMap[$netSlot] = $entry;
+		if(isset($this->inventories[spl_object_id($inventory)])){
+			throw new \InvalidArgumentException("Inventory " . get_class($inventory) . " is already tracked");
+		}
+		$complexSlotMap = new ComplexInventoryMapEntry($inventory, is_int($slotMap) ? [$slotMap => 0] : $slotMap);
+		$this->inventories[spl_object_id($inventory)] = new InventoryManagerEntry(
+			$inventory,
+			$complexSlotMap
+		);
+		foreach($complexSlotMap->getSlotMap() as $netSlot => $coreSlot){
+			$this->complexSlotToInventoryMap[$netSlot] = $complexSlotMap;
 		}
 	}
 
+	/**
+	 * @param int[]|int $slotMap
+	 * @phpstan-param array<int, int>|int $slotMap
+	 */
+	private function addComplexDynamic(array|int $slotMap, Inventory $inventory) : int{
+		$this->addComplex($slotMap, $inventory);
+		$id = $this->getNewWindowId();
+		$this->associateIdWithInventory($id, $inventory);
+		return $id;
+	}
+
 	private function remove(int $id) : void{
-		$inventory = $this->windowMap[$id];
-		$splObjectId = spl_object_id($inventory);
-		unset($this->windowMap[$id], $this->initiatedSlotChanges[$id], $this->complexWindows[$splObjectId]);
-		foreach($this->complexSlotToWindowMap as $netSlot => $entry){
-			if($entry->getInventory() === $inventory){
-				unset($this->complexSlotToWindowMap[$netSlot]);
+		$inventory = $this->networkIdToInventoryMap[$id];
+		unset($this->networkIdToInventoryMap[$id]);
+		if($this->getWindowId($inventory) === null){
+			unset($this->inventories[spl_object_id($inventory)]);
+			foreach($this->complexSlotToInventoryMap as $netSlot => $entry){
+				if($entry->getInventory() === $inventory){
+					unset($this->complexSlotToInventoryMap[$netSlot]);
+				}
 			}
 		}
 	}
 
 	public function getWindowId(Inventory $inventory) : ?int{
-		return ($id = array_search($inventory, $this->windowMap, true)) !== false ? $id : null;
+		return ($id = array_search($inventory, $this->networkIdToInventoryMap, true)) !== false ? $id : null;
 	}
 
 	public function getCurrentWindowId() : int{
@@ -159,28 +197,33 @@ class InventoryManager{
 	}
 
 	/**
-	 * @phpstan-return array{Inventory, int}
+	 * @phpstan-return array{Inventory, int}|null
 	 */
 	public function locateWindowAndSlot(int $windowId, int $netSlotId) : ?array{
 		if($windowId === ContainerIds::UI){
-			$entry = $this->complexSlotToWindowMap[$netSlotId] ?? null;
+			$entry = $this->complexSlotToInventoryMap[$netSlotId] ?? null;
 			if($entry === null){
 				return null;
 			}
 			$coreSlotId = $entry->mapNetToCore($netSlotId);
 			return $coreSlotId !== null ? [$entry->getInventory(), $coreSlotId] : null;
 		}
-		if(isset($this->windowMap[$windowId])){
-			return [$this->windowMap[$windowId], $netSlotId];
+		if(isset($this->networkIdToInventoryMap[$windowId])){
+			return [$this->networkIdToInventoryMap[$windowId], $netSlotId];
 		}
 		return null;
 	}
 
-	public function onTransactionStart(InventoryTransaction $tx) : void{
+	private function addPredictedSlotChange(Inventory $inventory, int $slot, ItemStack $item) : void{
+		$this->inventories[spl_object_id($inventory)]->predictions[$slot] = $item;
+	}
+
+	public function addTransactionPredictedSlotChanges(InventoryTransaction $tx) : void{
 		foreach($tx->getActions() as $action){
-			if($action instanceof SlotChangeAction && ($windowId = $this->getWindowId($action->getInventory())) !== null){
-				//in some cases the inventory might not have a window ID, but still be referenced by a transaction (e.g. crafting grid changes), so we can't unconditionally record the change here or we might leak things
-				$this->initiatedSlotChanges[$windowId][$action->getSlot()] = $action->getTargetItem();
+			if($action instanceof SlotChangeAction){
+				//TODO: ItemStackRequestExecutor can probably build these predictions with much lower overhead
+				$itemStack = TypeConverter::getInstance()->coreItemStackToNet($action->getTargetItem());
+				$this->addPredictedSlotChange($action->getInventory(), $action->getSlot(), $itemStack);
 			}
 		}
 	}
@@ -189,22 +232,34 @@ class InventoryManager{
 	 * @param NetworkInventoryAction[] $networkInventoryActions
 	 * @throws PacketHandlingException
 	 */
-	public function addPredictedSlotChanges(array $networkInventoryActions) : void{
+	public function addRawPredictedSlotChanges(array $networkInventoryActions) : void{
 		foreach($networkInventoryActions as $action){
-			if($action->sourceType === NetworkInventoryAction::SOURCE_CONTAINER && (
-				isset($this->windowMap[$action->windowId]) ||
-				($action->windowId === ContainerIds::UI && isset($this->complexSlotToWindowMap[$action->inventorySlot]))
-			)){
-				try{
-					$item = TypeConverter::getInstance()->netItemStackToCore($action->newItem->getItemStack());
-				}catch(TypeConversionException $e){
-					throw new PacketHandlingException($e->getMessage(), 0, $e);
-				}
-				$this->initiatedSlotChanges[$action->windowId][$action->inventorySlot] = $item;
+			if($action->sourceType !== NetworkInventoryAction::SOURCE_CONTAINER){
+				continue;
 			}
+
+			//legacy transactions should not modify or predict anything other than these inventories, since these are
+			//the only ones accessible when not in-game (ItemStackRequest is used for everything else)
+			if(match($action->windowId){
+				ContainerIds::INVENTORY, ContainerIds::OFFHAND, ContainerIds::ARMOR => false,
+				default => true
+			}){
+				throw new PacketHandlingException("Legacy transactions cannot predict changes to inventory with ID " . $action->windowId);
+			}
+			$info = $this->locateWindowAndSlot($action->windowId, $action->inventorySlot);
+			if($info === null){
+				continue;
+			}
+
+			[$inventory, $slot] = $info;
+			$this->addPredictedSlotChange($inventory, $slot, $action->newItem->getItemStack());
 		}
 	}
 
+	public function setCurrentItemStackRequestId(?int $id) : void{
+		$this->currentItemStackRequestId = $id;
+	}
+
 	/**
 	 * When the server initiates a window close, it does so by sending a ContainerClose to the client, which causes the
 	 * client to behave as if it initiated the close itself. It responds by sending a ContainerClose back to the server,
@@ -248,9 +303,10 @@ class InventoryManager{
 		$this->onCurrentWindowRemove();
 
 		$this->openWindowDeferred(function() use ($inventory) : void{
-			$windowId = $this->addDynamic($inventory);
 			if(($slotMap = $this->createComplexSlotMapping($inventory)) !== null){
-				$this->addComplex($slotMap, $inventory);
+				$windowId = $this->addComplexDynamic($slotMap, $inventory);
+			}else{
+				$windowId = $this->addDynamic($inventory);
 			}
 
 			foreach($this->containerOpenCallbacks as $callback){
@@ -304,7 +360,8 @@ class InventoryManager{
 		$this->onCurrentWindowRemove();
 
 		$this->openWindowDeferred(function() : void{
-			$windowId = $this->addDynamic($this->player->getInventory());
+			$windowId = $this->getNewWindowId();
+			$this->associateIdWithInventory($windowId, $this->player->getInventory());
 
 			$this->session->sendDataPacket(ContainerOpenPacket::entityInv(
 				$windowId,
@@ -315,7 +372,7 @@ class InventoryManager{
 	}
 
 	public function onCurrentWindowRemove() : void{
-		if(isset($this->windowMap[$this->lastInventoryNetworkId])){
+		if(isset($this->networkIdToInventoryMap[$this->lastInventoryNetworkId])){
 			$this->remove($this->lastInventoryNetworkId);
 			$this->session->sendDataPacket(ContainerClosePacket::create($this->lastInventoryNetworkId, true));
 			if($this->pendingCloseWindowId !== null){
@@ -327,7 +384,7 @@ class InventoryManager{
 
 	public function onClientRemoveWindow(int $id) : void{
 		if($id === $this->lastInventoryNetworkId){
-			if(isset($this->windowMap[$id]) && $id !== $this->pendingCloseWindowId){
+			if(isset($this->networkIdToInventoryMap[$id]) && $id !== $this->pendingCloseWindowId){
 				$this->remove($id);
 				$this->player->removeCurrentWindow();
 			}
@@ -349,96 +406,159 @@ class InventoryManager{
 		}
 	}
 
-	public function syncSlot(Inventory $inventory, int $slot) : void{
-		$slotMap = $this->complexWindows[spl_object_id($inventory)] ?? null;
-		if($slotMap !== null){
-			$windowId = ContainerIds::UI;
-			$netSlot = $slotMap->mapCoreToNet($slot) ?? null;
+	public function onSlotChange(Inventory $inventory, int $slot) : void{
+		$inventoryEntry = $this->inventories[spl_object_id($inventory)] ?? null;
+		if($inventoryEntry === null){
+			//this can happen when an inventory changed during InventoryCloseEvent, or when a temporary inventory
+			//is cleared before removal.
+			return;
+		}
+		$currentItem = TypeConverter::getInstance()->coreItemStackToNet($inventory->getItem($slot));
+		$clientSideItem = $inventoryEntry->predictions[$slot] ?? null;
+		if($clientSideItem === null || !$clientSideItem->equals($currentItem)){
+			//no prediction or incorrect - do not associate this with the currently active itemstack request
+			$this->trackItemStack($inventoryEntry, $slot, $currentItem, null);
+			$inventoryEntry->pendingSyncs[$slot] = $currentItem;
 		}else{
-			$windowId = $this->getWindowId($inventory);
+			//correctly predicted - associate the change with the currently active itemstack request
+			$this->trackItemStack($inventoryEntry, $slot, $currentItem, $this->currentItemStackRequestId);
+		}
+
+		unset($inventoryEntry->predictions[$slot]);
+	}
+
+	public function syncSlot(Inventory $inventory, int $slot, ItemStack $itemStack) : void{
+		$entry = $this->inventories[spl_object_id($inventory)] ?? null;
+		if($entry === null){
+			throw new \LogicException("Cannot sync an untracked inventory");
+		}
+		$itemStackInfo = $entry->itemStackInfos[$slot];
+		if($itemStackInfo === null){
+			throw new \LogicException("Cannot sync an untracked inventory slot");
+		}
+		if($entry->complexSlotMap !== null){
+			$windowId = ContainerIds::UI;
+			$netSlot = $entry->complexSlotMap->mapCoreToNet($slot) ?? throw new AssumptionFailedError("We already have an ItemStackInfo, so this should not be null");
+		}else{
+			$windowId = $this->getWindowId($inventory) ?? throw new AssumptionFailedError("We already have an ItemStackInfo, so this should not be null");
 			$netSlot = $slot;
 		}
-		if($windowId !== null && $netSlot !== null){
-			$currentItem = $inventory->getItem($slot);
-			$clientSideItem = $this->initiatedSlotChanges[$windowId][$netSlot] ?? null;
-			if($clientSideItem === null || !$clientSideItem->equalsExact($currentItem)){
-				$itemStackWrapper = ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($currentItem));
-				if($windowId === ContainerIds::OFFHAND){
-					//TODO: HACK!
-					//The client may sometimes ignore the InventorySlotPacket for the offhand slot.
-					//This can cause a lot of problems (totems, arrows, and more...).
-					//The workaround is to send an InventoryContentPacket instead
-					//BDS (Bedrock Dedicated Server) also seems to work this way.
-					$this->session->sendDataPacket(InventoryContentPacket::create($windowId, [$itemStackWrapper]));
-				}else{
-					$this->session->sendDataPacket(InventorySlotPacket::create($windowId, $netSlot, $itemStackWrapper));
-				}
+
+		$itemStackWrapper = new ItemStackWrapper($itemStackInfo->getStackId(), $itemStack);
+		if($windowId === ContainerIds::OFFHAND){
+			//TODO: HACK!
+			//The client may sometimes ignore the InventorySlotPacket for the offhand slot.
+			//This can cause a lot of problems (totems, arrows, and more...).
+			//The workaround is to send an InventoryContentPacket instead
+			//BDS (Bedrock Dedicated Server) also seems to work this way.
+			$this->session->sendDataPacket(InventoryContentPacket::create($windowId, [$itemStackWrapper]));
+		}else{
+			if($windowId === ContainerIds::ARMOR){
+				//TODO: HACK!
+				//When right-clicking to equip armour, the client predicts the content of the armour slot, but
+				//doesn't report it in the transaction packet. The server then sends an InventorySlotPacket to
+				//the client, assuming the slot changed for some other reason, since there is no prediction for
+				//the slot.
+				//However, later requests involving that itemstack will refer to the request ID in which the
+				//armour was equipped, instead of the stack ID provided by the server in the outgoing
+				//InventorySlotPacket. (Perhaps because the item is already the same as the client actually
+				//predicted, but didn't tell us?)
+				//We work around this bug by setting the slot to air and then back to the correct item. In
+				//theory, setting a different count and then back again (or changing any other property) would
+				//also work, but this is simpler.
+				$this->session->sendDataPacket(InventorySlotPacket::create($windowId, $netSlot, new ItemStackWrapper(0, ItemStack::null())));
 			}
-			unset($this->initiatedSlotChanges[$windowId][$netSlot]);
+			$this->session->sendDataPacket(InventorySlotPacket::create($windowId, $netSlot, $itemStackWrapper));
 		}
+		unset($entry->predictions[$slot], $entry->pendingSyncs[$slot]);
 	}
 
 	public function syncContents(Inventory $inventory) : void{
-		$slotMap = $this->complexWindows[spl_object_id($inventory)] ?? null;
-		if($slotMap !== null){
+		$entry = $this->inventories[spl_object_id($inventory)] ?? null;
+		if($entry === null){
+			//this can happen when an inventory changed during InventoryCloseEvent, or when a temporary inventory
+			//is cleared before removal.
+			return;
+		}
+		if($entry->complexSlotMap !== null){
 			$windowId = ContainerIds::UI;
 		}else{
 			$windowId = $this->getWindowId($inventory);
 		}
-		$typeConverter = TypeConverter::getInstance();
 		if($windowId !== null){
-			if($slotMap !== null){
-				foreach($inventory->getContents(true) as $slotId => $item){
-					$packetSlot = $slotMap->mapCoreToNet($slotId) ?? null;
+			$entry->predictions = [];
+			$entry->pendingSyncs = [];
+			$contents = [];
+			$typeConverter = TypeConverter::getInstance();
+			foreach($inventory->getContents(true) as $slot => $item){
+				$itemStack = $typeConverter->coreItemStackToNet($item);
+				$info = $this->trackItemStack($entry, $slot, $itemStack, null);
+				$contents[] = new ItemStackWrapper($info->getStackId(), $itemStack);
+			}
+			if($entry->complexSlotMap !== null){
+				foreach($contents as $slotId => $info){
+					$packetSlot = $entry->complexSlotMap->mapCoreToNet($slotId) ?? null;
 					if($packetSlot === null){
 						continue;
 					}
-					unset($this->initiatedSlotChanges[$windowId][$packetSlot]);
 					$this->session->sendDataPacket(InventorySlotPacket::create(
 						$windowId,
 						$packetSlot,
-						ItemStackWrapper::legacy($typeConverter->coreItemStackToNet($inventory->getItem($slotId)))
+						$info
 					));
 				}
 			}else{
-				unset($this->initiatedSlotChanges[$windowId]);
-				$this->session->sendDataPacket(InventoryContentPacket::create($windowId, array_map(function(Item $itemStack) use ($typeConverter) : ItemStackWrapper{
-					return ItemStackWrapper::legacy($typeConverter->coreItemStackToNet($itemStack));
-				}, $inventory->getContents(true))));
+				$this->session->sendDataPacket(InventoryContentPacket::create($windowId, $contents));
 			}
 		}
 	}
 
 	public function syncAll() : void{
-		foreach($this->windowMap as $inventory){
-			$this->syncContents($inventory);
-		}
-		foreach($this->complexWindows as $entry){
-			$this->syncContents($entry->getInventory());
+		foreach($this->inventories as $entry){
+			$this->syncContents($entry->inventory);
 		}
 	}
 
-	public function syncMismatchedPredictedSlotChanges() : void{
-		foreach($this->initiatedSlotChanges as $windowId => $slots){
-			foreach($slots as $netSlot => $expectedItem){
-				$located = $this->locateWindowAndSlot($windowId, $netSlot);
-				if($located === null){
-					continue;
-				}
-				[$inventory, $slot] = $located;
+	public function requestSyncAll() : void{
+		$this->fullSyncRequested = true;
+	}
 
-				if(!$inventory->slotExists($slot)){
+	public function syncMismatchedPredictedSlotChanges() : void{
+		$typeConverter = TypeConverter::getInstance();
+		foreach($this->inventories as $entry){
+			$inventory = $entry->inventory;
+			foreach($entry->predictions as $slot => $expectedItem){
+				if(!$inventory->slotExists($slot) || $entry->itemStackInfos[$slot] === null){
 					continue; //TODO: size desync ???
 				}
-				$actualItem = $inventory->getItem($slot);
-				if(!$actualItem->equalsExact($expectedItem)){
-					$this->session->getLogger()->debug("Detected prediction mismatch in inventory " . get_class($inventory) . "#" . spl_object_id($inventory) . " slot $slot");
-					$this->syncSlot($inventory, $slot);
+
+				//any prediction that still exists at this point is a slot that was predicted to change but didn't
+				$this->session->getLogger()->debug("Detected prediction mismatch in inventory " . get_class($inventory) . "#" . spl_object_id($inventory) . " slot $slot");
+				$entry->pendingSyncs[$slot] = $typeConverter->coreItemStackToNet($inventory->getItem($slot));
+			}
+
+			$entry->predictions = [];
+		}
+	}
+
+	public function flushPendingUpdates() : void{
+		if($this->fullSyncRequested){
+			$this->fullSyncRequested = false;
+			$this->session->getLogger()->debug("Full inventory sync requested, sending contents of " . count($this->inventories) . " inventories");
+			$this->syncAll();
+		}else{
+			foreach($this->inventories as $entry){
+				if(count($entry->pendingSyncs) === 0){
+					continue;
 				}
+				$inventory = $entry->inventory;
+				$this->session->getLogger()->debug("Syncing slots " . implode(", ", array_keys($entry->pendingSyncs)) . " in inventory " . get_class($inventory) . "#" . spl_object_id($inventory));
+				foreach($entry->pendingSyncs as $slot => $itemStack){
+					$this->syncSlot($inventory, $slot, $itemStack);
+				}
+				$entry->pendingSyncs = [];
 			}
 		}
-
-		$this->initiatedSlotChanges = [];
 	}
 
 	public function syncData(Inventory $inventory, int $propertyId, int $value) : void{
@@ -453,11 +573,17 @@ class InventoryManager{
 	}
 
 	public function syncSelectedHotbarSlot() : void{
-		$selected = $this->player->getInventory()->getHeldItemIndex();
+		$playerInventory = $this->player->getInventory();
+		$selected = $playerInventory->getHeldItemIndex();
 		if($selected !== $this->clientSelectedHotbarSlot){
+			$itemStackInfo = $this->getItemStackInfo($playerInventory, $selected);
+			if($itemStackInfo === null){
+				throw new AssumptionFailedError("Player inventory slots should always be tracked");
+			}
+
 			$this->session->sendDataPacket(MobEquipmentPacket::create(
 				$this->player->getId(),
-				ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($this->player->getInventory()->getItemInHand())),
+				new ItemStackWrapper($itemStackInfo->getStackId(), TypeConverter::getInstance()->coreItemStackToNet($playerInventory->getItemInHand())),
 				$selected,
 				$selected,
 				ContainerIds::INVENTORY
@@ -469,9 +595,28 @@ class InventoryManager{
 	public function syncCreative() : void{
 		$typeConverter = TypeConverter::getInstance();
 
-		$nextEntryId = 1;
-		$this->session->sendDataPacket(CreativeContentPacket::create(array_map(function(Item $item) use($typeConverter, &$nextEntryId) : CreativeContentEntry{
-			return new CreativeContentEntry($nextEntryId++, $typeConverter->coreItemStackToNet($item));
-		}, $this->player->isSpectator() ? [] : CreativeInventory::getInstance()->getAll())));
+		$entries = [];
+		if(!$this->player->isSpectator()){
+			//creative inventory may have holes if items were unregistered - ensure network IDs used are always consistent
+			foreach(CreativeInventory::getInstance()->getAll() as $k => $item){
+				$entries[] = new CreativeContentEntry($k, $typeConverter->coreItemStackToNet($item));
+			}
+		}
+		$this->session->sendDataPacket(CreativeContentPacket::create($entries));
+	}
+
+	private function newItemStackId() : int{
+		return $this->nextItemStackId++;
+	}
+
+	public function getItemStackInfo(Inventory $inventory, int $slot) : ?ItemStackInfo{
+		$entry = $this->inventories[spl_object_id($inventory)] ?? null;
+		return $entry?->itemStackInfos[$slot] ?? null;
+	}
+
+	private function trackItemStack(InventoryManagerEntry $entry, int $slotId, ItemStack $itemStack, ?int $itemStackRequestId) : ItemStackInfo{
+		//TODO: ItemStack->isNull() would be nice to have here
+		$info = new ItemStackInfo($itemStackRequestId, $itemStack->getId() === 0 ? 0 : $this->newItemStackId());
+		return $entry->itemStackInfos[$slotId] = $info;
 	}
 }

src/network/mcpe/InventoryManagerEntry.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe;
+
+use pocketmine\inventory\Inventory;
+use pocketmine\network\mcpe\protocol\types\inventory\ItemStack;
+
+final class InventoryManagerEntry{
+	/**
+	 * @var ItemStack[]
+	 * @phpstan-var array<int, ItemStack>
+	 */
+	public array $predictions = [];
+
+	/**
+	 * @var ItemStackInfo[]
+	 * @phpstan-var array<int, ItemStackInfo>
+	 */
+	public array $itemStackInfos = [];
+
+	/**
+	 * @var int[]
+	 * @phpstan-var array<int, ItemStack>
+	 */
+	public array $pendingSyncs = [];
+
+	public function __construct(
+		public Inventory $inventory,
+		public ?ComplexInventoryMapEntry $complexSlotMap = null
+	){}
+}

src/network/mcpe/ItemStackInfo.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe;
+
+final class ItemStackInfo{
+
+	public function __construct(
+		private ?int $requestId,
+		private int $stackId
+	){}
+
+	public function getRequestId() : ?int{ return $this->requestId; }
+
+	public function getStackId() : int{ return $this->stackId; }
+}

src/network/mcpe/NetworkBroadcastUtils.php

@@ -0,0 +1,103 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe;
+
+use pocketmine\event\server\DataPacketSendEvent;
+use pocketmine\network\mcpe\protocol\ClientboundPacket;
+use pocketmine\player\Player;
+use pocketmine\timings\Timings;
+use function count;
+use function spl_object_id;
+
+final class NetworkBroadcastUtils{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	/**
+	 * @param Player[]            $recipients
+	 * @param ClientboundPacket[] $packets
+	 */
+	public static function broadcastPackets(array $recipients, array $packets) : bool{
+		if(count($packets) === 0){
+			throw new \InvalidArgumentException("Cannot broadcast empty list of packets");
+		}
+
+		return Timings::$broadcastPackets->time(function() use ($recipients, $packets) : bool{
+			/** @var NetworkSession[] $sessions */
+			$sessions = [];
+			foreach($recipients as $player){
+				if($player->isConnected()){
+					$sessions[] = $player->getNetworkSession();
+				}
+			}
+			if(count($sessions) === 0){
+				return false;
+			}
+
+			$ev = new DataPacketSendEvent($sessions, $packets);
+			$ev->call();
+			if($ev->isCancelled()){
+				return false;
+			}
+			$sessions = $ev->getTargets();
+
+			/** @var PacketBroadcaster[] $uniqueBroadcasters */
+			$uniqueBroadcasters = [];
+			/** @var NetworkSession[][] $broadcasterTargets */
+			$broadcasterTargets = [];
+			foreach($sessions as $recipient){
+				$broadcaster = $recipient->getBroadcaster();
+				$uniqueBroadcasters[spl_object_id($broadcaster)] = $broadcaster;
+				$broadcasterTargets[spl_object_id($broadcaster)][spl_object_id($recipient)] = $recipient;
+			}
+			foreach($uniqueBroadcasters as $broadcaster){
+				$broadcaster->broadcastPackets($broadcasterTargets[spl_object_id($broadcaster)], $packets);
+			}
+
+			return true;
+		});
+	}
+
+	/**
+	 * @param Player[] $recipients
+	 * @phpstan-param \Closure(EntityEventBroadcaster, array<int, NetworkSession>) : void $callback
+	 */
+	public static function broadcastEntityEvent(array $recipients, \Closure $callback) : void{
+		$uniqueBroadcasters = [];
+		$broadcasterTargets = [];
+
+		foreach($recipients as $recipient){
+			$session = $recipient->getNetworkSession();
+			$broadcaster = $session->getEntityEventBroadcaster();
+			$uniqueBroadcasters[spl_object_id($broadcaster)] = $broadcaster;
+			$broadcasterTargets[spl_object_id($broadcaster)][spl_object_id($session)] = $session;
+		}
+
+		foreach($uniqueBroadcasters as $k => $broadcaster){
+			$callback($broadcaster, $broadcasterTargets[$k]);
+		}
+	}
+}

src/network/mcpe/NetworkSession.php

@@ -23,13 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\network\mcpe;
 
-use pocketmine\data\bedrock\EffectIdMap;
-use pocketmine\entity\Attribute;
 use pocketmine\entity\effect\EffectInstance;
-use pocketmine\entity\Entity;
-use pocketmine\entity\Human;
-use pocketmine\entity\Living;
 use pocketmine\event\player\PlayerDuplicateLoginEvent;
+use pocketmine\event\server\DataPacketDecodeEvent;
 use pocketmine\event\server\DataPacketReceiveEvent;
 use pocketmine\event\server\DataPacketSendEvent;
 use pocketmine\form\Form;
@@ -43,7 +39,6 @@ use pocketmine\network\mcpe\cache\ChunkCache;
 use pocketmine\network\mcpe\compression\CompressBatchPromise;
 use pocketmine\network\mcpe\compression\Compressor;
 use pocketmine\network\mcpe\compression\DecompressionException;
-use pocketmine\network\mcpe\convert\GlobalItemTypeDictionary;
 use pocketmine\network\mcpe\convert\SkinAdapterSingleton;
 use pocketmine\network\mcpe\convert\TypeConverter;
 use pocketmine\network\mcpe\encryption\DecryptionException;
@@ -62,10 +57,6 @@ use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
 use pocketmine\network\mcpe\protocol\ChunkRadiusUpdatedPacket;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\DisconnectPacket;
-use pocketmine\network\mcpe\protocol\EmotePacket;
-use pocketmine\network\mcpe\protocol\MobArmorEquipmentPacket;
-use pocketmine\network\mcpe\protocol\MobEffectPacket;
-use pocketmine\network\mcpe\protocol\MobEquipmentPacket;
 use pocketmine\network\mcpe\protocol\ModalFormRequestPacket;
 use pocketmine\network\mcpe\protocol\MovePlayerPacket;
 use pocketmine\network\mcpe\protocol\NetworkChunkPublisherUpdatePacket;
@@ -74,19 +65,16 @@ use pocketmine\network\mcpe\protocol\PacketDecodeException;
 use pocketmine\network\mcpe\protocol\PacketPool;
 use pocketmine\network\mcpe\protocol\PlayerListPacket;
 use pocketmine\network\mcpe\protocol\PlayStatusPacket;
-use pocketmine\network\mcpe\protocol\RemoveActorPacket;
 use pocketmine\network\mcpe\protocol\serializer\PacketBatch;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializer;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
 use pocketmine\network\mcpe\protocol\ServerboundPacket;
 use pocketmine\network\mcpe\protocol\ServerToClientHandshakePacket;
-use pocketmine\network\mcpe\protocol\SetActorDataPacket;
 use pocketmine\network\mcpe\protocol\SetDifficultyPacket;
 use pocketmine\network\mcpe\protocol\SetPlayerGameTypePacket;
 use pocketmine\network\mcpe\protocol\SetSpawnPositionPacket;
 use pocketmine\network\mcpe\protocol\SetTimePacket;
 use pocketmine\network\mcpe\protocol\SetTitlePacket;
-use pocketmine\network\mcpe\protocol\TakeItemActorPacket;
 use pocketmine\network\mcpe\protocol\TextPacket;
 use pocketmine\network\mcpe\protocol\ToastRequestPacket;
 use pocketmine\network\mcpe\protocol\TransferPacket;
@@ -98,16 +86,10 @@ use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
 use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
 use pocketmine\network\mcpe\protocol\types\command\CommandPermissions;
 use pocketmine\network\mcpe\protocol\types\DimensionIds;
-use pocketmine\network\mcpe\protocol\types\entity\Attribute as NetworkAttribute;
-use pocketmine\network\mcpe\protocol\types\entity\MetadataProperty;
-use pocketmine\network\mcpe\protocol\types\entity\PropertySyncData;
-use pocketmine\network\mcpe\protocol\types\inventory\ContainerIds;
-use pocketmine\network\mcpe\protocol\types\inventory\ItemStackWrapper;
 use pocketmine\network\mcpe\protocol\types\PlayerListEntry;
 use pocketmine\network\mcpe\protocol\types\PlayerPermissions;
 use pocketmine\network\mcpe\protocol\UpdateAbilitiesPacket;
 use pocketmine\network\mcpe\protocol\UpdateAdventureSettingsPacket;
-use pocketmine\network\mcpe\protocol\UpdateAttributesPacket;
 use pocketmine\network\NetworkSessionManager;
 use pocketmine\network\PacketHandlingException;
 use pocketmine\permission\DefaultPermissionNames;
@@ -136,7 +118,6 @@ use function hrtime;
 use function in_array;
 use function intdiv;
 use function json_encode;
-use function ksort;
 use function min;
 use function strcasecmp;
 use function strlen;
@@ -145,7 +126,6 @@ use function substr;
 use function time;
 use function ucfirst;
 use const JSON_THROW_ON_ERROR;
-use const SORT_NUMERIC;
 
 class NetworkSession{
 	private const INCOMING_PACKET_BATCH_PER_TICK = 2; //usually max 1 per tick, but transactions may arrive separately
@@ -189,8 +169,6 @@ class NetworkSession{
 	private bool $forceAsyncCompression = true;
 	private bool $enableCompression = false; //disabled until handshake completed
 
-	private PacketSerializerContext $packetSerializerContext;
-
 	private ?InventoryManager $invManager = null;
 
 	/**
@@ -203,8 +181,10 @@ class NetworkSession{
 		private Server $server,
 		private NetworkSessionManager $manager,
 		private PacketPool $packetPool,
+		private PacketSerializerContext $packetSerializerContext,
 		private PacketSender $sender,
 		private PacketBroadcaster $broadcaster,
+		private EntityEventBroadcaster $entityEventBroadcaster,
 		private Compressor $compressor,
 		private string $ip,
 		private int $port
@@ -213,9 +193,6 @@ class NetworkSession{
 
 		$this->compressedQueue = new \SplQueue();
 
-		//TODO: allow this to be injected
-		$this->packetSerializerContext = new PacketSerializerContext(GlobalItemTypeDictionary::getInstance()->getDictionary());
-
 		$this->disposeHooks = new ObjectSet();
 
 		$this->connectTime = time();
@@ -279,10 +256,10 @@ class NetworkSession{
 
 		$effectManager = $this->player->getEffects();
 		$effectManager->getEffectAddHooks()->add($effectAddHook = function(EffectInstance $effect, bool $replacesOldEffect) : void{
-			$this->onEntityEffectAdded($this->player, $effect, $replacesOldEffect);
+			$this->entityEventBroadcaster->onEntityEffectAdded([$this], $this->player, $effect, $replacesOldEffect);
 		});
 		$effectManager->getEffectRemoveHooks()->add($effectRemoveHook = function(EffectInstance $effect) : void{
-			$this->onEntityEffectRemoved($this->player, $effect);
+			$this->entityEventBroadcaster->onEntityEffectRemoved([$this], $this->player, $effect);
 		});
 		$this->disposeHooks->add(static function() use ($effectManager, $effectAddHook, $effectRemoveHook) : void{
 			$effectManager->getEffectAddHooks()->remove($effectAddHook);
@@ -400,7 +377,7 @@ class NetworkSession{
 				$stream = new BinaryStream($decompressed);
 				$count = 0;
 				foreach(PacketBatch::decodeRaw($stream) as $buffer){
-					if(++$count > 1300){
+					if(++$count > 100){
 						throw new PacketHandlingException("Too many packets in batch");
 					}
 					$packet = $this->packetPool->getPacket($buffer);
@@ -436,6 +413,12 @@ class NetworkSession{
 		$timings->startTiming();
 
 		try{
+			$ev = new DataPacketDecodeEvent($this, $packet->pid(), $buffer);
+			$ev->call();
+			if($ev->isCancelled()){
+				return;
+			}
+
 			$decodeTimings = Timings::getDecodeDataPacketTimings($packet);
 			$decodeTimings->startTiming();
 			try{
@@ -453,18 +436,18 @@ class NetworkSession{
 				$decodeTimings->stopTiming();
 			}
 
-			$handlerTimings = Timings::getHandleDataPacketTimings($packet);
-			$handlerTimings->startTiming();
-			try{
-				//TODO: I'm not sure DataPacketReceiveEvent should be included in the handler timings, but it needs to be
-				//included for now to ensure the receivePacket timings are counted the way they were before
-				$ev = new DataPacketReceiveEvent($this, $packet);
-				$ev->call();
-				if(!$ev->isCancelled() && ($this->handler === null || !$packet->handle($this->handler))){
-					$this->logger->debug("Unhandled " . $packet->getName() . ": " . base64_encode($stream->getBuffer()));
+			$ev = new DataPacketReceiveEvent($this, $packet);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				$handlerTimings = Timings::getHandleDataPacketTimings($packet);
+				$handlerTimings->startTiming();
+				try{
+					if($this->handler === null || !$packet->handle($this->handler)){
+						$this->logger->debug("Unhandled " . $packet->getName() . ": " . base64_encode($stream->getBuffer()));
+					}
+				}finally{
+					$handlerTimings->stopTiming();
 				}
-			}finally{
-				$handlerTimings->stopTiming();
 			}
 		}finally{
 			$timings->stopTiming();
@@ -553,6 +536,8 @@ class NetworkSession{
 
 	public function getBroadcaster() : PacketBroadcaster{ return $this->broadcaster; }
 
+	public function getEntityEventBroadcaster() : EntityEventBroadcaster{ return $this->entityEventBroadcaster; }
+
 	public function getCompressor() : Compressor{
 		return $this->compressor;
 	}
@@ -577,20 +562,25 @@ class NetworkSession{
 				$this->compressedQueue->enqueue($payload);
 				$payload->onResolve(function(CompressBatchPromise $payload) : void{
 					if($this->connected && $this->compressedQueue->bottom() === $payload){
-						$this->compressedQueue->dequeue(); //result unused
-						$this->sendEncoded($payload->getResult());
+						Timings::$playerNetworkSend->startTiming();
+						try{
+							$this->compressedQueue->dequeue(); //result unused
+							$this->sendEncoded($payload->getResult());
 
-						while(!$this->compressedQueue->isEmpty()){
-							/** @var CompressBatchPromise $current */
-							$current = $this->compressedQueue->bottom();
-							if($current->hasResult()){
-								$this->compressedQueue->dequeue();
+							while(!$this->compressedQueue->isEmpty()){
+								/** @var CompressBatchPromise $current */
+								$current = $this->compressedQueue->bottom();
+								if($current->hasResult()){
+									$this->compressedQueue->dequeue();
 
-								$this->sendEncoded($current->getResult());
-							}else{
-								//can't send any more queued until this one is ready
-								break;
+									$this->sendEncoded($current->getResult());
+								}else{
+									//can't send any more queued until this one is ready
+									break;
+								}
 							}
+						}finally{
+							Timings::$playerNetworkSend->stopTiming();
 						}
 					}
 				});
@@ -823,7 +813,7 @@ class NetworkSession{
 	}
 
 	public function onServerRespawn() : void{
-		$this->syncAttributes($this->player, $this->player->getAttributeMap()->getAll());
+		$this->entityEventBroadcaster->syncAttributes([$this], $this->player, $this->player->getAttributeMap()->getAll());
 		$this->player->sendData(null);
 
 		$this->syncAbilities($this->player);
@@ -933,41 +923,6 @@ class NetworkSession{
 		));
 	}
 
-	/**
-	 * @param Attribute[] $attributes
-	 */
-	public function syncAttributes(Living $entity, array $attributes) : void{
-		if(count($attributes) > 0){
-			$this->sendDataPacket(UpdateAttributesPacket::create($entity->getId(), array_map(function(Attribute $attr) : NetworkAttribute{
-				return new NetworkAttribute($attr->getId(), $attr->getMinValue(), $attr->getMaxValue(), $attr->getValue(), $attr->getDefaultValue(), []);
-			}, $attributes), 0));
-		}
-	}
-
-	/**
-	 * @param MetadataProperty[] $properties
-	 * @phpstan-param array<int, MetadataProperty> $properties
-	 */
-	public function syncActorData(Entity $entity, array $properties) : void{
-		//TODO: HACK! as of 1.18.10, the client responds differently to the same data ordered in different orders - for
-		//example, sending HEIGHT in the list before FLAGS when unsetting the SWIMMING flag results in a hitbox glitch
-		ksort($properties, SORT_NUMERIC);
-		$this->sendDataPacket(SetActorDataPacket::create($entity->getId(), $properties, new PropertySyncData([], []), 0));
-	}
-
-	public function onEntityEffectAdded(Living $entity, EffectInstance $effect, bool $replacesOldEffect) : void{
-		//TODO: we may need yet another effect <=> ID map in the future depending on protocol changes
-		$this->sendDataPacket(MobEffectPacket::add($entity->getId(), $replacesOldEffect, EffectIdMap::getInstance()->toId($effect->getType()), $effect->getAmplifier(), $effect->isVisible(), $effect->getDuration()));
-	}
-
-	public function onEntityEffectRemoved(Living $entity, EffectInstance $effect) : void{
-		$this->sendDataPacket(MobEffectPacket::remove($entity->getId(), EffectIdMap::getInstance()->toId($effect->getType())));
-	}
-
-	public function onEntityRemoved(Entity $entity) : void{
-		$this->sendDataPacket(RemoveActorPacket::create($entity->getId()));
-	}
-
 	public function syncAvailableCommands() : void{
 		$commandData = [];
 		foreach($this->server->getCommandMap()->getCommands() as $name => $command){
@@ -1103,36 +1058,6 @@ class NetworkSession{
 		return $this->invManager;
 	}
 
-	/**
-	 * TODO: expand this to more than just humans
-	 */
-	public function onMobMainHandItemChange(Human $mob) : void{
-		//TODO: we could send zero for slot here because remote players don't need to know which slot was selected
-		$inv = $mob->getInventory();
-		$this->sendDataPacket(MobEquipmentPacket::create($mob->getId(), ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($inv->getItemInHand())), $inv->getHeldItemIndex(), $inv->getHeldItemIndex(), ContainerIds::INVENTORY));
-	}
-
-	public function onMobOffHandItemChange(Human $mob) : void{
-		$inv = $mob->getOffHandInventory();
-		$this->sendDataPacket(MobEquipmentPacket::create($mob->getId(), ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($inv->getItem(0))), 0, 0, ContainerIds::OFFHAND));
-	}
-
-	public function onMobArmorChange(Living $mob) : void{
-		$inv = $mob->getArmorInventory();
-		$converter = TypeConverter::getInstance();
-		$this->sendDataPacket(MobArmorEquipmentPacket::create(
-			$mob->getId(),
-			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getHelmet())),
-			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getChestplate())),
-			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getLeggings())),
-			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getBoots()))
-		));
-	}
-
-	public function onPlayerPickUpItem(Player $collector, Entity $pickedUp) : void{
-		$this->sendDataPacket(TakeItemActorPacket::create($collector->getId(), $pickedUp->getId()));
-	}
-
 	/**
 	 * @param Player[] $players
 	 */
@@ -1176,10 +1101,6 @@ class NetworkSession{
 		$this->sendDataPacket(SetTitlePacket::setAnimationTimes($fadeIn, $stay, $fadeOut));
 	}
 
-	public function onEmote(Human $from, string $emoteId) : void{
-		$this->sendDataPacket(EmotePacket::create($from->getId(), $emoteId, EmotePacket::FLAG_SERVER));
-	}
-
 	public function onToastNotification(string $title, string $body) : void{
 		$this->sendDataPacket(ToastRequestPacket::create($title, $body));
 	}
@@ -1219,13 +1140,19 @@ class NetworkSession{
 			$this->player->doChunkRequests();
 
 			$dirtyAttributes = $this->player->getAttributeMap()->needSend();
-			$this->syncAttributes($this->player, $dirtyAttributes);
+			$this->entityEventBroadcaster->syncAttributes([$this], $this->player, $dirtyAttributes);
 			foreach($dirtyAttributes as $attribute){
 				//TODO: we might need to send these to other players in the future
 				//if that happens, this will need to become more complex than a flag on the attribute itself
 				$attribute->markSynchronized();
 			}
 		}
+		Timings::$playerNetworkSendInventorySync->startTiming();
+		try{
+			$this->invManager?->flushPendingUpdates();
+		}finally{
+			Timings::$playerNetworkSendInventorySync->stopTiming();
+		}
 
 		$this->flushSendBuffer();
 	}

src/network/mcpe/StandardEntityEventBroadcaster.php

@@ -0,0 +1,143 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe;
+
+use pocketmine\data\bedrock\EffectIdMap;
+use pocketmine\entity\Attribute;
+use pocketmine\entity\effect\EffectInstance;
+use pocketmine\entity\Entity;
+use pocketmine\entity\Human;
+use pocketmine\entity\Living;
+use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\protocol\ClientboundPacket;
+use pocketmine\network\mcpe\protocol\EmotePacket;
+use pocketmine\network\mcpe\protocol\MobArmorEquipmentPacket;
+use pocketmine\network\mcpe\protocol\MobEffectPacket;
+use pocketmine\network\mcpe\protocol\MobEquipmentPacket;
+use pocketmine\network\mcpe\protocol\RemoveActorPacket;
+use pocketmine\network\mcpe\protocol\SetActorDataPacket;
+use pocketmine\network\mcpe\protocol\TakeItemActorPacket;
+use pocketmine\network\mcpe\protocol\types\entity\Attribute as NetworkAttribute;
+use pocketmine\network\mcpe\protocol\types\entity\PropertySyncData;
+use pocketmine\network\mcpe\protocol\types\inventory\ContainerIds;
+use pocketmine\network\mcpe\protocol\types\inventory\ItemStackWrapper;
+use pocketmine\network\mcpe\protocol\UpdateAttributesPacket;
+use function array_map;
+use function count;
+use function ksort;
+use const SORT_NUMERIC;
+
+final class StandardEntityEventBroadcaster implements EntityEventBroadcaster{
+
+	public function __construct(
+		private StandardPacketBroadcaster $broadcaster
+	){}
+
+	/**
+	 * @param NetworkSession[] $recipients
+	 */
+	private function sendDataPacket(array $recipients, ClientboundPacket $packet) : void{
+		$this->broadcaster->broadcastPackets($recipients, [$packet]);
+	}
+
+	public function syncAttributes(array $recipients, Living $entity, array $attributes) : void{
+		if(count($attributes) > 0){
+			$this->sendDataPacket($recipients, UpdateAttributesPacket::create(
+				$entity->getId(),
+				array_map(fn(Attribute $attr) => new NetworkAttribute($attr->getId(), $attr->getMinValue(), $attr->getMaxValue(), $attr->getValue(), $attr->getDefaultValue(), []), $attributes),
+				0
+			));
+		}
+	}
+
+	public function syncActorData(array $recipients, Entity $entity, array $properties) : void{
+		//TODO: HACK! as of 1.18.10, the client responds differently to the same data ordered in different orders - for
+		//example, sending HEIGHT in the list before FLAGS when unsetting the SWIMMING flag results in a hitbox glitch
+		ksort($properties, SORT_NUMERIC);
+		$this->sendDataPacket($recipients, SetActorDataPacket::create($entity->getId(), $properties, new PropertySyncData([], []), 0));
+	}
+
+	public function onEntityEffectAdded(array $recipients, Living $entity, EffectInstance $effect, bool $replacesOldEffect) : void{
+		//TODO: we may need yet another effect <=> ID map in the future depending on protocol changes
+		$this->sendDataPacket($recipients, MobEffectPacket::add(
+			$entity->getId(),
+			$replacesOldEffect,
+			EffectIdMap::getInstance()->toId($effect->getType()),
+			$effect->getAmplifier(),
+			$effect->isVisible(),
+			$effect->getDuration()
+		));
+	}
+
+	public function onEntityEffectRemoved(array $recipients, Living $entity, EffectInstance $effect) : void{
+		$this->sendDataPacket($recipients, MobEffectPacket::remove($entity->getId(), EffectIdMap::getInstance()->toId($effect->getType())));
+	}
+
+	public function onEntityRemoved(array $recipients, Entity $entity) : void{
+		$this->sendDataPacket($recipients, RemoveActorPacket::create($entity->getId()));
+	}
+
+	public function onMobMainHandItemChange(array $recipients, Human $mob) : void{
+		//TODO: we could send zero for slot here because remote players don't need to know which slot was selected
+		$inv = $mob->getInventory();
+		$this->sendDataPacket($recipients, MobEquipmentPacket::create(
+			$mob->getId(),
+			ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($inv->getItemInHand())),
+			$inv->getHeldItemIndex(),
+			$inv->getHeldItemIndex(),
+			ContainerIds::INVENTORY
+		));
+	}
+
+	public function onMobOffHandItemChange(array $recipients, Human $mob) : void{
+		$inv = $mob->getOffHandInventory();
+		$this->sendDataPacket($recipients, MobEquipmentPacket::create(
+			$mob->getId(),
+			ItemStackWrapper::legacy(TypeConverter::getInstance()->coreItemStackToNet($inv->getItem(0))),
+			0,
+			0,
+			ContainerIds::OFFHAND
+		));
+	}
+
+	public function onMobArmorChange(array $recipients, Living $mob) : void{
+		$inv = $mob->getArmorInventory();
+		$converter = TypeConverter::getInstance();
+		$this->sendDataPacket($recipients, MobArmorEquipmentPacket::create(
+			$mob->getId(),
+			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getHelmet())),
+			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getChestplate())),
+			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getLeggings())),
+			ItemStackWrapper::legacy($converter->coreItemStackToNet($inv->getBoots()))
+		));
+	}
+
+	public function onPickUpItem(array $recipients, Entity $collector, Entity $pickedUp) : void{
+		$this->sendDataPacket($recipients, TakeItemActorPacket::create($collector->getId(), $pickedUp->getId()));
+	}
+
+	public function onEmote(array $recipients, Human $from, string $emoteId) : void{
+		$this->sendDataPacket($recipients, EmotePacket::create($from->getId(), $emoteId, EmotePacket::FLAG_SERVER));
+	}
+}

src/network/mcpe/StandardPacketBroadcaster.php

@@ -25,62 +25,65 @@ namespace pocketmine\network\mcpe;
 
 use pocketmine\network\mcpe\protocol\serializer\PacketBatch;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializer;
+use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
 use pocketmine\Server;
 use pocketmine\timings\Timings;
 use pocketmine\utils\BinaryStream;
 use function count;
+use function log;
 use function spl_object_id;
 use function strlen;
 
 final class StandardPacketBroadcaster implements PacketBroadcaster{
-	public function __construct(private Server $server){}
+	public function __construct(
+		private Server $server,
+		private PacketSerializerContext $protocolContext
+	){}
 
 	public function broadcastPackets(array $recipients, array $packets) : void{
-		$packetBufferTotalLengths = [];
-		$packetBuffers = [];
 		$compressors = [];
-		/** @var NetworkSession[][][] $targetMap */
-		$targetMap = [];
+
+		/** @var NetworkSession[][] $targetsByCompressor */
+		$targetsByCompressor = [];
 		foreach($recipients as $recipient){
-			$serializerContext = $recipient->getPacketSerializerContext();
-			$bufferId = spl_object_id($serializerContext);
-			if(!isset($packetBuffers[$bufferId])){
-				$packetBufferTotalLengths[$bufferId] = 0;
-				$packetBuffers[$bufferId] = [];
-				foreach($packets as $packet){
-					$buffer = NetworkSession::encodePacketTimed(PacketSerializer::encoder($serializerContext), $packet);
-					$packetBufferTotalLengths[$bufferId] += strlen($buffer);
-					$packetBuffers[$bufferId][] = $buffer;
-				}
+			if($recipient->getPacketSerializerContext() !== $this->protocolContext){
+				throw new \InvalidArgumentException("Only recipients with the same protocol context as the broadcaster can be broadcast to by this broadcaster");
 			}
 
 			//TODO: different compressors might be compatible, it might not be necessary to split them up by object
 			$compressor = $recipient->getCompressor();
 			$compressors[spl_object_id($compressor)] = $compressor;
 
-			$targetMap[$bufferId][spl_object_id($compressor)][] = $recipient;
+			$targetsByCompressor[spl_object_id($compressor)][] = $recipient;
 		}
 
-		foreach($targetMap as $bufferId => $compressorMap){
-			foreach($compressorMap as $compressorId => $compressorTargets){
-				$compressor = $compressors[$compressorId];
+		$totalLength = 0;
+		$packetBuffers = [];
+		foreach($packets as $packet){
+			$buffer = NetworkSession::encodePacketTimed(PacketSerializer::encoder($this->protocolContext), $packet);
+			//varint length prefix + packet buffer
+			$totalLength += (((int) log(strlen($buffer), 128)) + 1) + strlen($buffer);
+			$packetBuffers[] = $buffer;
+		}
 
-				$threshold = $compressor->getCompressionThreshold();
-				if(count($compressorTargets) > 1 && $threshold !== null && $packetBufferTotalLengths[$bufferId] >= $threshold){
-					//do not prepare shared batch unless we're sure it will be compressed
-					$stream = new BinaryStream();
-					PacketBatch::encodeRaw($stream, $packetBuffers[$bufferId]);
-					$batchBuffer = $stream->getBuffer();
+		foreach($targetsByCompressor as $compressorId => $compressorTargets){
+			$compressor = $compressors[$compressorId];
 
-					$promise = $this->server->prepareBatch(new PacketBatch($batchBuffer), $compressor, timings: Timings::$playerNetworkSendCompressBroadcast);
-					foreach($compressorTargets as $target){
-						$target->queueCompressed($promise);
-					}
-				}else{
-					foreach($compressorTargets as $target){
-						foreach($packetBuffers[$bufferId] as $packetBuffer){
-							$target->addToSendBuffer($packetBuffer);
-						}
+			$threshold = $compressor->getCompressionThreshold();
+			if(count($compressorTargets) > 1 && $threshold !== null && $totalLength >= $threshold){
+				//do not prepare shared batch unless we're sure it will be compressed
+				$stream = new BinaryStream();
+				PacketBatch::encodeRaw($stream, $packetBuffers);
+				$batchBuffer = $stream->getBuffer();
+
+				$promise = $this->server->prepareBatch(new PacketBatch($batchBuffer), $compressor, timings: Timings::$playerNetworkSendCompressBroadcast);
+				foreach($compressorTargets as $target){
+					$target->queueCompressed($promise);
+				}
+			}else{
+				foreach($compressorTargets as $target){
+					foreach($packetBuffers as $packetBuffer){
+						$target->addToSendBuffer($packetBuffer);
 					}
 				}
 			}

src/network/mcpe/cache/CraftingDataCache.php

@@ -25,6 +25,8 @@ namespace pocketmine\network\mcpe\cache;
 
 use pocketmine\crafting\CraftingManager;
 use pocketmine\crafting\FurnaceType;
+use pocketmine\crafting\ShapedRecipe;
+use pocketmine\crafting\ShapelessRecipe;
 use pocketmine\crafting\ShapelessRecipeType;
 use pocketmine\item\Item;
 use pocketmine\network\mcpe\convert\ItemTranslator;
@@ -76,12 +78,12 @@ final class CraftingDataCache{
 	private function buildCraftingDataCache(CraftingManager $manager) : CraftingDataPacket{
 		Timings::$craftingDataCacheRebuild->startTiming();
 
-		$counter = 0;
 		$nullUUID = Uuid::fromString(Uuid::NIL);
 		$converter = TypeConverter::getInstance();
 		$recipesWithTypeIds = [];
-		foreach($manager->getShapelessRecipes() as $list){
-			foreach($list as $recipe){
+
+		foreach($manager->getCraftingRecipeIndex() as $index => $recipe){
+			if($recipe instanceof ShapelessRecipe){
 				$typeTag = match($recipe->getType()->id()){
 					ShapelessRecipeType::CRAFTING()->id() => CraftingRecipeBlockName::CRAFTING_TABLE,
 					ShapelessRecipeType::STONECUTTER()->id() => CraftingRecipeBlockName::STONECUTTER,
@@ -89,7 +91,7 @@ final class CraftingDataCache{
 				};
 				$recipesWithTypeIds[] = new ProtocolShapelessRecipe(
 					CraftingDataPacket::ENTRY_SHAPELESS,
-					Binary::writeInt(++$counter),
+					Binary::writeInt($index),
 					array_map(function(Item $item) use ($converter) : RecipeIngredient{
 						return $converter->coreItemStackToRecipeIngredient($item);
 					}, $recipe->getIngredientList()),
@@ -99,12 +101,9 @@ final class CraftingDataCache{
 					$nullUUID,
 					$typeTag,
 					50,
-					$counter
+					$index
 				);
-			}
-		}
-		foreach($manager->getShapedRecipes() as $list){
-			foreach($list as $recipe){
+			}elseif($recipe instanceof ShapedRecipe){
 				$inputs = [];
 
 				for($row = 0, $height = $recipe->getHeight(); $row < $height; ++$row){
@@ -114,7 +113,7 @@ final class CraftingDataCache{
 				}
 				$recipesWithTypeIds[] = $r = new ProtocolShapedRecipe(
 					CraftingDataPacket::ENTRY_SHAPED,
-					Binary::writeInt(++$counter),
+					Binary::writeInt($index),
 					$inputs,
 					array_map(function(Item $item) use ($converter) : ItemStack{
 						return $converter->coreItemStackToNet($item);
@@ -122,8 +121,10 @@ final class CraftingDataCache{
 					$nullUUID,
 					CraftingRecipeBlockName::CRAFTING_TABLE,
 					50,
-					$counter
+					$index
 				);
+			}else{
+				//TODO: probably special recipe types
 			}
 		}
 

src/network/mcpe/convert/RuntimeBlockMapping.php

@@ -29,8 +29,7 @@ use pocketmine\data\bedrock\BedrockDataFiles;
 use pocketmine\data\bedrock\LegacyBlockIdToStringIdMap;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\network\mcpe\protocol\serializer\NetworkNbtSerializer;
-use pocketmine\network\mcpe\protocol\serializer\PacketSerializer;
-use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
+use pocketmine\utils\BinaryStream;
 use pocketmine\utils\Filesystem;
 use pocketmine\utils\SingletonTrait;
 
@@ -55,14 +54,14 @@ final class RuntimeBlockMapping{
 	}
 
 	public function __construct(string $canonicalBlockStatesFile, string $r12ToCurrentBlockMapFile){
-		$stream = PacketSerializer::decoder(
-			Filesystem::fileGetContents($canonicalBlockStatesFile),
-			0,
-			new PacketSerializerContext(GlobalItemTypeDictionary::getInstance()->getDictionary())
-		);
+		$stream = new BinaryStream(Filesystem::fileGetContents($canonicalBlockStatesFile));
 		$list = [];
+		$nbtReader = new NetworkNbtSerializer();
 		while(!$stream->feof()){
-			$list[] = $stream->getNbtCompoundRoot();
+			$offset = $stream->getOffset();
+			$blockState = $nbtReader->read($stream->getBuffer(), $offset)->mustGetCompoundTag();
+			$stream->setOffset($offset);
+			$list[] = $blockState;
 		}
 		$this->bedrockKnownStates = $list;
 
@@ -73,14 +72,10 @@ final class RuntimeBlockMapping{
 		$legacyIdMap = LegacyBlockIdToStringIdMap::getInstance();
 		/** @var R12ToCurrentBlockMapEntry[] $legacyStateMap */
 		$legacyStateMap = [];
-		$legacyStateMapReader = PacketSerializer::decoder(
-			Filesystem::fileGetContents($r12ToCurrentBlockMapFile),
-			0,
-			new PacketSerializerContext(GlobalItemTypeDictionary::getInstance()->getDictionary())
-		);
+		$legacyStateMapReader = new BinaryStream(Filesystem::fileGetContents($r12ToCurrentBlockMapFile));
 		$nbtReader = new NetworkNbtSerializer();
 		while(!$legacyStateMapReader->feof()){
-			$id = $legacyStateMapReader->getString();
+			$id = $legacyStateMapReader->get($legacyStateMapReader->getUnsignedVarInt());
 			$meta = $legacyStateMapReader->getLShort();
 
 			$offset = $legacyStateMapReader->getOffset();

src/network/mcpe/convert/TypeConverter.php

@@ -24,11 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\network\mcpe\convert;
 
 use pocketmine\block\BlockLegacyIds;
-use pocketmine\inventory\transaction\action\CreateItemAction;
-use pocketmine\inventory\transaction\action\DestroyItemAction;
-use pocketmine\inventory\transaction\action\DropItemAction;
-use pocketmine\inventory\transaction\action\InventoryAction;
-use pocketmine\inventory\transaction\action\SlotChangeAction;
 use pocketmine\item\Durable;
 use pocketmine\item\Item;
 use pocketmine\item\ItemFactory;
@@ -37,17 +32,12 @@ use pocketmine\item\VanillaItems;
 use pocketmine\nbt\NbtException;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\nbt\tag\IntTag;
-use pocketmine\network\mcpe\InventoryManager;
 use pocketmine\network\mcpe\protocol\types\GameMode as ProtocolGameMode;
-use pocketmine\network\mcpe\protocol\types\inventory\ContainerIds;
 use pocketmine\network\mcpe\protocol\types\inventory\ItemStack;
-use pocketmine\network\mcpe\protocol\types\inventory\NetworkInventoryAction;
-use pocketmine\network\mcpe\protocol\types\inventory\UIInventorySlotOffset;
 use pocketmine\network\mcpe\protocol\types\recipe\IntIdMetaItemDescriptor;
 use pocketmine\network\mcpe\protocol\types\recipe\RecipeIngredient;
 use pocketmine\network\mcpe\protocol\types\recipe\StringIdMetaItemDescriptor;
 use pocketmine\player\GameMode;
-use pocketmine\player\Player;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\SingletonTrait;
 
@@ -261,60 +251,4 @@ class TypeConverter{
 			throw TypeConversionException::wrap($e, "Bad itemstack NBT data");
 		}
 	}
-
-	/**
-	 * @throws TypeConversionException
-	 */
-	public function createInventoryAction(NetworkInventoryAction $action, Player $player, InventoryManager $inventoryManager) : ?InventoryAction{
-		if($action->oldItem->getItemStack()->equals($action->newItem->getItemStack())){
-			//filter out useless noise in 1.13
-			return null;
-		}
-		try{
-			$old = $this->netItemStackToCore($action->oldItem->getItemStack());
-		}catch(TypeConversionException $e){
-			throw TypeConversionException::wrap($e, "Inventory action: oldItem");
-		}
-		try{
-			$new = $this->netItemStackToCore($action->newItem->getItemStack());
-		}catch(TypeConversionException $e){
-			throw TypeConversionException::wrap($e, "Inventory action: newItem");
-		}
-		switch($action->sourceType){
-			case NetworkInventoryAction::SOURCE_CONTAINER:
-				if($action->windowId === ContainerIds::UI && $action->inventorySlot === UIInventorySlotOffset::CREATED_ITEM_OUTPUT){
-					return null; //useless noise
-				}
-				$located = $inventoryManager->locateWindowAndSlot($action->windowId, $action->inventorySlot);
-				if($located !== null){
-					[$window, $slot] = $located;
-					return new SlotChangeAction($window, $slot, $old, $new);
-				}
-
-				throw new TypeConversionException("No open container with window ID $action->windowId");
-			case NetworkInventoryAction::SOURCE_WORLD:
-				if($action->inventorySlot !== NetworkInventoryAction::ACTION_MAGIC_SLOT_DROP_ITEM){
-					throw new TypeConversionException("Only expecting drop-item world actions from the client!");
-				}
-
-				return new DropItemAction($new);
-			case NetworkInventoryAction::SOURCE_CREATIVE:
-				switch($action->inventorySlot){
-					case NetworkInventoryAction::ACTION_MAGIC_SLOT_CREATIVE_DELETE_ITEM:
-						return new DestroyItemAction($new);
-					case NetworkInventoryAction::ACTION_MAGIC_SLOT_CREATIVE_CREATE_ITEM:
-						return new CreateItemAction($old);
-					default:
-						throw new TypeConversionException("Unexpected creative action type $action->inventorySlot");
-
-				}
-			case NetworkInventoryAction::SOURCE_TODO:
-				//These are used to balance a transaction that involves special actions, like crafting, enchanting, etc.
-				//The vanilla server just accepted these without verifying them. We don't need to care about them since
-				//we verify crafting by checking for imbalances anyway.
-				return null;
-			default:
-				throw new TypeConversionException("Unknown inventory source type $action->sourceType");
-		}
-	}
 }

src/network/mcpe/handler/InGamePacketHandler.php

@@ -32,10 +32,10 @@ use pocketmine\entity\animation\ConsumingItemAnimation;
 use pocketmine\entity\Attribute;
 use pocketmine\entity\InvalidSkinException;
 use pocketmine\event\player\PlayerEditBookEvent;
-use pocketmine\inventory\transaction\action\InventoryAction;
-use pocketmine\inventory\transaction\CraftingTransaction;
+use pocketmine\inventory\transaction\action\DropItemAction;
 use pocketmine\inventory\transaction\InventoryTransaction;
-use pocketmine\inventory\transaction\TransactionException;
+use pocketmine\inventory\transaction\TransactionBuilder;
+use pocketmine\inventory\transaction\TransactionCancelledException;
 use pocketmine\inventory\transaction\TransactionValidationException;
 use pocketmine\item\VanillaItems;
 use pocketmine\item\WritableBook;
@@ -46,7 +46,6 @@ use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\nbt\tag\StringTag;
 use pocketmine\network\mcpe\convert\SkinAdapterSingleton;
-use pocketmine\network\mcpe\convert\TypeConversionException;
 use pocketmine\network\mcpe\convert\TypeConverter;
 use pocketmine\network\mcpe\InventoryManager;
 use pocketmine\network\mcpe\NetworkSession;
@@ -65,6 +64,8 @@ use pocketmine\network\mcpe\protocol\EmotePacket;
 use pocketmine\network\mcpe\protocol\InteractPacket;
 use pocketmine\network\mcpe\protocol\InventoryTransactionPacket;
 use pocketmine\network\mcpe\protocol\ItemFrameDropItemPacket;
+use pocketmine\network\mcpe\protocol\ItemStackRequestPacket;
+use pocketmine\network\mcpe\protocol\ItemStackResponsePacket;
 use pocketmine\network\mcpe\protocol\LabTablePacket;
 use pocketmine\network\mcpe\protocol\LecternUpdatePacket;
 use pocketmine\network\mcpe\protocol\LevelSoundEventPacket;
@@ -96,7 +97,8 @@ use pocketmine\network\mcpe\protocol\types\inventory\MismatchTransactionData;
 use pocketmine\network\mcpe\protocol\types\inventory\NetworkInventoryAction;
 use pocketmine\network\mcpe\protocol\types\inventory\NormalTransactionData;
 use pocketmine\network\mcpe\protocol\types\inventory\ReleaseItemTransactionData;
-use pocketmine\network\mcpe\protocol\types\inventory\UIInventorySlotOffset;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\ItemStackRequest;
+use pocketmine\network\mcpe\protocol\types\inventory\stackresponse\ItemStackResponse;
 use pocketmine\network\mcpe\protocol\types\inventory\UseItemOnEntityTransactionData;
 use pocketmine\network\mcpe\protocol\types\inventory\UseItemTransactionData;
 use pocketmine\network\mcpe\protocol\types\PlayerAction;
@@ -108,17 +110,18 @@ use pocketmine\player\Player;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Limits;
 use pocketmine\utils\TextFormat;
+use pocketmine\utils\Utils;
 use pocketmine\world\format\Chunk;
 use function array_push;
 use function base64_encode;
 use function count;
 use function fmod;
+use function implode;
 use function in_array;
 use function is_bool;
 use function is_infinite;
 use function is_nan;
 use function json_decode;
-use function json_encode;
 use function max;
 use function mb_strlen;
 use function microtime;
@@ -133,9 +136,6 @@ use const JSON_THROW_ON_ERROR;
 class InGamePacketHandler extends PacketHandler{
 	private const MAX_FORM_RESPONSE_DEPTH = 2; //modal/simple will be 1, custom forms 2 - they will never contain anything other than string|int|float|bool|null
 
-	/** @var CraftingTransaction|null */
-	protected $craftingTransaction = null;
-
 	/** @var float */
 	protected $lastRightClickTime = 0.0;
 	/** @var UseItemTransactionData|null */
@@ -276,13 +276,22 @@ class InGamePacketHandler extends PacketHandler{
 			if(count($useItemTransaction->getTransactionData()->getActions()) > 100){
 				throw new PacketHandlingException("Too many actions in item use transaction");
 			}
-			$this->inventoryManager->addPredictedSlotChanges($useItemTransaction->getTransactionData()->getActions());
+
+			$this->inventoryManager->setCurrentItemStackRequestId($useItemTransaction->getRequestId());
+			$this->inventoryManager->addRawPredictedSlotChanges($useItemTransaction->getTransactionData()->getActions());
 			if(!$this->handleUseItemTransaction($useItemTransaction->getTransactionData())){
 				$packetHandled = false;
 				$this->session->getLogger()->debug("Unhandled transaction in PlayerAuthInputPacket (type " . $useItemTransaction->getTransactionData()->getActionType() . ")");
 			}else{
 				$this->inventoryManager->syncMismatchedPredictedSlotChanges();
 			}
+			$this->inventoryManager->setCurrentItemStackRequestId(null);
+		}
+
+		$itemStackRequest = $packet->getItemStackRequest();
+		if($itemStackRequest !== null){
+			$result = $this->handleSingleItemStackRequest($itemStackRequest);
+			$this->session->sendDataPacket(ItemStackResponsePacket::create([$result]));
 		}
 
 		return $packetHandled;
@@ -316,17 +325,18 @@ class InGamePacketHandler extends PacketHandler{
 	public function handleInventoryTransaction(InventoryTransactionPacket $packet) : bool{
 		$result = true;
 
-		if(count($packet->trData->getActions()) > 100){
+		if(count($packet->trData->getActions()) > 50){
 			throw new PacketHandlingException("Too many actions in inventory transaction");
 		}
 
-		$this->inventoryManager->addPredictedSlotChanges($packet->trData->getActions());
+		$this->inventoryManager->setCurrentItemStackRequestId($packet->requestId);
+		$this->inventoryManager->addRawPredictedSlotChanges($packet->trData->getActions());
 
 		if($packet->trData instanceof NormalTransactionData){
-			$result = $this->handleNormalTransaction($packet->trData);
+			$result = $this->handleNormalTransaction($packet->trData, $packet->requestId);
 		}elseif($packet->trData instanceof MismatchTransactionData){
 			$this->session->getLogger()->debug("Mismatch transaction received");
-			$this->inventoryManager->syncAll();
+			$this->inventoryManager->requestSyncAll();
 			$result = true;
 		}elseif($packet->trData instanceof UseItemTransactionData){
 			$result = $this->handleUseItemTransaction($packet->trData);
@@ -336,96 +346,93 @@ class InGamePacketHandler extends PacketHandler{
 			$result = $this->handleReleaseItemTransaction($packet->trData);
 		}
 
-		if($this->craftingTransaction === null){ //don't sync if we're waiting to complete a crafting transaction
-			$this->inventoryManager->syncMismatchedPredictedSlotChanges();
-		}
+		$this->inventoryManager->syncMismatchedPredictedSlotChanges();
+		$this->inventoryManager->setCurrentItemStackRequestId(null);
 		return $result;
 	}
 
-	private function handleNormalTransaction(NormalTransactionData $data) : bool{
-		/** @var InventoryAction[] $actions */
-		$actions = [];
+	private function executeInventoryTransaction(InventoryTransaction $transaction, int $requestId) : bool{
+		$this->player->setUsingItem(false);
 
-		$isCraftingPart = false;
-		$converter = TypeConverter::getInstance();
-		foreach($data->getActions() as $networkInventoryAction){
-			if(
-				$networkInventoryAction->sourceType === NetworkInventoryAction::SOURCE_TODO || (
-					$this->craftingTransaction !== null &&
-					!$networkInventoryAction->oldItem->getItemStack()->equals($networkInventoryAction->newItem->getItemStack()) &&
-					$networkInventoryAction->sourceType === NetworkInventoryAction::SOURCE_CONTAINER &&
-					$networkInventoryAction->windowId === ContainerIds::UI &&
-					$networkInventoryAction->inventorySlot === UIInventorySlotOffset::CREATED_ITEM_OUTPUT
-				)
-			){
-				$isCraftingPart = true;
-			}
+		$this->inventoryManager->setCurrentItemStackRequestId($requestId);
+		$this->inventoryManager->addTransactionPredictedSlotChanges($transaction);
+		try{
+			$transaction->execute();
+		}catch(TransactionValidationException $e){
+			$this->inventoryManager->requestSyncAll();
+			$logger = $this->session->getLogger();
+			$logger->debug("Invalid inventory transaction $requestId: " . $e->getMessage());
 
-			try{
-				$action = $converter->createInventoryAction($networkInventoryAction, $this->player, $this->inventoryManager);
-				if($action !== null){
-					$actions[] = $action;
-				}
-			}catch(TypeConversionException $e){
-				$this->session->getLogger()->debug("Error unpacking inventory action: " . $e->getMessage());
-				return false;
-			}
-		}
+			return false;
+		}catch(TransactionCancelledException){
+			$this->session->getLogger()->debug("Inventory transaction $requestId cancelled by a plugin");
 
-		if($isCraftingPart){
-			if($this->craftingTransaction === null){
-				//TODO: this might not be crafting if there is a special inventory open (anvil, enchanting, loom etc)
-				$this->craftingTransaction = new CraftingTransaction($this->player, $this->player->getServer()->getCraftingManager(), $actions);
-			}else{
-				foreach($actions as $action){
-					$this->craftingTransaction->addAction($action);
-				}
-			}
-
-			try{
-				$this->craftingTransaction->validate();
-			}catch(TransactionValidationException $e){
-				//transaction is incomplete - crafting transaction comes in lots of little bits, so we have to collect
-				//all of the parts before we can execute it
-				return true;
-			}
-			$this->player->setUsingItem(false);
-			try{
-				$this->craftingTransaction->execute();
-			}catch(TransactionException $e){
-				$this->session->getLogger()->debug("Failed to execute crafting transaction: " . $e->getMessage());
-				return false;
-			}finally{
-				$this->craftingTransaction = null;
-			}
-		}else{
-			//normal transaction fallthru
-			if($this->craftingTransaction !== null){
-				$this->session->getLogger()->debug("Got unexpected normal inventory action with incomplete crafting transaction, refusing to execute crafting");
-				$this->craftingTransaction = null;
-				return false;
-			}
-
-			if(count($actions) === 0){
-				//TODO: 1.13+ often sends transactions with nothing but useless crap in them, no need for the debug noise
-				return true;
-			}
-
-			$this->player->setUsingItem(false);
-			$transaction = new InventoryTransaction($this->player, $actions);
-			try{
-				$transaction->execute();
-			}catch(TransactionException $e){
-				$logger = $this->session->getLogger();
-				$logger->debug("Failed to execute inventory transaction: " . $e->getMessage());
-				$logger->debug("Actions: " . json_encode($data->getActions()));
-				return false;
-			}
+			return false;
+		}finally{
+			$this->inventoryManager->syncMismatchedPredictedSlotChanges();
+			$this->inventoryManager->setCurrentItemStackRequestId(null);
 		}
 
 		return true;
 	}
 
+	private function handleNormalTransaction(NormalTransactionData $data, int $itemStackRequestId) : bool{
+		//When the ItemStackRequest system is used, this transaction type is only used for dropping items by pressing Q.
+		//I don't know why they don't just use ItemStackRequest for that too, which already supports dropping items by
+		//clicking them outside an open inventory menu, but for now it is what it is.
+		//Fortunately, this means we can be extremely strict about the validation criteria.
+
+		if(count($data->getActions()) > 2){
+			throw new PacketHandlingException("Expected exactly 2 actions for dropping an item");
+		}
+
+		$sourceSlot = null;
+		$clientItemStack = null;
+		$droppedCount = null;
+
+		foreach($data->getActions() as $networkInventoryAction){
+			if($networkInventoryAction->sourceType === NetworkInventoryAction::SOURCE_WORLD && $networkInventoryAction->inventorySlot == NetworkInventoryAction::ACTION_MAGIC_SLOT_DROP_ITEM){
+				$droppedCount = $networkInventoryAction->newItem->getItemStack()->getCount();
+				if($droppedCount <= 0){
+					throw new PacketHandlingException("Expected positive count for dropped item");
+				}
+			}elseif($networkInventoryAction->sourceType === NetworkInventoryAction::SOURCE_CONTAINER && $networkInventoryAction->windowId === ContainerIds::INVENTORY){
+				//mobile players can drop an item from a non-selected hotbar slot
+				$sourceSlot = $networkInventoryAction->inventorySlot;
+				$clientItemStack = $networkInventoryAction->oldItem->getItemStack();
+			}else{
+				throw new PacketHandlingException("Unexpected action type in drop item transaction");
+			}
+		}
+		if($sourceSlot === null || $clientItemStack === null || $droppedCount === null){
+			throw new PacketHandlingException("Missing information in drop item transaction, need source slot, client item stack and dropped count");
+		}
+
+		$inventory = $this->player->getInventory();
+
+		if(!$inventory->slotExists($sourceSlot)){
+			return false; //TODO: size desync??
+		}
+
+		$sourceSlotItem = $inventory->getItem($sourceSlot);
+		$serverItemStack = TypeConverter::getInstance()->coreItemStackToNet($sourceSlotItem);
+		//because the client doesn't tell us the expected itemstack ID, we have to deep-compare our known
+		//itemstack info with the one the client sent. This is costly, but we don't have any other option :(
+		if(!$serverItemStack->equals($clientItemStack)){
+			return false;
+		}
+
+		//this modifies $sourceSlotItem
+		$droppedItem = $sourceSlotItem->pop($droppedCount);
+
+		$builder = new TransactionBuilder();
+		$builder->getInventory($inventory)->setItem($sourceSlot, $sourceSlotItem);
+		$builder->addAction(new DropItemAction($droppedItem));
+
+		$transaction = new InventoryTransaction($this->player, $builder->generateActions());
+		return $this->executeInventoryTransaction($transaction, $itemStackRequestId);
+	}
+
 	private function handleUseItemTransaction(UseItemTransactionData $data) : bool{
 		$this->player->selectHotbarSlot($data->getHotbarSlot());
 
@@ -537,6 +544,43 @@ class InGamePacketHandler extends PacketHandler{
 		return false;
 	}
 
+	private function handleSingleItemStackRequest(ItemStackRequest $request) : ItemStackResponse{
+		if(count($request->getActions()) > 20){
+			//TODO: we can probably lower this limit, but this will do for now
+			throw new PacketHandlingException("Too many actions in ItemStackRequest");
+		}
+		$executor = new ItemStackRequestExecutor($this->player, $this->inventoryManager, $request);
+		try{
+			$transaction = $executor->generateInventoryTransaction();
+			$result = $this->executeInventoryTransaction($transaction, $request->getRequestId());
+		}catch(ItemStackRequestProcessException $e){
+			$result = false;
+			$this->session->getLogger()->debug("ItemStackRequest #" . $request->getRequestId() . " failed: " . $e->getMessage());
+			$this->session->getLogger()->debug(implode("\n", Utils::printableExceptionInfo($e)));
+			$this->inventoryManager->requestSyncAll();
+		}
+
+		if(!$result){
+			return new ItemStackResponse(ItemStackResponse::RESULT_ERROR, $request->getRequestId());
+		}
+		return $executor->buildItemStackResponse();
+	}
+
+	public function handleItemStackRequest(ItemStackRequestPacket $packet) : bool{
+		$responses = [];
+		if(count($packet->getRequests()) > 80){
+			//TODO: we can probably lower this limit, but this will do for now
+			throw new PacketHandlingException("Too many requests in ItemStackRequestPacket");
+		}
+		foreach($packet->getRequests() as $request){
+			$responses[] = $this->handleSingleItemStackRequest($request);
+		}
+
+		$this->session->sendDataPacket(ItemStackResponsePacket::create($responses));
+
+		return true;
+	}
+
 	public function handleMobEquipment(MobEquipmentPacket $packet) : bool{
 		if($packet->windowId === ContainerIds::OFFHAND){
 			return true; //this happens when we put an item into the offhand

src/network/mcpe/handler/ItemStackContainerIdTranslator.php

@@ -0,0 +1,90 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe\handler;
+
+use pocketmine\network\mcpe\protocol\types\inventory\ContainerIds;
+use pocketmine\network\mcpe\protocol\types\inventory\ContainerUIIds;
+use pocketmine\network\PacketHandlingException;
+
+final class ItemStackContainerIdTranslator{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	public static function translate(int $containerInterfaceId, int $currentWindowId) : int{
+		return match($containerInterfaceId){
+			ContainerUIIds::ARMOR => ContainerIds::ARMOR,
+
+			ContainerUIIds::HOTBAR,
+			ContainerUIIds::INVENTORY,
+			ContainerUIIds::COMBINED_HOTBAR_AND_INVENTORY => ContainerIds::INVENTORY,
+
+			ContainerUIIds::OFFHAND => ContainerIds::OFFHAND,
+
+			ContainerUIIds::ANVIL_INPUT,
+			ContainerUIIds::ANVIL_MATERIAL,
+			ContainerUIIds::BEACON_PAYMENT,
+			ContainerUIIds::CARTOGRAPHY_ADDITIONAL,
+			ContainerUIIds::CARTOGRAPHY_INPUT,
+			ContainerUIIds::COMPOUND_CREATOR_INPUT,
+			ContainerUIIds::CRAFTING_INPUT,
+			ContainerUIIds::CREATED_OUTPUT,
+			ContainerUIIds::CURSOR,
+			ContainerUIIds::ENCHANTING_INPUT,
+			ContainerUIIds::ENCHANTING_MATERIAL,
+			ContainerUIIds::GRINDSTONE_ADDITIONAL,
+			ContainerUIIds::GRINDSTONE_INPUT,
+			ContainerUIIds::LAB_TABLE_INPUT,
+			ContainerUIIds::LOOM_DYE,
+			ContainerUIIds::LOOM_INPUT,
+			ContainerUIIds::LOOM_MATERIAL,
+			ContainerUIIds::MATERIAL_REDUCER_INPUT,
+			ContainerUIIds::MATERIAL_REDUCER_OUTPUT,
+			ContainerUIIds::SMITHING_TABLE_INPUT,
+			ContainerUIIds::SMITHING_TABLE_MATERIAL,
+			ContainerUIIds::STONECUTTER_INPUT,
+			ContainerUIIds::TRADE2_INGREDIENT1,
+			ContainerUIIds::TRADE2_INGREDIENT2,
+			ContainerUIIds::TRADE_INGREDIENT1,
+			ContainerUIIds::TRADE_INGREDIENT2 => ContainerIds::UI,
+
+			ContainerUIIds::BARREL,
+			ContainerUIIds::BLAST_FURNACE_INGREDIENT,
+			ContainerUIIds::BREWING_STAND_FUEL,
+			ContainerUIIds::BREWING_STAND_INPUT,
+			ContainerUIIds::BREWING_STAND_RESULT,
+			ContainerUIIds::FURNACE_FUEL,
+			ContainerUIIds::FURNACE_INGREDIENT,
+			ContainerUIIds::FURNACE_RESULT,
+			ContainerUIIds::LEVEL_ENTITY, //chest
+			ContainerUIIds::SHULKER_BOX,
+			ContainerUIIds::SMOKER_INGREDIENT => $currentWindowId,
+
+			//all preview slots are ignored, since the client shouldn't be modifying those directly
+
+			default => throw new PacketHandlingException("Unexpected container UI ID $containerInterfaceId")
+		};
+	}
+}

src/network/mcpe/handler/ItemStackRequestExecutor.php

@@ -0,0 +1,385 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe\handler;
+
+use pocketmine\crafting\CraftingGrid;
+use pocketmine\inventory\CreativeInventory;
+use pocketmine\inventory\Inventory;
+use pocketmine\inventory\transaction\action\CreateItemAction;
+use pocketmine\inventory\transaction\action\DestroyItemAction;
+use pocketmine\inventory\transaction\action\DropItemAction;
+use pocketmine\inventory\transaction\CraftingTransaction;
+use pocketmine\inventory\transaction\InventoryTransaction;
+use pocketmine\inventory\transaction\TransactionBuilder;
+use pocketmine\inventory\transaction\TransactionBuilderInventory;
+use pocketmine\item\Item;
+use pocketmine\network\mcpe\InventoryManager;
+use pocketmine\network\mcpe\protocol\types\inventory\ContainerUIIds;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\CraftingConsumeInputStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\CraftingCreateSpecificResultStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\CraftRecipeAutoStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\CraftRecipeStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\CreativeCreateStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\DeprecatedCraftingResultsStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\DestroyStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\DropStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\ItemStackRequest;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\ItemStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\ItemStackRequestSlotInfo;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\PlaceStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\SwapStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\TakeStackRequestAction;
+use pocketmine\network\mcpe\protocol\types\inventory\stackresponse\ItemStackResponse;
+use pocketmine\network\mcpe\protocol\types\inventory\UIInventorySlotOffset;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use function array_key_first;
+use function count;
+use function spl_object_id;
+
+class ItemStackRequestExecutor{
+	private TransactionBuilder $builder;
+
+	/** @var ItemStackRequestSlotInfo[] */
+	private array $requestSlotInfos = [];
+
+	private ?InventoryTransaction $specialTransaction = null;
+
+	/** @var Item[] */
+	private array $craftingResults = [];
+
+	private ?Item $nextCreatedItem = null;
+	private bool $createdItemFromCreativeInventory = false;
+	private int $createdItemsTakenCount = 0;
+
+	public function __construct(
+		private Player $player,
+		private InventoryManager $inventoryManager,
+		private ItemStackRequest $request
+	){
+		$this->builder = new TransactionBuilder();
+	}
+
+	protected function prettyInventoryAndSlot(Inventory $inventory, int $slot) : string{
+		if($inventory instanceof TransactionBuilderInventory){
+			$inventory = $inventory->getActualInventory();
+		}
+		return (new \ReflectionClass($inventory))->getShortName() . "#" . spl_object_id($inventory) . ", slot: $slot";
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	private function matchItemStack(Inventory $inventory, int $slotId, int $clientItemStackId) : void{
+		$info = $this->inventoryManager->getItemStackInfo($inventory, $slotId);
+		if($info === null){
+			throw new AssumptionFailedError("The inventory is tracked and the slot is valid, so this should not be null");
+		}
+
+		if(!($clientItemStackId < 0 ? $info->getRequestId() === $clientItemStackId : $info->getStackId() === $clientItemStackId)){
+			throw new ItemStackRequestProcessException(
+				$this->prettyInventoryAndSlot($inventory, $slotId) . ": " .
+				"Mismatched expected itemstack, " .
+				"client expected: $clientItemStackId, server actual: " . $info->getStackId() . ", last modified by request: " . ($info->getRequestId() ?? "none")
+			);
+		}
+	}
+
+	/**
+	 * @phpstan-return array{TransactionBuilderInventory, int}
+	 *
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function getBuilderInventoryAndSlot(ItemStackRequestSlotInfo $info) : array{
+		$windowId = ItemStackContainerIdTranslator::translate($info->getContainerId(), $this->inventoryManager->getCurrentWindowId());
+		$windowAndSlot = $this->inventoryManager->locateWindowAndSlot($windowId, $info->getSlotId());
+		if($windowAndSlot === null){
+			throw new ItemStackRequestProcessException("No open inventory matches container UI ID: " . $info->getContainerId() . ", slot ID: " . $info->getSlotId());
+		}
+		[$inventory, $slot] = $windowAndSlot;
+		if(!$inventory->slotExists($slot)){
+			throw new ItemStackRequestProcessException("No such inventory slot :" . $this->prettyInventoryAndSlot($inventory, $slot));
+		}
+
+		if($info->getStackId() !== $this->request->getRequestId()){ //the itemstack may have been modified by the current request
+			$this->matchItemStack($inventory, $slot, $info->getStackId());
+		}
+
+		return [$this->builder->getInventory($inventory), $slot];
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function transferItems(ItemStackRequestSlotInfo $source, ItemStackRequestSlotInfo $destination, int $count) : void{
+		$removed = $this->removeItemFromSlot($source, $count);
+		$this->addItemToSlot($destination, $removed, $count);
+	}
+
+	/**
+	 * Deducts items from an inventory slot, returning a stack containing the removed items.
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function removeItemFromSlot(ItemStackRequestSlotInfo $slotInfo, int $count) : Item{
+		$this->requestSlotInfos[] = $slotInfo;
+		[$inventory, $slot] = $this->getBuilderInventoryAndSlot($slotInfo);
+		if($count < 1){
+			//this should be impossible at the protocol level, but in case of buggy core code this will prevent exploits
+			throw new ItemStackRequestProcessException($this->prettyInventoryAndSlot($inventory, $slot) . ": Cannot take less than 1 items from a stack");
+		}
+
+		$existingItem = $inventory->getItem($slot);
+		if($existingItem->getCount() < $count){
+			throw new ItemStackRequestProcessException($this->prettyInventoryAndSlot($inventory, $slot) . ": Cannot take $count items from a stack of " . $existingItem->getCount());
+		}
+
+		$removed = $existingItem->pop($count);
+		$inventory->setItem($slot, $existingItem);
+
+		return $removed;
+	}
+
+	/**
+	 * Adds items to the target slot, if they are stackable.
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function addItemToSlot(ItemStackRequestSlotInfo $slotInfo, Item $item, int $count) : void{
+		$this->requestSlotInfos[] = $slotInfo;
+		[$inventory, $slot] = $this->getBuilderInventoryAndSlot($slotInfo);
+		if($count < 1){
+			//this should be impossible at the protocol level, but in case of buggy core code this will prevent exploits
+			throw new ItemStackRequestProcessException($this->prettyInventoryAndSlot($inventory, $slot) . ": Cannot take less than 1 items from a stack");
+		}
+
+		$existingItem = $inventory->getItem($slot);
+		if(!$existingItem->isNull() && !$existingItem->canStackWith($item)){
+			throw new ItemStackRequestProcessException($this->prettyInventoryAndSlot($inventory, $slot) . ": Can only add items to an empty slot, or a slot containing the same item");
+		}
+
+		//we can't use the existing item here; it may be an empty stack
+		$newItem = clone $item;
+		$newItem->setCount($existingItem->getCount() + $count);
+		$inventory->setItem($slot, $newItem);
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function setNextCreatedItem(?Item $item, bool $creative = false) : void{
+		if($item !== null && $item->isNull()){
+			$item = null;
+		}
+		if($this->nextCreatedItem !== null){
+			//while this is more complicated than simply adding the action when the item is taken, this ensures that
+			//plugins can tell the difference between 1 item that got split into 2 slots, vs 2 separate items.
+			if($this->createdItemFromCreativeInventory && $this->createdItemsTakenCount > 0){
+				$this->nextCreatedItem->setCount($this->createdItemsTakenCount);
+				$this->builder->addAction(new CreateItemAction($this->nextCreatedItem));
+			}elseif($this->createdItemsTakenCount < $this->nextCreatedItem->getCount()){
+				throw new ItemStackRequestProcessException("Not all of the previous created item was taken");
+			}
+		}
+		$this->nextCreatedItem = $item;
+		$this->createdItemFromCreativeInventory = $creative;
+		$this->createdItemsTakenCount = 0;
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function beginCrafting(int $recipeId, int $repetitions) : void{
+		if($this->specialTransaction !== null){
+			throw new ItemStackRequestProcessException("Another special transaction is already in progress");
+		}
+		if($repetitions < 1){
+			throw new ItemStackRequestProcessException("Cannot craft a recipe less than 1 time");
+		}
+		if($repetitions > 256){
+			//TODO: we can probably lower this limit to 64, but I'm unsure if there are cases where the client may
+			//request more than 64 repetitions of a recipe.
+			//It's already hard-limited to 256 repetitions in the protocol, so this is just a sanity check.
+			throw new ItemStackRequestProcessException("Cannot craft a recipe more than 256 times");
+		}
+		$craftingManager = $this->player->getServer()->getCraftingManager();
+		$recipe = $craftingManager->getCraftingRecipeFromIndex($recipeId);
+		if($recipe === null){
+			throw new ItemStackRequestProcessException("No such crafting recipe index: $recipeId");
+		}
+
+		$this->specialTransaction = new CraftingTransaction($this->player, $craftingManager, [], $recipe, $repetitions);
+
+		$currentWindow = $this->player->getCurrentWindow();
+		if($currentWindow !== null && !($currentWindow instanceof CraftingGrid)){
+			throw new ItemStackRequestProcessException("Player's current window is not a crafting grid");
+		}
+		$craftingGrid = $currentWindow ?? $this->player->getCraftingGrid();
+
+		$craftingResults = $recipe->getResultsFor($craftingGrid);
+		foreach($craftingResults as $k => $craftingResult){
+			$craftingResult->setCount($craftingResult->getCount() * $repetitions);
+			$this->craftingResults[$k] = $craftingResult;
+		}
+		if(count($this->craftingResults) === 1){
+			//for multi-output recipes, later actions will tell us which result to create and when
+			$this->setNextCreatedItem($this->craftingResults[array_key_first($this->craftingResults)]);
+		}
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function takeCreatedItem(ItemStackRequestSlotInfo $destination, int $count) : void{
+		if($count < 1){
+			//this should be impossible at the protocol level, but in case of buggy core code this will prevent exploits
+			throw new ItemStackRequestProcessException("Cannot take less than 1 created item");
+		}
+		$createdItem = $this->nextCreatedItem;
+		if($createdItem === null){
+			throw new ItemStackRequestProcessException("No created item is waiting to be taken");
+		}
+
+		if(!$this->createdItemFromCreativeInventory){
+			$availableCount = $createdItem->getCount() - $this->createdItemsTakenCount;
+			if($count > $availableCount){
+				throw new ItemStackRequestProcessException("Not enough created items available to be taken (have $availableCount, tried to take $count)");
+			}
+		}
+
+		$this->createdItemsTakenCount += $count;
+		$this->addItemToSlot($destination, $createdItem, $count);
+		if(!$this->createdItemFromCreativeInventory && $this->createdItemsTakenCount >= $createdItem->getCount()){
+			$this->setNextCreatedItem(null);
+		}
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	private function assertDoingCrafting() : void{
+		if(!$this->specialTransaction instanceof CraftingTransaction){
+			if($this->specialTransaction === null){
+				throw new ItemStackRequestProcessException("Expected CraftRecipe or CraftRecipeAuto action to precede this action");
+			}else{
+				throw new ItemStackRequestProcessException("A different special transaction is already in progress");
+			}
+		}
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	protected function processItemStackRequestAction(ItemStackRequestAction $action) : void{
+		if(
+			$action instanceof TakeStackRequestAction ||
+			$action instanceof PlaceStackRequestAction
+		){
+			$source = $action->getSource();
+			$destination = $action->getDestination();
+
+			if($source->getContainerId() === ContainerUIIds::CREATED_OUTPUT && $source->getSlotId() === UIInventorySlotOffset::CREATED_ITEM_OUTPUT){
+				$this->takeCreatedItem($destination, $action->getCount());
+			}else{
+				$this->transferItems($source, $destination, $action->getCount());
+			}
+		}elseif($action instanceof SwapStackRequestAction){
+			$this->requestSlotInfos[] = $action->getSlot1();
+			$this->requestSlotInfos[] = $action->getSlot2();
+
+			[$inventory1, $slot1] = $this->getBuilderInventoryAndSlot($action->getSlot1());
+			[$inventory2, $slot2] = $this->getBuilderInventoryAndSlot($action->getSlot2());
+
+			$item1 = $inventory1->getItem($slot1);
+			$item2 = $inventory2->getItem($slot2);
+			$inventory1->setItem($slot1, $item2);
+			$inventory2->setItem($slot2, $item1);
+		}elseif($action instanceof DropStackRequestAction){
+			//TODO: this action has a "randomly" field, I have no idea what it's used for
+			$dropped = $this->removeItemFromSlot($action->getSource(), $action->getCount());
+			$this->builder->addAction(new DropItemAction($dropped));
+
+		}elseif($action instanceof DestroyStackRequestAction){
+			$destroyed = $this->removeItemFromSlot($action->getSource(), $action->getCount());
+			$this->builder->addAction(new DestroyItemAction($destroyed));
+
+		}elseif($action instanceof CreativeCreateStackRequestAction){
+			$item = CreativeInventory::getInstance()->getItem($action->getCreativeItemId());
+			if($item === null){
+				throw new ItemStackRequestProcessException("No such creative item index: " . $action->getCreativeItemId());
+			}
+
+			$this->setNextCreatedItem($item, true);
+		}elseif($action instanceof CraftRecipeStackRequestAction){
+			$this->beginCrafting($action->getRecipeId(), 1);
+		}elseif($action instanceof CraftRecipeAutoStackRequestAction){
+			$this->beginCrafting($action->getRecipeId(), $action->getRepetitions());
+		}elseif($action instanceof CraftingConsumeInputStackRequestAction){
+			$this->assertDoingCrafting();
+			$this->removeItemFromSlot($action->getSource(), $action->getCount()); //output discarded - we allow CraftingTransaction to verify the balance
+
+		}elseif($action instanceof CraftingCreateSpecificResultStackRequestAction){
+			$this->assertDoingCrafting();
+
+			$nextResultItem = $this->craftingResults[$action->getResultIndex()] ?? null;
+			if($nextResultItem === null){
+				throw new ItemStackRequestProcessException("No such crafting result index: " . $action->getResultIndex());
+			}
+			$this->setNextCreatedItem($nextResultItem);
+		}elseif($action instanceof DeprecatedCraftingResultsStackRequestAction){
+			//no obvious use
+		}else{
+			throw new ItemStackRequestProcessException("Unhandled item stack request action");
+		}
+	}
+
+	/**
+	 * @throws ItemStackRequestProcessException
+	 */
+	public function generateInventoryTransaction() : InventoryTransaction{
+		foreach($this->request->getActions() as $k => $action){
+			try{
+				$this->processItemStackRequestAction($action);
+			}catch(ItemStackRequestProcessException $e){
+				throw new ItemStackRequestProcessException("Error processing action $k (" . (new \ReflectionClass($action))->getShortName() . "): " . $e->getMessage(), 0, $e);
+			}
+		}
+		$this->setNextCreatedItem(null);
+		$inventoryActions = $this->builder->generateActions();
+
+		$transaction = $this->specialTransaction ?? new InventoryTransaction($this->player);
+		foreach($inventoryActions as $action){
+			$transaction->addAction($action);
+		}
+
+		return $transaction;
+	}
+
+	public function buildItemStackResponse() : ItemStackResponse{
+		$builder = new ItemStackResponseBuilder($this->request->getRequestId(), $this->inventoryManager);
+		foreach($this->requestSlotInfos as $requestInfo){
+			$builder->addSlot($requestInfo->getContainerId(), $requestInfo->getSlotId());
+		}
+
+		return $builder->build();
+	}
+}

src/network/mcpe/handler/ItemStackRequestProcessException.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe\handler;
+
+/**
+ * Thrown when an error occurs during processing of an ItemStackRequest.
+ */
+final class ItemStackRequestProcessException extends \RuntimeException{
+
+}

src/network/mcpe/handler/ItemStackResponseBuilder.php

@@ -0,0 +1,106 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\network\mcpe\handler;
+
+use pocketmine\inventory\Inventory;
+use pocketmine\network\mcpe\InventoryManager;
+use pocketmine\network\mcpe\protocol\types\inventory\ContainerUIIds;
+use pocketmine\network\mcpe\protocol\types\inventory\stackresponse\ItemStackResponse;
+use pocketmine\network\mcpe\protocol\types\inventory\stackresponse\ItemStackResponseContainerInfo;
+use pocketmine\network\mcpe\protocol\types\inventory\stackresponse\ItemStackResponseSlotInfo;
+use pocketmine\utils\AssumptionFailedError;
+
+final class ItemStackResponseBuilder{
+
+	/**
+	 * @var int[][]
+	 * @phpstan-var array<int, array<int, int>>
+	 */
+	private array $changedSlots = [];
+
+	public function __construct(
+		private int $requestId,
+		private InventoryManager $inventoryManager
+	){}
+
+	public function addSlot(int $containerInterfaceId, int $slotId) : void{
+		$this->changedSlots[$containerInterfaceId][$slotId] = $slotId;
+	}
+
+	/**
+	 * @phpstan-return array{Inventory, int}
+	 */
+	private function getInventoryAndSlot(int $containerInterfaceId, int $slotId) : ?array{
+		$windowId = ItemStackContainerIdTranslator::translate($containerInterfaceId, $this->inventoryManager->getCurrentWindowId());
+		$windowAndSlot = $this->inventoryManager->locateWindowAndSlot($windowId, $slotId);
+		if($windowAndSlot === null){
+			return null;
+		}
+		[$inventory, $slot] = $windowAndSlot;
+		if(!$inventory->slotExists($slot)){
+			return null;
+		}
+
+		return [$inventory, $slot];
+	}
+
+	public function build() : ItemStackResponse{
+		$responseInfosByContainer = [];
+		foreach($this->changedSlots as $containerInterfaceId => $slotIds){
+			if($containerInterfaceId === ContainerUIIds::CREATED_OUTPUT){
+				continue;
+			}
+			foreach($slotIds as $slotId){
+				$inventoryAndSlot = $this->getInventoryAndSlot($containerInterfaceId, $slotId);
+				if($inventoryAndSlot === null){
+					//a plugin may have closed the inventory during an event, or the slot may have been invalid
+					continue;
+				}
+				[$inventory, $slot] = $inventoryAndSlot;
+
+				$itemStackInfo = $this->inventoryManager->getItemStackInfo($inventory, $slot);
+				if($itemStackInfo === null){
+					throw new AssumptionFailedError("ItemStackInfo should never be null for an open inventory");
+				}
+				$item = $inventory->getItem($slot);
+
+				$responseInfosByContainer[$containerInterfaceId][] = new ItemStackResponseSlotInfo(
+					$slotId,
+					$slotId,
+					$item->getCount(),
+					$itemStackInfo->getStackId(),
+					$item->getCustomName(),
+					0
+				);
+			}
+		}
+
+		$responseContainerInfos = [];
+		foreach($responseInfosByContainer as $containerInterfaceId => $responseInfos){
+			$responseContainerInfos[] = new ItemStackResponseContainerInfo($containerInterfaceId, $responseInfos);
+		}
+
+		return new ItemStackResponse(ItemStackResponse::RESULT_OK, $this->requestId, $responseContainerInfos);
+	}
+}

src/network/mcpe/handler/PreSpawnPacketHandler.php

@@ -98,7 +98,7 @@ class PreSpawnPacketHandler extends PacketHandler{
 			0,
 			0,
 			"",
-			false,
+			true,
 			sprintf("%s %s", VersionInfo::NAME, VersionInfo::VERSION()->getFullVersion(true)),
 			Uuid::fromString(Uuid::NIL),
 			false,
@@ -114,7 +114,7 @@ class PreSpawnPacketHandler extends PacketHandler{
 		$this->session->sendDataPacket(StaticPacketCache::getInstance()->getBiomeDefs());
 
 		$this->session->getLogger()->debug("Sending attributes");
-		$this->session->syncAttributes($this->player, $this->player->getAttributeMap()->getAll());
+		$this->session->getEntityEventBroadcaster()->syncAttributes([$this->session], $this->player, $this->player->getAttributeMap()->getAll());
 
 		$this->session->getLogger()->debug("Sending available commands");
 		$this->session->syncAvailableCommands();
@@ -125,7 +125,7 @@ class PreSpawnPacketHandler extends PacketHandler{
 
 		$this->session->getLogger()->debug("Sending effects");
 		foreach($this->player->getEffects()->all() as $effect){
-			$this->session->onEntityEffectAdded($this->player, $effect, false);
+			$this->session->getEntityEventBroadcaster()->onEntityEffectAdded([$this->session], $this->player, $effect, false);
 		}
 
 		$this->session->getLogger()->debug("Sending actor metadata");

src/network/mcpe/raklib/RakLibInterface.php

@@ -26,11 +26,12 @@ namespace pocketmine\network\mcpe\raklib;
 use pocketmine\network\AdvancedNetworkInterface;
 use pocketmine\network\mcpe\compression\ZlibCompressor;
 use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
 use pocketmine\network\mcpe\NetworkSession;
 use pocketmine\network\mcpe\PacketBroadcaster;
 use pocketmine\network\mcpe\protocol\PacketPool;
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
-use pocketmine\network\mcpe\StandardPacketBroadcaster;
+use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
 use pocketmine\network\Network;
 use pocketmine\network\NetworkInterfaceStartException;
 use pocketmine\network\PacketHandlingException;
@@ -78,10 +79,16 @@ class RakLibInterface implements ServerEventListener, AdvancedNetworkInterface{
 
 	private SleeperNotifier $sleeper;
 
-	private PacketBroadcaster $broadcaster;
+	private PacketBroadcaster $packetBroadcaster;
+	private EntityEventBroadcaster $entityEventBroadcaster;
+	private PacketSerializerContext $packetSerializerContext;
 
-	public function __construct(Server $server, string $ip, int $port, bool $ipV6){
+	public function __construct(Server $server, string $ip, int $port, bool $ipV6, PacketBroadcaster $packetBroadcaster, EntityEventBroadcaster $entityEventBroadcaster, PacketSerializerContext $packetSerializerContext){
 		$this->server = $server;
+		$this->packetBroadcaster = $packetBroadcaster;
+		$this->packetSerializerContext = $packetSerializerContext;
+		$this->entityEventBroadcaster = $entityEventBroadcaster;
+
 		$this->rakServerId = mt_rand(0, PHP_INT_MAX);
 
 		$this->sleeper = new SleeperNotifier();
@@ -105,8 +112,6 @@ class RakLibInterface implements ServerEventListener, AdvancedNetworkInterface{
 		$this->interface = new UserToRakLibThreadMessageSender(
 			new PthreadsChannelWriter($mainToThreadBuffer)
 		);
-
-		$this->broadcaster = new StandardPacketBroadcaster($this->server);
 	}
 
 	public function start() : void{
@@ -166,8 +171,10 @@ class RakLibInterface implements ServerEventListener, AdvancedNetworkInterface{
 			$this->server,
 			$this->network->getSessionManager(),
 			PacketPool::getInstance(),
+			$this->packetSerializerContext,
 			new RakLibPacketSender($sessionId, $this),
-			$this->broadcaster,
+			$this->packetBroadcaster,
+			$this->entityEventBroadcaster,
 			ZlibCompressor::getInstance(), //TODO: this shouldn't be hardcoded, but we might need the RakNet protocol version to select it
 			$address,
 			$port

src/player/Player.php

@@ -1212,6 +1212,15 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 	 * @param Vector3 $newPos Coordinates of the player's feet, centered horizontally at the base of their bounding box.
 	 */
 	public function handleMovement(Vector3 $newPos) : void{
+		Timings::$playerMove->startTiming();
+		try{
+			$this->actuallyHandleMovement($newPos);
+		}finally{
+			Timings::$playerMove->stopTiming();
+		}
+	}
+
+	private function actuallyHandleMovement(Vector3 $newPos) : void{
 		$this->moveRateLimit--;
 		if($this->moveRateLimit < 0){
 			return;
@@ -1365,13 +1374,15 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		$this->timings->startTiming();
 
 		if($this->spawned){
+			Timings::$playerMove->startTiming();
 			$this->processMostRecentMovements();
-			$this->motion = new Vector3(0, 0, 0); //TODO: HACK! (Fixes player knockback being messed up)
+			$this->motion = Vector3::zero(); //TODO: HACK! (Fixes player knockback being messed up)
 			if($this->onGround){
 				$this->inAirTicks = 0;
 			}else{
 				$this->inAirTicks += $tickDiff;
 			}
+			Timings::$playerMove->stopTiming();
 
 			Timings::$entityBaseTick->startTiming();
 			$this->entityBaseTick($tickDiff);

src/timings/Timings.php

@@ -27,9 +27,7 @@ use pocketmine\block\tile\Tile;
 use pocketmine\entity\Entity;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\ServerboundPacket;
-use pocketmine\player\Player;
 use pocketmine\scheduler\TaskHandler;
-use function dechex;
 
 abstract class Timings{
 	public const INCLUDED_BY_OTHER_TIMINGS_PREFIX = "** ";
@@ -58,6 +56,9 @@ abstract class Timings{
 
 	/** @var TimingsHandler */
 	public static $playerNetworkSendEncrypt;
+
+	public static TimingsHandler $playerNetworkSendInventorySync;
+
 	/** @var TimingsHandler */
 	public static $playerNetworkReceive;
 	/** @var TimingsHandler */
@@ -91,6 +92,12 @@ abstract class Timings{
 
 	/** @var TimingsHandler */
 	public static $entityMove;
+
+	public static TimingsHandler $entityMoveCollision;
+
+	public static TimingsHandler $projectileMove;
+	public static TimingsHandler $projectileMoveRayTrace;
+
 	/** @var TimingsHandler */
 	public static $playerCheckNearEntities;
 	/** @var TimingsHandler */
@@ -103,6 +110,8 @@ abstract class Timings{
 	/** @var TimingsHandler */
 	public static $livingEntityBaseTick;
 
+	public static TimingsHandler $itemEntityBaseTick;
+
 	/** @var TimingsHandler */
 	public static $schedulerSync;
 	/** @var TimingsHandler */
@@ -142,6 +151,8 @@ abstract class Timings{
 	/** @var TimingsHandler */
 	public static $broadcastPackets;
 
+	public static TimingsHandler $playerMove;
+
 	public static function init() : void{
 		if(self::$initialized){
 			return;
@@ -155,21 +166,24 @@ abstract class Timings{
 		self::$garbageCollector = new TimingsHandler("Garbage Collector", self::$memoryManager);
 		self::$titleTick = new TimingsHandler("Console Title Tick");
 
-		self::$playerNetworkSend = new TimingsHandler("Player Network Send");
+		self::$connection = new TimingsHandler("Connection Handler");
+
+		self::$playerNetworkSend = new TimingsHandler("Player Network Send", self::$connection);
 		self::$playerNetworkSendCompress = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Compression", self::$playerNetworkSend);
 		self::$playerNetworkSendCompressBroadcast = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Compression (Broadcast)", self::$playerNetworkSendCompress);
 		self::$playerNetworkSendCompressSessionBuffer = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Compression (Session Buffer)", self::$playerNetworkSendCompress);
 		self::$playerNetworkSendEncrypt = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Encryption", self::$playerNetworkSend);
+		self::$playerNetworkSendInventorySync = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Inventory Sync", self::$playerNetworkSend);
 
-		self::$playerNetworkReceive = new TimingsHandler("Player Network Receive");
+		self::$playerNetworkReceive = new TimingsHandler("Player Network Receive", self::$connection);
 		self::$playerNetworkReceiveDecompress = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Receive - Decompression", self::$playerNetworkReceive);
 		self::$playerNetworkReceiveDecrypt = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Receive - Decryption", self::$playerNetworkReceive);
 
 		self::$broadcastPackets = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Broadcast Packets", self::$playerNetworkSend);
 
+		self::$playerMove = new TimingsHandler("Player Movement");
 		self::$playerChunkOrder = new TimingsHandler("Player Order Chunks");
-		self::$playerChunkSend = new TimingsHandler("Player Send Chunks");
-		self::$connection = new TimingsHandler("Connection Handler");
+		self::$playerChunkSend = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Network Send - Chunks", self::$playerNetworkSend);
 		self::$scheduler = new TimingsHandler("Scheduler");
 		self::$serverCommand = new TimingsHandler("Server Command");
 		self::$worldLoad = new TimingsHandler("World Load");
@@ -183,19 +197,25 @@ abstract class Timings{
 		self::$syncPlayerDataLoad = new TimingsHandler("Player Data Load");
 		self::$syncPlayerDataSave = new TimingsHandler("Player Data Save");
 
-		self::$entityMove = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "entityMove");
-		self::$playerCheckNearEntities = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "checkNearEntities");
-		self::$tickEntity = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickEntity");
-		self::$tickTileEntity = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickTileEntity");
+		self::$entityMove = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Movement");
+		self::$entityMoveCollision = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Movement - Collision Checks", self::$entityMove);
 
-		self::$entityBaseTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "entityBaseTick");
-		self::$livingEntityBaseTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "livingEntityBaseTick");
+		self::$projectileMove = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Projectile Movement", self::$entityMove);
+		self::$projectileMoveRayTrace = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Projectile Movement - Ray Tracing", self::$projectileMove);
+
+		self::$playerCheckNearEntities = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "checkNearEntities");
+		self::$tickEntity = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Tick");
+		self::$tickTileEntity = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Block Entity Tick");
+
+		self::$entityBaseTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Base Tick");
+		self::$livingEntityBaseTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Base Tick - Living");
+		self::$itemEntityBaseTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Base Tick - ItemEntity");
 
 		self::$schedulerSync = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Scheduler - Sync Tasks");
 		self::$schedulerAsync = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Scheduler - Async Tasks");
 
-		self::$playerCommand = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "playerCommand");
-		self::$craftingDataCacheRebuild = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "craftingDataCacheRebuild");
+		self::$playerCommand = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Player Command");
+		self::$craftingDataCacheRebuild = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Build CraftingDataPacket Cache");
 
 	}
 
@@ -218,11 +238,7 @@ abstract class Timings{
 	public static function getEntityTimings(Entity $entity) : TimingsHandler{
 		$entityType = (new \ReflectionClass($entity))->getShortName();
 		if(!isset(self::$entityTypeTimingMap[$entityType])){
-			if($entity instanceof Player){
-				self::$entityTypeTimingMap[$entityType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickEntity - EntityPlayer", self::$tickEntity);
-			}else{
-				self::$entityTypeTimingMap[$entityType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickEntity - " . $entityType, self::$tickEntity);
-			}
+			self::$entityTypeTimingMap[$entityType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Entity Tick - " . $entityType, self::$tickEntity);
 		}
 
 		return self::$entityTypeTimingMap[$entityType];
@@ -231,7 +247,7 @@ abstract class Timings{
 	public static function getTileEntityTimings(Tile $tile) : TimingsHandler{
 		$tileType = (new \ReflectionClass($tile))->getShortName();
 		if(!isset(self::$tileEntityTypeTimingMap[$tileType])){
-			self::$tileEntityTypeTimingMap[$tileType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickTileEntity - " . $tileType, self::$tickTileEntity);
+			self::$tileEntityTypeTimingMap[$tileType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Block Entity Tick - " . $tileType, self::$tickTileEntity);
 		}
 
 		return self::$tileEntityTypeTimingMap[$tileType];
@@ -240,7 +256,7 @@ abstract class Timings{
 	public static function getReceiveDataPacketTimings(ServerboundPacket $pk) : TimingsHandler{
 		$pid = $pk->pid();
 		if(!isset(self::$packetReceiveTimingMap[$pid])){
-			self::$packetReceiveTimingMap[$pid] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "receivePacket - " . $pk->getName() . " [0x" . dechex($pid) . "]", self::$playerNetworkReceive);
+			self::$packetReceiveTimingMap[$pid] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Receive - " . $pk->getName(), self::$playerNetworkReceive);
 		}
 
 		return self::$packetReceiveTimingMap[$pid];
@@ -249,7 +265,7 @@ abstract class Timings{
 	public static function getDecodeDataPacketTimings(ServerboundPacket $pk) : TimingsHandler{
 		$pid = $pk->pid();
 		return self::$packetDecodeTimingMap[$pid] ??= new TimingsHandler(
-			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Decode - " . $pk->getName() . " [0x" . dechex($pid) . "]",
+			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Decode - " . $pk->getName(),
 			self::getReceiveDataPacketTimings($pk)
 		);
 	}
@@ -257,7 +273,7 @@ abstract class Timings{
 	public static function getHandleDataPacketTimings(ServerboundPacket $pk) : TimingsHandler{
 		$pid = $pk->pid();
 		return self::$packetHandleTimingMap[$pid] ??= new TimingsHandler(
-			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Handler - " . $pk->getName() . " [0x" . dechex($pid) . "]",
+			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Handler - " . $pk->getName(),
 			self::getReceiveDataPacketTimings($pk)
 		);
 	}
@@ -265,7 +281,7 @@ abstract class Timings{
 	public static function getEncodeDataPacketTimings(ClientboundPacket $pk) : TimingsHandler{
 		$pid = $pk->pid();
 		return self::$packetEncodeTimingMap[$pid] ??= new TimingsHandler(
-			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Encode - " . $pk->getName() . " [0x" . dechex($pid) . "]",
+			self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Encode - " . $pk->getName(),
 			self::getSendDataPacketTimings($pk)
 		);
 	}
@@ -273,7 +289,7 @@ abstract class Timings{
 	public static function getSendDataPacketTimings(ClientboundPacket $pk) : TimingsHandler{
 		$pid = $pk->pid();
 		if(!isset(self::$packetSendTimingMap[$pid])){
-			self::$packetSendTimingMap[$pid] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "sendPacket - " . $pk->getName() . " [0x" . dechex($pid) . "]", self::$playerNetworkSend);
+			self::$packetSendTimingMap[$pid] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Send - " . $pk->getName(), self::$playerNetworkSend);
 		}
 
 		return self::$packetSendTimingMap[$pid];

src/world/World.php

@@ -65,6 +65,7 @@ use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\IntTag;
 use pocketmine\nbt\tag\StringTag;
 use pocketmine\network\mcpe\convert\RuntimeBlockMapping;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
 use pocketmine\network\mcpe\protocol\BlockActorDataPacket;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\types\BlockPosition;
@@ -685,7 +686,7 @@ class World implements ChunkManager{
 					$this->broadcastPacketToViewers($pos, $e);
 				}
 			}else{
-				$this->server->broadcastPackets($this->filterViewersForPosition($pos, $players), $pk);
+				NetworkBroadcastUtils::broadcastPackets($this->filterViewersForPosition($pos, $players), $pk);
 			}
 		}
 	}
@@ -711,7 +712,7 @@ class World implements ChunkManager{
 					$this->broadcastPacketToViewers($pos, $e);
 				}
 			}else{
-				$this->server->broadcastPackets($this->filterViewersForPosition($pos, $ev->getRecipients()), $pk);
+				NetworkBroadcastUtils::broadcastPackets($this->filterViewersForPosition($pos, $ev->getRecipients()), $pk);
 			}
 		}
 	}
@@ -1021,7 +1022,7 @@ class World implements ChunkManager{
 			World::getXZ($index, $chunkX, $chunkZ);
 			$chunkPlayers = $this->getChunkPlayers($chunkX, $chunkZ);
 			if(count($chunkPlayers) > 0){
-				$this->server->broadcastPackets($chunkPlayers, $entries);
+				NetworkBroadcastUtils::broadcastPackets($chunkPlayers, $entries);
 			}
 		}
 

tests/phpstan/configs/actual-problems.neon

@@ -645,21 +645,6 @@ parameters:
 			count: 1
 			path: ../../../src/network/mcpe/NetworkSession.php
 
-		-
-			message: "#^Parameter \\#1 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\NetworkSession\\:\\:onEntityEffectAdded\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
-			count: 1
-			path: ../../../src/network/mcpe/NetworkSession.php
-
-		-
-			message: "#^Parameter \\#1 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\NetworkSession\\:\\:onEntityEffectRemoved\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
-			count: 1
-			path: ../../../src/network/mcpe/NetworkSession.php
-
-		-
-			message: "#^Parameter \\#1 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\NetworkSession\\:\\:syncAttributes\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
-			count: 1
-			path: ../../../src/network/mcpe/NetworkSession.php
-
 		-
 			message: "#^Parameter \\#1 \\$for of method pocketmine\\\\network\\\\mcpe\\\\NetworkSession\\:\\:syncAbilities\\(\\) expects pocketmine\\\\player\\\\Player, pocketmine\\\\player\\\\Player\\|null given\\.$#"
 			count: 2
@@ -680,6 +665,21 @@ parameters:
 			count: 1
 			path: ../../../src/network/mcpe/NetworkSession.php
 
+		-
+			message: "#^Parameter \\#2 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\EntityEventBroadcaster\\:\\:onEntityEffectAdded\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
+			count: 1
+			path: ../../../src/network/mcpe/NetworkSession.php
+
+		-
+			message: "#^Parameter \\#2 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\EntityEventBroadcaster\\:\\:onEntityEffectRemoved\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
+			count: 1
+			path: ../../../src/network/mcpe/NetworkSession.php
+
+		-
+			message: "#^Parameter \\#2 \\$entity of method pocketmine\\\\network\\\\mcpe\\\\EntityEventBroadcaster\\:\\:syncAttributes\\(\\) expects pocketmine\\\\entity\\\\Living, pocketmine\\\\player\\\\Player\\|null given\\.$#"
+			count: 1
+			path: ../../../src/network/mcpe/NetworkSession.php
+
 		-
 			message: "#^Parameter \\#2 \\$player of class pocketmine\\\\network\\\\mcpe\\\\handler\\\\PreSpawnPacketHandler constructor expects pocketmine\\\\player\\\\Player, pocketmine\\\\player\\\\Player\\|null given\\.$#"
 			count: 1