Release 4.22.0

closes #5794

.github/workflows/build-docker-image.yml

@@ -20,6 +20,13 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Clone pmmp/PocketMine-Docker repository
         uses: actions/checkout@v3
         with:
@@ -52,7 +59,7 @@ jobs:
           context: ./pocketmine-mp
           tags: |
             ${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.TAG_NAME }}
-#            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.TAG_NAME }}
+            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.TAG_NAME }}
           build-args: |
             PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
             PMMP_REPO=${{ github.repository }}
@@ -65,7 +72,7 @@ jobs:
           context: ./pocketmine-mp
           tags: |
             ${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MAJOR }}
-#            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MAJOR }}
+            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MAJOR }}
           build-args: |
             PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
             PMMP_REPO=${{ github.repository }}
@@ -78,7 +85,7 @@ jobs:
           context: ./pocketmine-mp
           tags: |
             ${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MINOR }}
-#            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MINOR }}
+            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:${{ steps.tag-name.outputs.MINOR }}
           build-args: |
             PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
             PMMP_REPO=${{ github.repository }}
@@ -91,7 +98,7 @@ jobs:
           context: ./pocketmine-mp
           tags: |
             ${{ steps.docker-repo-name.outputs.NAME }}:latest
-#            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:latest
+            ghcr.io/${{ steps.docker-repo-name.outputs.NAME }}:latest
           build-args: |
             PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
             PMMP_REPO=${{ github.repository }}

.github/workflows/discord-release-notify.yml

@@ -13,9 +13,9 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.24.0
+        uses: shivammathur/setup-php@2.25.2
         with:
-          php-version: 8.0
+          php-version: 8.1
 
       - name: Restore Composer package cache
         uses: actions/cache@v3

.github/workflows/draft-release.yml

@@ -18,9 +18,9 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.24.0
+        uses: shivammathur/setup-php@2.25.2
         with:
-          php-version: 8.0
+          php-version: 8.1
 
       - name: Restore Composer package cache
         uses: actions/cache@v3

.github/workflows/main.yml

@@ -6,47 +6,26 @@ on:
   workflow_dispatch:
 
 jobs:
-  build-php:
-    name: Prepare PHP
-    runs-on: ${{ matrix.image }}
-
-    strategy:
-      matrix:
-        image: [ubuntu-20.04]
-        php: [8.0.28, 8.1.16, 8.2.3]
-
-    steps:
-      - name: Build and prepare PHP cache
-        uses: pmmp/setup-php-action@6dd74c145250109942b08fc63cd5118edd2fd256
-        with:
-          php-version: ${{ matrix.php }}
-          install-path: "./bin"
-          pm-version-major: "4"
-
   phpstan:
     name: PHPStan analysis
-    needs: build-php
     runs-on: ${{ matrix.image }}
 
     strategy:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.28, 8.1.16, 8.2.3]
+        php: ["8.1", "8.2"]
 
     steps:
       - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@6dd74c145250109942b08fc63cd5118edd2fd256
+        uses: pmmp/setup-php-action@2.0.0
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
           pm-version-major: "4"
 
-      - name: Install Composer
-        run: curl -sS https://getcomposer.org/installer | php
-
       - name: Restore Composer package cache
         uses: actions/cache@v3
         with:
@@ -58,34 +37,30 @@ jobs:
             composer-v2-cache-
 
       - name: Install Composer dependencies
-        run: php composer.phar install --prefer-dist --no-interaction
+        run: composer install --prefer-dist --no-interaction
 
       - name: Run PHPStan
         run: ./vendor/bin/phpstan analyze --no-progress --memory-limit=2G
 
   phpunit:
     name: PHPUnit tests
-    needs: build-php
     runs-on: ${{ matrix.image }}
     strategy:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.28, 8.1.16, 8.2.3]
+        php: ["8.1", "8.2"]
 
     steps:
       - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@6dd74c145250109942b08fc63cd5118edd2fd256
+        uses: pmmp/setup-php-action@2.0.0
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
           pm-version-major: "4"
 
-      - name: Install Composer
-        run: curl -sS https://getcomposer.org/installer | php
-
       - name: Restore Composer package cache
         uses: actions/cache@v3
         with:
@@ -97,20 +72,19 @@ jobs:
             composer-v2-cache-
 
       - name: Install Composer dependencies
-        run: php composer.phar install --prefer-dist --no-interaction
+        run: composer install --prefer-dist --no-interaction
 
       - name: Run PHPUnit tests
         run: ./vendor/bin/phpunit --bootstrap vendor/autoload.php --fail-on-warning tests/phpunit
 
   integration:
     name: Integration tests
-    needs: build-php
     runs-on: ${{ matrix.image }}
     strategy:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.28, 8.1.16, 8.2.3]
+        php: ["8.1", "8.2"]
 
     steps:
       - uses: actions/checkout@v3
@@ -118,15 +92,12 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@6dd74c145250109942b08fc63cd5118edd2fd256
+        uses: pmmp/setup-php-action@2.0.0
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
           pm-version-major: "4"
 
-      - name: Install Composer
-        run: curl -sS https://getcomposer.org/installer | php
-
       - name: Restore Composer package cache
         uses: actions/cache@v3
         with:
@@ -138,34 +109,30 @@ jobs:
             composer-v2-cache-
 
       - name: Install Composer dependencies
-        run: php composer.phar install --no-dev --prefer-dist --no-interaction
+        run: composer install --no-dev --prefer-dist --no-interaction
 
       - name: Run integration tests
         run: ./tests/travis.sh -t4
 
   codegen:
     name: Generated Code consistency checks
-    needs: build-php
     runs-on: ${{ matrix.image }}
     strategy:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.28, 8.1.16, 8.2.3]
+        php: ["8.1", "8.2"]
 
     steps:
       - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@6dd74c145250109942b08fc63cd5118edd2fd256
+        uses: pmmp/setup-php-action@2.0.0
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
           pm-version-major: "4"
 
-      - name: Install Composer
-        run: curl -sS https://getcomposer.org/installer | php
-
       - name: Restore Composer package cache
         uses: actions/cache@v3
         with:
@@ -177,7 +144,7 @@ jobs:
             composer-v2-cache-
 
       - name: Install Composer dependencies
-        run: php composer.phar install --no-dev --prefer-dist --no-interaction
+        run: composer install --no-dev --prefer-dist --no-interaction
 
       - name: Regenerate registry annotations
         run: php build/generate-registry-annotations.php src
@@ -203,10 +170,10 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.24.0
+        uses: shivammathur/setup-php@2.25.2
         with:
-          php-version: 8.0
-          tools: php-cs-fixer:3.11
+          php-version: 8.1
+          tools: php-cs-fixer:3.16
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/update-php-versions.php

@@ -1,51 +0,0 @@
-<?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);
-
-const VERSIONS = [
-	"8.0",
-	"8.1",
-	"8.2"
-];
-
-$workflowFile = file_get_contents(__DIR__ . '/main.yml');
-$newWorkflowFile = $workflowFile;
-foreach(VERSIONS as $v){
-	$releaseInfo = file_get_contents("https://secure.php.net/releases?json&version=$v");
-	if($releaseInfo === false){
-		throw new \RuntimeException("Failed to contact php.net API");
-	}
-	$data = json_decode($releaseInfo, true);
-	if(!is_array($data) || !isset($data["version"]) || !is_string($data["version"]) || preg_match('/^\d+\.\d+\.\d+(-[A-Za-z\d]+)?$/', $data["version"]) === 0){
-		throw new \RuntimeException("Invalid data returned by API");
-	}
-	$updated = preg_replace("/$v\.\d+/", $data["version"], $newWorkflowFile);
-	if($updated !== $newWorkflowFile){
-		echo "Updated $v revision to " . $data["version"] . "\n";
-	}
-	$newWorkflowFile = $updated;
-}
-
-if($workflowFile !== $newWorkflowFile){
-	echo "Writing modified workflow file\n";
-	file_put_contents(__DIR__ . '/main.yml', $newWorkflowFile);
-}

.idea/codeStyles/Project.xml

@@ -30,6 +30,13 @@
         <option name="USE_TAB_CHARACTER" value="true" />
       </indentOptions>
     </codeStyleSettings>
+    <codeStyleSettings language="Markdown">
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+        <option name="TAB_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
     <codeStyleSettings language="PHP">
       <option name="CLASS_BRACE_STYLE" value="1" />
       <option name="METHOD_BRACE_STYLE" value="1" />

BUILDING.md

@@ -2,13 +2,13 @@
 ## Pre-requisites
 - A bash shell (git bash is sufficient for Windows)
 - [`git`](https://git-scm.com) available in your shell
-- PHP 8.0 or newer available in your shell
+- PHP 8.1 or newer available in your shell
 - [`composer`](https://getcomposer.org) available in your shell
 
 ## Custom PHP binaries
 Because PocketMine-MP requires several non-standard PHP extensions and configuration, PMMP provides scripts to build custom binaries for running PocketMine-MP, as well as prebuilt binaries.
 
-- [Prebuilt binaries](https://jenkins.pmmp.io/job/PHP-8.0-Aggregate)
+- [Prebuilt binaries](https://github.com/pmmp/PHP-Binaries/releases)
 - [Compile scripts](https://github.com/pmmp/php-build-scripts) are provided as a submodule in the path `build/php`
 
 If you use a custom binary, you'll need to replace `composer` usages in this guide with `path/to/your/php path/to/your/composer.phar`.
@@ -29,11 +29,5 @@ Run `composer make-server` using your preferred PHP binary. It'll drop a `Pocket
 
 You can also use the `--out` option to change the output filename.
 
-There is a bug in PHP that might cause an error which looks like this:
-```
-Fatal error: Uncaught BadMethodCallException: unable to create temporary file in PocketMine-MP/build/server-phar.php:119
-```
-You can work around it by setting `ulimit -n` to some bigger number, e.g. `8192`, or by updating your PHP version to at least 8.0.3.
-
 ## Running PocketMine-MP from source code
 Run `src/PocketMine.php` using your preferred PHP binary.

CONTRIBUTING.md

@@ -18,24 +18,49 @@ Larger contributions like feature additions should be preceded by a [Change Prop
 ## Other things you'll need
 - [git](https://git-scm.com/)
 
+## List of `pocketmine` namespaces which are in other repos
+PocketMine-MP has several dependencies which are independent from the main server code. Most of them use the `pocketmine` namespace.
+Some of these add extra classes to packages which already exist in PocketMine-MP.
+
+Take a look at the table below if you can't find the class or function you're looking for.
+
+| Source URL                                                      | Namespace, class or function                                                                                                             |
+|:----------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------|
+| [pmmp/BedrockProtocol](https://github.com/pmmp/BedrockProtocol) | `pocketmine\network\mcpe\protocol`                                                                                                       |
+| [pmmp/BinaryUtils](https://github.com/pmmp/BinaryUtils)         | `pocketmine\utils\BinaryDataException`</br>`pocketmine\utils\BinaryStream`</br>`pocketmine\utils\Binary`                                 |
+| [pmmp/ClassLoader](https://github.com/pmmp/`ClassLoader`)       | `BaseClassLoader`</br>`ClassLoader`</br>`DynamicClassLoader`                                                                             |
+| [pmmp/Color](https://github.com/pmmp/Color)                     | `pocketmine\color`                                                                                                                       |
+| [pmmp/ErrorHandler](https://github.com/pmmp/ErrorHandler)       | `pocketmine\errorhandler`                                                                                                                |
+| [pmmp/LogPthreads](https://github.com/pmmp/LogPthreads)         | `ThreadedLoggerAttachment`</br>`ThreadedLogger`</br>`AttachableThreadedLogger`                                                           |
+| [pmmp/Log](https://github.com/pmmp/Log)                         | `AttachableLogger`</br>`BufferedLogger`</br>`GlobalLogger`</br>`LogLevel`</br>`Logger`</br>`PrefixedLogger`</br>`SimpleLogger`           |
+| [pmmp/Math](https://github.com/pmmp/Math)                       | `pocketmine\math`                                                                                                                        |
+| [pmmp/NBT](https://github.com/pmmp/NBT)                         | `pocketmine\nbt`                                                                                                                         |
+| [pmmp/RakLibIpc](https://github.com/pmmp/RakLibIpc)             | `raklib\server\ipc`                                                                                                                      |
+| [pmmp/RakLib](https://github.com/pmmp/RakLib)                   | `raklib`                                                                                                                                 |
+| [pmmp/Snooze](https://github.com/pmmp/Snooze)                   | `pocketmine\snooze`                                                                                                                      |
+| [pmmp/ext-chunkutils2](https://github.com/pmmp/ext-chunkutils2) | `pocketmine\world\format\LightArray`</br>`pocketmine\world\format\PalettedBlockArray`</br>`pocketmine\world\format\io\SubChunkConverter` |
+| [pmmp/ext-morton](https://github.com/pmmp/ext-morton)           | `morton2d_decode`</br>`morton2d_encode`</br>`morton3d_decode`</br>`morton3d_encode`                                                      |
+| [pmmp/ext-libdeflate](https://github.com/pmmp/ext-libdeflate)   | `libdeflate_deflate_compress`</br>`libdeflate_gzip_compress`</br>`libdeflate_zlib_compress`                                              |
+
 ## 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 +68,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:

README.md

@@ -14,7 +14,6 @@
 <p align="center">
 	<a href="https://github.com/pmmp/PocketMine-MP/actions/workflows/main.yml"><img src="https://github.com/pmmp/PocketMine-MP/workflows/CI/badge.svg" alt="CI" /></a>
 	<a href="https://github.com/pmmp/PocketMine-MP/releases/latest"><img alt="GitHub release (latest SemVer)" src="https://img.shields.io/github/v/release/pmmp/PocketMine-MP?label=release&sort=semver"></a>
-	<a href="https://hub.docker.com/r/pmmp/pocketmine-mp"><img src="https://img.shields.io/docker/v/pmmp/pocketmine-mp?logo=docker&label=image" alt="Docker image version (latest semver)" /></a>
 	<a href="https://discord.gg/bmSAZBG"><img src="https://img.shields.io/discord/373199722573201408?label=discord&color=7289DA&logo=discord" alt="Discord" /></a>
 	<br>
 	<a href="https://github.com/pmmp/PocketMine-MP/releases"><img alt="GitHub all releases" src="https://img.shields.io/github/downloads/pmmp/PocketMine-MP/total?label=downloads%40total"></a>
@@ -24,7 +23,7 @@
 ## Getting started
 - [Documentation](http://pmmp.readthedocs.org/)
 - [Installation instructions](https://pmmp.readthedocs.io/en/rtfd/installation.html)
-- [Docker image](https://hub.docker.com/r/pmmp/pocketmine-mp)
+- [Docker image](https://github.com/pmmp/PocketMine-MP/pkgs/container/pocketmine-mp)
 - [Plugin repository](https://poggit.pmmp.io/plugins)
 
 ## Discussion/Help
@@ -36,7 +35,7 @@
  * [Building and running from source](BUILDING.md)
  * [Developer documentation](https://devdoc.pmmp.io) - General documentation for PocketMine-MP plugin developers
  * [Latest release API documentation](https://apidoc.pmmp.io) - Doxygen API documentation generated for each release
- * [Latest bleeding-edge API documentation](https://apidoc-dev.pmmp.io) - Doxygen API documentation generated weekly from `next-major` branch
+ * [Latest bleeding-edge API documentation](https://apidoc-dev.pmmp.io) - Doxygen API documentation generated weekly from `major-next` branch
  * [DevTools](https://github.com/pmmp/DevTools/) - Development tools plugin for creating plugins
  * [ExamplePlugin](https://github.com/pmmp/ExamplePlugin/) - Example plugin demonstrating some basic API features
  * [Contributing Guidelines](CONTRIBUTING.md)

changelogs/4.17.md

@@ -11,4 +11,29 @@ Released 14th March 2023.
 
 ## General
 - Added support for Minecraft: Bedrock Edition 1.19.70.
-- Removed support for older versions.
+- Removed support for older versions.
+
+# 4.17.1
+Released 22nd March 2023.
+
+## General
+- Docker images for PocketMine-MP are now published on [GitHub Container Registry](https://github.com/pmmp/PocketMine-MP/pkgs/container/pocketmine-mp). The Docker Hub images will stop being maintained in the future.
+- Updated translations.
+
+## Fixes
+- Fixed server crash on empty packets in certain cases.
+- Fixed mushroom blocks dropping the wrong items when broken with a silk-touch tool.
+- Fixed mushroom blocks giving the wrong items when block-picked.
+- Fixed missing ability flag `PRIVILEGED_BUILDER`.
+
+## Internals
+- `update-updater-api.yml` workflow now uses `github.repository_owner` to make it easier to test the workflow on forks.
+- Added version-specific channels to `update.pmmp.io`, such as `4`, `4.18-beta`, `4.17`, etc.
+- Replaced deprecated `::set-output` commands in GitHub Actions workflows.
+- `build/make-release.php` no longer automatically pushes changes, to avoid accidents when testing release workflows on forks.
+
+# 4.17.2
+Released 29th March 2023.
+
+## Fixes
+- Fixed players being unable to join due to the appearance of a new `x5t` field in the JWT header of Xbox Live authentication tokens.

changelogs/4.18-alpha.md

@@ -43,3 +43,49 @@ Released 16th March 2023.
 - `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,123 @@
+**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.
+
+# 4.18.1
+Released 27th March 2023.
+
+## General
+- `RakLibInterface` now logs the name of the currently active session if a crash occurs when processing a packet. This makes it easier to reproduce bugs, which is important to be able to fix them.
+- Added more detailed debugging information to `InventoryManager->syncSelectedHotbarSlot()`.
+
+## Fixes
+- Fixed server crash when attempting to drop more of an item from a stack than available in the inventory.
+- Fixed packet processing errors when editing writable books.
+- Fixed packet processing errors when shift-clicking on the recipe book to craft recipes which draw from a large number of inventory slots.
+
+# 4.18.2
+Released 29th March 2023.
+
+## Fixes
+- Fixed players being unable to join due to the appearance of a new `x5t` field in the JWT header of Xbox Live authentication tokens.
+- Fixed items' durability appearing to reset when moving them around in the inventory.
+
+# 4.18.3
+Released 5th April 2023.
+
+## Fixes
+- Fixed Average Players not being shown on timings reports when custom player classes are used.
+- Fixed incorrect tick violation calculation in timings reports.
+- Fixed not being able to add or remove items from the offhand slot.
+- Fixed creative inventory item count corruption when taking items (some players would see 64x items in the creative inventory after rejoining or changing gamemode).
+- Fixed not being able to drop items directly from the creative inventory on mobile.
+- Fixed `DataPacketReceiveEvent` not being called for packets sent by `EntityEventBroadcaster`.
+- `CreativeInventory::getItem()` and `CreativeInventory::getAll()` now return cloned itemstacks, to prevent accidental modification of the creative inventory.
+
+# 4.18.4
+Released 10th April 2023.
+
+## Fixes
+- Fixed movement becoming broken when the player moves at high speed (e.g. due to high levels of the Speed effect).
+- Updated dependencies to get fixes in `pocketmine/nbt` and `pocketmine/bedrock-protocol`.
+
+## Internals
+### Network
+- Game packets are now rate-limited in a similar manner to packet batches. This helps to more effectively mitigate certain types of DoS attacks.
+- Added a new class `PacketRateLimiter`, implementing functionality previously baked directly into `NetworkSession` in a more generic way to allow reuse.

changelogs/4.19.md

@@ -0,0 +1,111 @@
+**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 introduces support for a new, more advanced version of Timings.
+This improved system provides more detail than the old system, and supports being displayed in a tree view, making it much easier to see which timers contribute to which other timers.
+
+In addition, some minor performance improvements have been made, along with a couple of minor API additions.
+
+# 4.19.0
+Released 11th April 2023.
+
+## General
+- Updated the Timings system.
+  - Timings records now include parent information, allowing them to be displayed in a tree view (e.g. https://timings.pmmp.io/?id=303556).
+  - Timings records now include additional information, such as Peak (max time spent on any single tick), and Ticks (number of ticks the timer was active on).
+  - New timings have been added for every event.
+  - A new timer `Player Network Send - Pre-Spawn Game Data` has been added, and covers most of the time spent handling `ResourcePackClientResponsePacket`, giving a clearer picture of what's happening.
+- Improved performance of the plugin event system.
+  - By introducing some caching, the event system now has 90% less overhead than in previous versions.
+- Improved performance of the random chunk ticking system.
+  - The selection of ticked random chunks, and their validation for ticking, is now cached. This significantly reduces the overhead of chunk selection.
+  - Factions servers and other game modes with big maps and sparsely populated areas will see the most benefit from this change.
+  - Real-world performance benefit of this change is anywhere from 0-20%, depending on server type and configuration.
+- The `timings paste` command now logs a debug message with the server response on failure to paste a timings report.
+
+## API
+### `pocketmine\entity\object`
+- The following API constants have been added:
+  - `ExperienceOrb::DEFAULT_DESPAWN_DELAY` - the default delay in ticks before an experience orb despawns
+  - `ExperienceOrb::NEVER_DESPAWN` - magic value for `setDespawnDelay()` to make an experience orb never despawn
+  - `ExperienceOrb::MAX_DESPAWN_DELAY` - the maximum delay in ticks before an experience orb despawns
+- The following API methods have been added:
+  - `public ExperienceOrb->getDespawnDelay() : int` - returns the delay in ticks before this experience orb despawns
+  - `public ExperienceOrb->setDespawnDelay(int $despawnDelay) : void` - sets the delay in ticks before this experience orb despawns
+- The following properties have been deprecated
+  - `ExperienceOrb->age` - superseded by despawn delay methods
+
+### `pocketmine\event`
+- The following API methods have been added:
+  - `public HandlerList->getListenerList() : list<RegisteredListener>` - returns an ordered list of handlers to be called for the event
+
+### `pocketmine\player`
+- The following API methods have behavioural changes:
+  - `ChunkSelector->selectChunks()` now yields the distance in chunks from the center as the key, instead of an incrementing integer.
+- The following classes have been deprecated:
+  - `PlayerChunkLoader` (this was technically internal, but never marked as such)
+
+### `pocketmine\timings`
+- The following API constants have been deprecated:
+  - `Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX` - this is superseded by timings group support (see `Timings::GROUP_BREAKDOWN`)
+- The following API constants have been added:
+  - `Timings::GROUP_BREAKDOWN` - this group makes a timer appear in the `Minecraft - Breakdown` section of a timings report
+- The following API methods have been added:
+  - `public TimingsHandler->getGroup() : string` - returns the name of the table in which this timer will appear in a timings report
+- The following API methods have changed signatures:
+  - `TimingsHandler->__construct()` now accepts an additional, optional `string $group` parameter, which defaults to `Minecraft`.
+
+### `pocketmine\world`
+#### Highlights
+Ticking chunks is now done using the `ChunkTicker` system, which has a much more fine-grained API than the old `TickingChunkLoader` system, as well as better performance.
+It works similarly to the `ChunkLoader` system, in that chunks will be ticked as long as at least one `ChunkTicker` is registered for them.
+
+#### API changes
+- The following classes have been deprecated:
+  - `TickingChunkLoader` - this has been superseded by the more powerful and performant `ChunkTicker` APIs
+- The following classes have been added:
+  - `ChunkTicker` - an opaque object used for `registerTickingChunk()` to instruct the `World` that we want a chunk to be ticked
+- The following API methods have been added:
+  - `public World->registerTickingChunk(ChunkTicker $ticker, int $chunkX, int $chunkZ) : void` - registers a chunk to be ticked by the given `ChunkTicker`
+  - `public World->unregisterTickingChunk(ChunkTicker $ticker, int $chunkX, int $chunkZ) : void` - unregisters a chunk from being ticked by the given `ChunkTicker`
+
+# 4.19.1
+Released 14th April 2023.
+
+## Fixes
+- Fixed inventory rollbacks when spreading items in ender chests.
+- Fixed inventory rollbacks when shift-clicking to craft and the outputs would have been split across multiple inventory slots.
+- Fixed incorrect spawn terrain generation for newly created worlds.
+- Fixed `chunk-ticking.tick-radius` not disabling chunk ticking when set to `0`.
+- Fixed chunks not being ticked if they previously left a player's simulation distance without leaving their view distance.
+- Fixed height of collision boxes for Grass Path and Farmland blocks.
+
+# 4.19.2
+Released 14th April 2023.
+
+## Fixes
+- Fixed player timings duplication leading to extremely large timings reports when timings runs for a long time with many players.
+- Packet timings are now indexed by class FQN instead of packet ID. This prevents erroneous timer reuse on packet ID reuse (e.g. multi version servers).
+- Fixed entity timings being shared by different classes with the same short name. This led to incorrect timings being reported for some entities when custom entities were used.
+
+# 4.19.3
+Released 21st April 2023.
+
+## General
+- Error IDs for `Packet processing error` disconnects are now split into 4-character chunks to make them easier to type (since they can't be copied from the disconnection screen of a client).
+
+## Fixes
+- Fixed entity-block intersections being checked twice per tick. Besides wasting CPU time, this may have caused unexpected behaviour during entity-block interactions with blocks like water or cacti.
+- Fixed performance issue in network inventory synchronization due item NBT being prepared twice.
+- Fixed `tools/simulate-chunk-selector.php` argument parsing being completely broken (weird behaviour of PHP `getopt()`).
+
+## Internals
+- `TimingsHandler->stopTiming()` now logs an error message if a subtimer wasn't stopped, rather than throwing an exception.
+  - Due to interactions between `try...finally` and unexpected errors, throwing exceptions made it difficult for plugin developers to debug errors in their plugins, since it obscured the original error.

changelogs/4.20.md

@@ -0,0 +1,79 @@
+**For Minecraft: Bedrock Edition 1.19.80**
+
+### 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.
+
+### Interim releases
+If you're upgrading from 4.17.x directly to 4.20.x, please also read the following changelogs, as the interim releases contain important changes:
+
+- [4.18.0](https://github.com/pmmp/PocketMine-MP/blob/4.20.0/changelogs/4.18.md#4180) - major performance improvements, internal network changes, minor API additions
+- [4.19.0](https://github.com/pmmp/PocketMine-MP/blob/4.20.0/changelogs/4.19.md#4190) - minor performance improvements, improved timings system, minor API additions
+
+# 4.20.0
+Released 26th April 2023.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.80.
+- Removed support for older versions.
+
+## Fixes
+- Fixed packet processing error when attempting to use a stonecutter.
+- Fixed armor slots containing ghost items when cancelling right-click to equip armor.
+- Fixed crash in `HandlerList->getListenersByPriority()` when no listeners are registered at the given priority.
+
+## API
+### `pocketmine\block`
+- The following API methods have been added:
+  - `public BaseSign->getEditorEntityRuntimeId() : int` - returns the entity runtime ID of the player currently editing this sign, or `null` if none
+  - `public BaseSign->setEditorEntityRuntimeId(?int $editorEntityRuntimeId) : $this` - sets the entity runtime ID of the player currently editing this sign
+
+### `pocketmine\player`
+- The following API methods have been added:
+  - `public Player->openSignEditor(Vector3 $position) : void` - opens the client-side sign editor GUI for the given position
+
+# 4.20.1
+Released 27th April 2023.
+
+## Fixes
+- Fixed server crash when firing a bow while holding arrows in the offhand slot.
+
+## Internals
+- `ItemStackContainerIdTranslator::translate()` now requires an additional `int $slotId` parameter and returns `array{int, int}` (translated window ID, translated slot ID) to be used with `InventoryManager->locateWindowAndSlot()`.
+- `InventoryManager->locateWindowAndSlot()` now checks if the translated slot actually exists in the requested inventory, and returns `null` if not. Previously, it would return potentially invalid slot IDs without checking them, potentially leading to crashes.
+
+# 4.20.2
+Released 4th May 2023.
+
+## Fixes
+- Fixed all types of wooden logs appearing as oak in the inventory.
+- Fixed a performance issue in `BaseInventory->canAddItem()` (missing `continue` causing useless logic to run).
+
+# 4.20.3
+Released 6th May 2023.
+
+## Improvements
+- Reduced memory usage of `RuntimeBlockMapping` from 25 MB to 9 MB. Since every thread has its own copy of the block map, this saves a substantial amount of memory.
+
+## Fixes
+- Fixed players falling through blocks in spectator mode.
+- Fixed timings reports getting bloated by prolific usage of `PluginManager->registerEvent()`.
+  - This was caused by creating a new timings handler for each call, regardless of whether a timer already existed for the given event and callback.
+- Fixed `Full Server Tick` and other records being missing from timings reports.
+  - This was caused by timings handler depth not getting reset when timings was disabled and later re-enabled.
+
+# 4.20.4
+Released 6th May 2023.
+
+## Fixes
+- Fixed players being forced into flight mode in every game mode.
+  - Moral of the story: do not assume anything in Mojang internals does what its name suggests...
+
+# 4.20.5
+Released 30th May 2023.
+
+## Fixes
+- Fixed server crash due to a bug in upstream dependency [`netresearch/jsonmapper`](https://github.com/cweiske/JsonMapper).

changelogs/4.21.md

@@ -0,0 +1,77 @@
+**For Minecraft: Bedrock Edition 1.19.80**
+
+### Note about API versions
+Plugins which don't touch the `pocketmine\network\mcpe` namespace, and don't use reflection or any internal methods,
+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.
+
+# 4.21.0
+Released 17th May 2023.
+
+## General
+- PHP 8.1 is now required. Most plugins should run without changes, but some might need to be updated due to language-level deprecations.
+- Ticking chunk count is now shown separately from loaded chunk count in the `/status` command, providing useful performance information.
+- Further improved performance of ticking chunk selection.
+- Improved performance of some inventory functions.
+- Reduced server memory footprint in most cases by ~9 MB per thread.
+- Due to large overhead, async network compression is now only used for packets larger than 10 KB by default.
+
+## Configuration
+- Added the following new `pocketmine.yml` configuration options:
+  - `network.async-compression-threshold` - minimum size of packet which will be compressed using `AsyncTask`
+    - Default is 10 KB, which means that very few packets will use async compression in practice. This is because the overhead of compressing async is currently so high that it's not worth it for smaller packets.
+
+## Timings
+- Timings reports no longer include the unused metadata fields `Entities` and `LivingEntities`.
+- Timings reports now correctly calculate the peak time of a timer.
+  - Previously it was incorrectly recorded as the longest time spent in a single tick, rather than the longest time spent in a single activation.
+  - Timings report version has been bumped to `2` to reflect this change.
+- All world-specific timers now have generic aggregate timings, making it much easier to locate performance patterns across all worlds.
+
+## Gameplay
+- Players in spectator mode are no longer able to pick blocks, and now have finite resources similar to survival mode.
+
+## API
+### `pocketmine\world`
+- The following API methods have been added:
+  - `public World->getTickingChunks() : list<int>` - returns a list of chunk position hashes (a la `World::chunkHash()`) which are currently valid for random ticking
+
+### `pocketmine\inventory`
+- The following API methods have been added:
+  - `protected BaseInventory->getMatchingItemCount(int $slot, Item $test, bool $checkDamage, bool $checkTags) : int` - returns the number of items in the given stack if the content of the slot matches the test item, or zero otherwise
+    - This should be overridden if directly extending `BaseInventory` to provide a performance-optimised version. A slow default implementation is provided, but it will be removed in the future.
+  
+## Internals
+### Entity
+- Unused `NameTag` tag is no longer saved for `Human` entities.
+
+### Inventory
+- `BaseInventory` now uses a new internal method `getMatchingItemCount()` to locate items in the inventory without useless cloning. This improves performance of various API methods, such as `addItem()`, `contains()`, and more.
+- Specialization of `Inventory->isSlotEmpty()` in `BaseInventory` subclasses has been added to improve performance of some API methods.
+
+### Network
+- `RuntimeBlockMapping` no longer keeps all block palette NBT data in memory.
+  - This significantly reduces server idle memory footprint.
+  - For multi-version implementations, this will have a significant impact on memory usage, since a different block palette is often required to support each version.
+  - NBT will be lazy-loaded into memory and cached if `getBedrockKnownStates()` is called. However, this is not used by PocketMine-MP under normal circumstances.
+- Removed unnecessary usage of `Utils::validateCallableSignature()` from some internal network pathways, improving performance.
+
+### Scheduler
+- `AsyncPool` no longer double-checks progress updates on completed tasks.
+
+### World
+- Ticking chunks are now tracked in `World->validTickingChunks` and `World->recheckTickingChunks`.
+    - This allows avoiding rechecking every ticking chunk for validity during ticking chunk selection, improving performance.
+    - In some cases, this allows bypassing chunk selection entirely, reducing selection cost to zero.
+- Registered but ineligible ticking chunks are no longer rechecked every tick.
+    - This was causing wasted cycles during async worker backlog.
+    - The internal system must call `markTickingChunkForRecheck()` whenever a ticking chunk's eligibility for ticking has potentially changed, rather than just when it has changed from a yes to a no.
+
+# 4.21.1
+Released 30th May 2023.
+
+## Fixes
+- Fixed server crash due to a bug in upstream dependency [`netresearch/jsonmapper`](https://github.com/cweiske/JsonMapper).

changelogs/4.22.md

@@ -0,0 +1,24 @@
+# 4.22.0
+Released 7th June 2023.
+
+**For Minecraft: Bedrock Edition 1.20.0**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.0.
+
+**Plugin compatibility:** Plugins for previous 4.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**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.
+
+## Interim releases
+If you're upgrading from 4.20.x directly to 4.22.x, please also read the following changelogs, as the interim releases contain important changes:
+- [4.21.0](https://github.com/pmmp/PocketMine-MP/blob/4.22.0/changelogs/4.21.md#4210) - PHP 8.1 minimum version, minor performance improvements
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.0.
+- Removed support for older versions.
+
+## Fixes
+- Removed deprecated `ReflectionProperty::setAccessible()` calls.
+- Fixed jukebox music not stopping when destroyed by an explosion.

composer.json

@@ -5,7 +5,7 @@
    "homepage": "https://pmmp.io",
    "license": "LGPL-3.0",
    "require": {
-      "php": "^8.0",
+      "php": "^8.1",
       "php-64bit": "*",
       "ext-chunkutils2": "^0.3.1",
       "ext-crypto": "^0.3.1",
@@ -33,17 +33,17 @@
       "composer-runtime-api": "^2.0",
       "adhocore/json-comment": "^1.1",
       "fgrosse/phpasn1": "^2.3",
-      "netresearch/jsonmapper": "^4.0",
-      "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/netresearch-jsonmapper": "~v4.2.999",
+      "pocketmine/bedrock-block-upgrade-schema": "~2.2.0+bedrock-1.20.0",
+      "pocketmine/bedrock-data": "~2.3.0+bedrock-1.20.0",
+      "pocketmine/bedrock-item-upgrade-schema": "~1.3.0+bedrock-1.20.0",
+      "pocketmine/bedrock-protocol": "~22.0.0+bedrock-1.20.0",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/classloader": "^0.2.0",
       "pocketmine/color": "^0.3.0",
       "pocketmine/errorhandler": "^0.6.0",
-      "pocketmine/locale-data": "~2.18.0",
+      "pocketmine/locale-data": "~2.19.0",
       "pocketmine/log": "^0.4.0",
       "pocketmine/log-pthreads": "^0.4.0",
       "pocketmine/math": "^0.4.0",
@@ -56,10 +56,10 @@
       "webmozart/path-util": "^2.3"
    },
    "require-dev": {
-      "phpstan/phpstan": "1.10.6",
+      "phpstan/phpstan": "1.10.15",
       "phpstan/phpstan-phpunit": "^1.1.0",
       "phpstan/phpstan-strict-rules": "^1.2.0",
-      "phpunit/phpunit": "^9.2"
+      "phpunit/phpunit": "^10.1"
    },
    "autoload": {
       "psr-4": {
@@ -77,7 +77,7 @@
    },
    "config": {
       "platform": {
-         "php": "8.0.0"
+         "php": "8.1.0"
       },
       "sort-packages": true
    },

phpstan.neon.dist

@@ -5,7 +5,6 @@ includes:
 	- tests/phpstan/configs/impossible-generics.neon
 	- tests/phpstan/configs/php-bugs.neon
 	- tests/phpstan/configs/phpstan-bugs.neon
-	- tests/phpstan/configs/runtime-type-checks.neon
 	- tests/phpstan/configs/spl-fixed-array-sucks.neon
 	- vendor/phpstan/phpstan-phpunit/extension.neon
 	- vendor/phpstan/phpstan-phpunit/rules.neon

resources/pocketmine.yml

@@ -85,8 +85,11 @@ network:
   batch-threshold: 256
   #Compression level used when sending batched packets. Higher = more CPU, less bandwidth usage
   compression-level: 6
-  #Use AsyncTasks for compression. Adds half/one tick delay, less CPU load on main thread
+  #Use AsyncTasks for compression during the main game session. Increases latency, but may reduce main thread load
   async-compression: false
+  #Threshold for async compression, in bytes. Only packets larger than this will be compressed asynchronously
+  #Due to large overhead of AsyncTask, async compression isn't worth it except for large packets
+  async-compression-threshold: 10000
   #Experimental. Use UPnP to automatically port forward
   upnp-forwarding: false
   #Maximum size in bytes of packets sent over the network (default 1492 bytes). Packets larger than this will be

src/MemoryManager.php

@@ -316,9 +316,6 @@ class MemoryManager{
 					continue;
 				}
 
-				if(!$property->isPublic()){
-					$property->setAccessible(true);
-				}
 				if(!$property->isInitialized()){
 					continue;
 				}
@@ -442,9 +439,6 @@ class MemoryManager{
 									continue;
 								}
 							}
-							if(!$property->isPublic()){
-								$property->setAccessible(true);
-							}
 							if(!$property->isInitialized($object)){
 								continue;
 							}

src/PocketMine.php

@@ -50,7 +50,7 @@ namespace pocketmine {
 
 	require_once __DIR__ . '/VersionInfo.php';
 
-	const MIN_PHP_VERSION = "8.0.0";
+	const MIN_PHP_VERSION = "8.1.0";
 
 	/**
 	 * @param string $message
@@ -265,9 +265,6 @@ JIT_WARNING
 				exit(1);
 			}
 		}
-		if(extension_loaded('parallel')){
-			\parallel\bootstrap(\pocketmine\COMPOSER_AUTOLOADER_PATH);
-		}
 
 		ErrorToExceptionHandler::set();
 

src/Server.php

@@ -208,6 +208,8 @@ class Server{
 	private const TICKS_PER_TPS_OVERLOAD_WARNING = 5 * self::TARGET_TICKS_PER_SECOND;
 	private const TICKS_PER_STATS_REPORT = 300 * self::TARGET_TICKS_PER_SECOND;
 
+	private const DEFAULT_ASYNC_COMPRESSION_THRESHOLD = 10_000;
+
 	private static ?Server $instance = null;
 
 	private TimeTrackingSleeperHandler $tickSleeper;
@@ -266,6 +268,7 @@ class Server{
 
 	private Network $network;
 	private bool $networkCompressionAsync = true;
+	private int $networkCompressionAsyncThreshold = self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD;
 
 	private Language $language;
 	private bool $forceLanguage = false;
@@ -908,6 +911,10 @@ class Server{
 			ZlibCompressor::setInstance(new ZlibCompressor($netCompressionLevel, $netCompressionThreshold, ZlibCompressor::DEFAULT_MAX_DECOMPRESSION_SIZE));
 
 			$this->networkCompressionAsync = $this->configGroup->getPropertyBool("network.async-compression", true);
+			$this->networkCompressionAsyncThreshold = max(
+				$this->configGroup->getPropertyInt("network.async-compression-threshold", self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD),
+				$netCompressionThreshold ?? self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD
+			);
 
 			EncryptionContext::$ENABLED = $this->configGroup->getPropertyBool("network.enable-encryption", true);
 
@@ -1375,7 +1382,7 @@ class Server{
 			}
 
 			$promise = new CompressBatchPromise();
-			if(!$sync){
+			if(!$sync && strlen($buffer) >= $this->networkCompressionAsyncThreshold){
 				$task = new CompressBatchTask($buffer, $promise, $compressor);
 				$this->asyncPool->submitTask($task);
 			}else{

src/VersionInfo.php

@@ -31,9 +31,9 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "4.18.0-ALPHA1";
+	public const BASE_VERSION = "4.22.0";
 	public const IS_DEVELOPMENT_BUILD = false;
-	public const BUILD_CHANNEL = "alpha";
+	public const BUILD_CHANNEL = "stable";
 
 	private function __construct(){
 		//NOOP

src/block/BaseSign.php

@@ -97,6 +97,15 @@ abstract class BaseSign extends Transparent{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
+	public function onPostPlace() : void{
+		$player = $this->editorEntityRuntimeId !== null ?
+			$this->position->getWorld()->getEntity($this->editorEntityRuntimeId) :
+			null;
+		if($player instanceof Player){
+			$player->openSignEditor($this->position);
+		}
+	}
+
 	/**
 	 * Returns an object containing information about the sign text.
 	 */
@@ -110,6 +119,19 @@ abstract class BaseSign extends Transparent{
 		return $this;
 	}
 
+	/**
+	 * Sets the runtime entity ID of the player editing this sign. Only this player will be able to edit the sign.
+	 * This is used to prevent multiple players from editing the same sign at the same time, and to prevent players
+	 * from editing signs they didn't place.
+	 */
+	public function getEditorEntityRuntimeId() : ?int{ return $this->editorEntityRuntimeId; }
+
+	/** @return $this */
+	public function setEditorEntityRuntimeId(?int $editorEntityRuntimeId) : self{
+		$this->editorEntityRuntimeId = $editorEntityRuntimeId;
+		return $this;
+	}
+
 	/**
 	 * Called by the player controller (network session) to update the sign text, firing events as appropriate.
 	 *
@@ -133,6 +155,7 @@ abstract class BaseSign extends Transparent{
 		$ev->call();
 		if(!$ev->isCancelled()){
 			$this->setText($ev->getNewText());
+			$this->setEditorEntityRuntimeId(null);
 			$this->position->getWorld()->setBlock($this->position, $this);
 			return true;
 		}

src/block/Farmland.php

@@ -64,7 +64,7 @@ class Farmland extends Transparent{
 	 * @return AxisAlignedBB[]
 	 */
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()]; //TODO: this should be trimmed at the top by 1/16, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
+		return [AxisAlignedBB::one()->trim(Facing::UP, 1 / 16)];
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/GrassPath.php

@@ -33,7 +33,7 @@ class GrassPath extends Transparent{
 	 * @return AxisAlignedBB[]
 	 */
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()]; //TODO: this should be trimmed at the top by 1/16, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
+		return [AxisAlignedBB::one()->trim(Facing::UP, 1 / 16)];
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/inventory/DoubleChestInventory.php

@@ -85,6 +85,20 @@ class DoubleChestInventory extends BaseInventory implements BlockInventory, Inve
 		$this->right->setContents($rightContents);
 	}
 
+	protected function getMatchingItemCount(int $slot, Item $test, bool $checkDamage, bool $checkTags) : int{
+		$leftSize = $this->left->getSize();
+		return $slot < $leftSize ?
+			$this->left->getMatchingItemCount($slot, $test, $checkDamage, $checkTags) :
+			$this->right->getMatchingItemCount($slot - $leftSize, $test, $checkDamage, $checkTags);
+	}
+
+	public function isSlotEmpty(int $index) : bool{
+		$leftSize = $this->left->getSize();
+		return $index < $leftSize ?
+			$this->left->isSlotEmpty($index) :
+			$this->right->isSlotEmpty($index - $leftSize);
+	}
+
 	protected function getOpenSound() : Sound{ return new ChestOpenSound(); }
 
 	protected function getCloseSound() : Sound{ return new ChestCloseSound(); }

src/block/tile/Jukebox.php

@@ -26,6 +26,7 @@ namespace pocketmine\block\tile;
 use pocketmine\item\Item;
 use pocketmine\item\Record;
 use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\world\sound\RecordStopSound;
 
 class Jukebox extends Spawnable{
 	private const TAG_RECORD = "RecordItem"; //Item CompoundTag
@@ -61,4 +62,8 @@ class Jukebox extends Spawnable{
 			$nbt->setTag(self::TAG_RECORD, $this->record->nbtSerialize());
 		}
 	}
+
+	protected function onBlockDestroyedHook() : void{
+		$this->position->getWorld()->addSound($this->position, new RecordStopSound());
+	}
 }

src/block/tile/Sign.php

@@ -45,12 +45,18 @@ class Sign extends Spawnable{
 	public const TAG_TEXT_LINE = "Text%d"; //sprintf()able
 	public const TAG_TEXT_COLOR = "SignTextColor";
 	public const TAG_GLOWING_TEXT = "IgnoreLighting";
+	public const TAG_PERSIST_FORMATTING = "PersistFormatting"; //TAG_Byte
 	/**
 	 * This tag is set to indicate that MCPE-117835 has been addressed in whatever version this sign was created.
 	 * @see https://bugs.mojang.com/browse/MCPE-117835
 	 */
 	public const TAG_LEGACY_BUG_RESOLVE = "TextIgnoreLegacyBugResolved";
 
+	public const TAG_FRONT_TEXT = "FrontText"; //TAG_Compound
+	public const TAG_BACK_TEXT = "BackText"; //TAG_Compound
+	public const TAG_WAXED = "IsWaxed"; //TAG_Byte
+	public const TAG_LOCKED_FOR_EDITING_BY = "LockedForEditingBy"; //TAG_Long
+
 	/**
 	 * @return string[]
 	 */
@@ -118,12 +124,22 @@ class Sign extends Spawnable{
 	}
 
 	protected function addAdditionalSpawnData(CompoundTag $nbt) : void{
-		$nbt->setString(self::TAG_TEXT_BLOB, implode("\n", $this->text->getLines()));
-
-		//the following are not yet used by the server, but needed to roll back any changes to glowing state or colour
-		//if the client uses dye on the sign
-		$nbt->setInt(self::TAG_TEXT_COLOR, Binary::signInt(0xff_00_00_00));
-		$nbt->setByte(self::TAG_GLOWING_TEXT, 0);
-		$nbt->setByte(self::TAG_LEGACY_BUG_RESOLVE, 1);
+		$textPolyfill = function(CompoundTag $textTag) : CompoundTag{
+			//the following are not yet used by the server, but needed to roll back any changes to glowing state or colour
+			//if the client uses dye on the sign
+			return $textTag
+				->setInt(self::TAG_TEXT_COLOR, Binary::signInt(0xff_00_00_00))
+				->setByte(self::TAG_GLOWING_TEXT, 0)
+				->setByte(self::TAG_PERSIST_FORMATTING, 1); //TODO: not sure what this is used for
+		};
+		$nbt->setTag(self::TAG_FRONT_TEXT, $textPolyfill(CompoundTag::create()
+			->setString(self::TAG_TEXT_BLOB, implode("\n", $this->text->getLines()))
+		));
+		//TODO: this is not yet used by the server, but needed to rollback any client-side changes to the back text
+		$nbt->setTag(self::TAG_BACK_TEXT, $textPolyfill(CompoundTag::create()
+			->setString(self::TAG_TEXT_BLOB, "")
+		));
+		$nbt->setByte(self::TAG_WAXED, 0);
+		$nbt->setLong(self::TAG_LOCKED_FOR_EDITING_BY, $this->editorEntityRuntimeId ?? -1);
 	}
 }

src/command/Command.php

@@ -139,7 +139,7 @@ abstract class Command{
 	public function setLabel(string $name) : bool{
 		$this->nextLabel = $name;
 		if(!$this->isRegistered()){
-			$this->timings = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Command: " . $name);
+			$this->timings = new TimingsHandler("Command: " . $name, group: Timings::GROUP_BREAKDOWN);
 			$this->label = $name;
 
 			return true;

src/command/defaults/StatusCommand.php

@@ -110,7 +110,8 @@ class StatusCommand extends VanillaCommand{
 			$worldName = $world->getFolderName() !== $world->getDisplayName() ? " (" . $world->getDisplayName() . ")" : "";
 			$timeColor = $world->getTickRateTime() > 40 ? TextFormat::RED : TextFormat::YELLOW;
 			$sender->sendMessage(TextFormat::GOLD . "World \"{$world->getFolderName()}\"$worldName: " .
-				TextFormat::RED . number_format(count($world->getLoadedChunks())) . TextFormat::GREEN . " chunks, " .
+				TextFormat::RED . number_format(count($world->getLoadedChunks())) . TextFormat::GREEN . " loaded chunks, " .
+				TextFormat::RED . number_format(count($world->getTickingChunks())) . TextFormat::GREEN . " ticking chunks, " .
 				TextFormat::RED . number_format(count($world->getEntities())) . TextFormat::GREEN . " entities. " .
 				"Time $timeColor" . round($world->getTickRateTime(), 2) . "ms"
 			);

src/command/defaults/TimingsCommand.php

@@ -167,6 +167,7 @@ class TimingsCommand extends VanillaCommand{
 							Command::broadcastCommandMessage($sender, KnownTranslationFactory::pocketmine_command_timings_timingsRead(
 								"https://" . $host . "/?id=" . $response["id"]));
 						}else{
+							$sender->getServer()->getLogger()->debug("Invalid response from timings server (" . $result->getCode() . "): " . $result->getBody());
 							Command::broadcastCommandMessage($sender, KnownTranslationFactory::pocketmine_command_timings_pasteError());
 						}
 					}

src/crafting/CraftingManager.php

@@ -45,11 +45,17 @@ class CraftingManager{
 	 */
 	protected $shapelessRecipes = [];
 
+	/**
+	 * @var CraftingRecipe[]
+	 * @phpstan-var array<int, CraftingRecipe>
+	 */
+	private array $craftingRecipeIndex = [];
+
 	/**
 	 * @var FurnaceRecipeManager[]
 	 * @phpstan-var array<int, FurnaceRecipeManager>
 	 */
-	protected $furnaceRecipeManagers;
+	protected $furnaceRecipeManagers = [];
 
 	/**
 	 * @var PotionTypeRecipe[][]
@@ -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/crash/CrashDump.php

@@ -248,7 +248,6 @@ class CrashDump{
 			if(file_exists($filePath)){
 				$reflection = new \ReflectionClass(PluginBase::class);
 				$file = $reflection->getProperty("file");
-				$file->setAccessible(true);
 				foreach($this->server->getPluginManager()->getPlugins() as $plugin){
 					$filePath = Filesystem::cleanPath($file->getValue($plugin));
 					if(str_starts_with($frameCleanPath, $filePath)){

src/entity/Entity.php

@@ -115,6 +115,8 @@ abstract class Entity{
 	/** @var Block[]|null */
 	protected $blocksAround;
 
+	private bool $checkBlockIntersectionsNextTick = true;
+
 	/** @var Location */
 	protected $location;
 	/** @var Location */
@@ -246,7 +248,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();
@@ -649,7 +651,10 @@ abstract class Entity{
 
 		$hasUpdate = false;
 
-		$this->checkBlockIntersections();
+		if($this->checkBlockIntersectionsNextTick){
+			$this->checkBlockIntersections();
+		}
+		$this->checkBlockIntersectionsNextTick = true;
 
 		if($this->location->y <= World::Y_MIN - 16 && $this->isAlive()){
 			$ev = new EntityDamageEvent($this, EntityDamageEvent::CAUSE_VOID, 10);
@@ -1139,6 +1144,7 @@ abstract class Entity{
 		$this->blocksAround = null;
 
 		Timings::$entityMove->startTiming();
+		Timings::$entityMoveCollision->startTiming();
 
 		$wantedX = $dx;
 		$wantedY = $dy;
@@ -1223,6 +1229,7 @@ abstract class Entity{
 
 			$this->boundingBox = $moveBB;
 		}
+		Timings::$entityMoveCollision->stopTiming();
 
 		$this->location = new Location(
 			($this->boundingBox->minX + $this->boundingBox->maxX) / 2,
@@ -1306,6 +1313,7 @@ abstract class Entity{
 	}
 
 	protected function checkBlockIntersections() : void{
+		$this->checkBlockIntersectionsNextTick = false;
 		$vectors = [];
 
 		foreach($this->getBlocksAroundWithEntityInsideActions() as $block){
@@ -1317,10 +1325,12 @@ abstract class Entity{
 			}
 		}
 
-		$vector = Vector3::sum(...$vectors);
-		if($vector->lengthSquared() > 0){
-			$d = 0.014;
-			$this->motion = $this->motion->addVector($vector->normalize()->multiply($d));
+		if(count($vectors) > 0){
+			$vector = Vector3::sum(...$vectors);
+			if($vector->lengthSquared() > 0){
+				$d = 0.014;
+				$this->motion = $this->motion->addVector($vector->normalize()->multiply($d));
+			}
 		}
 	}
 

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

@@ -92,7 +92,6 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 	private const TAG_XP_PROGRESS = "XpP"; //TAG_Float
 	private const TAG_LIFETIME_XP_TOTAL = "XpTotal"; //TAG_Int
 	private const TAG_XP_SEED = "XpSeed"; //TAG_Int
-	private const TAG_NAME_TAG = "NameTag"; //TAG_String
 	private const TAG_SKIN = "Skin"; //TAG_Compound
 	private const TAG_SKIN_NAME = "Name"; //TAG_String
 	private const TAG_SKIN_DATA = "Data"; //TAG_ByteArray
@@ -245,10 +244,6 @@ class Human extends Living implements ProjectileSource, InventoryHolder{
 	 * For Human entities which are not players, sets their properties such as nametag, skin and UUID from NBT.
 	 */
 	protected function initHumanData(CompoundTag $nbt) : void{
-		if(($nameTagTag = $nbt->getTag(self::TAG_NAME_TAG)) instanceof StringTag){
-			$this->setNameTag($nameTagTag->getValue());
-		}
-
 		//TODO: use of NIL UUID for namespace is a hack; we should provide a proper UUID for the namespace
 		$this->uuid = Uuid::uuid3(Uuid::NIL, ((string) $this->getId()) . $this->skin->getSkinData() . $this->getNameTag());
 	}

src/entity/object/ExperienceOrb.php

@@ -32,6 +32,7 @@ use pocketmine\network\mcpe\protocol\types\entity\EntityIds;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataCollection;
 use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataProperties;
 use pocketmine\player\Player;
+use function max;
 use function sqrt;
 
 class ExperienceOrb extends Entity{
@@ -48,6 +49,10 @@ class ExperienceOrb extends Entity{
 	/** Split sizes used for dropping experience orbs. */
 	public const ORB_SPLIT_SIZES = [2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]; //This is indexed biggest to smallest so that we can return as soon as we found the biggest value.
 
+	public const DEFAULT_DESPAWN_DELAY = 6000;
+	public const NEVER_DESPAWN = -1;
+	public const MAX_DESPAWN_DELAY = 32767 + self::DEFAULT_DESPAWN_DELAY; //max value storable by mojang NBT :(
+
 	/**
 	 * Returns the largest size of normal XP orb that will be spawned for the specified amount of XP. Used to split XP
 	 * up into multiple orbs when an amount of XP is dropped.
@@ -82,7 +87,10 @@ class ExperienceOrb extends Entity{
 	public $gravity = 0.04;
 	public $drag = 0.02;
 
-	/** @var int */
+	/**
+	 * @var int
+	 * @deprecated
+	 */
 	protected $age = 0;
 
 	/**
@@ -100,6 +108,8 @@ class ExperienceOrb extends Entity{
 	/** @var int */
 	protected $xpValue;
 
+	private int $despawnDelay = self::DEFAULT_DESPAWN_DELAY;
+
 	public function __construct(Location $location, int $xpValue, ?CompoundTag $nbt = null){
 		$this->xpValue = $xpValue;
 		parent::__construct($location, $nbt);
@@ -111,12 +121,22 @@ class ExperienceOrb extends Entity{
 		parent::initEntity($nbt);
 
 		$this->age = $nbt->getShort(self::TAG_AGE, 0);
+		if($this->age === -32768){
+			$this->despawnDelay = self::NEVER_DESPAWN;
+		}else{
+			$this->despawnDelay = max(0, self::DEFAULT_DESPAWN_DELAY - $this->age);
+		}
 	}
 
 	public function saveNBT() : CompoundTag{
 		$nbt = parent::saveNBT();
 
-		$nbt->setShort(self::TAG_AGE, $this->age);
+		if($this->despawnDelay === self::NEVER_DESPAWN){
+			$age = -32768;
+		}else{
+			$age = self::DEFAULT_DESPAWN_DELAY - $this->despawnDelay;
+		}
+		$nbt->setShort(self::TAG_AGE, $age);
 
 		$nbt->setShort(self::TAG_VALUE_PC, $this->getXpValue());
 		$nbt->setInt(self::TAG_VALUE_PE, $this->getXpValue());
@@ -124,6 +144,15 @@ class ExperienceOrb extends Entity{
 		return $nbt;
 	}
 
+	public function getDespawnDelay() : int{ return $this->despawnDelay; }
+
+	public function setDespawnDelay(int $despawnDelay) : void{
+		if(($despawnDelay < 0 || $despawnDelay > self::MAX_DESPAWN_DELAY) && $despawnDelay !== self::NEVER_DESPAWN){
+			throw new \InvalidArgumentException("Despawn ticker must be in range 0 ... " . self::MAX_DESPAWN_DELAY . " or " . self::NEVER_DESPAWN . ", got $despawnDelay");
+		}
+		$this->despawnDelay = $despawnDelay;
+	}
+
 	public function getXpValue() : int{
 		return $this->xpValue;
 	}
@@ -161,7 +190,8 @@ class ExperienceOrb extends Entity{
 		$hasUpdate = parent::entityBaseTick($tickDiff);
 
 		$this->age += $tickDiff;
-		if($this->age > 6000){
+		$this->despawnDelay -= $tickDiff;
+		if($this->despawnDelay <= 0){
 			$this->flagForDespawn();
 			return true;
 		}

src/entity/object/ItemEntity.php

@@ -41,6 +41,7 @@ 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{
@@ -113,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;
 	}
 
 	/**

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/Event.php

@@ -26,6 +26,7 @@ declare(strict_types=1);
  */
 namespace pocketmine\event;
 
+use pocketmine\timings\Timings;
 use function get_class;
 
 abstract class Event{
@@ -51,22 +52,19 @@ abstract class Event{
 			throw new \RuntimeException("Recursive event call detected (reached max depth of " . self::MAX_EVENT_CALL_DEPTH . " calls)");
 		}
 
+		$timings = Timings::getEventTimings($this);
+		$timings->startTiming();
+
 		$handlerList = HandlerListManager::global()->getListFor(get_class($this));
 
 		++self::$eventCallDepth;
 		try{
-			foreach(EventPriority::ALL as $priority){
-				$currentList = $handlerList;
-				while($currentList !== null){
-					foreach($currentList->getListenersByPriority($priority) as $registration){
-						$registration->callEvent($this);
-					}
-
-					$currentList = $currentList->getParent();
-				}
+			foreach($handlerList->getListenerList() as $registration){
+				$registration->callEvent($this);
 			}
 		}finally{
 			--self::$eventCallDepth;
+			$timings->stopTiming();
 		}
 	}
 }

src/event/EventPriority.php

@@ -32,6 +32,8 @@ use function mb_strtoupper;
  * LOWEST -> LOW -> NORMAL -> HIGH -> HIGHEST -> MONITOR
  *
  * MONITOR events should not change the event outcome or contents
+ *
+ * WARNING: If these values are changed, handler sorting in HandlerList::getListenerList() may need to be updated.
  */
 final class EventPriority{
 

src/event/HandlerList.php

@@ -24,13 +24,20 @@ declare(strict_types=1);
 namespace pocketmine\event;
 
 use pocketmine\plugin\Plugin;
-use function array_fill_keys;
+use function array_merge;
+use function krsort;
 use function spl_object_id;
+use const SORT_NUMERIC;
 
 class HandlerList{
 	/** @var RegisteredListener[][] */
 	private array $handlerSlots = [];
 
+	private RegisteredListenerCache $handlerCache;
+
+	/** @var RegisteredListenerCache[] */
+	private array $affectedHandlerCaches = [];
+
 	/**
 	 * @phpstan-template TEvent of Event
 	 * @phpstan-param class-string<TEvent> $class
@@ -39,7 +46,10 @@ class HandlerList{
 		private string $class,
 		private ?HandlerList $parentList
 	){
-		$this->handlerSlots = array_fill_keys(EventPriority::ALL, []);
+		$this->handlerCache = new RegisteredListenerCache();
+		for($list = $this; $list !== null; $list = $list->parentList){
+			$list->affectedHandlerCaches[spl_object_id($this->handlerCache)] = $this->handlerCache;
+		}
 	}
 
 	/**
@@ -50,6 +60,7 @@ class HandlerList{
 			throw new \InvalidArgumentException("This listener is already registered to priority {$listener->getPriority()} of event {$this->class}");
 		}
 		$this->handlerSlots[$listener->getPriority()][spl_object_id($listener)] = $listener;
+		$this->invalidateAffectedCaches();
 	}
 
 	/**
@@ -59,6 +70,7 @@ class HandlerList{
 		foreach($listeners as $listener){
 			$this->register($listener);
 		}
+		$this->invalidateAffectedCaches();
 	}
 
 	/**
@@ -76,24 +88,60 @@ class HandlerList{
 				}
 			}
 		}elseif($object instanceof RegisteredListener){
-			if(isset($this->handlerSlots[$object->getPriority()][spl_object_id($object)])){
-				unset($this->handlerSlots[$object->getPriority()][spl_object_id($object)]);
-			}
+			unset($this->handlerSlots[$object->getPriority()][spl_object_id($object)]);
 		}
+		$this->invalidateAffectedCaches();
 	}
 
 	public function clear() : void{
-		$this->handlerSlots = array_fill_keys(EventPriority::ALL, []);
+		$this->handlerSlots = [];
+		$this->invalidateAffectedCaches();
 	}
 
 	/**
 	 * @return RegisteredListener[]
 	 */
 	public function getListenersByPriority(int $priority) : array{
-		return $this->handlerSlots[$priority];
+		return $this->handlerSlots[$priority] ?? [];
 	}
 
 	public function getParent() : ?HandlerList{
 		return $this->parentList;
 	}
+
+	/**
+	 * Invalidates all known caches which might be affected by this list's contents.
+	 */
+	private function invalidateAffectedCaches() : void{
+		foreach($this->affectedHandlerCaches as $cache){
+			$cache->list = null;
+		}
+	}
+
+	/**
+	 * @return RegisteredListener[]
+	 * @phpstan-return list<RegisteredListener>
+	 */
+	public function getListenerList() : array{
+		if($this->handlerCache->list !== null){
+			return $this->handlerCache->list;
+		}
+
+		$handlerLists = [];
+		for($currentList = $this; $currentList !== null; $currentList = $currentList->parentList){
+			$handlerLists[] = $currentList;
+		}
+
+		$listenersByPriority = [];
+		foreach($handlerLists as $currentList){
+			foreach($currentList->handlerSlots as $priority => $listeners){
+				$listenersByPriority[$priority] = array_merge($listenersByPriority[$priority] ?? [], $listeners);
+			}
+		}
+
+		//TODO: why on earth do the priorities have higher values for lower priority?
+		krsort($listenersByPriority, SORT_NUMERIC);
+
+		return $this->handlerCache->list = array_merge(...$listenersByPriority);
+	}
 }

src/event/RegisteredListener.php

@@ -57,8 +57,11 @@ class RegisteredListener{
 			return;
 		}
 		$this->timings->startTiming();
-		($this->handler)($event);
-		$this->timings->stopTiming();
+		try{
+			($this->handler)($event);
+		}finally{
+			$this->timings->stopTiming();
+		}
 	}
 
 	public function isHandlingCancelled() : bool{

src/event/RegisteredListenerCache.php

@@ -0,0 +1,38 @@
+<?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;
+
+/**
+ * @internal
+ */
+final class RegisteredListenerCache{
+
+	/**
+	 * List of all handlers that will be called for a particular event, ordered by execution order.
+	 *
+	 * @var RegisteredListener[]
+	 * @phpstan-var list<RegisteredListener>
+	 */
+	public ?array $list = null;
+}

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/inventory/BaseInventory.php

@@ -108,13 +108,23 @@ abstract class BaseInventory implements Inventory{
 		$this->onContentChange($oldContents);
 	}
 
+	/**
+	 * Helper for utility functions which search the inventory.
+	 * TODO: make this abstract instead of providing a slow default implementation (BC break)
+	 */
+	protected function getMatchingItemCount(int $slot, Item $test, bool $checkDamage, bool $checkTags) : int{
+		$item = $this->getItem($slot);
+		return $item->equals($test, $checkDamage, $checkTags) ? $item->getCount() : 0;
+	}
+
 	public function contains(Item $item) : bool{
 		$count = max(1, $item->getCount());
 		$checkDamage = !$item->hasAnyDamageValue();
 		$checkTags = $item->hasNamedTag();
-		foreach($this->getContents() as $i){
-			if($item->equals($i, $checkDamage, $checkTags)){
-				$count -= $i->getCount();
+		for($i = 0, $size = $this->getSize(); $i < $size; $i++){
+			$slotCount = $this->getMatchingItemCount($i, $item, $checkDamage, $checkTags);
+			if($slotCount > 0){
+				$count -= $slotCount;
 				if($count <= 0){
 					return true;
 				}
@@ -128,9 +138,9 @@ abstract class BaseInventory implements Inventory{
 		$slots = [];
 		$checkDamage = !$item->hasAnyDamageValue();
 		$checkTags = $item->hasNamedTag();
-		foreach($this->getContents() as $index => $i){
-			if($item->equals($i, $checkDamage, $checkTags)){
-				$slots[$index] = $i;
+		for($i = 0, $size = $this->getSize(); $i < $size; $i++){
+			if($this->getMatchingItemCount($i, $item, $checkDamage, $checkTags) > 0){
+				$slots[$i] = $this->getItem($i);
 			}
 		}
 
@@ -142,18 +152,9 @@ abstract class BaseInventory implements Inventory{
 		$checkDamage = $exact || !$item->hasAnyDamageValue();
 		$checkTags = $exact || $item->hasNamedTag();
 
-		foreach($this->getContents() as $index => $i){
-			if($item->equals($i, $checkDamage, $checkTags) && ($i->getCount() === $count || (!$exact && $i->getCount() > $count))){
-				return $index;
-			}
-		}
-
-		return -1;
-	}
-
-	public function firstEmpty() : int{
-		foreach($this->getContents(true) as $i => $slot){
-			if($slot->isNull()){
+		for($i = 0, $size = $this->getSize(); $i < $size; $i++){
+			$slotCount = $this->getMatchingItemCount($i, $item, $checkDamage, $checkTags);
+			if($slotCount > 0 && ($slotCount === $count || (!$exact && $slotCount > $count))){
 				return $i;
 			}
 		}
@@ -161,6 +162,20 @@ abstract class BaseInventory implements Inventory{
 		return -1;
 	}
 
+	public function firstEmpty() : int{
+		for($i = 0, $size = $this->getSize(); $i < $size; $i++){
+			if($this->isSlotEmpty($i)){
+				return $i;
+			}
+		}
+
+		return -1;
+	}
+
+	/**
+	 * TODO: make this abstract and force implementations to implement it properly (BC break)
+	 * This default implementation works, but is slow.
+	 */
 	public function isSlotEmpty(int $index) : bool{
 		return $this->getItem($index)->isNull();
 	}
@@ -171,14 +186,16 @@ abstract class BaseInventory implements Inventory{
 
 	public function getAddableItemQuantity(Item $item) : int{
 		$count = $item->getCount();
+		$maxStackSize = min($this->getMaxStackSize(), $item->getMaxStackSize());
+
 		for($i = 0, $size = $this->getSize(); $i < $size; ++$i){
-			$slot = $this->getItem($i);
-			if($item->canStackWith($slot)){
-				if(($diff = min($slot->getMaxStackSize(), $item->getMaxStackSize()) - $slot->getCount()) > 0){
+			if($this->isSlotEmpty($i)){
+				$count -= $maxStackSize;
+			}else{
+				$slotCount = $this->getMatchingItemCount($i, $item, true, true);
+				if($slotCount > 0 && ($diff = $maxStackSize - $slotCount) > 0){
 					$count -= $diff;
 				}
-			}elseif($slot->isNull()){
-				$count -= min($this->getMaxStackSize(), $item->getMaxStackSize());
 			}
 
 			if($count <= 0){
@@ -212,22 +229,29 @@ abstract class BaseInventory implements Inventory{
 		return $returnSlots;
 	}
 
-	private function internalAddItem(Item $slot) : Item{
+	private function internalAddItem(Item $newItem) : Item{
 		$emptySlots = [];
 
+		$maxStackSize = min($this->getMaxStackSize(), $newItem->getMaxStackSize());
+
 		for($i = 0, $size = $this->getSize(); $i < $size; ++$i){
-			$item = $this->getItem($i);
-			if($item->isNull()){
+			if($this->isSlotEmpty($i)){
 				$emptySlots[] = $i;
+				continue;
+			}
+			$slotCount = $this->getMatchingItemCount($i, $newItem, true, true);
+			if($slotCount === 0){
+				continue;
 			}
 
-			if($slot->canStackWith($item) && $item->getCount() < $item->getMaxStackSize()){
-				$amount = min($item->getMaxStackSize() - $item->getCount(), $slot->getCount(), $this->getMaxStackSize());
+			if($slotCount < $maxStackSize){
+				$amount = min($maxStackSize - $slotCount, $newItem->getCount());
 				if($amount > 0){
-					$slot->setCount($slot->getCount() - $amount);
-					$item->setCount($item->getCount() + $amount);
-					$this->setItem($i, $item);
-					if($slot->getCount() <= 0){
+					$newItem->setCount($newItem->getCount() - $amount);
+					$slotItem = $this->getItem($i);
+					$slotItem->setCount($slotItem->getCount() + $amount);
+					$this->setItem($i, $slotItem);
+					if($newItem->getCount() <= 0){
 						break;
 					}
 				}
@@ -236,65 +260,67 @@ abstract class BaseInventory implements Inventory{
 
 		if(count($emptySlots) > 0){
 			foreach($emptySlots as $slotIndex){
-				$amount = min($slot->getMaxStackSize(), $slot->getCount(), $this->getMaxStackSize());
-				$slot->setCount($slot->getCount() - $amount);
-				$item = clone $slot;
-				$item->setCount($amount);
-				$this->setItem($slotIndex, $item);
-				if($slot->getCount() <= 0){
+				$amount = min($maxStackSize, $newItem->getCount());
+				$newItem->setCount($newItem->getCount() - $amount);
+				$slotItem = clone $newItem;
+				$slotItem->setCount($amount);
+				$this->setItem($slotIndex, $slotItem);
+				if($newItem->getCount() <= 0){
 					break;
 				}
 			}
 		}
 
-		return $slot;
+		return $newItem;
 	}
 
 	public function remove(Item $item) : void{
 		$checkDamage = !$item->hasAnyDamageValue();
 		$checkTags = $item->hasNamedTag();
 
-		foreach($this->getContents() as $index => $i){
-			if($item->equals($i, $checkDamage, $checkTags)){
-				$this->clear($index);
+		for($i = 0, $size = $this->getSize(); $i < $size; $i++){
+			if($this->getMatchingItemCount($i, $item, $checkDamage, $checkTags) > 0){
+				$this->clear($i);
 			}
 		}
 	}
 
 	public function removeItem(Item ...$slots) : array{
-		/** @var Item[] $itemSlots */
+		/** @var Item[] $searchItems */
 		/** @var Item[] $slots */
-		$itemSlots = [];
+		$searchItems = [];
 		foreach($slots as $slot){
 			if(!$slot->isNull()){
-				$itemSlots[] = clone $slot;
+				$searchItems[] = clone $slot;
 			}
 		}
 
 		for($i = 0, $size = $this->getSize(); $i < $size; ++$i){
-			$item = $this->getItem($i);
-			if($item->isNull()){
+			if($this->isSlotEmpty($i)){
 				continue;
 			}
 
-			foreach($itemSlots as $index => $slot){
-				if($slot->equals($item, !$slot->hasAnyDamageValue(), $slot->hasNamedTag())){
-					$amount = min($item->getCount(), $slot->getCount());
-					$slot->setCount($slot->getCount() - $amount);
-					$item->setCount($item->getCount() - $amount);
-					$this->setItem($i, $item);
-					if($slot->getCount() <= 0){
-						unset($itemSlots[$index]);
+			foreach($searchItems as $index => $search){
+				$slotCount = $this->getMatchingItemCount($i, $search, !$search->hasAnyDamageValue(), $search->hasNamedTag());
+				if($slotCount > 0){
+					$amount = min($slotCount, $search->getCount());
+					$search->setCount($search->getCount() - $amount);
+
+					$slotItem = $this->getItem($i);
+					$slotItem->setCount($slotItem->getCount() - $amount);
+					$this->setItem($i, $slotItem);
+					if($search->getCount() <= 0){
+						unset($searchItems[$index]);
 					}
 				}
 			}
 
-			if(count($itemSlots) === 0){
+			if(count($searchItems) === 0){
 				break;
 			}
 		}
 
-		return $itemSlots;
+		return $searchItems;
 	}
 
 	public function clear(int $index) : void{
@@ -348,7 +374,7 @@ abstract class BaseInventory implements Inventory{
 			if($invManager === null){
 				continue;
 			}
-			$invManager->syncSlot($this, $index);
+			$invManager->onSlotChange($this, $index);
 		}
 	}
 

src/inventory/CreativeInventory.php

@@ -27,6 +27,7 @@ use pocketmine\item\Durable;
 use pocketmine\item\Item;
 use pocketmine\utils\Filesystem;
 use pocketmine\utils\SingletonTrait;
+use pocketmine\utils\Utils;
 use Symfony\Component\Filesystem\Path;
 use function json_decode;
 
@@ -60,11 +61,11 @@ final class CreativeInventory{
 	 * @return Item[]
 	 */
 	public function getAll() : array{
-		return $this->creative;
+		return Utils::cloneObjectArray($this->creative);
 	}
 
 	public function getItem(int $index) : ?Item{
-		return $this->creative[$index] ?? null;
+		return isset($this->creative[$index]) ? clone $this->creative[$index] : null;
 	}
 
 	public function getItemIndex(Item $item) : int{

src/inventory/DelegateInventory.php

@@ -30,6 +30,7 @@ use pocketmine\item\Item;
  */
 class DelegateInventory extends BaseInventory{
 	private InventoryListener $inventoryListener;
+	private bool $backingInventoryChanging = false;
 
 	public function __construct(
 		private Inventory $backingInventory
@@ -39,12 +40,22 @@ class DelegateInventory extends BaseInventory{
 		$this->backingInventory->getListeners()->add($this->inventoryListener = new CallbackInventoryListener(
 			static function(Inventory $unused, int $slot, Item $oldItem) use ($weakThis) : void{
 				if(($strongThis = $weakThis->get()) !== null){
-					$strongThis->onSlotChange($slot, $oldItem);
+					$strongThis->backingInventoryChanging = true;
+					try{
+						$strongThis->onSlotChange($slot, $oldItem);
+					}finally{
+						$strongThis->backingInventoryChanging = false;
+					}
 				}
 			},
 			static function(Inventory $unused, array $oldContents) use ($weakThis) : void{
 				if(($strongThis = $weakThis->get()) !== null){
-					$strongThis->onContentChange($oldContents);
+					$strongThis->backingInventoryChanging = true;
+					try{
+						$strongThis->onContentChange($oldContents);
+					}finally{
+						$strongThis->backingInventoryChanging = false;
+					}
 				}
 			}
 		));
@@ -73,4 +84,20 @@ class DelegateInventory extends BaseInventory{
 	protected function internalSetContents(array $items) : void{
 		$this->backingInventory->setContents($items);
 	}
+
+	public function isSlotEmpty(int $index) : bool{
+		return $this->backingInventory->isSlotEmpty($index);
+	}
+
+	protected function onSlotChange(int $index, Item $before) : void{
+		if($this->backingInventoryChanging){
+			parent::onSlotChange($index, $before);
+		}
+	}
+
+	protected function onContentChange(array $itemsBefore) : void{
+		if($this->backingInventoryChanging){
+			parent::onContentChange($itemsBefore);
+		}
+	}
 }

src/inventory/SimpleInventory.php

@@ -83,4 +83,13 @@ class SimpleInventory extends BaseInventory{
 			}
 		}
 	}
+
+	protected function getMatchingItemCount(int $slot, Item $test, bool $checkDamage, bool $checkTags) : int{
+		$slotItem = $this->slots[$slot];
+		return $slotItem !== null && $slotItem->equals($test, $checkDamage, $checkTags) ? $slotItem->getCount() : 0;
+	}
+
+	public function isSlotEmpty(int $index) : bool{
+		return $this->slots[$index] === null || $this->slots[$index]->isNull();
+	}
 }

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/item/Item.php

@@ -353,30 +353,35 @@ class Item implements \JsonSerializable{
 	}
 
 	protected function serializeCompoundTag(CompoundTag $tag) : void{
-		$display = $tag->getCompoundTag(self::TAG_DISPLAY) ?? new CompoundTag();
+		$display = $tag->getCompoundTag(self::TAG_DISPLAY);
 
-		$this->hasCustomName() ?
-			$display->setString(self::TAG_DISPLAY_NAME, $this->getCustomName()) :
-			$display->removeTag(self::TAG_DISPLAY_NAME);
+		if($this->customName !== ""){
+			$display ??= new CompoundTag();
+			$display->setString(self::TAG_DISPLAY_NAME, $this->customName);
+		}else{
+			$display?->removeTag(self::TAG_DISPLAY_NAME);
+		}
 
 		if(count($this->lore) > 0){
 			$loreTag = new ListTag();
 			foreach($this->lore as $line){
 				$loreTag->push(new StringTag($line));
 			}
+			$display ??= new CompoundTag();
 			$display->setTag(self::TAG_DISPLAY_LORE, $loreTag);
 		}else{
-			$display->removeTag(self::TAG_DISPLAY_LORE);
+			$display?->removeTag(self::TAG_DISPLAY_LORE);
 		}
-		$display->count() > 0 ?
+		$display !== null && $display->count() > 0 ?
 			$tag->setTag(self::TAG_DISPLAY, $display) :
 			$tag->removeTag(self::TAG_DISPLAY);
 
-		if($this->hasEnchantments()){
+		if(count($this->enchantments) > 0){
 			$ench = new ListTag();
-			foreach($this->getEnchantments() as $enchantmentInstance){
+			$enchantmentIdMap = EnchantmentIdMap::getInstance();
+			foreach($this->enchantments as $enchantmentInstance){
 				$ench->push(CompoundTag::create()
-					->setShort(self::TAG_ENCH_ID, EnchantmentIdMap::getInstance()->toId($enchantmentInstance->getType()))
+					->setShort(self::TAG_ENCH_ID, $enchantmentIdMap->toId($enchantmentInstance->getType()))
 					->setShort(self::TAG_ENCH_LVL, $enchantmentInstance->getLevel())
 				);
 			}
@@ -385,8 +390,8 @@ class Item implements \JsonSerializable{
 			$tag->removeTag(self::TAG_ENCH);
 		}
 
-		($blockData = $this->getCustomBlockData()) !== null ?
-			$tag->setTag(self::TAG_BLOCK_ENTITY_TAG, clone $blockData) :
+		$this->blockEntityTag !== null ?
+			$tag->setTag(self::TAG_BLOCK_ENTITY_TAG, clone $this->blockEntityTag) :
 			$tag->removeTag(self::TAG_BLOCK_ENTITY_TAG);
 
 		if(count($this->canPlaceOn) > 0){

src/lang/KnownTranslationFactory.php

@@ -1606,6 +1606,14 @@ final class KnownTranslationFactory{
 		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_BAN_NOREASON, []);
 	}
 
+	public static function pocketmine_disconnect_clientDisconnect() : Translatable{
+		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_CLIENTDISCONNECT, []);
+	}
+
+	public static function pocketmine_disconnect_clientReconnect() : Translatable{
+		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_CLIENTRECONNECT, []);
+	}
+
 	public static function pocketmine_disconnect_error(Translatable|string $error, Translatable|string $errorId) : Translatable{
 		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_ERROR, [
 			"error" => $error,
@@ -1633,6 +1641,10 @@ final class KnownTranslationFactory{
 		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_ERROR_RESPAWN, []);
 	}
 
+	public static function pocketmine_disconnect_error_timeout() : Translatable{
+		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_ERROR_TIMEOUT, []);
+	}
+
 	public static function pocketmine_disconnect_incompatibleProtocol(Translatable|string $param0) : Translatable{
 		return new Translatable(KnownTranslationKeys::POCKETMINE_DISCONNECT_INCOMPATIBLEPROTOCOL, [
 			0 => $param0,

src/lang/KnownTranslationKeys.php

@@ -349,12 +349,15 @@ final class KnownTranslationKeys{
 	public const POCKETMINE_DISCONNECT_BAN_HARDCORE = "pocketmine.disconnect.ban.hardcore";
 	public const POCKETMINE_DISCONNECT_BAN_IP = "pocketmine.disconnect.ban.ip";
 	public const POCKETMINE_DISCONNECT_BAN_NOREASON = "pocketmine.disconnect.ban.noReason";
+	public const POCKETMINE_DISCONNECT_CLIENTDISCONNECT = "pocketmine.disconnect.clientDisconnect";
+	public const POCKETMINE_DISCONNECT_CLIENTRECONNECT = "pocketmine.disconnect.clientReconnect";
 	public const POCKETMINE_DISCONNECT_ERROR = "pocketmine.disconnect.error";
 	public const POCKETMINE_DISCONNECT_ERROR_AUTHENTICATION = "pocketmine.disconnect.error.authentication";
 	public const POCKETMINE_DISCONNECT_ERROR_BADPACKET = "pocketmine.disconnect.error.badPacket";
 	public const POCKETMINE_DISCONNECT_ERROR_INTERNAL = "pocketmine.disconnect.error.internal";
 	public const POCKETMINE_DISCONNECT_ERROR_LOGINTIMEOUT = "pocketmine.disconnect.error.loginTimeout";
 	public const POCKETMINE_DISCONNECT_ERROR_RESPAWN = "pocketmine.disconnect.error.respawn";
+	public const POCKETMINE_DISCONNECT_ERROR_TIMEOUT = "pocketmine.disconnect.error.timeout";
 	public const POCKETMINE_DISCONNECT_INCOMPATIBLEPROTOCOL = "pocketmine.disconnect.incompatibleProtocol";
 	public const POCKETMINE_DISCONNECT_INVALIDSESSION = "pocketmine.disconnect.invalidSession";
 	public const POCKETMINE_DISCONNECT_INVALIDSESSION_BADSIGNATURE = "pocketmine.disconnect.invalidSession.badSignature";

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/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,35 @@ 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;
 			}
+			$inventory = $entry->getInventory();
 			$coreSlotId = $entry->mapNetToCore($netSlotId);
-			return $coreSlotId !== null ? [$entry->getInventory(), $coreSlotId] : null;
+			return $coreSlotId !== null && $inventory->slotExists($coreSlotId) ? [$inventory, $coreSlotId] : null;
 		}
-		if(isset($this->windowMap[$windowId])){
-			return [$this->windowMap[$windowId], $netSlotId];
+		$inventory = $this->networkIdToInventoryMap[$windowId] ?? null;
+		if($inventory !== null && $inventory->slotExists($netSlotId)){
+			return [$inventory, $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 +234,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 +305,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 +362,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 +374,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 +386,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 +408,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 +575,21 @@ class InventoryManager{
 	}
 
 	public function syncSelectedHotbarSlot() : void{
-		$selected = $this->player->getInventory()->getHeldItemIndex();
+		$playerInventory = $this->player->getInventory();
+		$selected = $playerInventory->getHeldItemIndex();
 		if($selected !== $this->clientSelectedHotbarSlot){
+			$inventoryEntry = $this->inventories[spl_object_id($playerInventory)] ?? null;
+			if($inventoryEntry === null){
+				throw new AssumptionFailedError("Player inventory should always be tracked");
+			}
+			$itemStackInfo = $inventoryEntry->itemStackInfos[$selected] ?? null;
+			if($itemStackInfo === null){
+				throw new AssumptionFailedError("Untracked player inventory slot $selected");
+			}
+
 			$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 +601,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 ItemStack[]
+	 * @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

@@ -23,7 +23,6 @@ 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;
@@ -57,13 +56,6 @@ final class NetworkBroadcastUtils{
 				return false;
 			}
 
-			$ev = new DataPacketSendEvent($sessions, $packets);
-			$ev->call();
-			if($ev->isCancelled()){
-				return false;
-			}
-			$sessions = $ev->getTargets();
-
 			/** @var PacketBroadcaster[] $uniqueBroadcasters */
 			$uniqueBroadcasters = [];
 			/** @var NetworkSession[][] $broadcasterTargets */

src/network/mcpe/NetworkSession.php

@@ -60,6 +60,7 @@ use pocketmine\network\mcpe\protocol\DisconnectPacket;
 use pocketmine\network\mcpe\protocol\ModalFormRequestPacket;
 use pocketmine\network\mcpe\protocol\MovePlayerPacket;
 use pocketmine\network\mcpe\protocol\NetworkChunkPublisherUpdatePacket;
+use pocketmine\network\mcpe\protocol\OpenSignPacket;
 use pocketmine\network\mcpe\protocol\Packet;
 use pocketmine\network\mcpe\protocol\PacketDecodeException;
 use pocketmine\network\mcpe\protocol\PacketPool;
@@ -102,10 +103,10 @@ use pocketmine\player\XboxLivePlayerInfo;
 use pocketmine\Server;
 use pocketmine\timings\Timings;
 use pocketmine\utils\AssumptionFailedError;
+use pocketmine\utils\BinaryDataException;
 use pocketmine\utils\BinaryStream;
 use pocketmine\utils\ObjectSet;
 use pocketmine\utils\TextFormat;
-use pocketmine\utils\Utils;
 use pocketmine\world\Position;
 use function array_map;
 use function array_values;
@@ -113,11 +114,8 @@ use function base64_encode;
 use function bin2hex;
 use function count;
 use function get_class;
-use function hrtime;
 use function in_array;
-use function intdiv;
 use function json_encode;
-use function min;
 use function strcasecmp;
 use function strlen;
 use function strtolower;
@@ -127,19 +125,14 @@ use function ucfirst;
 use const JSON_THROW_ON_ERROR;
 
 class NetworkSession{
-	private const INCOMING_PACKET_BATCH_PER_TICK = 2; //usually max 1 per tick, but transactions may arrive separately
-	private const INCOMING_PACKET_BATCH_MAX_BUDGET = 100 * self::INCOMING_PACKET_BATCH_PER_TICK; //enough to account for a 5-second lag spike
+	private const INCOMING_PACKET_BATCH_PER_TICK = 2; //usually max 1 per tick, but transactions arrive separately
+	private const INCOMING_PACKET_BATCH_BUFFER_TICKS = 100; //enough to account for a 5-second lag spike
 
-	/**
-	 * At most this many more packets can be received. If this reaches zero, any additional packets received will cause
-	 * the player to be kicked from the server.
-	 * This number is increased every tick up to a maximum limit.
-	 *
-	 * @see self::INCOMING_PACKET_BATCH_PER_TICK
-	 * @see self::INCOMING_PACKET_BATCH_MAX_BUDGET
-	 */
-	private int $incomingPacketBatchBudget = self::INCOMING_PACKET_BATCH_MAX_BUDGET;
-	private int $lastPacketBudgetUpdateTimeNs;
+	private const INCOMING_GAME_PACKETS_PER_TICK = 2;
+	private const INCOMING_GAME_PACKETS_BUFFER_TICKS = 100;
+
+	private PacketRateLimiter $packetBatchLimiter;
+	private PacketRateLimiter $gamePacketLimiter;
 
 	private \PrefixedLogger $logger;
 	private ?Player $player = null;
@@ -195,7 +188,8 @@ class NetworkSession{
 		$this->disposeHooks = new ObjectSet();
 
 		$this->connectTime = time();
-		$this->lastPacketBudgetUpdateTimeNs = hrtime(true);
+		$this->packetBatchLimiter = new PacketRateLimiter("Packet Batches", self::INCOMING_PACKET_BATCH_PER_TICK, self::INCOMING_PACKET_BATCH_BUFFER_TICKS);
+		$this->gamePacketLimiter = new PacketRateLimiter("Game Packets", self::INCOMING_GAME_PACKETS_PER_TICK, self::INCOMING_GAME_PACKETS_BUFFER_TICKS);
 
 		$this->setHandler(new SessionStartPacketHandler(
 			$this->server,
@@ -338,13 +332,7 @@ class NetworkSession{
 
 		Timings::$playerNetworkReceive->startTiming();
 		try{
-			if($this->incomingPacketBatchBudget <= 0){
-				$this->updatePacketBudget();
-				if($this->incomingPacketBatchBudget <= 0){
-					throw new PacketHandlingException("Receiving packets too fast");
-				}
-			}
-			$this->incomingPacketBatchBudget--;
+			$this->packetBatchLimiter->decrement();
 
 			if($this->cipher !== null){
 				Timings::$playerNetworkReceiveDecrypt->startTiming();
@@ -376,7 +364,8 @@ class NetworkSession{
 				$stream = new BinaryStream($decompressed);
 				$count = 0;
 				foreach(PacketBatch::decodeRaw($stream) as $buffer){
-					if(++$count > 1300){
+					$this->gamePacketLimiter->decrement();
+					if(++$count > 100){
 						throw new PacketHandlingException("Too many packets in batch");
 					}
 					$packet = $this->packetPool->getPacket($buffer);
@@ -391,7 +380,7 @@ class NetworkSession{
 						throw PacketHandlingException::wrap($e, "Error processing " . $packet->getName());
 					}
 				}
-			}catch(PacketDecodeException $e){
+			}catch(PacketDecodeException|BinaryDataException $e){
 				$this->logger->logException($e);
 				throw PacketHandlingException::wrap($e, "Packet batch decode error");
 			}
@@ -561,20 +550,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();
 						}
 					}
 				});
@@ -889,16 +883,29 @@ class NetworkSession{
 			AbilitiesLayer::ABILITY_OPEN_CONTAINERS => !$for->isSpectator(),
 			AbilitiesLayer::ABILITY_ATTACK_PLAYERS => !$for->isSpectator(),
 			AbilitiesLayer::ABILITY_ATTACK_MOBS => !$for->isSpectator(),
+			AbilitiesLayer::ABILITY_PRIVILEGED_BUILDER => false,
 		];
 
+		$layers = [
+			//TODO: dynamic flying speed! FINALLY!!!!!!!!!!!!!!!!!
+			new AbilitiesLayer(AbilitiesLayer::LAYER_BASE, $boolAbilities, 0.05, 0.1),
+		];
+		if(!$for->hasBlockCollision()){
+			//TODO: HACK! In 1.19.80, the client starts falling in our faux spectator mode when it clips into a
+			//block. We can't seem to prevent this short of forcing the player to always fly when block collision is
+			//disabled. Also, for some reason the client always reads flight state from this layer if present, even
+			//though the player isn't in spectator mode.
+
+			$layers[] = new AbilitiesLayer(AbilitiesLayer::LAYER_SPECTATOR, [
+				AbilitiesLayer::ABILITY_FLYING => true,
+			], null, null);
+		}
+
 		$this->sendDataPacket(UpdateAbilitiesPacket::create(new AbilitiesData(
 			$isOp ? CommandPermissions::OPERATOR : CommandPermissions::NORMAL,
 			$isOp ? PlayerPermissions::OPERATOR : PlayerPermissions::MEMBER,
 			$for->getId(),
-			[
-				//TODO: dynamic flying speed! FINALLY!!!!!!!!!!!!!!!!!
-				new AbilitiesLayer(AbilitiesLayer::LAYER_BASE, $boolAbilities, 0.05, 0.1),
-			]
+			$layers
 		)));
 	}
 
@@ -992,8 +999,6 @@ class NetworkSession{
 	 * @phpstan-param \Closure() : void $onCompletion
 	 */
 	public function startUsingChunk(int $chunkX, int $chunkZ, \Closure $onCompletion) : void{
-		Utils::validateCallableSignature(function() : void{}, $onCompletion);
-
 		$world = $this->player->getLocation()->getWorld();
 		ChunkCache::getInstance($world, $this->compressor)->request($chunkX, $chunkZ)->onResolve(
 
@@ -1098,21 +1103,8 @@ class NetworkSession{
 		$this->sendDataPacket(ToastRequestPacket::create($title, $body));
 	}
 
-	private function updatePacketBudget() : void{
-		$nowNs = hrtime(true);
-		$timeSinceLastUpdateNs = $nowNs - $this->lastPacketBudgetUpdateTimeNs;
-		if($timeSinceLastUpdateNs > 50_000_000){
-			$ticksSinceLastUpdate = intdiv($timeSinceLastUpdateNs, 50_000_000);
-			/*
-			 * If the server takes an abnormally long time to process a tick, add the budget for time difference to
-			 * compensate. This extra budget may be very large, but it will disappear the next time a normal update
-			 * occurs. This ensures that backlogs during a large lag spike don't cause everyone to get kicked.
-			 * As long as all the backlogged packets are processed before the next tick, everything should be OK for
-			 * clients behaving normally.
-			 */
-			$this->incomingPacketBatchBudget = min($this->incomingPacketBatchBudget, self::INCOMING_PACKET_BATCH_MAX_BUDGET) + (self::INCOMING_PACKET_BATCH_PER_TICK * 2 * $ticksSinceLastUpdate);
-			$this->lastPacketBudgetUpdateTimeNs = $nowNs;
-		}
+	public function onOpenSignEditor(Vector3 $signPosition, bool $frontSide) : void{
+		$this->sendDataPacket(OpenSignPacket::create(BlockPosition::fromVector3($signPosition), $frontSide));
 	}
 
 	public function tick() : void{
@@ -1140,6 +1132,12 @@ class NetworkSession{
 				$attribute->markSynchronized();
 			}
 		}
+		Timings::$playerNetworkSendInventorySync->startTiming();
+		try{
+			$this->invManager?->flushPendingUpdates();
+		}finally{
+			Timings::$playerNetworkSendInventorySync->stopTiming();
+		}
 
 		$this->flushSendBuffer();
 	}

src/network/mcpe/PacketRateLimiter.php

@@ -0,0 +1,81 @@
+<?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\network\PacketHandlingException;
+use function hrtime;
+use function intdiv;
+use function min;
+
+final class PacketRateLimiter{
+	/**
+	 * At most this many more packets can be received. If this reaches zero, any additional packets received will cause
+	 * the player to be kicked from the server.
+	 * This number is increased every tick up to a maximum limit, and decreased by one every time a packet is received.
+	 */
+	private int $budget;
+	private int $lastUpdateTimeNs;
+	private int $maxBudget;
+
+	public function __construct(
+		private string $name,
+		private int $averagePerTick,
+		int $maxBufferTicks,
+		private int $updateFrequencyNs = 50_000_000,
+	){
+		$this->maxBudget = $this->averagePerTick * $maxBufferTicks;
+		$this->budget = $this->maxBudget;
+		$this->lastUpdateTimeNs = hrtime(true);
+	}
+
+	/**
+	 * @throws PacketHandlingException if the rate limit has been exceeded
+	 */
+	public function decrement(int $amount = 1) : void{
+		if($this->budget <= 0){
+			$this->update();
+			if($this->budget <= 0){
+				throw new PacketHandlingException("Exceeded rate limit for \"$this->name\"");
+			}
+		}
+		$this->budget -= $amount;
+	}
+
+	public function update() : void{
+		$nowNs = hrtime(true);
+		$timeSinceLastUpdateNs = $nowNs - $this->lastUpdateTimeNs;
+		if($timeSinceLastUpdateNs > $this->updateFrequencyNs){
+			$ticksSinceLastUpdate = intdiv($timeSinceLastUpdateNs, $this->updateFrequencyNs);
+			/*
+			 * If the server takes an abnormally long time to process a tick, add the budget for time difference to
+			 * compensate. This extra budget may be very large, but it will disappear the next time a normal update
+			 * occurs. This ensures that backlogs during a large lag spike don't cause everyone to get kicked.
+			 * As long as all the backlogged packets are processed before the next tick, everything should be OK for
+			 * clients behaving normally.
+			 */
+			$this->budget = min($this->budget, $this->maxBudget) + ($this->averagePerTick * 2 * $ticksSinceLastUpdate);
+			$this->lastUpdateTimeNs = $nowNs;
+		}
+	}
+}

src/network/mcpe/StandardEntityEventBroadcaster.php

@@ -138,6 +138,6 @@ final class StandardEntityEventBroadcaster implements EntityEventBroadcaster{
 	}
 
 	public function onEmote(array $recipients, Human $from, string $emoteId) : void{
-		$this->sendDataPacket($recipients, EmotePacket::create($from->getId(), $emoteId, EmotePacket::FLAG_SERVER));
+		$this->sendDataPacket($recipients, EmotePacket::create($from->getId(), $emoteId, "", "", EmotePacket::FLAG_SERVER));
 	}
 }

src/network/mcpe/StandardPacketBroadcaster.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\network\mcpe;
 
+use pocketmine\event\server\DataPacketSendEvent;
 use pocketmine\network\mcpe\protocol\serializer\PacketBatch;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializer;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
@@ -41,6 +42,15 @@ final class StandardPacketBroadcaster implements PacketBroadcaster{
 	){}
 
 	public function broadcastPackets(array $recipients, array $packets) : void{
+		//TODO: this shouldn't really be called here, since the broadcaster might be replaced by an alternative
+		//implementation that doesn't fire events
+		$ev = new DataPacketSendEvent($recipients, $packets);
+		$ev->call();
+		if($ev->isCancelled()){
+			return;
+		}
+		$packets = $ev->getPackets();
+
 		$compressors = [];
 
 		/** @var NetworkSession[][] $targetsByCompressor */

src/network/mcpe/auth/ProcessLoginTask.php

@@ -38,7 +38,10 @@ use function time;
 class ProcessLoginTask extends AsyncTask{
 	private const TLS_KEY_ON_COMPLETION = "completion";
 
-	public const MOJANG_ROOT_PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE8ELkixyLcwlZryUQcu1TvPOmI2B7vX83ndnWRUaXm74wFfa5f/lwQNTfrLVHa2PmenpGI6JhIMUJaWZrjmMj90NoKNFSNBuKdm8rYiXsfaz3K36x/1U26HpG0ZxK/V1V";
+	public const MOJANG_OLD_ROOT_PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE8ELkixyLcwlZryUQcu1TvPOmI2B7vX83ndnWRUaXm74wFfa5f/lwQNTfrLVHa2PmenpGI6JhIMUJaWZrjmMj90NoKNFSNBuKdm8rYiXsfaz3K36x/1U26HpG0ZxK/V1V";
+	public const MOJANG_OLD_KEY_EXPIRY = 1688169600; //2023-07-01 00:00:00 UTC - there is no official date for the changeover to the new key, so this is a guess
+
+	public const MOJANG_ROOT_PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
 
 	private const CLOCK_DRIFT_MAX = 60;
 
@@ -151,7 +154,7 @@ class ProcessLoginTask extends AsyncTask{
 			throw new VerifyLoginException($e->getMessage(), 0, $e);
 		}
 
-		if($headers->x5u === self::MOJANG_ROOT_PUBLIC_KEY){
+		if($headers->x5u === self::MOJANG_ROOT_PUBLIC_KEY || (time() < self::MOJANG_OLD_KEY_EXPIRY && $headers->x5u === self::MOJANG_OLD_ROOT_PUBLIC_KEY)){
 			$this->authenticated = true; //we're signed into xbox live
 		}
 

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/compression/CompressBatchPromise.php

@@ -23,7 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\network\mcpe\compression;
 
-use pocketmine\utils\Utils;
 use function array_push;
 
 class CompressBatchPromise{
@@ -42,9 +41,6 @@ class CompressBatchPromise{
 	 */
 	public function onResolve(\Closure ...$callbacks) : void{
 		$this->checkCancelled();
-		foreach($callbacks as $callback){
-			Utils::validateCallableSignature(function(CompressBatchPromise $promise) : void{}, $callback);
-		}
 		if($this->result !== null){
 			foreach($callbacks as $callback){
 				$callback($this);

src/network/mcpe/convert/ItemTranslator.php

@@ -110,6 +110,12 @@ final class ItemTranslator{
 					//new item without a fixed legacy ID - we can't handle this right now
 					continue;
 				}
+				if(isset($complexMappings[$newId]) && $complexMappings[$newId][0] === $intId && $complexMappings[$newId][1] <= $meta){
+					//TODO: HACK! Multiple legacy ID/meta pairs can be mapped to the same new ID (see minecraft:log)
+					//Assume that the first one is the most relevant for now
+					//However, this could catch fire in the future if this assumption is broken
+					continue;
+				}
 				$complexMappings[$newId] = [$intId, (int) $meta];
 			}
 		}

src/network/mcpe/convert/RuntimeBlockMapping.php

@@ -27,7 +27,12 @@ use pocketmine\block\Block;
 use pocketmine\block\BlockLegacyIds;
 use pocketmine\data\bedrock\BedrockDataFiles;
 use pocketmine\data\bedrock\LegacyBlockIdToStringIdMap;
+use pocketmine\nbt\LittleEndianNbtSerializer;
+use pocketmine\nbt\tag\ByteTag;
 use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\nbt\tag\IntTag;
+use pocketmine\nbt\tag\StringTag;
+use pocketmine\nbt\TreeRoot;
 use pocketmine\network\mcpe\protocol\serializer\NetworkNbtSerializer;
 use pocketmine\utils\BinaryStream;
 use pocketmine\utils\Filesystem;
@@ -43,8 +48,8 @@ final class RuntimeBlockMapping{
 	private array $legacyToRuntimeMap = [];
 	/** @var int[] */
 	private array $runtimeToLegacyMap = [];
-	/** @var CompoundTag[] */
-	private array $bedrockKnownStates;
+	/** @var CompoundTag[]|null */
+	private ?array $bedrockKnownStates = null;
 
 	private static function make() : self{
 		return new self(
@@ -53,22 +58,40 @@ final class RuntimeBlockMapping{
 		);
 	}
 
-	public function __construct(string $canonicalBlockStatesFile, string $r12ToCurrentBlockMapFile){
-		$stream = new BinaryStream(Filesystem::fileGetContents($canonicalBlockStatesFile));
-		$list = [];
-		$nbtReader = new NetworkNbtSerializer();
-		while(!$stream->feof()){
-			$offset = $stream->getOffset();
-			$blockState = $nbtReader->read($stream->getBuffer(), $offset)->mustGetCompoundTag();
-			$stream->setOffset($offset);
-			$list[] = $blockState;
+	/**
+	 * @param string[]                       $keyIndex
+	 * @param (ByteTag|StringTag|IntTag)[][] $valueIndex
+	 * @phpstan-param array<string, string> $keyIndex
+	 * @phpstan-param array<int, array<int|string, ByteTag|IntTag|StringTag>> $valueIndex
+	 */
+	private static function deduplicateCompound(CompoundTag $tag, array &$keyIndex, array &$valueIndex) : CompoundTag{
+		if($tag->count() === 0){
+			return $tag;
 		}
-		$this->bedrockKnownStates = $list;
 
-		$this->setupLegacyMappings($r12ToCurrentBlockMapFile);
+		$newTag = CompoundTag::create();
+		foreach($tag as $key => $value){
+			$key = $keyIndex[$key] ??= $key;
+
+			if($value instanceof CompoundTag){
+				$value = $valueIndex[$value->getType()][(new LittleEndianNbtSerializer())->write(new TreeRoot($value))] ??= self::deduplicateCompound($value, $keyIndex, $valueIndex);
+			}elseif($value instanceof ByteTag || $value instanceof IntTag || $value instanceof StringTag){
+				$value = $valueIndex[$value->getType()][$value->getValue()] ??= $value;
+			}
+
+			$newTag->setTag($key, $value);
+		}
+
+		return $newTag;
 	}
 
-	private function setupLegacyMappings(string $r12ToCurrentBlockMapFile) : void{
+	public function __construct(
+		private string $canonicalBlockStatesFile,
+		string $r12ToCurrentBlockMapFile
+	){
+		//do not cache this - we only need it to set up mappings under normal circumstances
+		$bedrockKnownStates = $this->loadBedrockKnownStates();
+
 		$legacyIdMap = LegacyBlockIdToStringIdMap::getInstance();
 		/** @var R12ToCurrentBlockMapEntry[] $legacyStateMap */
 		$legacyStateMap = [];
@@ -88,7 +111,7 @@ final class RuntimeBlockMapping{
 		 * @var int[][] $idToStatesMap string id -> int[] list of candidate state indices
 		 */
 		$idToStatesMap = [];
-		foreach($this->bedrockKnownStates as $k => $state){
+		foreach($bedrockKnownStates as $k => $state){
 			$idToStatesMap[$state->getString("name")][] = $k;
 		}
 		foreach($legacyStateMap as $pair){
@@ -107,7 +130,7 @@ final class RuntimeBlockMapping{
 				throw new \RuntimeException("Mapped new state does not appear in network table");
 			}
 			foreach($idToStatesMap[$mappedName] as $k){
-				$networkState = $this->bedrockKnownStates[$k];
+				$networkState = $bedrockKnownStates[$k];
 				if($mappedState->equals($networkState)){
 					$this->registerMapping($k, $id, $data);
 					continue 2;
@@ -117,6 +140,25 @@ final class RuntimeBlockMapping{
 		}
 	}
 
+	/**
+	 * @return CompoundTag[]
+	 */
+	private function loadBedrockKnownStates() : array{
+		$stream = new BinaryStream(Filesystem::fileGetContents($this->canonicalBlockStatesFile));
+		$list = [];
+		$nbtReader = new NetworkNbtSerializer();
+
+		$keyIndex = [];
+		$valueIndex = [];
+		while(!$stream->feof()){
+			$offset = $stream->getOffset();
+			$blockState = $nbtReader->read($stream->getBuffer(), $offset)->mustGetCompoundTag();
+			$stream->setOffset($offset);
+			$list[] = self::deduplicateCompound($blockState, $keyIndex, $valueIndex);
+		}
+		return $list;
+	}
+
 	public function toRuntimeId(int $internalStateId) : int{
 		return $this->legacyToRuntimeMap[$internalStateId] ?? $this->legacyToRuntimeMap[BlockLegacyIds::INFO_UPDATE << Block::INTERNAL_METADATA_BITS];
 	}
@@ -131,9 +173,14 @@ final class RuntimeBlockMapping{
 	}
 
 	/**
+	 * WARNING: This method may load the palette from disk, which is a slow operation.
+	 * Afterwards, it will cache the palette in memory, which requires (in some cases) tens of MB of memory.
+	 * Avoid using this where possible.
+	 *
+	 * @deprecated
 	 * @return CompoundTag[]
 	 */
 	public function getBedrockKnownStates() : array{
-		return $this->bedrockKnownStates;
+		return $this->bedrockKnownStates ??= $this->loadBedrockKnownStates();
 	}
 }

src/network/mcpe/convert/TypeConverter.php

@@ -23,12 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine\network\mcpe\convert;
 
+use pocketmine\block\Block;
 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 +33,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;
 
@@ -145,14 +136,16 @@ class TypeConverter{
 		if($itemStack->isNull()){
 			return ItemStack::null();
 		}
-		$nbt = null;
-		if($itemStack->hasNamedTag()){
-			$nbt = clone $itemStack->getNamedTag();
+		$nbt = $itemStack->getNamedTag();
+		if($nbt->count() === 0){
+			$nbt = null;
+		}else{
+			$nbt = clone $nbt;
 		}
 
-		$isBlockItem = $itemStack->getId() < 256;
-
-		$idMeta = ItemTranslator::getInstance()->toNetworkIdQuiet($itemStack->getId(), $itemStack->getMeta());
+		$internalId = $itemStack->getId();
+		$internalMeta = $itemStack->getMeta();
+		$idMeta = ItemTranslator::getInstance()->toNetworkIdQuiet($internalId, $internalMeta);
 		if($idMeta === null){
 			//Display unmapped items as INFO_UPDATE, but stick something in their NBT to make sure they don't stack with
 			//other unmapped items.
@@ -160,8 +153,8 @@ class TypeConverter{
 			if($nbt === null){
 				$nbt = new CompoundTag();
 			}
-			$nbt->setInt(self::PM_ID_TAG, $itemStack->getId());
-			$nbt->setInt(self::PM_META_TAG, $itemStack->getMeta());
+			$nbt->setInt(self::PM_ID_TAG, $internalId);
+			$nbt->setInt(self::PM_META_TAG, $internalMeta);
 		}else{
 			[$id, $meta] = $idMeta;
 
@@ -176,23 +169,15 @@ class TypeConverter{
 				}
 				$nbt->setInt(self::DAMAGE_TAG, $itemStack->getDamage());
 				$meta = 0;
-			}elseif($isBlockItem && $itemStack->getMeta() !== 0){
-				//TODO HACK: This foul-smelling code ensures that we can correctly deserialize an item when the
-				//client sends it back to us, because as of 1.16.220, blockitems quietly discard their metadata
-				//client-side. Aside from being very annoying, this also breaks various server-side behaviours.
-				if($nbt === null){
-					$nbt = new CompoundTag();
-				}
-				$nbt->setInt(self::PM_META_TAG, $itemStack->getMeta());
-				$meta = 0;
 			}
 		}
 
 		$blockRuntimeId = 0;
-		if($isBlockItem){
+		if($internalId < 256){
 			$block = $itemStack->getBlock();
 			if($block->getId() !== BlockLegacyIds::AIR){
 				$blockRuntimeId = RuntimeBlockMapping::getInstance()->toRuntimeId($block->getFullId());
+				$meta = 0;
 			}
 		}
 
@@ -218,6 +203,11 @@ class TypeConverter{
 		$compound = $itemStack->getNbt();
 
 		[$id, $meta] = ItemTranslator::getInstance()->fromNetworkId($itemStack->getId(), $itemStack->getMeta());
+		if($itemStack->getBlockRuntimeId() !== 0){
+			//blockitem meta is zeroed out by the client, so we have to infer it from the block runtime ID
+			$blockFullId = RuntimeBlockMapping::getInstance()->fromRuntimeId($itemStack->getBlockRuntimeId());
+			$meta = $blockFullId & Block::INTERNAL_METADATA_MASK;
+		}
 
 		if($compound !== null){
 			$compound = clone $compound;
@@ -232,12 +222,6 @@ class TypeConverter{
 					$compound->removeTag(self::DAMAGE_TAG_CONFLICT_RESOLUTION);
 					$compound->setTag(self::DAMAGE_TAG, $conflicted);
 				}
-			}elseif(($metaTag = $compound->getTag(self::PM_META_TAG)) instanceof IntTag){
-				//TODO HACK: This foul-smelling code ensures that we can correctly deserialize an item when the
-				//client sends it back to us, because as of 1.16.220, blockitems quietly discard their metadata
-				//client-side. Aside from being very annoying, this also breaks various server-side behaviours.
-				$meta = $metaTag->getValue();
-				$compound->removeTag(self::PM_META_TAG);
 			}
 			if($compound->count() === 0){
 				$compound = null;
@@ -261,60 +245,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 */
@@ -214,7 +214,7 @@ class InGamePacketHandler extends PacketHandler{
 			if($newPos->distanceSquared($curPos) > 1){  //Tolerate up to 1 block to avoid problems with client-sided physics when spawning in blocks
 				$this->session->getLogger()->debug("Got outdated pre-teleport movement, received " . $newPos . ", expected " . $curPos);
 				//Still getting movements from before teleport, ignore them
-				return false;
+				return true;
 			}
 
 			// Once we get a movement within a reasonable distance, treat it as a teleport ACK and remove position lock
@@ -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,21 @@ 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");
 		}
+		if(count($packet->requestChangedSlots) > 10){
+			throw new PacketHandlingException("Too many slot sync requests 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 +349,121 @@ 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();
+
+		//requestChangedSlots asks the server to always send out the contents of the specified slots, even if they
+		//haven't changed. Handling these is necessary to ensure the client inventory stays in sync if the server
+		//rejects the transaction. The most common example of this is equipping armor by right-click, which doesn't send
+		//a legacy prediction action for the destination armor slot.
+		foreach($packet->requestChangedSlots as $containerInfo){
+			foreach($containerInfo->getChangedSlotIndexes() as $netSlot){
+				[$windowId, $slot] = ItemStackContainerIdTranslator::translate($containerInfo->getContainerId(), $this->inventoryManager->getCurrentWindowId(), $netSlot);
+				$inventoryAndSlot = $this->inventoryManager->locateWindowAndSlot($windowId, $slot);
+				if($inventoryAndSlot !== null){ //trigger the normal slot sync logic
+					$this->inventoryManager->onSlotChange($inventoryAndSlot[0], $inventoryAndSlot[1]);
+				}
+			}
 		}
+
+		$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 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 much stricter about the validation criteria.
+
+		$actionCount = count($data->getActions());
+		if($actionCount > 2){
+			if($actionCount > 5){
+				throw new PacketHandlingException("Too many actions ($actionCount) in normal inventory transaction");
+			}
+
+			//Due to a bug in the game, this transaction type is still sent when a player edits a book. We don't need
+			//these transactions for editing books, since we have BookEditPacket, so we can just ignore them.
+			$this->session->getLogger()->debug("Ignoring normal inventory transaction with $actionCount actions (drop-item should have exactly 2 actions)");
+			return false;
+		}
+
+		$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{
+				$this->session->getLogger()->debug("Unexpected inventory action type $networkInventoryAction->sourceType in drop item transaction");
+				return false;
+			}
+		}
+		if($sourceSlot === null || $clientItemStack === null || $droppedCount === null){
+			$this->session->getLogger()->debug("Missing information in drop item transaction, need source slot, client item stack and dropped count");
+			return false;
+		}
+
+		$inventory = $this->player->getInventory();
+
+		if(!$inventory->slotExists($sourceSlot)){
+			return false; //TODO: size desync??
+		}
+
+		$sourceSlotItem = $inventory->getItem($sourceSlot);
+		if($sourceSlotItem->getCount() < $droppedCount){
+			return false;
+		}
+		$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 +575,52 @@ class InGamePacketHandler extends PacketHandler{
 		return false;
 	}
 
+	private function handleSingleItemStackRequest(ItemStackRequest $request) : ItemStackResponse{
+		if(count($request->getActions()) > 60){
+			//recipe book auto crafting can affect all slots of the inventory when consuming inputs or producing outputs
+			//this means there could be as many as 50 CraftingConsumeInput actions or Place (taking the result) actions
+			//in a single request (there are certain ways items can be arranged which will result in the same stack
+			//being taken from multiple times, but this is behaviour with a calculable limit)
+			//this means there SHOULD be AT MOST 53 actions in a single request, but 60 is a nice round number.
+			//n64Stacks = ?
+			//n1Stacks = 45 - n64Stacks
+			//nItemsRequiredFor1Craft = 9
+			//nResults = floor((n1Stacks + (n64Stacks * 64)) / nItemsRequiredFor1Craft)
+			//nTakeActionsTotal = floor(64 / nResults) + max(1, 64 % nResults) + ((nResults * nItemsRequiredFor1Craft) - (n64Stacks * 64))
+			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
@@ -664,7 +748,7 @@ class InGamePacketHandler extends PacketHandler{
 		if(!($nbt instanceof CompoundTag)) throw new AssumptionFailedError("PHPStan should ensure this is a CompoundTag"); //for phpstorm's benefit
 
 		if($block instanceof BaseSign){
-			if(($textBlobTag = $nbt->getTag(Sign::TAG_TEXT_BLOB)) instanceof StringTag){
+			if(($textBlobTag = $nbt->getCompoundTag(Sign::TAG_FRONT_TEXT)?->getTag(Sign::TAG_TEXT_BLOB)) instanceof StringTag){
 				try{
 					$text = SignText::fromBlob($textBlobTag->getValue());
 				}catch(\InvalidArgumentException $e){

src/network/mcpe/handler/ItemStackContainerIdTranslator.php

@@ -0,0 +1,96 @@
+<?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
+	}
+
+	/**
+	 * @return int[]
+	 * @phpstan-return array{int, int}
+	 * @throws PacketHandlingException
+	 */
+	public static function translate(int $containerInterfaceId, int $currentWindowId, int $slotId) : array{
+		return match($containerInterfaceId){
+			ContainerUIIds::ARMOR => [ContainerIds::ARMOR, $slotId],
+
+			ContainerUIIds::HOTBAR,
+			ContainerUIIds::INVENTORY,
+			ContainerUIIds::COMBINED_HOTBAR_AND_INVENTORY => [ContainerIds::INVENTORY, $slotId],
+
+			//TODO: HACK! The client sends an incorrect slot ID for the offhand as of 1.19.70 (though this doesn't really matter since the offhand has only 1 slot anyway)
+			ContainerUIIds::OFFHAND => [ContainerIds::OFFHAND, 0],
+
+			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, $slotId],
+
+			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, $slotId],
+
+			//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,389 @@
+<?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\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, $slotId] = ItemStackContainerIdTranslator::translate($info->getContainerId(), $this->inventoryManager->getCurrentWindowId(), $info->getSlotId());
+		$windowAndSlot = $this->inventoryManager->locateWindowAndSlot($windowId, $slotId);
+		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{
+		if($slotInfo->getContainerId() === ContainerUIIds::CREATED_OUTPUT && $slotInfo->getSlotId() === UIInventorySlotOffset::CREATED_ITEM_OUTPUT){
+			//special case for the "created item" output slot
+			//TODO: do we need to send a response for this slot info?
+			return $this->takeCreatedItem($count);
+		}
+		$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);
+	}
+
+	protected function dropItem(Item $item, int $count) : void{
+		if($count < 1){
+			throw new ItemStackRequestProcessException("Cannot drop less than 1 of an item");
+		}
+		$this->builder->addAction(new DropItemAction((clone $item)->setCount($count)));
+	}
+
+	/**
+	 * @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);
+
+		//TODO: Since the system assumes that crafting can only be done in the crafting grid, we have to give it a
+		//crafting grid to make the API happy. No implementation of getResultsFor() actually uses the crafting grid
+		//right now, so this will work, but this will become a problem in the future for things like shulker boxes and
+		//custom crafting recipes.
+		$craftingResults = $recipe->getResultsFor($this->player->getCraftingGrid());
+		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(int $count) : Item{
+		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;
+		$takenItem = clone $createdItem;
+		$takenItem->setCount($count);
+		if(!$this->createdItemFromCreativeInventory && $this->createdItemsTakenCount >= $createdItem->getCount()){
+			$this->setNextCreatedItem(null);
+		}
+		return $takenItem;
+	}
+
+	/**
+	 * @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
+		){
+			$this->transferItems($action->getSource(), $action->getDestination(), $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,107 @@
+<?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\item\Durable;
+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, $slotId] = ItemStackContainerIdTranslator::translate($containerInterfaceId, $this->inventoryManager->getCurrentWindowId(), $slotId);
+		$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(),
+					$item instanceof Durable ? $item->getDamage() : 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

@@ -39,11 +39,13 @@ use pocketmine\network\mcpe\protocol\types\CacheableNbt;
 use pocketmine\network\mcpe\protocol\types\DimensionIds;
 use pocketmine\network\mcpe\protocol\types\Experiments;
 use pocketmine\network\mcpe\protocol\types\LevelSettings;
+use pocketmine\network\mcpe\protocol\types\NetworkPermissions;
 use pocketmine\network\mcpe\protocol\types\PlayerMovementSettings;
 use pocketmine\network\mcpe\protocol\types\PlayerMovementType;
 use pocketmine\network\mcpe\protocol\types\SpawnSettings;
 use pocketmine\player\Player;
 use pocketmine\Server;
+use pocketmine\timings\Timings;
 use pocketmine\VersionInfo;
 use Ramsey\Uuid\Uuid;
 use function sprintf;
@@ -60,89 +62,96 @@ class PreSpawnPacketHandler extends PacketHandler{
 	){}
 
 	public function setUp() : void{
-		$location = $this->player->getLocation();
-		$world = $location->getWorld();
+		Timings::$playerNetworkSendPreSpawnGameData->startTiming();
+		try{
+			$location = $this->player->getLocation();
+			$world = $location->getWorld();
 
-		$this->session->getLogger()->debug("Preparing StartGamePacket");
-		$levelSettings = new LevelSettings();
-		$levelSettings->seed = -1;
-		$levelSettings->spawnSettings = new SpawnSettings(SpawnSettings::BIOME_TYPE_DEFAULT, "", DimensionIds::OVERWORLD); //TODO: implement this properly
-		$levelSettings->worldGamemode = TypeConverter::getInstance()->coreGameModeToProtocol($this->server->getGamemode());
-		$levelSettings->difficulty = $world->getDifficulty();
-		$levelSettings->spawnPosition = BlockPosition::fromVector3($world->getSpawnLocation());
-		$levelSettings->hasAchievementsDisabled = true;
-		$levelSettings->time = $world->getTime();
-		$levelSettings->eduEditionOffer = 0;
-		$levelSettings->rainLevel = 0; //TODO: implement these properly
-		$levelSettings->lightningLevel = 0;
-		$levelSettings->commandsEnabled = true;
-		$levelSettings->gameRules = [
-			"naturalregeneration" => new BoolGameRule(false, false) //Hack for client side regeneration
-		];
-		$levelSettings->experiments = new Experiments([], false);
+			$this->session->getLogger()->debug("Preparing StartGamePacket");
+			$levelSettings = new LevelSettings();
+			$levelSettings->seed = -1;
+			$levelSettings->spawnSettings = new SpawnSettings(SpawnSettings::BIOME_TYPE_DEFAULT, "", DimensionIds::OVERWORLD); //TODO: implement this properly
+			$levelSettings->worldGamemode = TypeConverter::getInstance()->coreGameModeToProtocol($this->server->getGamemode());
+			$levelSettings->difficulty = $world->getDifficulty();
+			$levelSettings->spawnPosition = BlockPosition::fromVector3($world->getSpawnLocation());
+			$levelSettings->hasAchievementsDisabled = true;
+			$levelSettings->time = $world->getTime();
+			$levelSettings->eduEditionOffer = 0;
+			$levelSettings->rainLevel = 0; //TODO: implement these properly
+			$levelSettings->lightningLevel = 0;
+			$levelSettings->commandsEnabled = true;
+			$levelSettings->gameRules = [
+				"naturalregeneration" => new BoolGameRule(false, false) //Hack for client side regeneration
+			];
+			$levelSettings->experiments = new Experiments([], false);
 
-		$this->session->sendDataPacket(StartGamePacket::create(
-			$this->player->getId(),
-			$this->player->getId(),
-			TypeConverter::getInstance()->coreGameModeToProtocol($this->player->getGamemode()),
-			$this->player->getOffsetPosition($location),
-			$location->pitch,
-			$location->yaw,
-			new CacheableNbt(CompoundTag::create()), //TODO: we don't care about this right now
-			$levelSettings,
-			"",
-			$this->server->getMotd(),
-			"",
-			false,
-			new PlayerMovementSettings(PlayerMovementType::SERVER_AUTHORITATIVE_V1, 0, false),
-			0,
-			0,
-			"",
-			false,
-			sprintf("%s %s", VersionInfo::NAME, VersionInfo::VERSION()->getFullVersion(true)),
-			Uuid::fromString(Uuid::NIL),
-			false,
-			[],
-			0,
-			GlobalItemTypeDictionary::getInstance()->getDictionary()->getEntries(),
-		));
+			$this->session->sendDataPacket(StartGamePacket::create(
+				$this->player->getId(),
+				$this->player->getId(),
+				TypeConverter::getInstance()->coreGameModeToProtocol($this->player->getGamemode()),
+				$this->player->getOffsetPosition($location),
+				$location->pitch,
+				$location->yaw,
+				new CacheableNbt(CompoundTag::create()), //TODO: we don't care about this right now
+				$levelSettings,
+				"",
+				$this->server->getMotd(),
+				"",
+				false,
+				new PlayerMovementSettings(PlayerMovementType::SERVER_AUTHORITATIVE_V1, 0, false),
+				0,
+				0,
+				"",
+				true,
+				sprintf("%s %s", VersionInfo::NAME, VersionInfo::VERSION()->getFullVersion(true)),
+				Uuid::fromString(Uuid::NIL),
+				false,
+				false,
+				new NetworkPermissions(disableClientSounds: true),
+				[],
+				0,
+				GlobalItemTypeDictionary::getInstance()->getDictionary()->getEntries(),
+			));
 
-		$this->session->getLogger()->debug("Sending actor identifiers");
-		$this->session->sendDataPacket(StaticPacketCache::getInstance()->getAvailableActorIdentifiers());
+			$this->session->getLogger()->debug("Sending actor identifiers");
+			$this->session->sendDataPacket(StaticPacketCache::getInstance()->getAvailableActorIdentifiers());
 
-		$this->session->getLogger()->debug("Sending biome definitions");
-		$this->session->sendDataPacket(StaticPacketCache::getInstance()->getBiomeDefs());
+			$this->session->getLogger()->debug("Sending biome definitions");
+			$this->session->sendDataPacket(StaticPacketCache::getInstance()->getBiomeDefs());
 
-		$this->session->getLogger()->debug("Sending attributes");
-		$this->session->getEntityEventBroadcaster()->syncAttributes([$this->session], $this->player, $this->player->getAttributeMap()->getAll());
+			$this->session->getLogger()->debug("Sending attributes");
+			$this->session->getEntityEventBroadcaster()->syncAttributes([$this->session], $this->player, $this->player->getAttributeMap()->getAll());
 
-		$this->session->getLogger()->debug("Sending available commands");
-		$this->session->syncAvailableCommands();
+			$this->session->getLogger()->debug("Sending available commands");
+			$this->session->syncAvailableCommands();
 
-		$this->session->getLogger()->debug("Sending abilities");
-		$this->session->syncAbilities($this->player);
-		$this->session->syncAdventureSettings();
+			$this->session->getLogger()->debug("Sending abilities");
+			$this->session->syncAbilities($this->player);
+			$this->session->syncAdventureSettings();
 
-		$this->session->getLogger()->debug("Sending effects");
-		foreach($this->player->getEffects()->all() as $effect){
-			$this->session->getEntityEventBroadcaster()->onEntityEffectAdded([$this->session], $this->player, $effect, false);
+			$this->session->getLogger()->debug("Sending effects");
+			foreach($this->player->getEffects()->all() as $effect){
+				$this->session->getEntityEventBroadcaster()->onEntityEffectAdded([$this->session], $this->player, $effect, false);
+			}
+
+			$this->session->getLogger()->debug("Sending actor metadata");
+			$this->player->sendData([$this->player]);
+
+			$this->session->getLogger()->debug("Sending inventory");
+			$this->inventoryManager->syncAll();
+			$this->inventoryManager->syncSelectedHotbarSlot();
+
+			$this->session->getLogger()->debug("Sending creative inventory data");
+			$this->inventoryManager->syncCreative();
+
+			$this->session->getLogger()->debug("Sending crafting data");
+			$this->session->sendDataPacket(CraftingDataCache::getInstance()->getCache($this->server->getCraftingManager()));
+
+			$this->session->getLogger()->debug("Sending player list");
+			$this->session->syncPlayerList($this->server->getOnlinePlayers());
+		}finally{
+			Timings::$playerNetworkSendPreSpawnGameData->stopTiming();
 		}
-
-		$this->session->getLogger()->debug("Sending actor metadata");
-		$this->player->sendData([$this->player]);
-
-		$this->session->getLogger()->debug("Sending inventory");
-		$this->inventoryManager->syncAll();
-		$this->inventoryManager->syncSelectedHotbarSlot();
-
-		$this->session->getLogger()->debug("Sending creative inventory data");
-		$this->inventoryManager->syncCreative();
-
-		$this->session->getLogger()->debug("Sending crafting data");
-		$this->session->sendDataPacket(CraftingDataCache::getInstance()->getCache($this->server->getCraftingManager()));
-
-		$this->session->getLogger()->debug("Sending player list");
-		$this->session->syncPlayerList($this->server->getOnlinePlayers());
 	}
 
 	public function handleRequestChunkRadius(RequestChunkRadiusPacket $packet) : bool{

src/network/mcpe/raklib/RakLibInterface.php

@@ -53,6 +53,7 @@ use function implode;
 use function mt_rand;
 use function random_bytes;
 use function rtrim;
+use function str_split;
 use function substr;
 use const PHP_INT_MAX;
 
@@ -192,10 +193,11 @@ class RakLibInterface implements ServerEventListener, AdvancedNetworkInterface{
 			$session = $this->sessions[$sessionId];
 			$address = $session->getIp();
 			$buf = substr($packet, 1);
+			$name = $session->getDisplayName();
 			try{
 				$session->handleEncoded($buf);
 			}catch(PacketHandlingException $e){
-				$errorId = bin2hex(random_bytes(6));
+				$errorId = implode("-", str_split(bin2hex(random_bytes(6)), 4));
 
 				$logger = $session->getLogger();
 				$logger->error("Bad packet (error ID $errorId): " . $e->getMessage());
@@ -204,6 +206,10 @@ class RakLibInterface implements ServerEventListener, AdvancedNetworkInterface{
 				$logger->debug(implode("\n", Utils::printableExceptionInfo($e)));
 				$session->disconnect("Packet processing error (Error ID: $errorId)");
 				$this->interface->blockAddress($address, 5);
+			}catch(\Throwable $e){
+				//record the name of the player who caused the crash, to make it easier to find the reproducing steps
+				$this->server->getLogger()->emergency("Crash occurred while handling a packet from session: $name");
+				throw $e;
 			}
 		}
 	}

src/player/ChunkSelector.php

@@ -54,23 +54,23 @@ final class ChunkSelector{
 					//If the chunk is in the radius, others at the same offsets in different quadrants are also guaranteed to be.
 
 					/* Top right quadrant */
-					yield World::chunkHash($centerX + $x, $centerZ + $z);
+					yield $subRadius => World::chunkHash($centerX + $x, $centerZ + $z);
 					/* Top left quadrant */
-					yield World::chunkHash($centerX - $x - 1, $centerZ + $z);
+					yield $subRadius => World::chunkHash($centerX - $x - 1, $centerZ + $z);
 					/* Bottom right quadrant */
-					yield World::chunkHash($centerX + $x, $centerZ - $z - 1);
+					yield $subRadius => World::chunkHash($centerX + $x, $centerZ - $z - 1);
 					/* Bottom left quadrant */
-					yield World::chunkHash($centerX - $x - 1, $centerZ - $z - 1);
+					yield $subRadius => World::chunkHash($centerX - $x - 1, $centerZ - $z - 1);
 
 					if($x !== $z){
 						/* Top right quadrant mirror */
-						yield World::chunkHash($centerX + $z, $centerZ + $x);
+						yield $subRadius => World::chunkHash($centerX + $z, $centerZ + $x);
 						/* Top left quadrant mirror */
-						yield World::chunkHash($centerX - $z - 1, $centerZ + $x);
+						yield $subRadius => World::chunkHash($centerX - $z - 1, $centerZ + $x);
 						/* Bottom right quadrant mirror */
-						yield World::chunkHash($centerX + $z, $centerZ - $x - 1);
+						yield $subRadius => World::chunkHash($centerX + $z, $centerZ - $x - 1);
 						/* Bottom left quadrant mirror */
-						yield World::chunkHash($centerX - $z - 1, $centerZ - $x - 1);
+						yield $subRadius => World::chunkHash($centerX - $z - 1, $centerZ - $x - 1);
 					}
 				}
 			}

src/player/Player.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\player;
 
+use pocketmine\block\BaseSign;
 use pocketmine\block\Bed;
 use pocketmine\block\BlockLegacyIds;
 use pocketmine\block\UnknownBlock;
@@ -121,6 +122,8 @@ use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\TextFormat;
 use pocketmine\world\ChunkListener;
 use pocketmine\world\ChunkListenerNoOpTrait;
+use pocketmine\world\ChunkLoader;
+use pocketmine\world\ChunkTicker;
 use pocketmine\world\format\Chunk;
 use pocketmine\world\Position;
 use pocketmine\world\sound\EntityAttackNoDamageSound;
@@ -237,12 +240,16 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 	protected array $loadQueue = [];
 	protected int $nextChunkOrderRun = 5;
 
+	/** @var true[] */
+	private array $tickingChunks = [];
+
 	protected int $viewDistance = -1;
 	protected int $spawnThreshold;
 	protected int $spawnChunkLoadCount = 0;
 	protected int $chunksPerTick;
 	protected ChunkSelector $chunkSelector;
-	protected PlayerChunkLoader $chunkLoader;
+	protected ChunkLoader $chunkLoader;
+	protected ChunkTicker $chunkTicker;
 
 	/** @var bool[] map: raw UUID (string) => bool */
 	protected array $hiddenPlayers = [];
@@ -308,8 +315,8 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		$this->spawnThreshold = (int) (($this->server->getConfigGroup()->getPropertyInt("chunk-sending.spawn-radius", 4) ** 2) * M_PI);
 		$this->chunkSelector = new ChunkSelector();
 
-		$this->chunkLoader = new PlayerChunkLoader($spawnLocation);
-
+		$this->chunkLoader = new class implements ChunkLoader{};
+		$this->chunkTicker = new ChunkTicker();
 		$world = $spawnLocation->getWorld();
 		//load the spawn chunk so we can see the terrain
 		$xSpawnChunk = $spawnLocation->getFloorX() >> Chunk::COORD_BIT_SIZE;
@@ -747,6 +754,8 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		$world->unregisterChunkLoader($this->chunkLoader, $x, $z);
 		$world->unregisterChunkListener($this, $x, $z);
 		unset($this->loadQueue[$index]);
+		$world->unregisterTickingChunk($this->chunkTicker, $x, $z);
+		unset($this->tickingChunks[$index]);
 	}
 
 	protected function spawnEntitiesOnAllChunks() : void{
@@ -798,6 +807,9 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 			unset($this->loadQueue[$index]);
 			$this->getWorld()->registerChunkLoader($this->chunkLoader, $X, $Z, true);
 			$this->getWorld()->registerChunkListener($this, $X, $Z);
+			if(isset($this->tickingChunks[$index])){
+				$this->getWorld()->registerTickingChunk($this->chunkTicker, $X, $Z);
+			}
 
 			$this->getWorld()->requestChunkPopulation($X, $Z, $this->chunkLoader)->onCompletion(
 				function() use ($X, $Z, $index, $world) : void{
@@ -883,6 +895,31 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		}
 	}
 
+	/**
+	 * @param true[] $oldTickingChunks
+	 * @param true[] $newTickingChunks
+	 *
+	 * @phpstan-param array<int, true> $oldTickingChunks
+	 * @phpstan-param array<int, true> $newTickingChunks
+	 */
+	private function updateTickingChunkRegistrations(array $oldTickingChunks, array $newTickingChunks) : void{
+		$world = $this->getWorld();
+		foreach($oldTickingChunks as $hash => $_){
+			if(!isset($newTickingChunks[$hash]) && !isset($this->loadQueue[$hash])){
+				//we are (probably) still using this chunk, but it's no longer within ticking range
+				World::getXZ($hash, $tickingChunkX, $tickingChunkZ);
+				$world->unregisterTickingChunk($this->chunkTicker, $tickingChunkX, $tickingChunkZ);
+			}
+		}
+		foreach($newTickingChunks as $hash => $_){
+			if(!isset($oldTickingChunks[$hash]) && !isset($this->loadQueue[$hash])){
+				//we were already using this chunk, but it is now within ticking range
+				World::getXZ($hash, $tickingChunkX, $tickingChunkZ);
+				$world->registerTickingChunk($this->chunkTicker, $tickingChunkX, $tickingChunkZ);
+			}
+		}
+	}
+
 	/**
 	 * Calculates which new chunks this player needs to use, and which currently-used chunks it needs to stop using.
 	 * This is based on factors including the player's current render radius and current position.
@@ -895,16 +932,23 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		Timings::$playerChunkOrder->startTiming();
 
 		$newOrder = [];
+		$tickingChunks = [];
 		$unloadChunks = $this->usedChunks;
 
+		$world = $this->getWorld();
+		$tickingChunkRadius = $world->getChunkTickRadius();
+
 		foreach($this->chunkSelector->selectChunks(
 			$this->server->getAllowedViewDistance($this->viewDistance),
 			$this->location->getFloorX() >> Chunk::COORD_BIT_SIZE,
 			$this->location->getFloorZ() >> Chunk::COORD_BIT_SIZE
-		) as $hash){
+		) as $radius => $hash){
 			if(!isset($this->usedChunks[$hash]) || $this->usedChunks[$hash]->equals(UsedChunkStatus::NEEDED())){
 				$newOrder[$hash] = true;
 			}
+			if($radius < $tickingChunkRadius){
+				$tickingChunks[$hash] = true;
+			}
 			unset($unloadChunks[$hash]);
 		}
 
@@ -914,8 +958,11 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		}
 
 		$this->loadQueue = $newOrder;
+
+		$this->updateTickingChunkRegistrations($this->tickingChunks, $tickingChunks);
+		$this->tickingChunks = $tickingChunks;
+
 		if(count($this->loadQueue) > 0 || count($unloadChunks) > 0){
-			$this->chunkLoader->setCurrentLocation($this->location);
 			$this->getNetworkSession()->syncViewAreaCenterPoint($this->location, $this->viewDistance);
 		}
 
@@ -1144,7 +1191,7 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 	 * TODO: make this a dynamic ability instead of being hardcoded
 	 */
 	public function hasFiniteResources() : bool{
-		return $this->gamemode->equals(GameMode::SURVIVAL()) || $this->gamemode->equals(GameMode::ADVENTURE());
+		return !$this->gamemode->equals(GameMode::CREATIVE());
 	}
 
 	public function isFireProof() : bool{
@@ -1212,6 +1259,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;
@@ -1222,7 +1278,7 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 
 		$revert = false;
 
-		if($distanceSquared > 100){
+		if($distanceSquared > 225){ //15 blocks
 			//TODO: this is probably too big if we process every movement
 			/* !!! BEWARE YE WHO ENTER HERE !!!
 			 *
@@ -1234,7 +1290,7 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 			 * If you must tamper with this code, be aware that this can cause very nasty results. Do not waste our time
 			 * asking for help if you suffer the consequences of messing with this.
 			 */
-			$this->logger->debug("Moved too fast, reverting movement");
+			$this->logger->debug("Moved too fast (" . sqrt($distanceSquared) . " blocks in 1 movement), reverting movement");
 			$this->logger->debug("Old position: " . $oldPos->asVector3() . ", new position: " . $newPos);
 			$revert = true;
 		}elseif(!$this->getWorld()->isInLoadedTerrain($newPos)){
@@ -1365,13 +1421,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);
@@ -1599,7 +1657,7 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 
 		$ev = new PlayerBlockPickEvent($this, $block, $item);
 		$existingSlot = $this->inventory->first($item);
-		if($existingSlot === -1 && ($this->hasFiniteResources() || $this->isSpectator())){
+		if($existingSlot === -1 && $this->hasFiniteResources()){
 			$ev->cancel();
 		}
 		$ev->call();
@@ -2569,6 +2627,20 @@ class Player extends Human implements CommandSender, ChunkListener, IPlayer{
 		$this->permanentWindows = [];
 	}
 
+	/**
+	 * Opens the player's sign editor GUI for the sign at the given position.
+	 * TODO: add support for editing the rear side of the sign (not currently supported due to technical limitations)
+	 */
+	public function openSignEditor(Vector3 $position) : void{
+		$block = $this->getWorld()->getBlock($position);
+		if($block instanceof BaseSign){
+			$this->getWorld()->setBlock($position, $block->setEditorEntityRuntimeId($this->getId()));
+			$this->getNetworkSession()->onOpenSignEditor($position, true);
+		}else{
+			throw new \InvalidArgumentException("Block at this position is not a sign");
+		}
+	}
+
 	use ChunkListenerNoOpTrait {
 		onChunkChanged as private;
 		onChunkUnloaded as private;

src/player/PlayerChunkLoader.php

@@ -26,6 +26,10 @@ namespace pocketmine\player;
 use pocketmine\math\Vector3;
 use pocketmine\world\TickingChunkLoader;
 
+/**
+ * @deprecated This class was only needed to implement TickingChunkLoader, which is now deprecated.
+ * ChunkTicker should be registered on ticking chunks to make them tick instead.
+ */
 final class PlayerChunkLoader implements TickingChunkLoader{
 	public function __construct(private Vector3 $currentLocation){}
 

src/plugin/PluginManager.php

@@ -37,7 +37,7 @@ use pocketmine\permission\DefaultPermissions;
 use pocketmine\permission\PermissionManager;
 use pocketmine\permission\PermissionParser;
 use pocketmine\Server;
-use pocketmine\timings\TimingsHandler;
+use pocketmine\timings\Timings;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Utils;
 use Symfony\Component\Filesystem\Path;
@@ -651,7 +651,7 @@ class PluginManager{
 			throw new PluginException("Plugin attempted to register event handler " . $handlerName . "() to event " . $event . " while not enabled");
 		}
 
-		$timings = new TimingsHandler("Plugin: " . $plugin->getDescription()->getFullName() . " Event: " . $handlerName . "(" . (new \ReflectionClass($event))->getShortName() . ")");
+		$timings = Timings::getEventHandlerTimings($event, $handlerName, $plugin->getDescription()->getFullName());
 
 		$registeredListener = new RegisteredListener($handler, $priority, $plugin, $handleCancelled, $timings);
 		HandlerListManager::global()->getListFor($event)->register($registeredListener);

src/scheduler/AsyncPool.php

@@ -247,7 +247,6 @@ class AsyncPool{
 		while(!$queue->isEmpty()){
 			/** @var AsyncTask $task */
 			$task = $queue->bottom();
-			$task->checkProgressUpdates();
 			if($task->isFinished()){ //make sure the task actually executed before trying to collect
 				$queue->dequeue();
 
@@ -268,6 +267,7 @@ class AsyncPool{
 					$task->onCompletion();
 				}
 			}else{
+				$task->checkProgressUpdates();
 				$more = true;
 				break; //current task is still running, skip to next worker
 			}

src/timings/Timings.php

@@ -25,14 +25,22 @@ namespace pocketmine\timings;
 
 use pocketmine\block\tile\Tile;
 use pocketmine\entity\Entity;
+use pocketmine\event\Event;
 use pocketmine\network\mcpe\protocol\ClientboundPacket;
 use pocketmine\network\mcpe\protocol\ServerboundPacket;
 use pocketmine\player\Player;
 use pocketmine\scheduler\TaskHandler;
-use function dechex;
+use function get_class;
+use function str_starts_with;
 
 abstract class Timings{
+	/**
+	 * @deprecated This was used by the old timings viewer to make a timer appear in the Breakdown section of a timings
+	 * report. Provide a group to your timer's constructor instead.
+	 * @see Timings::GROUP_BREAKDOWN
+	 */
 	public const INCLUDED_BY_OTHER_TIMINGS_PREFIX = "** ";
+	public const GROUP_BREAKDOWN = "Minecraft - Breakdown";
 
 	private static bool $initialized = false;
 
@@ -58,6 +66,10 @@ abstract class Timings{
 
 	/** @var TimingsHandler */
 	public static $playerNetworkSendEncrypt;
+
+	public static TimingsHandler $playerNetworkSendInventorySync;
+	public static TimingsHandler $playerNetworkSendPreSpawnGameData;
+
 	/** @var TimingsHandler */
 	public static $playerNetworkReceive;
 	/** @var TimingsHandler */
@@ -75,14 +87,6 @@ abstract class Timings{
 	/** @var TimingsHandler */
 	public static $serverCommand;
 	/** @var TimingsHandler */
-	public static $worldLoad;
-	/** @var TimingsHandler */
-	public static $worldSave;
-	/** @var TimingsHandler */
-	public static $population;
-	/** @var TimingsHandler */
-	public static $generationCallback;
-	/** @var TimingsHandler */
 	public static $permissibleCalculation;
 	/** @var TimingsHandler */
 	public static $permissibleCalculationDiff;
@@ -91,18 +95,22 @@ 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 */
-	public static $tickEntity;
-	/** @var TimingsHandler */
-	public static $tickTileEntity;
 
 	/** @var TimingsHandler */
 	public static $entityBaseTick;
 	/** @var TimingsHandler */
 	public static $livingEntityBaseTick;
 
+	public static TimingsHandler $itemEntityBaseTick;
+
 	/** @var TimingsHandler */
 	public static $schedulerSync;
 	/** @var TimingsHandler */
@@ -142,6 +150,13 @@ abstract class Timings{
 	/** @var TimingsHandler */
 	public static $broadcastPackets;
 
+	public static TimingsHandler $playerMove;
+
+	/** @var TimingsHandler[] */
+	private static array $events = [];
+	/** @var TimingsHandler[][] */
+	private static array $eventHandlers = [];
+
 	public static function init() : void{
 		if(self::$initialized){
 			return;
@@ -149,58 +164,61 @@ abstract class Timings{
 		self::$initialized = true;
 
 		self::$fullTick = new TimingsHandler("Full Server Tick");
-		self::$serverTick = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Server Tick Update Cycle", self::$fullTick);
-		self::$serverInterrupts = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Server Mid-Tick Processing", self::$fullTick);
+		self::$serverTick = new TimingsHandler("Server Tick Update Cycle", self::$fullTick, group: self::GROUP_BREAKDOWN);
+		self::$serverInterrupts = new TimingsHandler("Server Mid-Tick Processing", self::$fullTick, group: self::GROUP_BREAKDOWN);
 		self::$memoryManager = new TimingsHandler("Memory Manager");
 		self::$garbageCollector = new TimingsHandler("Garbage Collector", self::$memoryManager);
 		self::$titleTick = new TimingsHandler("Console Title Tick");
 
-		self::$playerNetworkSend = new TimingsHandler("Player Network Send");
-		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::$playerNetworkReceive = new TimingsHandler("Player Network Receive");
-		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::$playerChunkOrder = new TimingsHandler("Player Order Chunks");
-		self::$playerChunkSend = new TimingsHandler("Player Send Chunks");
 		self::$connection = new TimingsHandler("Connection Handler");
+
+		self::$playerNetworkSend = new TimingsHandler("Player Network Send", self::$connection);
+		self::$playerNetworkSendCompress = new TimingsHandler("Player Network Send - Compression", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkSendCompressBroadcast = new TimingsHandler("Player Network Send - Compression (Broadcast)", self::$playerNetworkSendCompress, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkSendCompressSessionBuffer = new TimingsHandler("Player Network Send - Compression (Session Buffer)", self::$playerNetworkSendCompress, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkSendEncrypt = new TimingsHandler("Player Network Send - Encryption", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkSendInventorySync = new TimingsHandler("Player Network Send - Inventory Sync", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkSendPreSpawnGameData = new TimingsHandler("Player Network Send - Pre-Spawn Game Data", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
+
+		self::$playerNetworkReceive = new TimingsHandler("Player Network Receive", self::$connection);
+		self::$playerNetworkReceiveDecompress = new TimingsHandler("Player Network Receive - Decompression", self::$playerNetworkReceive, group: self::GROUP_BREAKDOWN);
+		self::$playerNetworkReceiveDecrypt = new TimingsHandler("Player Network Receive - Decryption", self::$playerNetworkReceive, group: self::GROUP_BREAKDOWN);
+
+		self::$broadcastPackets = new TimingsHandler("Broadcast Packets", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
+
+		self::$playerMove = new TimingsHandler("Player Movement");
+		self::$playerChunkOrder = new TimingsHandler("Player Order Chunks");
+		self::$playerChunkSend = new TimingsHandler("Player Network Send - Chunks", self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
 		self::$scheduler = new TimingsHandler("Scheduler");
 		self::$serverCommand = new TimingsHandler("Server Command");
-		self::$worldLoad = new TimingsHandler("World Load");
-		self::$worldSave = new TimingsHandler("World Save");
-		self::$population = new TimingsHandler("World Population");
-		self::$generationCallback = new TimingsHandler("World Generation Callback");
 		self::$permissibleCalculation = new TimingsHandler("Permissible Calculation");
-		self::$permissibleCalculationDiff = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Permissible Calculation - Diff", self::$permissibleCalculation);
-		self::$permissibleCalculationCallback = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "Permissible Calculation - Callbacks", self::$permissibleCalculation);
+		self::$permissibleCalculationDiff = new TimingsHandler("Permissible Calculation - Diff", self::$permissibleCalculation, group: self::GROUP_BREAKDOWN);
+		self::$permissibleCalculationCallback = new TimingsHandler("Permissible Calculation - Callbacks", self::$permissibleCalculation, group: self::GROUP_BREAKDOWN);
 
 		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("Entity Movement", group: self::GROUP_BREAKDOWN);
+		self::$entityMoveCollision = new TimingsHandler("Entity Movement - Collision Checks", self::$entityMove, group: self::GROUP_BREAKDOWN);
 
-		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("Projectile Movement", self::$entityMove, group: self::GROUP_BREAKDOWN);
+		self::$projectileMoveRayTrace = new TimingsHandler("Projectile Movement - Ray Tracing", self::$projectileMove, group: self::GROUP_BREAKDOWN);
 
-		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::$playerCheckNearEntities = new TimingsHandler("checkNearEntities", group: self::GROUP_BREAKDOWN);
+		self::$entityBaseTick = new TimingsHandler("Entity Base Tick", group: self::GROUP_BREAKDOWN);
+		self::$livingEntityBaseTick = new TimingsHandler("Entity Base Tick - Living", group: self::GROUP_BREAKDOWN);
+		self::$itemEntityBaseTick = new TimingsHandler("Entity Base Tick - ItemEntity", group: self::GROUP_BREAKDOWN);
 
-		self::$playerCommand = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "playerCommand");
-		self::$craftingDataCacheRebuild = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "craftingDataCacheRebuild");
+		self::$schedulerSync = new TimingsHandler("Scheduler - Sync Tasks", group: self::GROUP_BREAKDOWN);
+		self::$schedulerAsync = new TimingsHandler("Scheduler - Async Tasks", group: self::GROUP_BREAKDOWN);
+
+		self::$playerCommand = new TimingsHandler("Player Command", group: self::GROUP_BREAKDOWN);
+		self::$craftingDataCacheRebuild = new TimingsHandler("Build CraftingDataPacket Cache", group: self::GROUP_BREAKDOWN);
 
 	}
 
 	public static function getScheduledTaskTimings(TaskHandler $task, int $period) : TimingsHandler{
-		$name = "Task: " . $task->getOwnerName() . " Runnable: " . $task->getTaskName();
+		$name = "Task: " . $task->getTaskName();
 
 		if($period > 0){
 			$name .= "(interval:" . $period . ")";
@@ -209,73 +227,107 @@ abstract class Timings{
 		}
 
 		if(!isset(self::$pluginTaskTimingMap[$name])){
-			self::$pluginTaskTimingMap[$name] = new TimingsHandler($name, self::$schedulerSync);
+			self::$pluginTaskTimingMap[$name] = new TimingsHandler($name, self::$schedulerSync, $task->getOwnerName());
 		}
 
 		return self::$pluginTaskTimingMap[$name];
 	}
 
+	/**
+	 * @phpstan-template T of object
+	 * @phpstan-param class-string<T> $class
+	 */
+	private static function shortenCoreClassName(string $class, string $prefix) : string{
+		if(str_starts_with($class, $prefix)){
+			return (new \ReflectionClass($class))->getShortName();
+		}
+		return $class;
+	}
+
 	public static function getEntityTimings(Entity $entity) : TimingsHandler{
-		$entityType = (new \ReflectionClass($entity))->getShortName();
-		if(!isset(self::$entityTypeTimingMap[$entityType])){
+		if(!isset(self::$entityTypeTimingMap[$entity::class])){
 			if($entity instanceof Player){
-				self::$entityTypeTimingMap[$entityType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickEntity - EntityPlayer", self::$tickEntity);
+				//the timings viewer calculates average player count by looking at this timer, so we need to ensure it has
+				//a name it can identify. However, we also want to make it obvious if this is a custom Player class.
+				$displayName = $entity::class !== Player::class ? "Player (" . $entity::class . ")" : "Player";
 			}else{
-				self::$entityTypeTimingMap[$entityType] = new TimingsHandler(self::INCLUDED_BY_OTHER_TIMINGS_PREFIX . "tickEntity - " . $entityType, self::$tickEntity);
+				$displayName = self::shortenCoreClassName($entity::class, "pocketmine\\entity\\");
 			}
+			self::$entityTypeTimingMap[$entity::class] = new TimingsHandler("Entity Tick - " . $displayName, group: self::GROUP_BREAKDOWN);
 		}
 
-		return self::$entityTypeTimingMap[$entityType];
+		return self::$entityTypeTimingMap[$entity::class];
 	}
 
 	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);
+		if(!isset(self::$tileEntityTypeTimingMap[$tile::class])){
+			self::$tileEntityTypeTimingMap[$tile::class] = new TimingsHandler(
+				"Block Entity Tick - " . self::shortenCoreClassName($tile::class, "pocketmine\\block\\tile\\"),
+				group: self::GROUP_BREAKDOWN
+			);
 		}
 
-		return self::$tileEntityTypeTimingMap[$tileType];
+		return self::$tileEntityTypeTimingMap[$tile::class];
 	}
 
 	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);
+		if(!isset(self::$packetReceiveTimingMap[$pk::class])){
+			self::$packetReceiveTimingMap[$pk::class] = new TimingsHandler("Receive - " . $pk->getName(), self::$playerNetworkReceive, group: self::GROUP_BREAKDOWN);
 		}
 
-		return self::$packetReceiveTimingMap[$pid];
+		return self::$packetReceiveTimingMap[$pk::class];
 	}
 
 	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::getReceiveDataPacketTimings($pk)
+		return self::$packetDecodeTimingMap[$pk::class] ??= new TimingsHandler(
+			"Decode - " . $pk->getName(),
+			self::getReceiveDataPacketTimings($pk),
+			group: self::GROUP_BREAKDOWN
 		);
 	}
 
 	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::getReceiveDataPacketTimings($pk)
+		return self::$packetHandleTimingMap[$pk::class] ??= new TimingsHandler(
+			"Handler - " . $pk->getName(),
+			self::getReceiveDataPacketTimings($pk),
+			group: self::GROUP_BREAKDOWN
 		);
 	}
 
 	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::getSendDataPacketTimings($pk)
+		return self::$packetEncodeTimingMap[$pk::class] ??= new TimingsHandler(
+			"Encode - " . $pk->getName(),
+			self::getSendDataPacketTimings($pk),
+			group: self::GROUP_BREAKDOWN
 		);
 	}
 
 	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);
+		if(!isset(self::$packetSendTimingMap[$pk::class])){
+			self::$packetSendTimingMap[$pk::class] = new TimingsHandler("Send - " . $pk->getName(), self::$playerNetworkSend, group: self::GROUP_BREAKDOWN);
 		}
 
-		return self::$packetSendTimingMap[$pid];
+		return self::$packetSendTimingMap[$pk::class];
+	}
+
+	public static function getEventTimings(Event $event) : TimingsHandler{
+		$eventClass = get_class($event);
+		if(!isset(self::$events[$eventClass])){
+			self::$events[$eventClass] = new TimingsHandler(self::shortenCoreClassName($eventClass, "pocketmine\\event\\"), group: "Events");
+		}
+
+		return self::$events[$eventClass];
+	}
+
+	/**
+	 * @phpstan-template TEvent of Event
+	 * @phpstan-param class-string<TEvent> $event
+	 */
+	public static function getEventHandlerTimings(string $event, string $handlerName, string $group) : TimingsHandler{
+		if(!isset(self::$eventHandlers[$event][$handlerName])){
+			self::$eventHandlers[$event][$handlerName] = new TimingsHandler($handlerName . "(" . self::shortenCoreClassName($event, "pocketmine\\event\\") . ")", group: $group);
+		}
+
+		return self::$eventHandlers[$event][$handlerName];
 	}
 }

src/timings/TimingsHandler.php

@@ -23,18 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\timings;
 
-use pocketmine\entity\Living;
 use pocketmine\Server;
-use function count;
+use pocketmine\utils\Utils;
 use function hrtime;
+use function implode;
+use function spl_object_id;
 
 class TimingsHandler{
+	private const FORMAT_VERSION = 2; //peak timings fix
+
 	private static bool $enabled = false;
 	private static int $timingStart = 0;
 
 	/** @return string[] */
 	public static function printTimings() : array{
-		$result = ["Minecraft"];
+		$groups = [];
 
 		foreach(TimingsRecord::getAll() as $timings){
 			$time = $timings->getTotalTime();
@@ -46,25 +49,33 @@ class TimingsHandler{
 
 			$avg = $time / $count;
 
-			$result[] = "    " . $timings->getName() . " Time: $time Count: " . $count . " Avg: $avg Violations: " . $timings->getViolations();
+			$group = $timings->getGroup();
+			$groups[$group][] = implode(" ", [
+				$timings->getName(),
+				"Time: $time",
+				"Count: $count",
+				"Avg: $avg",
+				"Violations: " . $timings->getViolations(),
+				"RecordId: " . $timings->getId(),
+				"ParentRecordId: " . ($timings->getParentId() ?? "none"),
+				"TimerId: " . $timings->getTimerId(),
+				"Ticks: " . $timings->getTicksActive(),
+				"Peak: " . $timings->getPeakTime(),
+			]);
+		}
+		$result = [];
+
+		foreach(Utils::stringifyKeys($groups) as $groupName => $lines){
+			$result[] = $groupName;
+			foreach($lines as $line){
+				$result[] = "    $line";
+			}
 		}
 
 		$result[] = "# Version " . Server::getInstance()->getVersion();
 		$result[] = "# " . Server::getInstance()->getName() . " " . Server::getInstance()->getPocketMineVersion();
 
-		$entities = 0;
-		$livingEntities = 0;
-		foreach(Server::getInstance()->getWorldManager()->getWorlds() as $world){
-			$entities += count($world->getEntities());
-			foreach($world->getEntities() as $e){
-				if($e instanceof Living){
-					++$livingEntities;
-				}
-			}
-		}
-
-		$result[] = "# Entities " . $entities;
-		$result[] = "# LivingEntities " . $livingEntities;
+		$result[] = "# FormatVersion " . self::FORMAT_VERSION;
 
 		$sampleTime = hrtime(true) - self::$timingStart;
 		$result[] = "Sample time $sampleTime (" . ($sampleTime / 1000000000) . "s)";
@@ -85,7 +96,7 @@ class TimingsHandler{
 	}
 
 	public static function reload() : void{
-		TimingsRecord::clearRecords();
+		TimingsRecord::reset();
 		if(self::$enabled){
 			self::$timingStart = hrtime(true);
 		}
@@ -97,16 +108,25 @@ class TimingsHandler{
 		}
 	}
 
-	private ?TimingsRecord $record = null;
+	private ?TimingsRecord $rootRecord = null;
 	private int $timingDepth = 0;
 
+	/**
+	 * @var TimingsRecord[]
+	 * @phpstan-var array<int, TimingsRecord>
+	 */
+	private array $recordsByParent = [];
+
 	public function __construct(
 		private string $name,
-		private ?TimingsHandler $parent = null
+		private ?TimingsHandler $parent = null,
+		private string $group = "Minecraft"
 	){}
 
 	public function getName() : string{ return $this->name; }
 
+	public function getGroup() : string{ return $this->group; }
+
 	public function startTiming() : void{
 		if(self::$enabled){
 			$this->internalStartTiming(hrtime(true));
@@ -115,13 +135,24 @@ class TimingsHandler{
 
 	private function internalStartTiming(int $now) : void{
 		if(++$this->timingDepth === 1){
-			if($this->record === null){
-				$this->record = new TimingsRecord($this);
-			}
-			$this->record->startTiming($now);
 			if($this->parent !== null){
 				$this->parent->internalStartTiming($now);
 			}
+
+			$current = TimingsRecord::getCurrentRecord();
+			if($current !== null){
+				$record = $this->recordsByParent[spl_object_id($current)] ?? null;
+				if($record === null){
+					$record = new TimingsRecord($this, $current);
+					$this->recordsByParent[spl_object_id($current)] = $record;
+				}
+			}else{
+				if($this->rootRecord === null){
+					$this->rootRecord = new TimingsRecord($this, null);
+				}
+				$record = $this->rootRecord;
+			}
+			$record->startTiming($now);
 		}
 	}
 
@@ -142,10 +173,13 @@ class TimingsHandler{
 			return;
 		}
 
-		if($this->record !== null){
-			//this might be null if a timings reset occurred while the timer was running
-			$this->record->stopTiming($now);
+		$record = TimingsRecord::getCurrentRecord();
+		$timerId = spl_object_id($this);
+		for(; $record !== null && $record->getTimerId() !== $timerId; $record = TimingsRecord::getCurrentRecord()){
+			\GlobalLogger::get()->error("Timer \"" . $record->getName() . "\" should have been stopped before stopping timer \"" . $this->name . "\"");
+			$record->stopTiming($now);
 		}
+		$record?->stopTiming($now);
 		if($this->parent !== null){
 			$this->parent->internalStopTiming($now);
 		}
@@ -170,7 +204,9 @@ class TimingsHandler{
 	/**
 	 * @internal
 	 */
-	public function destroyCycles() : void{
-		$this->record = null;
+	public function reset() : void{
+		$this->rootRecord = null;
+		$this->recordsByParent = [];
+		$this->timingDepth = 0;
 	}
 }

src/timings/TimingsRecord.php

@@ -24,7 +24,8 @@ declare(strict_types=1);
 namespace pocketmine\timings;
 
 use pocketmine\Server;
-use function round;
+use pocketmine\utils\AssumptionFailedError;
+use function floor;
 use function spl_object_id;
 
 /**
@@ -39,11 +40,17 @@ final class TimingsRecord{
 	 */
 	private static array $records = [];
 
-	public static function clearRecords() : void{
+	private static ?self $currentRecord = null;
+
+	/**
+	 * @internal
+	 */
+	public static function reset() : void{
 		foreach(self::$records as $record){
-			$record->handler->destroyCycles();
+			$record->handler->reset();
 		}
 		self::$records = [];
+		self::$currentRecord = null;
 	}
 
 	/**
@@ -55,11 +62,14 @@ final class TimingsRecord{
 	public static function tick(bool $measure = true) : void{
 		if($measure){
 			foreach(self::$records as $record){
-				if($record->curTickTotal > Server::TARGET_NANOSECONDS_PER_TICK){
-					$record->violations += (int) round($record->curTickTotal / Server::TARGET_NANOSECONDS_PER_TICK);
+				if($record->curCount > 0){
+					if($record->curTickTotal > Server::TARGET_NANOSECONDS_PER_TICK){
+						$record->violations += (int) floor($record->curTickTotal / Server::TARGET_NANOSECONDS_PER_TICK);
+					}
+					$record->curTickTotal = 0;
+					$record->curCount = 0;
+					$record->ticksActive++;
 				}
-				$record->curTickTotal = 0;
-				$record->curCount = 0;
 			}
 		}else{
 			foreach(self::$records as $record){
@@ -78,16 +88,27 @@ final class TimingsRecord{
 	private int $totalTime = 0;
 	private int $curTickTotal = 0;
 	private int $violations = 0;
+	private int $ticksActive = 0;
+	private int $peakTime = 0;
 
 	public function __construct(
 		//I'm not the biggest fan of this cycle, but it seems to be the most effective way to avoid leaking anything.
-		private TimingsHandler $handler
+		private TimingsHandler $handler,
+		private ?TimingsRecord $parentRecord
 	){
 		self::$records[spl_object_id($this)] = $this;
 	}
 
+	public function getId() : int{ return spl_object_id($this); }
+
+	public function getParentId() : ?int{ return $this->parentRecord?->getId(); }
+
+	public function getTimerId() : int{ return spl_object_id($this->handler); }
+
 	public function getName() : string{ return $this->handler->getName(); }
 
+	public function getGroup() : string{ return $this->handler->getGroup(); }
+
 	public function getCount() : int{ return $this->count; }
 
 	public function getCurCount() : int{ return $this->curCount; }
@@ -100,19 +121,40 @@ final class TimingsRecord{
 
 	public function getViolations() : int{ return $this->violations; }
 
+	public function getTicksActive() : int{ return $this->ticksActive; }
+
+	public function getPeakTime() : int{ return $this->peakTime; }
+
 	public function startTiming(int $now) : void{
 		$this->start = $now;
+		self::$currentRecord = $this;
 	}
 
 	public function stopTiming(int $now) : void{
 		if($this->start == 0){
 			return;
 		}
+		if(self::$currentRecord !== $this){
+			if(self::$currentRecord === null){
+				//timings may have been stopped while this timer was running
+				return;
+			}
+
+			throw new AssumptionFailedError("stopTiming() called on a non-current timer");
+		}
+		self::$currentRecord = $this->parentRecord;
 		$diff = $now - $this->start;
 		$this->totalTime += $diff;
 		$this->curTickTotal += $diff;
 		++$this->curCount;
 		++$this->count;
 		$this->start = 0;
+		if($diff > $this->peakTime){
+			$this->peakTime = $diff;
+		}
+	}
+
+	public static function getCurrentRecord() : ?self{
+		return self::$currentRecord;
 	}
 }

src/world/ChunkTicker.php

@@ -0,0 +1,34 @@
+<?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\world;
+
+/**
+ * Used to signal to the World that a chunk should be ticked.
+ *
+ * @see World::registerTickingChunk()
+ * @see World::unregisterTickingChunk()
+ */
+final class ChunkTicker{
+
+}

src/world/TickingChunkLoader.php

@@ -27,6 +27,10 @@ namespace pocketmine\world;
  * TickingChunkLoader includes all of the same functionality as ChunkLoader (it can be used in the same way).
  * However, using this version will also cause chunks around the loader's reported coordinates to get random block
  * updates.
+ *
+ * @deprecated
+ * @see World::registerTickingChunk()
+ * @see World::unregisterTickingChunk()
  */
 interface TickingChunkLoader extends ChunkLoader{
 

src/world/World.php

@@ -77,7 +77,6 @@ use pocketmine\promise\PromiseResolver;
 use pocketmine\scheduler\AsyncPool;
 use pocketmine\Server;
 use pocketmine\ServerConfigGroup;
-use pocketmine\timings\Timings;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Limits;
 use pocketmine\utils\ReversePriorityQueue;
@@ -104,6 +103,7 @@ use pocketmine\world\utils\SubChunkExplorer;
 use function abs;
 use function array_filter;
 use function array_key_exists;
+use function array_keys;
 use function array_map;
 use function array_merge;
 use function array_sum;
@@ -210,13 +210,39 @@ class World implements ChunkManager{
 	/**
 	 * @var TickingChunkLoader[] spl_object_id => TickingChunkLoader
 	 * @phpstan-var array<int, TickingChunkLoader>
+	 *
+	 * @deprecated
 	 */
 	private array $tickingLoaders = [];
 	/**
 	 * @var int[] spl_object_id => number of chunks
 	 * @phpstan-var array<int, int>
+	 *
+	 * @deprecated
 	 */
 	private array $tickingLoaderCounter = [];
+
+	/**
+	 * @var ChunkTicker[][] chunkHash => [spl_object_id => ChunkTicker]
+	 * @phpstan-var array<ChunkPosHash, array<int, ChunkTicker>>
+	 */
+	private array $registeredTickingChunks = [];
+
+	/**
+	 * Set of chunks which are definitely ready for ticking.
+	 *
+	 * @var int[]
+	 * @phpstan-var array<ChunkPosHash, ChunkPosHash>
+	 */
+	private array $validTickingChunks = [];
+
+	/**
+	 * Set of chunks which might be ready for ticking. These will be checked at the next tick.
+	 * @var int[]
+	 * @phpstan-var array<ChunkPosHash, ChunkPosHash>
+	 */
+	private array $recheckTickingChunks = [];
+
 	/**
 	 * @var ChunkLoader[][] chunkHash => [spl_object_id => ChunkLoader]
 	 * @phpstan-var array<ChunkPosHash, array<int, ChunkLoader>>
@@ -496,7 +522,7 @@ class World implements ChunkManager{
 		$this->time = $this->provider->getWorldData()->getTime();
 
 		$cfg = $this->server->getConfigGroup();
-		$this->chunkTickRadius = min($this->server->getViewDistance(), max(1, $cfg->getPropertyInt("chunk-ticking.tick-radius", 4)));
+		$this->chunkTickRadius = min($this->server->getViewDistance(), max(0, $cfg->getPropertyInt("chunk-ticking.tick-radius", 4)));
 		if($cfg->getPropertyInt("chunk-ticking.per-tick", 40) <= 0){
 			//TODO: this needs l10n
 			$this->logger->warning("\"chunk-ticking.per-tick\" setting is deprecated, but you've used it to disable chunk ticking. Set \"chunk-ticking.tick-radius\" to 0 in \"pocketmine.yml\" instead.");
@@ -972,7 +998,6 @@ class World implements ChunkManager{
 
 		$this->timings->entityTick->startTiming();
 		//Update entities that need update
-		Timings::$tickEntity->startTiming();
 		foreach($this->updateEntities as $id => $entity){
 			if($entity->isClosed() || $entity->isFlaggedForDespawn() || !$entity->onUpdate($currentTick)){
 				unset($this->updateEntities[$id]);
@@ -981,7 +1006,6 @@ class World implements ChunkManager{
 				$entity->close();
 			}
 		}
-		Timings::$tickEntity->stopTiming();
 		$this->timings->entityTick->stopTiming();
 
 		$this->timings->randomChunkUpdates->startTiming();
@@ -1129,32 +1153,73 @@ class World implements ChunkManager{
 	}
 
 	/**
-	 * Returns the radius of chunks to be ticked around each ticking chunk loader (usually players). This is referred to
-	 * as "simulation distance" in the Minecraft: Bedrock world options screen.
+	 * Returns the radius of chunks to be ticked around each player. This is referred to as "simulation distance" in the
+	 * Minecraft: Bedrock world options screen.
 	 */
 	public function getChunkTickRadius() : int{
 		return $this->chunkTickRadius;
 	}
 
 	/**
-	 * Sets the radius of chunks ticked around each ticking chunk loader (usually players).
+	 * Sets the radius of chunks ticked around each player. This may not take effect immediately, since each player
+	 * needs to recalculate their tick radius.
 	 */
 	public function setChunkTickRadius(int $radius) : void{
 		$this->chunkTickRadius = $radius;
 	}
 
-	private function tickChunks() : void{
-		if($this->chunkTickRadius <= 0 || count($this->tickingLoaders) === 0){
-			return;
+	/**
+	 * Returns a list of chunk position hashes (as returned by World::chunkHash()) which are currently valid for
+	 * ticking.
+	 *
+	 * @return int[]
+	 * @phpstan-return list<ChunkPosHash>
+	 */
+	public function getTickingChunks() : array{
+		return array_keys($this->validTickingChunks);
+	}
+
+	/**
+	 * Instructs the World to tick the specified chunk, for as long as this chunk ticker (or any other chunk ticker) is
+	 * registered to it.
+	 */
+	public function registerTickingChunk(ChunkTicker $ticker, int $chunkX, int $chunkZ) : void{
+		$chunkPosHash = World::chunkHash($chunkX, $chunkZ);
+		$this->registeredTickingChunks[$chunkPosHash][spl_object_id($ticker)] = $ticker;
+		$this->recheckTickingChunks[$chunkPosHash] = $chunkPosHash;
+	}
+
+	/**
+	 * Unregisters the given chunk ticker from the specified chunk. If there are other tickers still registered to the
+	 * chunk, it will continue to be ticked.
+	 */
+	public function unregisterTickingChunk(ChunkTicker $ticker, int $chunkX, int $chunkZ) : void{
+		$chunkHash = World::chunkHash($chunkX, $chunkZ);
+		$tickerId = spl_object_id($ticker);
+		if(isset($this->registeredTickingChunks[$chunkHash][$tickerId])){
+			unset($this->registeredTickingChunks[$chunkHash][$tickerId]);
+			if(count($this->registeredTickingChunks[$chunkHash]) === 0){
+				unset(
+					$this->registeredTickingChunks[$chunkHash],
+					$this->recheckTickingChunks[$chunkHash],
+					$this->validTickingChunks[$chunkHash]
+				);
+			}
 		}
+	}
 
-		$this->timings->randomChunkUpdatesChunkSelection->startTiming();
-
-		/** @var bool[] $chunkTickList chunkhash => dummy */
-		$chunkTickList = [];
-
-		$chunkTickableCache = [];
-
+	/**
+	 * @deprecated
+	 *
+	 * @param true[] $chunkTickList
+	 * @param bool[] $chunkTickableCache
+	 *
+	 * @phpstan-param array<int, true> $chunkTickList
+	 * @phpstan-param array<int, bool> $chunkTickableCache
+	 * @phpstan-param-out array<int, true> $chunkTickList
+	 * @phpstan-param-out array<int, bool> $chunkTickableCache
+	 */
+	private function selectTickableChunksLegacy(array &$chunkTickList, array &$chunkTickableCache) : void{
 		$centerChunks = [];
 
 		$selector = new ChunkSelector();
@@ -1179,8 +1244,40 @@ class World implements ChunkManager{
 				}
 			}
 		}
+	}
 
-		$this->timings->randomChunkUpdatesChunkSelection->stopTiming();
+	private function tickChunks() : void{
+		if($this->chunkTickRadius <= 0 || (count($this->registeredTickingChunks) === 0 && count($this->tickingLoaders) === 0)){
+			return;
+		}
+
+		if(count($this->recheckTickingChunks) > 0 || count($this->tickingLoaders) > 0){
+			$this->timings->randomChunkUpdatesChunkSelection->startTiming();
+
+			$chunkTickableCache = [];
+
+			foreach($this->recheckTickingChunks as $hash => $_){
+				World::getXZ($hash, $chunkX, $chunkZ);
+				if($this->isChunkTickable($chunkX, $chunkZ, $chunkTickableCache)){
+					$this->validTickingChunks[$hash] = $hash;
+				}
+			}
+			$this->recheckTickingChunks = [];
+
+			//TODO: REMOVE THIS - we need a local var to add extra chunks to if we have legacy ticking loaders
+			//this is copy-on-write, so it won't have any performance impact if there are no legacy ticking loaders
+			$chunkTickList = $this->validTickingChunks;
+
+			//TODO: REMOVE THIS
+			//backwards compatibility for TickingChunkLoader, although I'm not sure this is really necessary in practice
+			if(count($this->tickingLoaders) !== 0){
+				$this->selectTickableChunksLegacy($chunkTickList, $chunkTickableCache);
+			}
+
+			$this->timings->randomChunkUpdatesChunkSelection->stopTiming();
+		}else{
+			$chunkTickList = $this->validTickingChunks;
+		}
 
 		foreach($chunkTickList as $index => $_){
 			World::getXZ($index, $chunkX, $chunkZ);
@@ -1230,11 +1327,35 @@ class World implements ChunkManager{
 		return true;
 	}
 
+	/**
+	 * Marks the 3x3 square of chunks centered on the specified chunk for chunk ticking eligibility recheck.
+	 *
+	 * This should be used whenever the chunk's eligibility to be ticked is changed. This includes:
+	 * - Loading/unloading the chunk (the chunk may be registered for ticking before it is loaded)
+	 * - Locking/unlocking the chunk (e.g. world population)
+	 * - Light populated state change (i.e. scheduled for light population, or light population completed)
+	 * - Arbitrary chunk replacement (i.e. setChunk() or similar)
+	 */
+	private function markTickingChunkForRecheck(int $chunkX, int $chunkZ) : void{
+		for($cx = -1; $cx <= 1; ++$cx){
+			for($cz = -1; $cz <= 1; ++$cz){
+				$chunkHash = World::chunkHash($chunkX + $cx, $chunkZ + $cz);
+				unset($this->validTickingChunks[$chunkHash]);
+				if(isset($this->registeredTickingChunks[$chunkHash])){
+					$this->recheckTickingChunks[$chunkHash] = $chunkHash;
+				}else{
+					unset($this->recheckTickingChunks[$chunkHash]);
+				}
+			}
+		}
+	}
+
 	private function orderLightPopulation(int $chunkX, int $chunkZ) : void{
 		$chunkHash = World::chunkHash($chunkX, $chunkZ);
 		$lightPopulatedState = $this->chunks[$chunkHash]->isLightPopulated();
 		if($lightPopulatedState === false){
 			$this->chunks[$chunkHash]->setLightPopulated(null);
+			$this->markTickingChunkForRecheck($chunkX, $chunkZ);
 
 			$this->workerPool->submitTask(new LightPopulationTask(
 				$this->chunks[$chunkHash],
@@ -1258,6 +1379,7 @@ class World implements ChunkManager{
 						$chunk->getSubChunk($y)->setBlockSkyLightArray($lightArray);
 					}
 					$chunk->setLightPopulated(true);
+					$this->markTickingChunkForRecheck($chunkX, $chunkZ);
 				}
 			));
 		}
@@ -1314,10 +1436,15 @@ class World implements ChunkManager{
 
 		(new WorldSaveEvent($this))->call();
 
+		$timings = $this->timings->syncDataSave;
+		$timings->startTiming();
+
 		$this->provider->getWorldData()->setTime($this->time);
 		$this->saveChunks();
 		$this->provider->getWorldData()->save();
 
+		$timings->stopTiming();
+
 		return true;
 	}
 
@@ -2302,6 +2429,7 @@ class World implements ChunkManager{
 			throw new \InvalidArgumentException("Chunk $chunkX $chunkZ is already locked");
 		}
 		$this->chunkLock[$chunkHash] = $lockId;
+		$this->markTickingChunkForRecheck($chunkX, $chunkZ);
 	}
 
 	/**
@@ -2316,6 +2444,7 @@ class World implements ChunkManager{
 		$chunkHash = World::chunkHash($chunkX, $chunkZ);
 		if(isset($this->chunkLock[$chunkHash]) && ($lockId === null || $this->chunkLock[$chunkHash] === $lockId)){
 			unset($this->chunkLock[$chunkHash]);
+			$this->markTickingChunkForRecheck($chunkX, $chunkZ);
 			return true;
 		}
 		return false;
@@ -2367,6 +2496,7 @@ class World implements ChunkManager{
 		unset($this->blockCache[$chunkHash]);
 		unset($this->changedBlocks[$chunkHash]);
 		$chunk->setTerrainDirty();
+		$this->markTickingChunkForRecheck($chunkX, $chunkZ); //this replacement chunk may not meet the conditions for ticking
 
 		if(!$this->isChunkInUse($chunkX, $chunkZ)){
 			$this->unloadChunkRequest($chunkX, $chunkZ);
@@ -2648,6 +2778,7 @@ class World implements ChunkManager{
 		foreach($this->getChunkListeners($x, $z) as $listener){
 			$listener->onChunkLoaded($x, $z, $this->chunks[$chunkHash]);
 		}
+		$this->markTickingChunkForRecheck($x, $z); //tickers may have been registered before the chunk was loaded
 
 		$this->timings->syncChunkLoad->stopTiming();
 
@@ -2809,6 +2940,8 @@ class World implements ChunkManager{
 		unset($this->chunks[$chunkHash]);
 		unset($this->blockCache[$chunkHash]);
 		unset($this->changedBlocks[$chunkHash]);
+		unset($this->registeredTickingChunks[$chunkHash]);
+		$this->markTickingChunkForRecheck($x, $z);
 
 		if(array_key_exists($chunkHash, $this->chunkPopulationRequestMap)){
 			$this->logger->debug("Rejecting population promise for chunk $x $z");
@@ -3117,7 +3250,8 @@ class World implements ChunkManager{
 	private function internalOrderChunkPopulation(int $chunkX, int $chunkZ, ?ChunkLoader $associatedChunkLoader, ?PromiseResolver $resolver) : Promise{
 		$chunkHash = World::chunkHash($chunkX, $chunkZ);
 
-		Timings::$population->startTiming();
+		$timings = $this->timings->chunkPopulationOrder;
+		$timings->startTiming();
 
 		try{
 			for($xx = -1; $xx <= 1; ++$xx){
@@ -3174,7 +3308,7 @@ class World implements ChunkManager{
 
 			return $resolver->getPromise();
 		}finally{
-			Timings::$population->stopTiming();
+			$timings->stopTiming();
 		}
 	}
 
@@ -3183,7 +3317,8 @@ class World implements ChunkManager{
 	 * @phpstan-param array<int, Chunk> $adjacentChunks
 	 */
 	private function generateChunkCallback(ChunkLockId $chunkLockId, int $x, int $z, Chunk $chunk, array $adjacentChunks, ChunkLoader $temporaryChunkLoader) : void{
-		Timings::$generationCallback->startTiming();
+		$timings = $this->timings->chunkPopulationCompletion;
+		$timings->startTiming();
 
 		$dirtyChunks = 0;
 		for($xx = -1; $xx <= 1; ++$xx){
@@ -3252,7 +3387,7 @@ class World implements ChunkManager{
 
 			$this->drainPopulationRequestQueue();
 		}
-		Timings::$generationCallback->stopTiming();
+		$timings->stopTiming();
 	}
 
 	public function doChunkGarbageCollection() : void{

src/world/WorldManager.php

@@ -30,7 +30,6 @@ use pocketmine\event\world\WorldUnloadEvent;
 use pocketmine\lang\KnownTranslationFactory;
 use pocketmine\player\ChunkSelector;
 use pocketmine\Server;
-use pocketmine\timings\Timings;
 use pocketmine\world\format\Chunk;
 use pocketmine\world\format\io\exception\CorruptedWorldException;
 use pocketmine\world\format\io\exception\UnsupportedWorldFormatException;
@@ -286,7 +285,7 @@ class WorldManager{
 			$centerX = $spawnLocation->getFloorX() >> Chunk::COORD_BIT_SIZE;
 			$centerZ = $spawnLocation->getFloorZ() >> Chunk::COORD_BIT_SIZE;
 
-			$selected = iterator_to_array((new ChunkSelector())->selectChunks(8, $centerX, $centerZ));
+			$selected = iterator_to_array((new ChunkSelector())->selectChunks(8, $centerX, $centerZ), preserve_keys: false);
 			$done = 0;
 			$total = count($selected);
 			foreach($selected as $index){
@@ -391,7 +390,6 @@ class WorldManager{
 	}
 
 	private function doAutoSave() : void{
-		Timings::$worldSave->startTiming();
 		foreach($this->worlds as $world){
 			foreach($world->getPlayers() as $player){
 				if($player->spawned){
@@ -400,6 +398,5 @@ class WorldManager{
 			}
 			$world->save(false);
 		}
-		Timings::$worldSave->stopTiming();
 	}
 }

src/world/WorldTimings.php

@@ -38,6 +38,7 @@ class WorldTimings{
 	public TimingsHandler $randomChunkUpdatesChunkSelection;
 	public TimingsHandler $doChunkGC;
 	public TimingsHandler $entityTick;
+	public TimingsHandler $tileTick;
 	public TimingsHandler $doTick;
 
 	public TimingsHandler $syncChunkSend;
@@ -48,33 +49,54 @@ class WorldTimings{
 	public TimingsHandler $syncChunkLoadFixInvalidBlocks;
 	public TimingsHandler $syncChunkLoadEntities;
 	public TimingsHandler $syncChunkLoadTileEntities;
+
+	public TimingsHandler $syncDataSave;
 	public TimingsHandler $syncChunkSave;
 
+	public TimingsHandler $chunkPopulationOrder;
+	public TimingsHandler $chunkPopulationCompletion;
+
+	/**
+	 * @var TimingsHandler[]
+	 * @phpstan-var array<string, TimingsHandler>
+	 */
+	private static array $aggregators = [];
+
+	private static function newTimer(string $worldName, string $timerName) : TimingsHandler{
+		$aggregator = self::$aggregators[$timerName] ??= new TimingsHandler("Worlds - $timerName"); //displayed in Minecraft primary table
+
+		return new TimingsHandler("$worldName - $timerName", $aggregator, Timings::GROUP_BREAKDOWN);
+	}
+
 	public function __construct(World $world){
-		$name = $world->getFolderName() . " - ";
+		$name = $world->getFolderName();
 
-		$this->setBlock = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "setBlock");
-		$this->doBlockLightUpdates = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Block Light Updates");
-		$this->doBlockSkyLightUpdates = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Sky Light Updates");
+		$this->setBlock = self::newTimer($name, "Set Blocks");
+		$this->doBlockLightUpdates = self::newTimer($name, "Block Light Updates");
+		$this->doBlockSkyLightUpdates = self::newTimer($name, "Sky Light Updates");
 
-		$this->doChunkUnload = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Unload Chunks");
-		$this->scheduledBlockUpdates = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Scheduled Block Updates");
-		$this->randomChunkUpdates = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Random Chunk Updates");
-		$this->randomChunkUpdatesChunkSelection = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Random Chunk Updates - Chunk Selection");
-		$this->doChunkGC = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Garbage Collection");
-		$this->entityTick = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Tick Entities");
+		$this->doChunkUnload = self::newTimer($name, "Unload Chunks");
+		$this->scheduledBlockUpdates = self::newTimer($name, "Scheduled Block Updates");
+		$this->randomChunkUpdates = self::newTimer($name, "Random Chunk Updates");
+		$this->randomChunkUpdatesChunkSelection = self::newTimer($name, "Random Chunk Updates - Chunk Selection");
+		$this->doChunkGC = self::newTimer($name, "Garbage Collection");
+		$this->entityTick = self::newTimer($name, "Entity Tick");
+		$this->tileTick = self::newTimer($name, "Block Entity Tick");
+		$this->doTick = self::newTimer($name, "World Tick");
 
-		Timings::init(); //make sure the timers we want are available
-		$this->syncChunkSend = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Player Send Chunks", Timings::$playerChunkSend);
-		$this->syncChunkSendPrepare = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Player Send Chunk Prepare", Timings::$playerChunkSend);
+		$this->syncChunkSend = self::newTimer($name, "Player Send Chunks");
+		$this->syncChunkSendPrepare = self::newTimer($name, "Player Send Chunk Prepare");
 
-		$this->syncChunkLoad = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Load", Timings::$worldLoad);
-		$this->syncChunkLoadData = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Load - Data");
-		$this->syncChunkLoadFixInvalidBlocks = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Load - Fix Invalid Blocks");
-		$this->syncChunkLoadEntities = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Load - Entities");
-		$this->syncChunkLoadTileEntities = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Load - TileEntities");
-		$this->syncChunkSave = new TimingsHandler(Timings::INCLUDED_BY_OTHER_TIMINGS_PREFIX . $name . "Chunk Save", Timings::$worldSave);
+		$this->syncChunkLoad = self::newTimer($name, "Chunk Load");
+		$this->syncChunkLoadData = self::newTimer($name, "Chunk Load - Data");
+		$this->syncChunkLoadFixInvalidBlocks = self::newTimer($name, "Chunk Load - Fix Invalid Blocks");
+		$this->syncChunkLoadEntities = self::newTimer($name, "Chunk Load - Entities");
+		$this->syncChunkLoadTileEntities = self::newTimer($name, "Chunk Load - Block Entities");
 
-		$this->doTick = new TimingsHandler($name . "World Tick");
+		$this->syncDataSave = self::newTimer($name, "Data Save");
+		$this->syncChunkSave = self::newTimer($name, "Chunk Save");
+
+		$this->chunkPopulationOrder = self::newTimer($name, "Chunk Population - Order");
+		$this->chunkPopulationCompletion = self::newTimer($name, "Chunk Population - Completion");
 	}
 }

tests/phpstan/configs/phpstan-bugs.neon

@@ -5,11 +5,6 @@ parameters:
 			count: 1
 			path: ../../../src/block/BaseBanner.php
 
-		-
-			message: "#^Comparison operation \"\\<\" between int\\<1, max\\> and 1 is always false\\.$#"
-			count: 1
-			path: ../../../src/console/ConsoleCommandSender.php
-
 		-
 			message: "#^Call to function assert\\(\\) with false and 'unknown hit type' will always evaluate to false\\.$#"
 			count: 1
@@ -35,21 +30,11 @@ parameters:
 			count: 1
 			path: ../../../src/network/mcpe/raklib/SnoozeAwarePthreadsChannelWriter.php
 
-		-
-			message: "#^Comparison operation \"\\<\" between int\\<1, max\\> and 1 is always false\\.$#"
-			count: 1
-			path: ../../../src/player/Player.php
-
 		-
 			message: "#^Dead catch \\- RuntimeException is never thrown in the try block\\.$#"
 			count: 1
 			path: ../../../src/plugin/PluginManager.php
 
-		-
-			message: "#^Offset \\(int\\|string\\) on array\\<pocketmine\\\\plugin\\\\Plugin\\> in isset\\(\\) always exists and is not nullable\\.$#"
-			count: 1
-			path: ../../../src/plugin/PluginManager.php
-
 		-
 			message: "#^Static property pocketmine\\\\scheduler\\\\AsyncTask\\:\\:\\$threadLocalStorage \\(ArrayObject\\<int, array\\<string, mixed\\>\\>\\|null\\) does not accept non\\-empty\\-array\\<int, non\\-empty\\-array\\<string, mixed\\>\\>\\|ArrayObject\\<int, array\\<string, mixed\\>\\>\\.$#"
 			count: 1
@@ -65,11 +50,6 @@ parameters:
 			count: 1
 			path: ../../../src/thread/Worker.php
 
-		-
-			message: "#^Call to function is_resource\\(\\) with resource will always evaluate to true\\.$#"
-			count: 2
-			path: ../../../src/world/format/io/region/RegionLoader.php
-
 		-
 			message: "#^Casting to int something that's already int\\.$#"
 			count: 1

tests/phpstan/configs/runtime-type-checks.neon

@@ -1,12 +0,0 @@
-parameters:
-	ignoreErrors:
-		-
-			message: "#^Casting to int something that's already int\\.$#"
-			count: 2
-			path: ../../../src/item/Item.php
-
-		-
-			message: "#^Instanceof between pocketmine\\\\nbt\\\\tag\\\\CompoundTag and pocketmine\\\\nbt\\\\tag\\\\CompoundTag will always evaluate to true\\.$#"
-			count: 1
-			path: ../../../src/network/mcpe/handler/InGamePacketHandler.php
-

tests/phpunit/block/BlockTest.php

@@ -104,7 +104,7 @@ class BlockTest extends TestCase{
 	 * @return int[][]
 	 * @phpstan-return list<array{int,int}>
 	 */
-	public function blockGetProvider() : array{
+	public static function blockGetProvider() : array{
 		return [
 			[BlockLegacyIds::STONE, 5],
 			[BlockLegacyIds::GOLD_BLOCK, 0],

tests/phpunit/block/BrewingStandTest.php

@@ -33,7 +33,7 @@ class BrewingStandTest extends TestCase{
 	/**
 	 * @phpstan-return \Generator<int, array{list<BrewingStandSlot>}, void, void>
 	 */
-	public function slotsProvider() : \Generator{
+	public static function slotsProvider() : \Generator{
 		yield [array_values(BrewingStandSlot::getAll())];
 		yield [[BrewingStandSlot::EAST()]];
 		yield [[BrewingStandSlot::EAST(), BrewingStandSlot::NORTHWEST()]];

tests/phpunit/command/utils/CommandStringHelperTest.php

@@ -27,7 +27,7 @@ use PHPUnit\Framework\TestCase;
 
 class CommandStringHelperTest extends TestCase{
 
-	public function parseQuoteAwareProvider() : \Generator{
+	public static function parseQuoteAwareProvider() : \Generator{
 		yield [
 			'give "steve jobs" apple',
 			['give', 'steve jobs', 'apple']

tests/phpunit/event/HandlerListManagerTest.php

@@ -49,7 +49,7 @@ class HandlerListManagerTest extends TestCase{
 	 * @return \Generator|mixed[][]
 	 * @phpstan-return \Generator<int, array{\ReflectionClass<Event>, bool, string}, void, void>
 	 */
-	public function isValidClassProvider() : \Generator{
+	public static function isValidClassProvider() : \Generator{
 		yield [new \ReflectionClass(Event::class), false, "event base should not be handleable"];
 		yield [new \ReflectionClass(TestConcreteEvent::class), true, ""];
 		yield [new \ReflectionClass(TestAbstractEvent::class), false, "abstract event cannot be handled"];
@@ -69,7 +69,7 @@ class HandlerListManagerTest extends TestCase{
 	 * @return \Generator|\ReflectionClass[][]
 	 * @phpstan-return \Generator<int, array{\ReflectionClass<Event>, \ReflectionClass<Event>|null}, void, void>
 	 */
-	public function resolveParentClassProvider() : \Generator{
+	public static function resolveParentClassProvider() : \Generator{
 		yield [new \ReflectionClass(TestConcreteExtendsAllowHandleEvent::class), new \ReflectionClass(TestAbstractAllowHandleEvent::class)];
 		yield [new \ReflectionClass(TestConcreteEvent::class), null];
 		yield [new \ReflectionClass(TestConcreteExtendsAbstractEvent::class), null];

tests/phpunit/item/LegacyStringToItemParserTest.php

@@ -31,7 +31,7 @@ class LegacyStringToItemParserTest extends TestCase{
 	 * @return mixed[][]
 	 * @phpstan-return list<array{string,int,int}>
 	 */
-	public function itemFromStringProvider() : array{
+	public static function itemFromStringProvider() : array{
 		return [
 			["dye:4", ItemIds::DYE, 4],
 			["351", ItemIds::DYE, 0],

tests/phpunit/plugin/ApiVersionTest.php

@@ -32,7 +32,7 @@ class ApiVersionTest extends TestCase{
 	 * @return \Generator|mixed[][]
 	 * @phpstan-return \Generator<int, array{string, string, bool}, void, void>
 	 */
-	public function compatibleApiProvider() : \Generator{
+	public static function compatibleApiProvider() : \Generator{
 		yield ["3.0.0", "3.0.0", true];
 		yield ["3.1.0", "3.0.0", true];
 		yield ["3.0.0", "3.1.0", false];
@@ -58,7 +58,7 @@ class ApiVersionTest extends TestCase{
 	 * @return mixed[][][]
 	 * @phpstan-return \Generator<int, array{list<string>, list<string>}, void, void>
 	 */
-	public function ambiguousVersionsProvider() : \Generator{
+	public static function ambiguousVersionsProvider() : \Generator{
 		yield [["3.0.0"], []];
 		yield [["3.0.0", "3.0.1"], ["3.0.0", "3.0.1"]];
 		yield [["3.0.0", "3.1.0", "4.0.0"], ["3.0.0", "3.1.0"]];