Release 5.0.0-ALPHA4

this will also make it marginally easier to switch to a unified system.

.github/dependabot.yml

@@ -6,3 +6,13 @@ updates:
     interval: daily
     time: "10:00"
   open-pull-requests-limit: 10
+
+- package-ecosystem: gitsubmodule
+  directory: "/"
+  schedule:
+    interval: daily
+
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily

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

@@ -0,0 +1,97 @@
+name: Update Docker Hub images
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    name: Update Docker Hub images
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Clone pmmp/PocketMine-Docker repository
+        uses: actions/checkout@v3
+        with:
+          repository: pmmp/PocketMine-Docker
+          fetch-depth: 1
+
+      - name: Get tag names
+        id: tag-name
+        run: |
+          VERSION=$(echo "${{ github.ref }}" | sed 's{^refs/tags/{{')
+          echo ::set-output name=TAG_NAME::$VERSION
+          echo ::set-output name=MAJOR::$(echo $VERSION | cut -d. -f1)
+          echo ::set-output name=MINOR::$(echo $VERSION | cut -d. -f1-2)
+
+      - name: Download new release information
+        run: curl -f -L ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ steps.tag-name.outputs.TAG_NAME }}/build_info.json -o new_build_info.json
+
+      - name: Detect channel
+        id: channel
+        run: echo ::set-output name=CHANNEL::$(jq -r '.channel' new_build_info.json)
+
+      - name: Get name of Docker repository name
+        id: docker-repo-name
+        run: echo ::set-output name=NAME::$(echo "${GITHUB_REPOSITORY,,}")
+
+      - name: Build image for tag
+        uses: docker/build-push-action@v3.1.1
+        with:
+          push: true
+          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 }}
+          build-args: |
+            PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
+            PMMP_REPO=${{ github.repository }}
+
+      - name: Build image for major tag
+        if: steps.channel.outputs.CHANNEL == 'stable'
+        uses: docker/build-push-action@v3.1.1
+        with:
+          push: true
+          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 }}
+          build-args: |
+            PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
+            PMMP_REPO=${{ github.repository }}
+
+      - name: Build image for minor tag
+        if: steps.channel.outputs.CHANNEL == 'stable'
+        uses: docker/build-push-action@v3.1.1
+        with:
+          push: true
+          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 }}
+          build-args: |
+            PMMP_TAG=${{ steps.tag-name.outputs.TAG_NAME }}
+            PMMP_REPO=${{ github.repository }}
+
+      - name: Build image for latest tag
+        if: steps.channel.outputs.CHANNEL == 'stable'
+        uses: docker/build-push-action@v3.1.1
+        with:
+          push: true
+          context: ./pocketmine-mp
+          tags: |
+            ${{ 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-embed.php

@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace pocketmine;
+
+use pocketmine\utils\Internet;
+use function dirname;
+use function fwrite;
+use function is_array;
+use function json_decode;
+use function json_encode;
+use const JSON_THROW_ON_ERROR;
+use const STDERR;
+
+require dirname(__DIR__, 2) . '/vendor/autoload.php';
+
+/**
+ * @phpstan-return array<string, mixed>
+ */
+function generateDiscordEmbed(string $version, string $channel, string $description, string $detailsUrl, string $sourceUrl, string $pharDownloadUrl, string $buildLogUrl) : array{
+	return [
+		"embeds" => [
+			[
+				"title" => "New PocketMine-MP release: $version ($channel)",
+				"description" => <<<DESCRIPTION
+$description
+
+[Details]($detailsUrl) | [Source Code]($sourceUrl) | [Build Log]($buildLogUrl) | [Download]($pharDownloadUrl)
+DESCRIPTION,
+				"url" => $detailsUrl,
+				"color" => $channel === "stable" ? 0x57ab5a : 0xc69026
+			]
+		]
+	];
+}
+
+if(count($argv) !== 5){
+	fwrite(STDERR, "Required arguments: github repo, version, API token\n");
+	exit(1);
+}
+[, $repo, $tagName, $token, $hookURL] = $argv;
+
+$result = Internet::getURL('https://api.github.com/repos/' . $repo . '/releases/tags/' . $tagName, extraHeaders: [
+	'Authorization: token ' . $token
+]);
+if($result === null){
+	fwrite(STDERR, "failed to access GitHub API\n");
+	return;
+}
+if($result->getCode() !== 200){
+	fwrite(STDERR, "Error accessing GitHub API: " . $result->getCode() . "\n");
+	fwrite(STDERR, $result->getBody() . "\n");
+	exit(1);
+}
+
+$releaseInfoJson = json_decode($result->getBody(), true, JSON_THROW_ON_ERROR);
+if(!is_array($releaseInfoJson)){
+	fwrite(STDERR, "Invalid release JSON returned from GitHub API\n");
+	exit(1);
+}
+$buildInfoPath = 'https://github.com/' . $repo . '/releases/download/' . $tagName . '/build_info.json';
+
+$buildInfoResult = Internet::getURL($buildInfoPath, extraHeaders: [
+	'Authorization: token ' . $token
+]);
+if($buildInfoResult === null){
+	fwrite(STDERR, "missing build_info.json\n");
+	exit(1);
+}
+if($buildInfoResult->getCode() !== 200){
+	fwrite(STDERR, "error accessing build_info.json: " . $buildInfoResult->getCode() . "\n");
+	fwrite(STDERR, $buildInfoResult->getBody() . "\n");
+	exit(1);
+}
+
+$buildInfoJson = json_decode($buildInfoResult->getBody(), true, JSON_THROW_ON_ERROR);
+if(!is_array($buildInfoJson)){
+	fwrite(STDERR, "invalid build_info.json\n");
+	exit(1);
+}
+$detailsUrl = $buildInfoJson["details_url"];
+$sourceUrl = $buildInfoJson["source_url"];
+$pharDownloadUrl = $buildInfoJson["download_url"];
+$buildLogUrl = $buildInfoJson["build_log_url"];
+
+$description = $releaseInfoJson["body"];
+
+$discordPayload = generateDiscordEmbed($buildInfoJson["base_version"], $buildInfoJson["channel"], $description, $detailsUrl, $sourceUrl, $pharDownloadUrl, $buildLogUrl);
+
+$response = Internet::postURL(
+	$hookURL,
+	json_encode($discordPayload, JSON_THROW_ON_ERROR),
+	extraHeaders: ['Content-Type: application/json']
+);
+if($response?->getCode() !== 204){
+	fwrite(STDERR, "failed to send Discord webhook\n");
+	fwrite(STDERR, $response?->getBody() ?? "no response body\n");
+	exit(1);
+}

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

@@ -0,0 +1,38 @@
+name: Notify Discord webhook of release
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup PHP and tools
+        uses: shivammathur/setup-php@2.21.2
+        with:
+          php-version: 8.0
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction --ignore-platform-reqs
+
+      - name: Get actual tag name
+        id: tag-name
+        run: echo ::set-output name=TAG_NAME::$(echo "${{ github.ref }}" | sed 's{^refs/tags/{{')
+
+      - name: Run webhook post script
+        run: php .github/workflows/discord-release-embed.php ${{ github.repository }} ${{ steps.tag-name.outputs.TAG_NAME }} ${{ github.token }} ${{ secrets.DISCORD_RELEASE_WEBHOOK }}

.github/workflows/draft-release.yml

@@ -13,17 +13,17 @@ jobs:
       fail-fast: false
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.12.0
+        uses: shivammathur/setup-php@2.21.2
         with:
           php-version: 8.0
 
       - name: Restore Composer package cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/composer/files
@@ -57,10 +57,10 @@ jobs:
           echo ::set-output name=PM_VERSION_MD::$(php -r 'require "vendor/autoload.php"; echo str_replace(".", "", \pocketmine\VersionInfo::BASE_VERSION);')
 
       - name: Generate build info
-        run: php build/generate-build-info-json.php ${{ github.sha }} ${{ steps.get-pm-version.outputs.PM_VERSION }} ${{ github.repository }} ${{ steps.build-number.outputs.BUILD_NUMBER }} > build_info.json
+        run: php build/generate-build-info-json.php ${{ github.sha }} ${{ steps.get-pm-version.outputs.PM_VERSION }} ${{ github.repository }} ${{ steps.build-number.outputs.BUILD_NUMBER }} ${{ github.run_id }} > build_info.json
 
       - name: Upload release artifacts
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: release_artifacts
           path: |
@@ -69,7 +69,7 @@ jobs:
             ${{ github.workspace }}/build_info.json
 
       - name: Create draft release
-        uses: ncipollo/release-action@v1.8.6
+        uses: ncipollo/release-action@v1.10.0
         with:
           artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json
           commit: ${{ github.sha }}
@@ -80,4 +80,4 @@ jobs:
           body: |
             **For Minecraft: Bedrock Edition ${{ steps.get-pm-version.outputs.MCPE_VERSION }}**
 
-            Please see the [changelogs](/changelogs/${{ steps.get-pm-version.outputs.PM_VERSION_SHORT }}.md#${{ steps.get-pm-version.outputs.PM_VERSION_MD }}) for details.
+            Please see the [changelogs](${{ github.server_url }}/${{ github.repository }}/blob/${{ steps.get-pm-version.outputs.PM_VERSION }}/changelogs/${{ steps.get-pm-version.outputs.PM_VERSION_SHORT }}.md#${{ steps.get-pm-version.outputs.PM_VERSION_MD }}) for details.

.github/workflows/main.yml

@@ -13,11 +13,11 @@ jobs:
     strategy:
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.14]
+        php: [8.0.23, 8.1.10]
 
     steps:
       - name: Build and prepare PHP cache
-        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
+        uses: pmmp/setup-php-action@82a44d659bf5046612c69f036af3e14dc32e3fa8
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
@@ -31,13 +31,13 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.14]
+        php: [8.0.23, 8.1.10]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
+        uses: pmmp/setup-php-action@82a44d659bf5046612c69f036af3e14dc32e3fa8
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
@@ -46,7 +46,7 @@ jobs:
         run: curl -sS https://getcomposer.org/installer | php
 
       - name: Restore Composer package cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/composer/files
@@ -69,13 +69,13 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.14]
+        php: [8.0.23, 8.1.10]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
+        uses: pmmp/setup-php-action@82a44d659bf5046612c69f036af3e14dc32e3fa8
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
@@ -84,7 +84,7 @@ jobs:
         run: curl -sS https://getcomposer.org/installer | php
 
       - name: Restore Composer package cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/composer/files
@@ -107,15 +107,15 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.14]
+        php: [8.0.23, 8.1.10]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: true
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
+        uses: pmmp/setup-php-action@82a44d659bf5046612c69f036af3e14dc32e3fa8
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
@@ -124,7 +124,7 @@ jobs:
         run: curl -sS https://getcomposer.org/installer | php
 
       - name: Restore Composer package cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/composer/files
@@ -147,13 +147,13 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [8.0.14]
+        php: [8.0.23, 8.1.10]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Setup PHP
-        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
+        uses: pmmp/setup-php-action@82a44d659bf5046612c69f036af3e14dc32e3fa8
         with:
           php-version: ${{ matrix.php }}
           install-path: "./bin"
@@ -162,7 +162,7 @@ jobs:
         run: curl -sS https://getcomposer.org/installer | php
 
       - name: Restore Composer package cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cache/composer/files
@@ -180,6 +180,9 @@ jobs:
       - name: Regenerate KnownTranslation APIs
         run: php build/generate-known-translation-apis.php
 
+      - name: Regenerate RuntimeEnum(De)serializer
+        run: php build/generate-runtime-enum-serializers.php
+
       - name: Verify code is unchanged
         run: |
           git diff
@@ -192,13 +195,13 @@ jobs:
       fail-fast: false
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.15.0
+        uses: shivammathur/setup-php@2.21.2
         with:
           php-version: 8.0
-          tools: php-cs-fixer:3.2
+          tools: php-cs-fixer:3.11
 
       - name: Run PHP-CS-Fixer
         run: php-cs-fixer fix --dry-run --diff --ansi

.github/workflows/support.yml

@@ -13,7 +13,14 @@ jobs:
           github-token: ${{ github.token }}
           support-label:  "Support request"
           issue-comment: >
-            Thanks, but this issue tracker is not intended for support requests. Please read the guidelines on [submitting an issue](https://github.com/pmmp/PocketMine-MP/blob/master/CONTRIBUTING.md#creating-an-issue).
+            Hi, we only accept **bug reports** on this issue tracker, but this issue looks like a support request.
+
+
+            Instead of creating an issue, try the following:
+
+            - Check our [Documentation](https://doc.pmmp.io) to see if you can find answers there
+
+            - Ask the community on our [Discord server](https://discord.gg/bmSAZBG) or our [Forums](https://forums.pmmp.io)
 
 
             [Docs](https://pmmp.rtfd.io) | [Discord](https://discord.gg/bmSAZBG) | [Forums](https://forums.pmmp.io)

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

@@ -22,7 +22,8 @@
 declare(strict_types=1);
 
 const VERSIONS = [
-	"8.0"
+	"8.0",
+	"8.1"
 ];
 
 $workflowFile = file_get_contents(__DIR__ . '/main.yml');

.github/workflows/update-updater-api.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Install jq
         run: sudo apt update && sudo apt install jq -y
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           repository: pmmp/update.pmmp.io
           ssh-key: ${{ secrets.UPDATE_PMMP_IO_DEPLOY_KEY }}

.idea/fileTemplates/includes/PHP File Header.php

@@ -16,6 +16,6 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);

.php-cs-fixer.php

@@ -42,12 +42,38 @@ return (new PhpCsFixer\Config)
 			'import_functions' => true,
 			'import_classes' => null,
 		],
+		'header_comment' => [
+			'comment_type' => 'comment',
+			'header' => <<<BODY
+
+ ____            _        _   __  __ _                  __  __ ____
+|  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+| |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+|  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+|_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+
+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/
+
+
+BODY,
+			'location' => 'after_open'
+		],
 		'indentation_type' => true,
 		'logical_operators' => true,
 		'native_function_invocation' => [
 			'scope' => 'namespaced',
 			'include' => ['@all'],
 		],
+		'new_with_braces' => [
+			'named_class' => true,
+			'anonymous_class' => false,
+		],
 		'no_closing_tag' => true,
 		'no_empty_phpdoc' => true,
 		'no_extra_blank_lines' => true,

README.md

@@ -1,5 +1,13 @@
 <p align="center">
-	<a href="https://pmmp.io"><img src="http://cdn.pocketmine.net/img/PocketMine-MP-h.png"></img></a><br>
+	<a href="https://pmmp.io">
+		<!--[if IE]>
+			<img src="https://github.com/pmmp/PocketMine-MP/blob/stable/.github/readme/pocketmine.png" alt="The PocketMine-MP logo" title="PocketMine" loading="eager" />
+		<![endif]-->
+		<picture>
+			<source srcset="https://github.com/pmmp/PocketMine-MP/raw/stable/.github/readme/pocketmine-dark.png" media="(prefers-color-scheme: dark)">
+			<img src="https://github.com/pmmp/PocketMine-MP/raw/stable/.github/readme/pocketmine.png" loading="eager" />
+		</picture>
+	</a><br>
 	<b>A highly customisable, open source server software for Minecraft: Bedrock Edition written in PHP</b>
 </p>
 
@@ -27,7 +35,8 @@
 ## For developers
  * [Building and running from source](BUILDING.md)
  * [Developer documentation](https://devdoc.pmmp.io) - General documentation for PocketMine-MP plugin developers
- * [Latest API documentation](https://jenkins.pmmp.io/job/PocketMine-MP-doc/doxygen/) - Doxygen documentation generated from development
+ * [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
  * [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)

SECURITY.md

@@ -7,10 +7,11 @@ GitHub is public and anyone can see the issues you post on the issue tracker, in
 
 **WARNING: You may put live servers at risk by reporting a vulnerability on the GitHub issue tracker.**
 
-**Contact us** by sending an email to [**team@pmmp.io**](mailto:team@pmmp.io?subject=Security%20Vulnerability%20in%20PocketMine-MP). Include the following information:
+**Contact us** by sending an email to [**security@pmmp.io**](mailto:security@pmmp.io). Include the following information:
 
 - Version of PocketMine-MP
 - Detailed description of the vulnerability (e.g. how to exploit it, what the effects are)
+- Your GitHub username, if you wish to be credited for reporting the problem in the security advisory
 
 Please note that we can't guarantee a reply to every email.
 

build/generate-block-serializer-consts.php

@@ -0,0 +1,195 @@
+<?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\build\generate_block_serializer_consts;
+
+use pocketmine\data\bedrock\block\BlockStateData;
+use pocketmine\data\bedrock\block\BlockStateNames;
+use pocketmine\data\bedrock\block\BlockStateStringValues;
+use pocketmine\data\bedrock\block\BlockTypeNames;
+use pocketmine\errorhandler\ErrorToExceptionHandler;
+use pocketmine\nbt\NbtException;
+use pocketmine\network\mcpe\convert\BlockStateDictionary;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\utils\Utils;
+use function array_values;
+use function asort;
+use function count;
+use function dirname;
+use function explode;
+use function fclose;
+use function file_get_contents;
+use function fopen;
+use function fwrite;
+use function is_string;
+use function ksort;
+use function mb_strtoupper;
+use function sort;
+use function strrpos;
+use function strtoupper;
+use function substr;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+class BlockPaletteReport{
+	/**
+	 * @var string[]
+	 * @phpstan-var array<string, string>
+	 */
+	public array $seenTypes = [];
+	/**
+	 * @var string[][]
+	 * @phpstan-var array<string, array<mixed, mixed>>
+	 */
+	public array $seenStateValues = [];
+}
+
+/**
+ * @param BlockStateData[] $states
+ * @phpstan-param list<BlockStateData> $states
+ */
+function generateBlockPaletteReport(array $states) : BlockPaletteReport{
+	$result = new BlockPaletteReport();
+
+	foreach($states as $stateData){
+		$name = $stateData->getName();
+		$result->seenTypes[$name] = $name;
+		foreach(Utils::stringifyKeys($stateData->getStates()) as $k => $v){
+			$result->seenStateValues[$k][$v->getValue()] = $v->getValue();
+			asort($result->seenStateValues[$k]);
+		}
+	}
+
+	ksort($result->seenTypes, SORT_STRING);
+	ksort($result->seenStateValues, SORT_STRING);
+	return $result;
+}
+
+function constifyMcId(string $id) : string{
+	return strtoupper(explode(":", $id, 2)[1]);
+}
+
+function generateClassHeader(string $className) : string{
+	$backslashPos = strrpos($className, "\\");
+	if($backslashPos === false){
+		throw new AssumptionFailedError("Expected a namespaced class FQN");
+	}
+	$namespace = substr($className, 0, $backslashPos);
+	$shortName = substr($className, $backslashPos + 1);
+	return <<<HEADER
+<?php
+
+declare(strict_types=1);
+
+namespace $namespace;
+
+/**
+ * This class is generated automatically from the block palette for the current version. Do not edit it manually.
+ */
+final class $shortName{
+	private function __construct(){
+		//NOOP
+	}
+
+
+HEADER;
+}
+
+/**
+ * @phpstan-param list<string> $seenIds
+ */
+function generateBlockIds(array $seenIds) : void{
+	$output = ErrorToExceptionHandler::trapAndRemoveFalse(fn() => fopen(dirname(__DIR__) . '/src/data/bedrock/block/BlockTypeNames.php', 'wb'));
+
+	fwrite($output, generateClassHeader(BlockTypeNames::class));
+
+	foreach($seenIds as $id){
+		fwrite($output, "\tpublic const " . constifyMcId($id) . " = \"" . $id . "\";\n");
+	}
+
+	fwrite($output, "}\n");
+	fclose($output);
+}
+
+function generateBlockStateNames(BlockPaletteReport $data) : void{
+	$output = ErrorToExceptionHandler::trapAndRemoveFalse(fn() => fopen(dirname(__DIR__) . '/src/data/bedrock/block/BlockStateNames.php', 'wb'));
+
+	fwrite($output, generateClassHeader(BlockStateNames::class));
+	foreach(Utils::stringifyKeys($data->seenStateValues) as $state => $values){
+		$constName = mb_strtoupper($state, 'US-ASCII');
+		fwrite($output, "\tpublic const $constName = \"$state\";\n");
+	}
+
+	fwrite($output, "}\n");
+	fclose($output);
+}
+
+function generateBlockStringValues(BlockPaletteReport $data) : void{
+	$output = ErrorToExceptionHandler::trapAndRemoveFalse(fn() => fopen(dirname(__DIR__) . '/src/data/bedrock/block/BlockStateStringValues.php', 'wb'));
+
+	fwrite($output, generateClassHeader(BlockStateStringValues::class));
+	foreach(Utils::stringifyKeys($data->seenStateValues) as $stateName => $values){
+		$anyWritten = false;
+		sort($values, SORT_STRING);
+		foreach($values as $value){
+			if(!is_string($value)){
+				continue;
+			}
+			$anyWritten = true;
+			$constName = mb_strtoupper($stateName . "_" . $value, 'US-ASCII');
+			fwrite($output, "\tpublic const $constName = \"$value\";\n");
+		}
+		if($anyWritten){
+			fwrite($output, "\n");
+		}
+	}
+	fwrite($output, "}\n");
+	fclose($output);
+}
+
+if(count($argv) !== 2){
+	fwrite(STDERR, "This script regenerates BlockTypeNames, BlockStateNames and BlockStateStringValues from a given palette file\n");
+	fwrite(STDERR, "Required arguments: path to block palette file\n");
+	exit(1);
+}
+
+$palettePath = $argv[1];
+$paletteRaw = file_get_contents($palettePath);
+if($paletteRaw === false){
+	fwrite(STDERR, "Failed to read block palette file\n");
+	exit(1);
+}
+
+try{
+	$states = BlockStateDictionary::loadPaletteFromString($paletteRaw);
+}catch(NbtException){
+	fwrite(STDERR, "Invalid block palette file $argv[1]\n");
+	exit(1);
+}
+
+$report = generateBlockPaletteReport($states);
+generateBlockIds(array_values($report->seenTypes));
+generateBlockStateNames($report);
+generateBlockStringValues($report);
+
+echo "Done. Don't forget to run CS fixup after generating code.\n";

build/generate-build-info-json.php

@@ -17,14 +17,14 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 require dirname(__DIR__) . '/vendor/autoload.php';
 
-if(count($argv) !== 5){
-	fwrite(STDERR, "required args: <git hash> <tag name> <github repo (owner/name)> <build number>");
+if(count($argv) !== 6){
+	fwrite(STDERR, "required args: <git hash> <tag name> <github repo (owner/name)> <build number> <github actions run ID>\n");
 	exit(1);
 }
 
@@ -40,4 +40,5 @@ echo json_encode([
 	"details_url" => "https://github.com/$argv[3]/releases/tag/$argv[2]",
 	"download_url" => "https://github.com/$argv[3]/releases/download/$argv[2]/PocketMine-MP.phar",
 	"source_url" => "https://github.com/$argv[3]/tree/$argv[2]",
+	"build_log_url" => "https://github.com/$argv[3]/actions/runs/$argv[5]",
 ], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR) . "\n";

build/generate-item-type-names.php

@@ -0,0 +1,95 @@
+<?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\build\generate_item_serializer_ids;
+
+use pocketmine\errorhandler\ErrorToExceptionHandler;
+use pocketmine\network\mcpe\convert\ItemTypeDictionaryFromDataHelper;
+use pocketmine\network\mcpe\protocol\serializer\ItemTypeDictionary;
+use pocketmine\utils\Utils;
+use function asort;
+use function count;
+use function dirname;
+use function explode;
+use function fclose;
+use function file_get_contents;
+use function fopen;
+use function fwrite;
+use function strtoupper;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+function constifyMcId(string $id) : string{
+	return strtoupper(explode(":", $id, 2)[1]);
+}
+
+function generateItemIds(ItemTypeDictionary $dictionary) : void{
+	$ids = [];
+	foreach($dictionary->getEntries() as $entry){
+		if($entry->getNumericId() < 256){ //blockitems are serialized via BlockStateSerializer
+			continue;
+		}
+		$ids[$entry->getStringId()] = $entry->getStringId();
+	}
+	asort($ids, SORT_STRING);
+
+	$file = ErrorToExceptionHandler::trapAndRemoveFalse(fn() => fopen(dirname(__DIR__) . '/src/data/bedrock/item/ItemTypeNames.php', 'wb'));
+
+	fwrite($file, <<<'HEADER'
+<?php
+
+declare(strict_types=1);
+
+namespace pocketmine\data\bedrock\item;
+
+/**
+ * This class is generated automatically from the item type dictionary for the current version. Do not edit it manually.
+ */
+final class ItemTypeNames{
+
+HEADER
+	);
+
+	foreach(Utils::stringifyKeys($ids) as $id){
+		fwrite($file, "\tpublic const " . constifyMcId($id) . " = \"" . $id . "\";\n");
+	}
+	fwrite($file, "}\n");
+	fclose($file);
+}
+
+if(count($argv) !== 2){
+	fwrite(STDERR, "This script regenerates ItemTypeNames from a given item dictionary file\n");
+	fwrite(STDERR, "Required argument: path to item type dictionary file\n");
+	exit(1);
+}
+
+$raw = file_get_contents($argv[1]);
+if($raw === false){
+	fwrite(STDERR, "Failed to read item type dictionary file\n");
+	exit(1);
+}
+
+$dictionary = ItemTypeDictionaryFromDataHelper::loadFromString($raw);
+generateItemIds($dictionary);
+
+echo "Done. Don't forget to run CS fixup after generating code.\n";

build/generate-known-translation-apis.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -75,7 +75,7 @@ const SHARED_HEADER = <<<'HEADER'
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

build/generate-registry-annotations.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -29,7 +29,9 @@ use function count;
 use function dirname;
 use function file_get_contents;
 use function file_put_contents;
+use function fwrite;
 use function implode;
+use function is_dir;
 use function ksort;
 use function mb_strtoupper;
 use function preg_match;
@@ -39,7 +41,8 @@ use function substr;
 use const SORT_STRING;
 
 if(count($argv) !== 2){
-	die("Provide a path to process");
+	fwrite(STDERR, "Provide a path to process\n");
+	exit(1);
 }
 
 /**
@@ -80,29 +83,24 @@ function generateMethodAnnotations(string $namespaceName, array $members) : stri
 	return implode("\n", $lines);
 }
 
-require dirname(__DIR__) . '/vendor/autoload.php';
-
-foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($argv[1], \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_PATHNAME)) as $file){
-	if(substr($file, -4) !== ".php"){
-		continue;
-	}
+function processFile(string $file) : void{
 	$contents = file_get_contents($file);
 	if($contents === false){
 		throw new \RuntimeException("Failed to get contents of $file");
 	}
 
 	if(preg_match("/(*ANYCRLF)^namespace (.+);$/m", $contents, $matches) !== 1 || preg_match('/(*ANYCRLF)^((final|abstract)\s+)?class /m', $contents) !== 1){
-		continue;
+		return;
 	}
 	$shortClassName = basename($file, ".php");
 	$className = $matches[1] . "\\" . $shortClassName;
 	if(!class_exists($className)){
-		continue;
+		return;
 	}
 	$reflect = new \ReflectionClass($className);
 	$docComment = $reflect->getDocComment();
 	if($docComment === false || preg_match("/(*ANYCRLF)^\s*\*\s*@generate-registry-docblock$/m", $docComment) !== 1){
-		continue;
+		return;
 	}
 	echo "Found registry in $file\n";
 
@@ -116,3 +114,18 @@ foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($argv[1],
 		echo "No changes made to file $file\n";
 	}
 }
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+if(is_dir($argv[1])){
+	/** @var string $file */
+	foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($argv[1], \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_PATHNAME)) as $file){
+		if(substr($file, -4) !== ".php"){
+			continue;
+		}
+
+		processFile($file);
+	}
+}else{
+	processFile($argv[1]);
+}

build/generate-runtime-enum-serializers.php

@@ -0,0 +1,248 @@
+<?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\build\generate_runtime_enum_serializers;
+
+use pocketmine\block\utils\BellAttachmentType;
+use pocketmine\block\utils\CopperOxidation;
+use pocketmine\block\utils\CoralType;
+use pocketmine\block\utils\DirtType;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\block\utils\FroglightType;
+use pocketmine\block\utils\LeverFacing;
+use pocketmine\block\utils\MushroomBlockType;
+use pocketmine\block\utils\SkullType;
+use pocketmine\block\utils\SlabType;
+use pocketmine\item\PotionType;
+use pocketmine\item\SuspiciousStewType;
+use function array_key_first;
+use function array_keys;
+use function array_map;
+use function ceil;
+use function count;
+use function dirname;
+use function file_put_contents;
+use function implode;
+use function ksort;
+use function lcfirst;
+use function log;
+use function ob_get_clean;
+use function ob_start;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+/**
+ * @param string[] $memberNames
+ * @phpstan-param list<string> $memberNames
+ *
+ * @return string[]
+ * @phpstan-return list<string>
+ */
+function buildWriterFunc(string $virtualTypeName, string $nativeTypeName, array $memberNames, string &$functionName) : array{
+	$bits = getBitsRequired($memberNames);
+	$lines = [];
+
+	$functionName = lcfirst($virtualTypeName);
+	$lines[] = "public function $functionName(\\$nativeTypeName \$value) : void{";
+	$lines[] = "\t\$this->int($bits, match(\$value){";
+
+	foreach($memberNames as $key => $memberName){
+		$lines[] = "\t\t$memberName => $key,";
+	}
+	$lines[] = "\t\tdefault => throw new \pocketmine\utils\AssumptionFailedError(\"All $virtualTypeName cases should be covered\")";
+	$lines[] = "\t});";
+	$lines[] = "}";
+
+	return $lines;
+}
+
+/**
+ * @param string[] $memberNames
+ * @phpstan-param list<string> $memberNames
+ *
+ * @return string[]
+ * @phpstan-return list<string>
+ */
+function buildReaderFunc(string $virtualTypeName, string $nativeTypeName, array $memberNames, string &$functionName) : array{
+	$bits = getBitsRequired($memberNames);
+	$lines = [];
+
+	$functionName = lcfirst($virtualTypeName);
+	$lines[] = "public function $functionName(\\$nativeTypeName &\$value) : void{";
+	$lines[] = "\t\$value = match(\$this->readInt($bits)){";
+
+	foreach($memberNames as $key => $memberName){
+		$lines[] = "\t\t$key => $memberName,";
+	}
+	$lines[] = "\t\tdefault => throw new InvalidSerializedRuntimeDataException(\"Invalid serialized value for $virtualTypeName\")";
+	$lines[] = "\t};";
+	$lines[] = "}";
+
+	return $lines;
+}
+
+/**
+ * @param mixed[] $members
+ */
+function getBitsRequired(array $members) : int{
+	return (int) ceil(log(count($members), 2));
+}
+
+/**
+ * @param object[] $members
+ * @phpstan-param array<string, object> $members
+ *
+ * @return string[]
+ * @phpstan-return list<string>
+ */
+function stringifyEnumMembers(array $members, string $enumClass) : array{
+	ksort($members, SORT_STRING);
+	return array_map(fn(string $enumCaseName) => "\\$enumClass::$enumCaseName()", array_keys($members));
+}
+
+/**
+ * @param object[] $enumMembers
+ * @phpstan-param array<string, object> $enumMembers
+ *
+ * @return string[]
+ * @phpstan-return list<string>
+ */
+function buildEnumWriterFunc(array $enumMembers, string &$functionName) : array{
+	$reflect = new \ReflectionClass($enumMembers[array_key_first($enumMembers)]);
+	return buildWriterFunc(
+		$reflect->getShortName(),
+		$reflect->getName(),
+		stringifyEnumMembers($enumMembers, $reflect->getName()),
+		$functionName
+	);
+}
+
+/**
+ * @param object[] $enumMembers
+ * @phpstan-param array<string, object> $enumMembers
+ *
+ * @return string[]
+ * @phpstan-return list<string>
+ */
+function buildEnumReaderFunc(array $enumMembers, string &$functionName) : array{
+	if(count($enumMembers) === 0){
+		throw new \InvalidArgumentException("Enum members cannot be empty");
+	}
+	$reflect = new \ReflectionClass($enumMembers[array_key_first($enumMembers)]);
+	return buildReaderFunc(
+		$reflect->getShortName(),
+		$reflect->getName(),
+		stringifyEnumMembers($enumMembers, $reflect->getName()),
+		$functionName
+	);
+}
+
+$enumsUsed = [
+	BellAttachmentType::getAll(),
+	CopperOxidation::getAll(),
+	CoralType::getAll(),
+	DirtType::getAll(),
+	DyeColor::getAll(),
+	FroglightType::getAll(),
+	LeverFacing::getAll(),
+	MushroomBlockType::getAll(),
+	SkullType::getAll(),
+	SlabType::getAll(),
+	SuspiciousStewType::getAll(),
+	PotionType::getAll()
+];
+
+$readerFuncs = [
+	"" => [
+		"abstract protected function readInt(int \$bits) : int;"
+	]
+];
+$writerFuncs = [
+	"" => [
+		"abstract public function int(int \$bits, int \$value) : void;"
+	]
+];
+$functionName = "";
+
+foreach($enumsUsed as $enumMembers){
+	$writerF = buildEnumWriterFunc($enumMembers, $functionName);
+	/** @var string $functionName */
+	$writerFuncs[$functionName] = $writerF;
+	$readerF = buildEnumReaderFunc($enumMembers, $functionName);
+	/** @var string $functionName */
+	$readerFuncs[$functionName] = $readerF;
+}
+
+/**
+ * @param string[][] $functions
+ * @phpstan-param array<string, list<string>> $functions
+ */
+function printFunctions(array $functions, string $className) : void{
+	ksort($functions, SORT_STRING);
+
+	ob_start();
+
+	echo <<<'HEADER'
+<?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\data\runtime;
+
+/**
+ * This class is auto-generated. Do not edit it manually.
+ * @see build/generate-runtime-enum-serializers.php
+ */
+
+HEADER;
+
+	echo "trait $className{\n\n";
+	echo implode("\n\n", array_map(fn(array $functionLines) => "\t" . implode("\n\t", $functionLines), $functions));
+	echo "\n\n}\n";
+
+	file_put_contents(dirname(__DIR__) . '/src/data/runtime/' . $className . '.php', ob_get_clean());
+}
+
+printFunctions($writerFuncs, "RuntimeEnumSerializerTrait");
+printFunctions($readerFuncs, "RuntimeEnumDeserializerTrait");
+
+echo "Done. Don't forget to run CS fixup after generating code.\n";

build/make-release.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

build/server-phar.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

changelogs/4.0.md

@@ -413,6 +413,7 @@ However, if we add `src-namespace-prefix: pmmp\TesterPlugin` to the `plugin.yml`
 
 ### Command
 - The following classes have been removed:
+  - `PluginIdentifiableCommand` - use `PluginOwned` and `PluginOwnedTrait`
   - `RemoteConsoleCommandSender`
 - The following API methods have signature changes:
   - `Command->setPermission()` argument is now mandatory (but still nullable).
@@ -1054,6 +1055,7 @@ However, if we add `src-namespace-prefix: pmmp\TesterPlugin` to the `plugin.yml`
   - `Player->addWindow()`: use `Player->setCurrentWindow()` instead
   - `Player->dataPacket()`: replaced by `NetworkSession->sendDataPacket()`
   - `Player->getAddress()`: replaced by `NetworkSession->getIp()`
+  - `Player->getClientId()`: the client ID can be found in `PlayerInfo->getExtraData()`
   - `Player->getPing()`: moved to `NetworkSession`
   - `Player->getPort()`: moved to `NetworkSession`
   - `Player->getWindow()`: use `Player->getCurrentWindow()` instead
@@ -1069,6 +1071,8 @@ However, if we add `src-namespace-prefix: pmmp\TesterPlugin` to the `plugin.yml`
 - API version checks are now more strict. It is no longer legal to declare multiple minimum versions on the same major version. Doing so will now cause the plugin to fail to load with the message `Multiple minimum API versions found for some major versions`.
 - `plugin.yml` YAML commands loading is now internalized inside `PluginBase`.
 - `PluginManager->registerEvent()` now has a simpler signature: `registerEvent(string $event, \Closure $handler, int $priority, Plugin $plugin, bool $handleCancelled = false)`. The provided closure must accept the specified event class as its only parameter. See [Event API changes](#event) for more details.
+- The following classes have been added:
+  - `PluginOwned`
 - The following classes have been removed:
   - `PluginLogger`
 - The following constants have been removed:
@@ -1627,3 +1631,21 @@ Released 25th January 2022.
 ## Fixes
 - Fixed ender chest not dropping itself when mined with a Silk Touch pickaxe.
 - The correct amount of fall damage is now taken when falling from a height onto hay bales.
+
+# 4.0.9
+Released 5th February 2022.
+
+## Fixes
+### Core
+- The spawn chunk of the default world is no longer loaded during shutdown. Previously, it would attempt to find a safe spawn to teleport players to, only to unload the target world of that safe spawn and not use it.
+- The spawn chunk of the default world is no longer loaded when unloading a non-default world containing zero players.
+- Fixed chunk version `8` in Bedrock worlds being treated as corrupted. These appeared in worlds between 1.2.13 and 1.8.0.
+
+### API
+- Added missing bounds check to `Liquid->setDecay()`.
+- Fixed `StringToItemParser` returning concrete instead of concrete powder when given `<color>_concrete_powder`.
+
+### Gameplay
+- Cobwebs now drop themselves when broken using shears.
+- Fixed spectator players being able to drop items.
+- Fixed collision shapes of Bell in different orientations.

changelogs/4.1-beta.md

@@ -0,0 +1,166 @@
+**For Minecraft: Bedrock Edition 1.18.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.1.0-BETA1
+Released 22nd January 2022.
+
+## General
+- Game mode names (e.g. `survival`, `creative`) may now be used for the `gamemode` property in `server.properties`.
+- Increased default maximum render distance to 16 chunks. Players with a render distance smaller than this will notice no difference.
+- The setup wizard now prompts for a maximum render distance value.
+- The setup wizard now prompts for an IPv6 port selection. Previously it would always use 19133.
+- `chunk-ticking.disable-block-ticking` now accepts block names like those used in the `/give` command.
+- The `/clear` command now behaves more like vanilla:
+  - The order of inventories is now the same as Bedrock.
+  - The cursor and offhand inventories are now cleared if necessary.
+
+## Technical
+- `PlayerAuthInputPacket` is now used instead of `MovePlayerPacket` for processing movements. This improves position and rotation accuracy.
+- `&&` and `||` are now always used instead of `and` and `or`.
+- New version of `pocketmine/errorhandler` is used by this version, adding support for `ErrorToExceptionHandler::trap()`. This enables reliably capturing `E_WARNING` and `E_NOTICE` from functions such as `yaml_parse()` and friends.
+- New dependency versions are required by this version:
+  - `pocketmine/bedrock-protocol` has been updated from 7.1.0 to [7.3.0](https://github.com/pmmp/BedrockProtocol/releases/tag/7.3.0%2Bbedrock-1.18.0).
+  - `pocketmine/errorhandler` has been updated from 0.3.0 to [0.6.0](https://github.com/pmmp/ErrorHandler/releases/tag/0.6.0).
+
+## API
+### Block
+- The following classes have been added:
+  - `Lectern`
+  - `Pumpkin`
+- The following public API methods have been added:
+  - `Block->getTypeId() : int` - returns an integer which uniquely identifies the block type, ignoring things like facing, colour etc.
+  - `VanillaBlocks::LECTERN()`
+
+### Entity
+- The following classes have been added:
+  - `animation\ItemEntityStackSizeChangeAnimation`
+- The following public API methods have been added:
+  - `object\ItemEntity->isMergeable(object\ItemEntity $other) : bool`
+  - `object\ItemEntity->setStackSize(int $size) : void`
+  - `object\ItemEntity->tryMergeInto(object\ItemEntity $other) : bool`
+  - `ExperienceManager->canAttractXpOrbs() : bool`
+  - `ExperienceManager->setCanAttractXpOrbs(bool $v = true) : void`
+  - `Entity->getSize() : EntitySizeInfo`
+  - `Living->isGliding() : bool`
+  - `Living->isSwimming() : bool`
+  - `Living->setGliding(bool $value = true) : void`
+  - `Living->setSwimming(bool $value = true) : void`
+- The following protected API methods have been added:
+  - `Entity->getBlocksIntersected(float $inset) : \Generator<int, Block, void, void>`
+
+### Event
+- `BlockSpreadEvent` is now called when fire spreads to the positions of blocks it burns away.
+- `BlockFormEvent` is now called when concrete powder turns into concrete due to contact with water.
+- The following classes have been added:
+  - `BlockMeltEvent` - called when ice or snow melts
+  - `ChestPairEvent` - called when two chests try to form a pair
+  - `PlayerToggleGlideEvent` - called when a player starts or stops gliding
+  - `PlayerToggleSwimEvent` - called when a player starts or stops swimming
+
+### Item
+- The following public API methods have been added:
+  - `SplashPotion->getType() : PotionType`
+  - `VanillaItems::AIR()`
+- The following API methods have been deprecated:
+  - `ItemFactory::air()` - use `VanillaItems::AIR()` instead
+
+### Player
+- The following public API methods have been added:
+  - `Player->hasBlockCollision() : bool`
+  - `Player->setHasBlockCollision(bool $value)` - allows controlling spectator-like no-clip behaviour without changing game mode
+  - `Player->toggleSwim(bool $swim) : bool` - called by the network system when the client tries to start/stop swimming
+  - `Player->toggleGlide(bool $glide) : bool` - called by the network system when the client tries to start/stop gliding
+
+### Server
+- The following public API constants have been added:
+  - `Server::DEFAULT_SERVER_NAME`
+  - `Server::DEFAULT_MAX_PLAYERS`
+  - `Server::DEFAULT_PORT_IPV4`
+  - `Server::DEFAULT_PORT_IPV6`
+  - `Server::DEFAULT_MAX_VIEW_DISTANCE`
+
+### Utils
+- Config parsing errors are now always represented by `ConfigLoadException` and include the path to the file in the message.
+- Added `TextFormat::MINECOIN_GOLD`, and support for it to the various `TextFormat` methods.
+- The following public API methods have been added:
+  - `Utils::assumeNotFalse()` - static analysis crutch to silence PHPStan errors without using `ignoreErrors` or `@phpstan-ignore-line`, which are both too coarse.
+- The following public API properties have been added:
+  - `Terminal::$COLOR_MINECOIN_GOLD`
+- The following classes have been added:
+  - `ConfigLoadException`
+- Fixed `Random->nextSignedInt()` to actually return a signed int. Previously it would return any integer value between 0 and 4,294,957,295.
+- Fixed `Random->nextSignedFloat()` to return a float between `-1.0` and `1.0`. Previously it would return any value between `0.0` and `2.0`.
+- `VersionString->getNumber()` output is now structured differently to fix overflow issues caused by the old format.
+
+### World
+- The following classes have been added:
+  - `sound\ItemUseOnBlockSound`
+  - `sound\LecternPlaceBookSound`
+
+## Gameplay
+### Blocks
+- Fire now spreads.
+- Implemented lectern blocks.
+- Added missing sounds for hoeing grass and dirt.
+- Added missing sounds for using a shovel on grass to create grass path.
+- Pumpkins can now be carved using shears.
+
+### Items
+- Dropped items of the same type now merge with each other.
+
+### Misc
+- Implemented player swimming.
+
+# 4.1.0-BETA2
+Released 27th January 2022.
+
+## API
+### Block
+- The following API methods have been added:
+  - `utils\BrewingStandSlot->getSlotNumber() : int`
+  - `utils\FurnaceType->getCookSound() : Sound`
+- The following API constants have been added:
+  - `tile\BrewingStand::BREW_TIME_TICKS`
+
+### Crafting
+- The following API methods have been added:
+  - `CraftingManager->getPotionContainerChangeRecipes() : array<int, array<string, PotionContainerChangeRecipe>>`
+  - `CraftingManager->getPotionTypeRecipes() : array<string, array<string, PotionTypeRecipe>>`
+  - `CraftingManager->registerPotionContainerChangeRecipe(PotionContainerChangeRecipe $recipe) : void`
+  - `CraftingManager->registerPotionTypeRecipe(PotionTypeRecipe $recipe) : void`
+- The following classes have been added:
+  - `BrewingRecipe`
+  - `PotionContainerChangeRecipe`
+  - `PotionTypeRecipe`
+
+### Event
+- The following classes have been added:
+  - `BrewItemEvent` - called when a brewing stand finishes brewing potions; this is called up to 3 times (once for each brewing slot, as needed)
+  - `BrewingFuelUseEvent` - called when a brewing stand consumes blaze powder
+  - `PlayerViewDistanceChangeEvent` - called whenever a player alters their render distance or requests one for the first time when connecting
+
+### World
+#### Sound
+- The following classes have been added:
+  - `BlastFurnaceSound` - the sound made by a blast furnace during smelting
+  - `FurnaceSound` - the sound made by a regular furnace during cooking or smelting
+  - `PotionFinishBrewingSound` - the sound made by a brewing stand when a potion finishes being brewed
+  - `SmokerSound` - the sound made by a smoker during cooking
+
+## Gameplay
+### Blocks
+- Brewing stands can now be used for brewing potions.
+- The visual appearance of a brewing stand now updates correctly when the contents of its inventory changes (adding/removing potions).
+- Added missing sounds for furnace, blast furnace and smoker.
+- Fixed ender chest not dropping itself when mined with a Silk Touch pickaxe.
+- Cobwebs now drop themselves when mined using shears.
+- The correct amount of fall damage is now taken when falling from a height onto hay bales.
+- Fixed block updating bug introduced by beta1 which caused crops and other plants to never grow.
+
+### Misc
+- Added a workaround for client hitbox size bug after swimming which caused the player to be able to fit into one-block-tall gaps.

changelogs/4.1.md

@@ -6,8 +6,8 @@ Plugin developers should **only** update their required API to this version if y
 
 **WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
 
-# 4.1.0-BETA1
-Released 22nd January 2022.
+# 4.1.0
+Released 7th February 2022.
 
 ## General
 - Game mode names (e.g. `survival`, `creative`) may now be used for the `gamemode` property in `server.properties`.
@@ -35,6 +35,21 @@ Released 22nd January 2022.
 - The following public API methods have been added:
   - `Block->getTypeId() : int` - returns an integer which uniquely identifies the block type, ignoring things like facing, colour etc.
   - `VanillaBlocks::LECTERN()`
+  - `utils\BrewingStandSlot->getSlotNumber() : int`
+  - `utils\FurnaceType->getCookSound() : Sound`
+- The following API constants have been added:
+  - `tile\BrewingStand::BREW_TIME_TICKS`
+
+### Crafting
+- The following API methods have been added:
+  - `CraftingManager->getPotionContainerChangeRecipes() : array<int, array<string, PotionContainerChangeRecipe>>`
+  - `CraftingManager->getPotionTypeRecipes() : array<string, array<string, PotionTypeRecipe>>`
+  - `CraftingManager->registerPotionContainerChangeRecipe(PotionContainerChangeRecipe $recipe) : void`
+  - `CraftingManager->registerPotionTypeRecipe(PotionTypeRecipe $recipe) : void`
+- The following classes have been added:
+  - `BrewingRecipe`
+  - `PotionContainerChangeRecipe`
+  - `PotionTypeRecipe`
 
 ### Entity
 - The following classes have been added:
@@ -58,9 +73,12 @@ Released 22nd January 2022.
 - `BlockFormEvent` is now called when concrete powder turns into concrete due to contact with water.
 - The following classes have been added:
   - `BlockMeltEvent` - called when ice or snow melts
+  - `BrewItemEvent` - called when a brewing stand finishes brewing potions; this is called up to 3 times (once for each brewing slot, as needed)
+  - `BrewingFuelUseEvent` - called when a brewing stand consumes blaze powder
   - `ChestPairEvent` - called when two chests try to form a pair
   - `PlayerToggleGlideEvent` - called when a player starts or stops gliding
   - `PlayerToggleSwimEvent` - called when a player starts or stops swimming
+  - `PlayerViewDistanceChangeEvent` - called whenever a player alters their render distance or requests one for the first time when connecting
 
 ### Item
 - The following public API methods have been added:
@@ -99,8 +117,12 @@ Released 22nd January 2022.
 
 ### World
 - The following classes have been added:
+  - `sound\BlastFurnaceSound` - the sound made by a blast furnace during smelting
+  - `sound\FurnaceSound` - the sound made by a regular furnace during cooking or smelting
   - `sound\ItemUseOnBlockSound`
   - `sound\LecternPlaceBookSound`
+  - `sound\PotionFinishBrewingSound` - the sound made by a brewing stand when a potion finishes being brewed
+  - `sound\SmokerSound` - the sound made by a smoker during cooking
 
 ## Gameplay
 ### Blocks
@@ -109,58 +131,12 @@ Released 22nd January 2022.
 - Added missing sounds for hoeing grass and dirt.
 - Added missing sounds for using a shovel on grass to create grass path.
 - Pumpkins can now be carved using shears.
-
-### Items
-- Dropped items of the same type now merge with each other.
-
-### Misc
-- Implemented player swimming.
-
-# 4.1.0-BETA2
-Released 27th January 2022.
-
-## API
-### Block
-- The following API methods have been added:
-  - `utils\BrewingStandSlot->getSlotNumber() : int`
-  - `utils\FurnaceType->getCookSound() : Sound`
-- The following API constants have been added:
-  - `tile\BrewingStand::BREW_TIME_TICKS`
-
-### Crafting
-- The following API methods have been added:
-  - `CraftingManager->getPotionContainerChangeRecipes() : array<int, array<string, PotionContainerChangeRecipe>>`
-  - `CraftingManager->getPotionTypeRecipes() : array<string, array<string, PotionTypeRecipe>>`
-  - `CraftingManager->registerPotionContainerChangeRecipe(PotionContainerChangeRecipe $recipe) : void`
-  - `CraftingManager->registerPotionTypeRecipe(PotionTypeRecipe $recipe) : void`
-- The following classes have been added:
-  - `BrewingRecipe`
-  - `PotionContainerChangeRecipe`
-  - `PotionTypeRecipe`
-
-### Event
-- The following classes have been added:
-  - `BrewItemEvent` - called when a brewing stand finishes brewing potions; this is called up to 3 times (once for each brewing slot, as needed)
-  - `BrewingFuelUseEvent` - called when a brewing stand consumes blaze powder
-  - `PlayerViewDistanceChangeEvent` - called whenever a player alters their render distance or requests one for the first time when connecting
-
-### World
-#### Sound
-- The following classes have been added:
-  - `BlastFurnaceSound` - the sound made by a blast furnace during smelting
-  - `FurnaceSound` - the sound made by a regular furnace during cooking or smelting
-  - `PotionFinishBrewingSound` - the sound made by a brewing stand when a potion finishes being brewed
-  - `SmokerSound` - the sound made by a smoker during cooking
-
-## Gameplay
-### Blocks
 - Brewing stands can now be used for brewing potions.
 - The visual appearance of a brewing stand now updates correctly when the contents of its inventory changes (adding/removing potions).
 - Added missing sounds for furnace, blast furnace and smoker.
 - Fixed ender chest not dropping itself when mined with a Silk Touch pickaxe.
 - Cobwebs now drop themselves when mined using shears.
 - The correct amount of fall damage is now taken when falling from a height onto hay bales.
-- Fixed block updating bug introduced by beta1 which caused crops and other plants to never grow.
 
-### Misc
-- Added a workaround for client hitbox size bug after swimming which caused the player to be able to fit into one-block-tall gaps.
+### Items
+- Dropped items of the same type now merge with each other.

changelogs/4.2.md

@@ -0,0 +1,121 @@
+**For Minecraft: Bedrock Edition 1.18.10**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.2.0
+- Added support for Minecraft: Bedrock Edition 1.18.10.
+
+# 4.2.1
+Released 19th February 2022.
+
+## General
+- Improved performance of `Item::nbtSerialize()` - this will improve performance during world saves.
+- Added more missing changes to the 4.0.0 changelog.
+
+## Fixes
+- Fixed multiple players being able to sleep in the same bed.
+- Fixed hitbox not resetting properly after swimming or gliding.
+
+# 4.2.2
+Released 2nd March 2022.
+
+## Fixes
+- Fixed crash in `/dumpmemory` due to usage of non-printable string keys in `CraftingManager`. Array contents in memory dumps are now rendered as prettified key-value pairs.
+- Fixed output directory for `/dumpmemory`.
+- `PlayerInventory->isHotbarSlot()` now correctly returns `false` when given `9`.
+- Fixed ghost items left in the inventory when dropping tools while mining.
+
+# 4.2.3
+Released 9th March 2022.
+
+## Technical
+- Now analysed using PHPStan 1.4.8.
+- Now using `pocketmine/bedrock-protocol` [`8.0.1`](https://github.com/pmmp/BedrockProtocol/releases/tag/8.0.1%2Bbedrock-1.18.10).
+
+## Fixes
+### Core
+- Fixed a memory leak and other bugs related to plugins disabling themselves during `onEnable()`.
+
+### Gameplay
+- Sweet berry bushes now absorb fall damage.
+- Fixed mycelium spreading onto coarse dirt.
+- Fixed blocks placed during `Block->onIncinerate()` getting overwritten.
+- Fixed shulker boxes being unopenable when underwater.
+- Fixed invisible fire on top of transparent non-flammable blocks.
+
+### API
+- Various APIs accepting `Vector3`, `Position` or `Location` no longer accept objects containing `INF` or `NaN` in any component. Previously, this was allowed, but would cause lots of obscure crashes later on.
+- `Entity->setRotation()` no longer accepts `INF` or `NaN`.
+- Fixed missing bounds check for `ItemFrame->setItemDropChance()`.
+
+# 4.2.4
+Released 18th March 2022.
+
+## Fixes
+- Fixed a crash when handling out-of-bounds meta values on the network.
+
+# 4.2.5
+Released 28th March 2022.
+
+## General
+- The layout of the human-readable part of crashdumps has been changed in an effort to improve the useful information density. It is hoped that this change will cause more useful information to be provided when people paste crash traces on Discord, since all the most important information is now at the top of the file.
+  - Version, git hash, PHP version and OS have been moved to the top of the crashdump.
+  - Backtrace has been moved above code sample.
+- Docker images are now built by GitHub Actions (first live test).
+
+## Technical
+- The methods of `Inventory` and `BaseInventory` have been rearranged to improve coherency.
+
+## Fixes
+### API
+- Enum members of enums created using `EnumTrait` are now able to have single-character names.
+- Registry members of registries created using `RegistryTrait` or `CloningRegistryTrait` now have their names checked for invalid characters.
+- `Entity::__construct()` now uses a guard variable to prevent it from being called multiple times unintentionally. This is necessary because `Entity::__construct()` has side effects.
+- Fixed `PlayerItemHeldEvent` not being called when the content of the held slot was changed (e.g. replacing the held item via inventory menu).
+
+### Gameplay
+- Reduced the appearance of ghost items in unsupported gameplay scenarios using client prediction information. This fixes, for example, the appearance of ghost items when right-clicking on a filled flower pot.
+
+# 4.2.6
+Released 1st April 2022.
+
+## Fixes
+- Fixed buffer length underflow crash in `LoginPacket` handling.
+
+# 4.2.7
+Released 15th April 2022.
+
+## General
+- Added lots more documentation (in comments) about the `aliases` section in `pocketmine.yml`. You can read about this feature in the `aliases` section of the [updated `pocketmine.yml` template](/resources/pocketmine.yml).
+- Improved wording of documentation of `PlayerPreLoginEvent`.
+
+## Fixes
+- Fixed core server crash when a plugin causes another plugin to be disabled during a scheduled task.
+- Fixed core server crash when loading a plugin with an abstract main class.
+- Fixed ghost items in many interaction situations (most notably, using projectiles while looking at an entity or block).
+- Implemented a workaround for a client teleport bug which led to player positions not updating properly when using ender pearls.
+- Fixed buggy movement when teleporting the player during `PlayerToggleSneakEvent`, `PlayerToggleSprintEvent`, `PlayerToggleSwimEvent` and `PlayerToggleGlideEvent`.
+
+# 4.2.8
+Released 17th April 2022.
+
+## Fixes
+- Fixed a memory leak in RakLib which could result in a server crash when players stay online for a long time.
+- Fixed server crash when attempting to load a corrupted empty resource pack.
+- Fixed users with the same name with differerently cased letters being able to duplicate items (userdata is matched by case-insensitive name).
+
+# 4.2.9
+Released 19th April 2022.
+
+## Fixes
+- Fixed several potential crashes when deserializing item NBT (due to insufficient validation of input data).
+
+# 4.2.10
+Released 20th April 2022.
+
+## Fixes
+- Fixed performance issue when chat messages received from the client contain many newlines. This security vulnerability was disclosed publicly necessitating a priority fix.

changelogs/4.3.md

@@ -0,0 +1,77 @@
+**For Minecraft: Bedrock Edition 1.18.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.3.0
+Released 20th April 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.18.30.
+- Removed support for older versions.
+
+# 4.3.1
+Released 23rd April 2022.
+
+## Fixes
+- Updated BedrockProtocol dependency to fix incorrect command argument types.
+- Creative players no longer die in the void.
+
+# 4.3.2
+Released 10th May 2022.
+
+## Fixes
+- Fixed an assertion failure in certain edge cases during world generation.
+- Fixed `Entity::setNameTagVisible()` not immediately showing results to players already online.
+
+## Documentation
+- Added more documentation in the template `pocketmine.yml` for the `aliases` config section.
+- Removed useless doc comment in `PlayerChangeSkinEvent`.
+
+# 4.3.3
+Released 16th May 2022.
+
+## General
+- Improved display of parameters in exception stack trace logs.
+- Exception stack traces now include names for dynamic named arguments (i.e. arguments that don't match any parameter of the function), if any were given.
+  - Note: Named arguments which do match parameters are not shown this way, since PHP reduces them to positional arguments for performance reasons.
+
+## Fixes
+- Fixed server crash when chunks are unloaded during chunk generation callbacks
+- Fixed dead coral fan items placing coral fans in the wrong orientation.
+- Fixed max stack size of boat items.
+
+# 4.3.4
+Released 22nd May 2022.
+
+## Fixes
+- Fixed `difficulty` in `server.properties` having no effect - it's now applied to newly generated worlds.
+  - Note: this setting still doesn't behave the same way as vanilla due to potential disruption to existing servers.
+- Fixed paintings not working in newly generated worlds and some other cases.
+- Fixed inventory window switching breaking the inventory UI in some cases (e.g. pressing E while clicking a chest).
+- Fixed minecart items incorrectly stacking.
+- Fixed incorrect light levels in translucent blocks at the top of the world.
+- Fixed teleporting sleeping players causing broken behaviour on the sleeping player's client.
+- Fixed `EntityExplodeEvent->setYield()` accepting values outside the range 0-100.
+- Fixed `ExplosionPrimeEvent->setForce()` accepting negative values (later resulting in crashes).
+
+## Documentation
+- Updated documentation for the following events:
+  - `CommandEvent`
+  - `EntityDespawnEvent`
+  - `EntityExplodeEvent`
+  - `EntitySpawnEvent`
+  - `ExplosionPrimeEvent`
+  - `InventoryTransactionEvent`
+  - `ItemDespawnEvent`
+  - `ItemSpawnEvent`
+  - `PlayerCommandPreprocessEvent`
+  - `PlayerDropItemEvent`
+  - `PlayerItemHeldEvent`
+  - `PlayerKickEvent`
+  - `PlayerQuitEvent`
+  - `PlayerTransferEvent`
+  - `UpdateNotifyEvent`

changelogs/4.4-beta.md

@@ -0,0 +1,77 @@
+**For Minecraft: Bedrock Edition 1.18.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.4.0-BETA1
+Released 25th May 2022.
+
+## General
+- The server will now shut itself down if any of the following errors occur during startup:
+  - Any plugin fails to load or enable (plugins loaded by other plugins post-startup are **not** affected by this change) (**PR [#4951](https://github.com/pmmp/PocketMine-MP/pull/4951)**)
+    - The motivation for this change is to prevent situations where plugins failing to load could result in adverse outcomes, such as a world protection plugin leaving a lobby unprotected from griefing.
+    - If you encounter this problem, remove the offending plugin(s) or prevent it from loading using `plugin_list.yml`.
+    - See **PR [#4951](https://github.com/pmmp/PocketMine-MP/pull/4951)** for more detail on this change.
+  - Any world mentioned in `server.properties` or `pocketmine.yml` fails to load (worlds loaded by plugins are **not** affected by this change)
+  - Any world mentioned in `server.properties` or `pocketmine.yml` fails to generate (e.g. due to invalid generator settings)
+- Enabling the server whitelist while the server is running (e.g. using `/whitelist on`) will now kick any non-whitelisted players currently on the server (**PR [#4774](https://github.com/pmmp/PocketMine-MP/pull/4774)**).
+- Help for commands (`/help <name of command>`) now displays a list of aliases of that command.
+- A CRITICAL log message is now generated if a plugin disables itself when enabling, in case the plugin doesn't emit any error of its own.
+- The `/give` command now shows the alias used to find the given item in the success message, instead of the item ID/meta.
+
+## Fixes
+- Block placement has been fixed in many places where it previously didn't work correctly (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**):
+  - torches on top of slabs, upside-down stairs
+  - torches on the back face of stairs
+  - flower pots on top of fences
+  - the list goes on and on ...
+- Fixed backslash escapes not getting properly removed from commands in some cases.
+- Fixed aliases defined in the `aliases` section of `pocketmine.yml` not being treated as quote-aware.
+
+## Gameplay
+- Plants in flower pots can now be removed by right-clicking on the flower pot.
+- Leaves now have a 2% chance of dropping sticks when destroyed by hand (**PR [#5019](https://github.com/pmmp/PocketMine-MP/pull/5019)**).
+- Food exhaustion now matches Bedrock 1.18.30 (**PR [#5034](https://github.com/pmmp/PocketMine-MP/pull/5034)**).
+- Implemented Stonecutter block (**PR [#4732](https://github.com/pmmp/PocketMine-MP/pull/4732)**).
+
+## API
+### Block
+- Added `Block->getSupportType(Facing) : SupportType` (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**).
+  - This is used to determine the kind of support a block face can provide to a block (e.g. a torch) placed on it.
+- Added `utils\SupportType` enum (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**).
+- `tile\Spawnable->isDirty()` and `tile\Spawnable->setDirty()` are now `@deprecated`.
+
+### Command
+- Added `CommandStringHelper::parseQuoteAware()`. This static method contains the code used by `SimpleCommandMap` used to parse quoted command arguments.
+
+### Entity
+- Added `Human::emote()` (**PR [#4610](https://github.com/pmmp/PocketMine-MP/pull/4610)**)
+
+### Event
+- `PlayerCommandPreprocessEvent` is now `@deprecated`, since its functionality is entirely replaced by other, general-purpose events.
+  - Use `CommandEvent` to intercept commands.
+  - Use `PlayerChatEvent` to intercept chat messages.
+  - To convert a chat message into a command, pass it directly to `Server->dispatchCommand()` with the player as sender.
+- Added `PlayerPostChunkSendEvent` (**PR [#4937](https://github.com/pmmp/PocketMine-MP/pull/4937)**).
+- Added `PlayerDeathEvent->setKeepXp()` (**PR [#4015](https://github.com/pmmp/PocketMine-MP/pull/4015)**).
+- `InventoryCloseEvent` is now called **after** the target window has been removed. This fixes various feedback loops caused by trying to open new windows to a player while there was one still active.
+  - As a side effect, this now means that `Player->getCurrentWindow()` will return `null` during `InventoryCloseEvent`. Use `InventoryCloseEvent->getInventory()` instead.
+
+### Item
+- `StringToItemParser` now recognizes `cod`, `raw_cod` and `cooked_cod` aliases.
+
+### Plugin
+- `DisablePluginException` may now be thrown from `Plugin::onEnable()` to make the server gracefully disable the plugin (without crashing) (**PR [#4780](https://github.com/pmmp/PocketMine-MP/pull/4780)**).
+- `PluginManager->registerEvent()` now returns the `RegisteredListener` created for the handler, to permit unregistering it later.
+
+## Internals
+- Private property declarations now use typed properties (PHP 7.4) and promoted constructor properties (PHP 8.0) wherever possible.
+  - Protected and public properties remain unchanged, since they can't be changed without breaking subclasses.
+- Promoted constructor properties are only used when it's consistently possible to promote most or all properties in a class.
+- Simplified and improved legibility of `FormattedCommandAlias`.
+- Added unit tests for the quote-aware command parser used by `SimpleCommandMap`.
+- Various hardcoded values in `block` package classes have been moved to private constants to improve readability.
+- Added various constants used in the `LevelDB` world provider.

changelogs/4.4.md

@@ -0,0 +1,97 @@
+**For Minecraft: Bedrock Edition 1.18.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.4.0
+Released 1st June 2022.
+
+## General
+- The server will now shut itself down if any of the following errors occur during startup:
+  - Any plugin fails to load or enable (plugins loaded by other plugins post-startup are **not** affected by this change) (**PR [#4951](https://github.com/pmmp/PocketMine-MP/pull/4951)**)
+    - The motivation for this change is to prevent situations where plugins failing to load could result in adverse outcomes, such as a world protection plugin leaving a lobby unprotected from griefing.
+    - If you encounter this problem, remove the offending plugin(s) or prevent it from loading using `plugin_list.yml`.
+    - See **PR [#4951](https://github.com/pmmp/PocketMine-MP/pull/4951)** for more detail on this change.
+  - Any world mentioned in `server.properties` or `pocketmine.yml` fails to load (worlds loaded by plugins are **not** affected by this change)
+  - Any world mentioned in `server.properties` or `pocketmine.yml` fails to generate (e.g. due to invalid generator settings)
+- Enabling the server whitelist while the server is running (e.g. using `/whitelist on`) will now kick any non-whitelisted players currently on the server (**PR [#4774](https://github.com/pmmp/PocketMine-MP/pull/4774)**).
+- Help for commands (`/help <name of command>`) now displays a list of aliases of that command.
+- A CRITICAL log message is now generated if a plugin disables itself when enabling, in case the plugin doesn't emit any error of its own.
+- The `/give` command now shows the alias used to find the given item in the success message, instead of the item ID/meta.
+
+## Fixes
+- Block placement has been fixed in many places where it previously didn't work correctly (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**):
+  - torches on top of slabs, upside-down stairs
+  - torches on the back face of stairs
+  - flower pots on top of fences
+  - the list goes on and on ...
+- Fixed backslash escapes not getting properly removed from commands in some cases.
+- Fixed aliases defined in the `aliases` section of `pocketmine.yml` not being treated as quote-aware.
+
+## Gameplay
+- Plants in flower pots can now be removed by right-clicking on the flower pot.
+- Leaves now have a 2% chance of dropping sticks when destroyed by hand (**PR [#5019](https://github.com/pmmp/PocketMine-MP/pull/5019)**).
+- Food exhaustion now matches Bedrock 1.18.30 (**PR [#5034](https://github.com/pmmp/PocketMine-MP/pull/5034)**).
+- Implemented Stonecutter block (**PR [#4732](https://github.com/pmmp/PocketMine-MP/pull/4732)**).
+
+## API
+### Block
+- Added `Block->getSupportType(Facing) : SupportType` (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**).
+  - This is used to determine the kind of support a block face can provide to a block (e.g. a torch) placed on it.
+- Added `utils\SupportType` enum (**PR [#4886](https://github.com/pmmp/PocketMine-MP/pull/4886)**).
+- `tile\Spawnable->isDirty()` and `tile\Spawnable->setDirty()` are now `@deprecated`.
+
+### Command
+- Added `CommandStringHelper::parseQuoteAware()`. This static method contains the code used by `SimpleCommandMap` used to parse quoted command arguments.
+
+### Entity
+- Added `Human::emote()` (**PR [#4610](https://github.com/pmmp/PocketMine-MP/pull/4610)**)
+
+### Event
+- `PlayerCommandPreprocessEvent` is now `@deprecated`, since its functionality is entirely replaced by other, general-purpose events.
+  - Use `CommandEvent` to intercept commands.
+  - Use `PlayerChatEvent` to intercept chat messages.
+  - To convert a chat message into a command, pass it directly to `Server->dispatchCommand()` with the player as sender.
+- Added `PlayerPostChunkSendEvent` (**PR [#4937](https://github.com/pmmp/PocketMine-MP/pull/4937)**).
+- Added `PlayerDeathEvent->setKeepXp()` (**PR [#4015](https://github.com/pmmp/PocketMine-MP/pull/4015)**).
+- `InventoryCloseEvent` is now called **after** the target window has been removed. This fixes various feedback loops caused by trying to open new windows to a player while there was one still active.
+  - As a side effect, this now means that `Player->getCurrentWindow()` will return `null` during `InventoryCloseEvent`. Use `InventoryCloseEvent->getInventory()` instead.
+
+### Item
+- `StringToItemParser` now recognizes `cod`, `raw_cod` and `cooked_cod` aliases.
+
+### Plugin
+- `DisablePluginException` may now be thrown from `Plugin::onEnable()` to make the server gracefully disable the plugin (without crashing) (**PR [#4780](https://github.com/pmmp/PocketMine-MP/pull/4780)**).
+- `PluginManager->registerEvent()` now returns the `RegisteredListener` created for the handler, to permit unregistering it later.
+
+## Internals
+- Private property declarations now use typed properties (PHP 7.4) and promoted constructor properties (PHP 8.0) wherever possible.
+  - Protected and public properties remain unchanged, since they can't be changed without breaking subclasses.
+- Promoted constructor properties are only used when it's consistently possible to promote most or all properties in a class.
+- Simplified and improved legibility of `FormattedCommandAlias`.
+- Added unit tests for the quote-aware command parser used by `SimpleCommandMap`.
+- Various hardcoded values in `block` package classes have been moved to private constants to improve readability.
+- Added various constants used in the `LevelDB` world provider.
+
+# 4.4.1
+Released 5th June 2022.
+
+## General
+- The server process will now exit with an error code if plugins, worlds or network interfaces failed to start.
+
+## Fixes
+- Fixed graylisted plugins preventing the server from starting.
+- Fixed `composer make-devtools` command.
+- Fixed the `Maximum memory (manager)` units being incorrectly displayed in `/status`.
+- Fixed `Player->removeCurrentWindow()` breaking inventory windows.
+
+# 4.4.2
+Released 7th June 2022.
+
+## Fixes
+- Fixed a crash when arbitrary item IDs appeared in network items in some cases.
+- Fixed saved paintings being deleted when loaded from disk (regression from 4.3.4).
+- Fixed max stack size of fishing rods.

changelogs/4.5.md

@@ -0,0 +1,28 @@
+**For Minecraft: Bedrock Edition 1.19.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.5.0
+Released 7th June 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.0.
+- Removed support for older versions.
+
+# 4.5.1
+Released 8th June 2022.
+
+## Fixes
+- Fixed commands defined in `pocketmine.yml` `aliases` not passing the correct arguments.
+- Updated BedrockProtocol to fix command argument types displayed on client-side command suggestions.
+
+# 4.5.2
+Released 29th June 2022.
+
+## Fixes
+- Fixed terrain getting redrawn when flying in spectator mode (or when using `Player->setHasBlockCollision(false)`).
+- Fixed skulls with the `noDrops` flag set being treated as unknown blocks.

changelogs/4.6.md

@@ -0,0 +1,42 @@
+**For Minecraft: Bedrock Edition 1.19.10**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.6.0
+Released 13th July 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.10.
+- Removed support for older versions.
+
+# 4.6.1
+Released 22nd July 2022.
+
+## Tools
+- `build/generate-registry-annotations.php` now supports processing single files (useful for PhpStorm file watchers).
+
+## API
+- Updated documentation for `AsyncTask`.
+
+## Fixes
+- Fixed incorrect items being displayed in item frames.
+- Fixed books not showing in lecterns.
+- Fixed incorrect damage interval of Wither status effect.
+- Fixed incorrect fire ticks when being set on fire by lava (8 seconds in Bedrock instead of 15).
+- `Entity->attack()` now cancels damage from `FIRE` and `FIRE_TICK` damage causes if the entity is fireproof.
+- Fixed inventory windows getting force-closed when the client attempts to use an enchanting table or anvil.
+
+# 4.6.2
+Released 6th August 2022.
+
+## Core
+- Improved server-side performance of `PlayerAuthInputPacket` handler.
+- Improved client-side performance of `FloatingTextParticle` by using an invisible falling block entity. This offered a roughly 5x performance improvement over using tiny invisible players in local testing.
+
+## Fixes
+- Fixed assert failures and debug spam on debug Minecraft clients related to abilities in `AddPlayerPacket`.
+- Fixed crash in `ReversePriorityQueue` on PHP 8.1 by adding `#[ReturnTypeWillChange]` attribute.

changelogs/4.7.md

@@ -0,0 +1,46 @@
+**For Minecraft: Bedrock Edition 1.19.20**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.7.0
+Released 9th August 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.20.
+- Removed support for older versions.
+
+# 4.7.1
+Released 14th August 2022.
+
+## Fixes
+- Fixed server crash when loading items from disk which have negative meta values.
+- Fixed Turtle Master potions not giving any effects.
+- Unimplemented items are no longer craftable.
+- Fixed incorrect items appearing in item frames (due to an obsolete workaround for 1.19.10).
+
+# 4.7.2
+Released 16th August 2022.
+
+## Fixes
+- Fixed crash when processing player skins with invalid geometry data.
+- Fixed spectator players being able to pick blocks using mousewheel click.
+- Improved supporting requirements for sugarcane.
+
+# 4.7.3
+Released 22nd August 2022.
+
+## General
+- Added complete translations for Spanish and Vietnamese.
+- All continuous integration (static analysis, unit tests, integration tests) are now performed on PHP 8.1 as well as 8.0.
+- InventoryTransaction now verifies that stack sizes of items after the transaction don't exceed the maximum stack size of the item type or the containing inventory.
+
+## Fixes
+- Fixed Normal generator crash on PHP 8.1.
+- Fixed a race condition during async worker shutdown that could lead to tasks executing in the wrong order. This (very rarely) led to a crash in `PopulationTask` due to its preceding `GeneratorRegisterTask` not being executed.
+- Fixed `/give` accepting negative amounts or amounts larger than 32767 (vanilla max).
+- Fixed placement conditions for vines (no longer able to be placed on the side of cacti).
+- Fixed incorrect documentation of `SignText::__construct()`.

changelogs/4.8.md

@@ -0,0 +1,23 @@
+**For Minecraft: Bedrock Edition 1.19.21**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.8.0
+Released 24th August 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.21.
+- Removed support for older versions.
+
+# 4.8.1
+Released 26th August 2022.
+
+## General
+- Crashdumps now include JIT mode information for use by the Crash Archive.
+
+## Fixes
+- Fixed uninitialized offset error in `DyeColorIdMap` when given invalid dye color IDs.

changelogs/4.9.md

@@ -0,0 +1,14 @@
+**For Minecraft: Bedrock Edition 1.19.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and 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 protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 4.9.0
+Released 20th September 2022.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.19.30.
+- Removed support for older versions.

changelogs/5.0-alpha.md

@@ -0,0 +1,620 @@
+**For Minecraft: Bedrock Edition 1.19.0**
+
+# 5.0.0-ALPHA1
+Released 6th July 2022.
+
+This is a development snapshot of 5.0.0, an upcoming major update to PocketMine-MP. This version includes many new improvements, including support for Bedrock worlds from 1.13 onwards, a large array of new blocks, and various changes to the plugin API.
+
+## WARNING
+**This is an ALPHA release.** It is an early development snapshot of the upcoming 5.0.0 release.
+This means it is LIKELY to be unstable, and/or have performance issues not found in the latest stable releases.
+
+**BACK UP your data before testing this.** This version will work with worlds and player data from 4.x, **BUT** any world or player data loaded in 5.0.0 **will not work in 4.x** due to backwards-incompatible storage format changes.
+
+In addition, there are a number of breaking API changes. Plugins for 4.x may require code changes to run on this version.
+
+The API is **not finalized**. You should expect further changes in later alphas.
+
+## Core
+- Worlds are now saved according to the Bedrock 1.19.0 format.
+- Worlds generated by Bedrock from 1.13.0 and up are now supported (previously, only worlds up to 1.12 were supported).
+- `/particle` now accepts strings for particle data instead of integers.
+- `/particle` no longer accepts integers for block or item IDs.
+- The usage of `blockcrack`, `iconcrack` and `blockdust` particle types in `/particle` now follows the same pattern as other particle types, with the data for each being passed in the `data` parameter instead of being baked into the particle name.
+
+## Tools
+- The following tool scripts have been added:
+  - `generate-block-palette-spec.php` - generates a JSON file with a readable overview of blocks, their state properties, and their possible values
+  - `generate-blockstate-upgrade-schema.php` - generates JSON blockstate upgrade schemas like those found in [BedrockBlockUpgradeSchema](https://github.com/pmmp/BedrockBlockUpgradeSchema)
+  - `generate-item-upgrade-schema.php` - generates JSON item ID/meta upgrade schemas like those found in [BedrockItemUpgradeSchema](https://github.com/pmmp/BedrockItemUpgradeSchema)
+
+## Gameplay
+### Blocks
+- Added the following new blocks:
+  - Amethyst Block
+  - Ancient Debris
+  - Basalt
+  - Blackstone blocks, slabs, stairs, and walls
+  - Calcite
+  - Chiseled Deepslate
+  - Chiseled Nether Bricks
+  - Chiseled Polished Blackstone
+  - Cobbled Deepslate blocks, slabs, stairs, and walls
+  - Copper Ore
+  - Cracked Deepslate Bricks
+  - Crached Deepslate Tiles
+  - Cracked Nether Bricks
+  - Cracked Polished Blackstone Bricks
+  - Crimson buttons, doors, fences, fence gates, hyphae, planks, pressure plates, signs, slabs, stairs, stems, and trapdoors
+  - Deepslate
+  - Deepslate Bricks blocks, slabs, stairs, and walls
+  - Deepslate Ores (coal, copper, diamond, emerald, gold, iron, lapis lazuli, redstone)
+  - Deepslate Tiles blocks, slabs, stairs, and walls
+  - Honeycomb Block
+  - Light Block
+  - Mangrove buttons, doors, fences, fence gates, logs, planks, pressure plates, signs, slabs, stairs, trapdoors, and wood
+  - Mud Bricks blocks, slabs, stairs, and walls
+  - Nether Gold Ore
+  - Polished Basalt
+  - Polished Blackstone blocks, buttons, pressure plates, slabs, stairs, and walls
+  - Polished Blackstone Bricks blocks, slabs, stairs, and walls
+  - Polished Deepslate blocks, slabs, stairs, and walls
+  - Quartz Bricks
+  - Shroomlight
+  - Smooth Basalt
+  - Soul Fire
+  - Soul Lantern
+  - Soul Soil
+  - Soul Torch
+  - Tuff
+  - Warped buttons, doors, fences, fence gates, hyphae, planks, pressure plates, signs, slabs, stairs, stems, and trapdoors
+- Added support for basalt generators
+- Iron Ore and Gold Ore now drop Raw Iron and Raw Gold respectively, instead of the ore blocks.
+- Item frames can now be placed on the top and bottom of blocks.
+- All-sided logs ("wood", for want of a better name) can now be placed in X, Y, and Z orientations.
+- Walls now connect when placed, following the pre-1.16 logic. (1.16 logic is planned to be implemented, but currently low priority.)
+- Stripping logs by right-clicking them with an axe is now supported.
+
+### Items
+- Added the following new items:
+  - Amethyst Shard
+  - Copper Ingot
+  - Disc Fragment (5)
+  - Echo Shard
+  - Glow Ink Sac
+  - Honeycomb
+  - Phantom Membrane
+  - Raw Copper
+  - Raw Gold
+  - Raw Iron
+  - Spyglass
+
+## API
+### General
+- Protected and public properties now use native property types wherever possible.
+- Parameter and return typehints have been applied in many places where it wasn't previously possible.
+
+### `pocketmine\block`
+#### Runtime block representation
+- Blocks no longer use internal Minecraft IDs and metadata to identify themselves. All APIs associated with legacy IDs and meta have been removed.
+- A new set of runtime IDs generated from `VanillaBlocks` is used to identify block types. These IDs are defined in `BlockTypeIds`.
+  - These new IDs are used for runtime representation of blocks on chunks, and for type comparison purposes.
+  - Block type IDs are used at **runtime only**. They should **NOT** be stored in configs or databases, as they are subject to change without warning.
+- Block state properties (e.g. facing, colour, etc.) are now represented by PM-specific state data instead of legacy metadata. The state data consists of:
+  - Dynamic type data - this is retained by items when the block is broken (colour, wet/dry, coral type, etc.) - handled by `Block->decodeType()` and `Block->encodeType()`
+  - State data - this is discarded when the block is broken (facing direction, lit/unlit, powered/unpowered, etc.) - handled by `Block->decodeState()` and `Block->encodeState()`
+
+**Block type IDs, and state/type data, are intended for use at RUNTIME only. The values of type IDs and state data may change without warning. They should NOT be saved in configs or databases.**
+
+#### Implementing new blocks
+To register a new block, the following changes are now required:
+
+- Add a new type ID to `BlockTypeIds`
+- Register the block in `BlockFactory`
+- Amend `VanillaBlocks` to include the new block
+- Amend `BlockStateToBlockObjectDeserializer` to deserialize the block from disk
+- Amend `BlockObjectToBlockStateSerializer` to serialize the block for disk
+- Optionally, amend `StringToItemParser` to add string alias(es) for the block, so that it can be given via `/give`
+
+This is admittedly rather more of a hassle than in the old days, but that's the price of abstraction. Research is underway for ways to improve this without spaghettifying the code again.
+
+#### Change list
+- The following classes have been removed:
+  - `BlockIdentifierFlattened`
+  - `BlockLegacyIds`
+  - `BlockLegacyMetadata`
+  - `utils\ColorInMetadataTrait` - `utils\ColoredTrait` now implements colour type data serialization uniformly
+  - `utils\InvalidBlockStateException` - this has been superseded by `pocketmine\data\runtime\InvalidSerializedRuntimeDataException`
+  - `utils\NormalHorizontalFacingInMetadataTrait` - `utils\HorizontalFacingTrait` now implements facing type data serialization uniformly
+  - `utils\PillarRotationInMetadataTrait` - `utils\PillarRotationTrait` now implements rotation type data serialization uniformly
+  - `utils\BlockDataSerializer`
+- The following classes have been added:
+  - `BaseFire`
+  - `SoulFire`
+  - `BlockTypeIds`
+    - This is a generated enum of PocketMine-MP-specific block type IDs
+    - There is one for every entry in `VanillaBlocks`
+    - Do NOT save these IDs in a config or database, as they may change without warning
+    - Block type IDs are intended for comparison purposes only
+    - Block type IDs cannot be negative
+  - `CopperOre`
+  - `GoldOre`
+  - `IronOre`
+  - `Light`
+  - `NetherGoldOre`
+  - `utils\WallConnectionType` - enum of all possible wall connection types
+  - `utils\WoodType` - enum of all possible wood types, used for wood material blocks like planks and logs
+  - `utils\WoodTypeTrait`
+- The following API methods have been removed:
+  - `Block->getId()` - for type comparisons, use `Block->getTypeId()` instead
+  - `Block->getMeta()` - for state comparisons, use `Block->getStateId()` instead
+  - `Block->readStateFromData()`
+  - `Block->writeStateToMeta()`
+  - `Block->writeStateToItemMeta()`
+  - `Block->getStateBitmask()`
+  - `BlockFactory->get()`
+    - To get a block at runtime, e.g. stone, use `VanillaBlocks::STONE()`
+    - To load a block from old config or database data:
+      1. Use `GlobalBlockStateHandlers::getUpgrader()->upgradeIntIdMeta()` to convert it to modern data
+      2. Pass the data to `GlobalBlockStateHandlers::getDeserializer()` to get a blockstate ID
+      3. Pass the blockstate ID to `BlockFactory::fromStateId()` to get a `Block` instance
+  - `BlockIdentifier->getBlockId()`
+  - `BlockIdentifier->getAllBlockIds()`
+  - `BlockIdentifier->getVariant()`
+  - `BlockIdentifier->getItemId()`
+  - `Door->isPowered()`
+  - `Door->setPowered()`
+  - `Skull->isNoDrops()`
+  - `Skull->setNoDrops()`
+  - `VanillaBlocks::*_GLAZED_TERRACOTTA()` - use `VanillaBlocks::GLAZED_TERRACOTTA()->setColor(DyeColor::WHATEVER())` instead
+  - `utils\FallableTrait->getId()` is no longer required
+  - `utils\FallableTrait->getMeta()` is no longer required
+- The following constants have been renamed:
+  - `Block::INTERNAL_METADATA_BITS` -> `Block::INTERNAL_STATE_DATA_BITS`
+  - `Block::INTERNAL_METADATA_MASK` -> `Block::INTERNAL_STATE_DATA_MASK`
+- The following API methods have been renamed:
+  - `Block->getFullId()` -> `Block->getStateId()`
+- The following API methods have signature changes:
+  - `BlockIdentifier->__construct()` now accepts `int $blockTypeId`, and no longer accepts `int $blockId, int $variant, ?int $itemId`
+  - `ItemFrame->getFacing()` may now return `Facing::UP` and `Facing::DOWN`
+  - `ItemFrame->setFacing()` now accepts `Facing::UP` and `Facing::DOWN`
+- The following API methods have been added:
+  - `protected Block->decodeState()` - encodes the block's state properties, e.g. facing, powered/unpowered, etc.
+  - `protected Block->decodeType()` - encodes the block's type properties, e.g. colour, wet/dry, coral type, etc.
+  - `public Block->getRequiredStateDataBits()` - returns the number of bits required to encode the block's state data
+  - `public Block->getRequiredTypeDataBits()` - returns the number of bits required to encode the block's type data
+  - `public BlockIdentifier->getBlockTypeId()` - returns the block's type ID according to `BlockTypeIds`
+  - `public GlazedTerracotta->getColor()` (from `ColoredTrait`) - this was previously unsupported due to legacy limitations
+  - `public GlazedTerracotta->setColor()` (from `ColoredTrait`) - this was previously unsupported due to legacy limitations
+  - `public Wall->getConnections()` - returns the wall's connections and their types (see `utils\WallConnectionType`)
+  - `public Wall->setConnections()` - sets the wall's connections and their types (see `utils\WallConnectionType`)
+  - `public Wall->getConnection()`
+  - `public Wall->setConnection()`
+  - `public Wall->isPost()`
+  - `public Wall->setPost()`
+  - `public Wood->isStripped()`
+  - `public Wood->setStripped()`
+- The following classes now use new traits, adding API methods and/or properties:
+  - `FenceGate` uses `utils\WoodTypeTrait`
+  - `GlazedTerracotta` uses `utils\ColoredTrait`
+  - `Planks` uses `utils\WoodTypeTrait`
+  - `Wood` uses `utils\WoodTypeTrait`
+  - `WoodenButton` uses `utils\WoodTypeTrait`
+  - `WoodenDoor` uses `utils\WoodTypeTrait`
+  - `WoodenFence` uses `utils\WoodTypeTrait`
+  - `WoodenPressurePlate` uses `utils\WoodTypeTrait`
+  - `WoodenSlab` uses `utils\WoodTypeTrait`
+  - `WoodenStairs` uses `utils\WoodTypeTrait`
+  - `WoodenTrapdoor` uses `utils\WoodTypeTrait`
+
+### `pocketmine\crafting`
+- The following classes have been added:
+  - `RecipeIngredient` interface
+  - `ExactRecipeIngredient` - matches an exact item
+  - `MetaWildcardRecipeIngredient` - matches an item with the given legacy Minecraft ID, but any metadata value
+- The following API methods have signature changes:
+  - `FurnaceRecipe->__construct()` now accepts `RecipeIngredient` instead of `Item`
+  - `FurnaceRecipe->getInput()` now returns `RecipeIngredient` instead of `Item`
+  - `PotionContainerChangeRecipe->__construct()` now accepts `string, RecipeIngredient, string` (using Minecraft string IDs instead of legacy integers).
+  - `PotionContainerChangeRecipe->getIngredient()` now returns `RecipeIngredient` instead of `Item`.
+  - `PotionContainerChangeRecipe->getInputItemId()` now returns `string` (using Minecraft string IDs instead of legacy integers).
+  - `PotionContainerChangeRecipe->getOutputItemId()` now returns `string` (using Minecraft string IDs instead of legacy integers).
+  - `PotionTypeRecipe->__construct()` now accepts `RecipeIngredient` instead of `Item`
+  - `PotionTypeRecipe->getIngredient()` now returns `RecipeIngredient` instead of `Item`
+  - `PotionTypeRecipe->getInput()` now returns `RecipeIngredient` instead of `Item`
+  - `ShapedRecipe->__construct()` now accepts `RecipeIngredient` instead of `Item`
+  - `ShapedRecipe->getIngredient()` now returns `?RecipeIngredient` instead of `?Item`
+  - `ShapedRecipe->getIngredientList()` now returns `RecipeIngredient[]` instead of `Item[]`
+  - `ShapedRecipe->getIngredientMap()` now returns `RecipeIngredient[][]` instead of `Item[][]`
+  - `ShapelessRecipe->__construct()` now accepts `RecipeIngredient` instead of `Item`
+  - `ShapelessRecipe->getIngredientList()` now returns `RecipeIngredient[]` instead of `Item[]`
+
+### `pocketmine\entity`
+- `Entity` now declares new abstract methods which must be implemented by subclasses:
+  - `public Entity->getInitialDragMultiplier()`
+  - `public Entity->getInitialGravity()`
+
+### `pocketmine\item`
+#### Runtime item representation
+- Items no longer use internal Minecraft string IDs and metadata to identify themselves. All APIs associated with legacy IDs and/or meta have been removed.
+- A new set of runtime item IDs generated from `VanillaItems` is now used to identify item types. These IDs are defined in `ItemTypeIds`.
+  - These new IDs are primarily intended for type comparison purposes.
+  - Item type IDs are used at **runtime only**. They should **NOT** be stored in configs or databases, as they are not guaranteed to remain the same between versions.
+- In some cases, items may have additional "type data" which provides extra type information about an item. This replaces item metadata in some cases.
+  - Type data may be used to store dynamic type information such as dye colour, potion type, etc.
+  - Items must have the same type ID **and** type data in order to be stackable.
+- Blocks, when represented as items:
+  - retain their block type data, but not state data (for example, different colours of concrete don't stack, but things like facing don't affect stackability)
+  - use the negative of their block type ID (e.g. a block with type ID `1` will have an item type ID of `-1`).
+- Durable items (e.g. tools, armour) now use NBT `Damage` tag to store durability (like Minecraft 1.13+), instead of legacy meta values.
+
+**Item type IDs and type data are intended for RUNTIME use only. The values of type IDs and/or type data may change without warning. They should NOT be saved in configs or databases.**
+
+#### Implementing new items
+To register a new item, the following changes are now required:
+
+- Add a new ID to `ItemTypeIds`
+- Register the item in `ItemFactory`
+- Amend `VanillaItems` to add the item
+- Amend `ItemDeserializer` to add a deserializer for loading the item from disk
+- Amend `ItemSerializer` to add a serializer for saving the item to disk
+- Optionally, amend `StringToItemParser` to add string alias(es) for the item, so it can be given via `/give`
+
+Again, it's acknowledged this is rather more cumbersome than it should be, but this is an ongoing process.
+
+#### Change list
+- `Item` is no longer `json_encode()`-able.
+  - The original purpose of this was to allow items to be serialized to JSON for crafting data generated from `CraftingDataPacket`. Due to changes in the generation methodology, bypassing `Item`s entirely, this is no longer necessary.
+  - `jsonSerialize()` requires the item to know about the method by which it will be serialized, creating a cyclic dependency between the `Item` implementation and its serialization method.
+  - It's relatively easy to write a replacement method to encode items to JSON as you desire.
+- The following classes have been removed:
+  - `ItemIds`
+  - `Skull`
+  - `Bed`
+- The following classes have been added:
+  - `CoralFan`
+  - `Spyglass`
+- The following API methods have been added:
+  - `public Dye->setColor()`
+  - `public ItemIdentifer->getTypeId()`
+  - `public static ItemIdentifier::fromBlock()`
+  - `public Potion->setType()`
+  - `public SplashPotion->setType()`
+- The following API methods have been removed:
+  - `Item->getId()` - for type comparisons, use `Item->getTypeId()` instead
+  - `Item->getMeta()` - use the item's specific API methods to compare information such as colour, potion type etc.
+  - `Item->hasAnyDamageValue()` - for meta wildcard recipe ingredients, use `pocketmine\crafting\MetaWildcardRecipeIngredient` instead
+  - `ItemFactory->get()`
+    - To get an item at runtime, e.g. iron ingot, use `VanillaItems::IRON_INGOT()`
+    - To get a block as an item, e.g. stone, use `VanillaBlocks::STONE()->asItem()`
+    - To load an item from legacy ID and meta:
+      1. Use `GlobalItemDataHandlers::getUpgrader()->upgradeItemTypeDataInt()` to convert the legacy ID and meta to `ItemStackData`
+      2. Pass the itemstack data to `GlobalItemDataHandlers::getDeserializer()` to get an `Item` instance
+  - `ItemFactory->remap()`
+  - `ItemIdentifier->getId()`
+  - `ItemIdentifier->getMeta()`
+- The following API methods have been renamed:
+  - `Item::jsonDeserialize()` -> `Item::legacyJsonDeserialize()`
+  - `ItemFactory->getAllRegistered()` -> `ItemFactory->getAllKnownTypes()`
+- The following API methods have signature changes:
+  - `ItemFactory->isRegistered()` no longer accepts a `$variant` parameter, and now expects an item type ID for the ID parameter
+  - `ItemIdentifier->__construct()` no longer accepts a `$variant` parameter, and now expects an item type ID for the ID parameter
+  - `LegacyStringToItemParser->addMapping()` now accepts a string for ID, instead of an integer
+
+### `pocketmine\world`
+- The following classes have been added:
+  - `pocketmine\world\format\io\GlobalBlockStateHandlers`
+  - `pocketmine\world\format\io\GlobalItemDataHandlers`
+
+# 5.0.0-ALPHA2
+Released 14th July 2022.
+
+## Core
+- Reduced memory usage of the server on startup.
+- Fixed error spam when loading item frames without items in them.
+
+## Gameplay
+### Blocks
+- Added the following new blocks:
+  - Cakes with Candle & Dyed Candle
+  - Candle & Dyed Candle
+  - Cartography Table (not currently usable due to maps not being implemented)
+  - Copper block (random oxidation not yet implemented)
+  - Cut Copper block, stairs and slabs (random oxidation not yet implemented)
+  - Crying Obsidian
+  - Gilded Blackstone
+  - Glow Item Frame
+  - Hanging Roots
+  - Lightning Rod
+  - Netherite Block
+  - Smithing Table
+  - Tinted Glass
+  - Warped Wart Block
+  - Wither Rose
+
+### Items
+- Added the following new items:
+  - Honey Bottle
+  - Netherite Axe
+  - Netherite Boots
+  - Netherite Chestplate
+  - Netherite Helmet
+  - Netherite Ingot
+  - Netherite Leggings
+  - Netherite Pickaxe
+  - Netherite Scrap
+  - Netherite Shovel
+  - Netherite Sword
+
+## API
+### `pocketmine\block`
+- Dependency between `BlockFactory` and `VanillaBlocks` has been inverted.
+  - Now, blocks are defined in `VanillaBlocks`, and automatically registered in `BlockFactory`.
+  - Manual registration in `BlockFactory` is still required for custom blocks.
+  - `BlockFactory` now has only one purpose, which is to map internal blockstate IDs to `Block` objects when reading blocks from chunks.
+- The following new API methods have been added:
+  - `public Block->isFireProofAsItem()`
+  - `public Block->onProjectileHit()`
+  - `public ItemFrame->isGlowing()`
+  - `public ItemFrame->setGlowing()`
+- The following new classes have been added:
+  - `BaseCake`
+  - `CakeWithCandle`
+  - `CakeWithDyedCandle`
+  - `Candle`
+  - `CartographyTable`
+  - `CopperSlab`
+  - `CopperStairs`
+  - `Copper`
+  - `DyedCandle`
+  - `GildedBlackstone`
+  - `HangingRoots`
+  - `LightningRod`
+  - `SmithingTable`
+  - `WitherRose`
+  - `utils\CandleTrait`
+  - `utils\CopperOxidation`
+  - `utils\CopperTrait`
+
+### `pocketmine\crafting`
+- JSON models have been updated to reflect updated crafting data format.
+- The following enum classes have new members:
+  - `ShapelessRecipeType` has new members `CARTOGRAPHY` and `SMITHING`
+
+### `pocketmine\data`
+- `LegacyToStringBidirectionalIdMap` has been reduced to `LegacyToStringIdMap`.
+  - Since we never map from string ID to legacy ID, bidirectional mapping is no longer necessary.
+  - This affects the following subclasses:
+    - `LegacyBiomeIdToStringIdMap`
+    - `LegacyBlockIdToStringIdMap`
+    - `LegacyEntityIdToStringIdMap`
+    - `LegacyItemIdToStringIdMap`
+- The following internal API methods have been added:
+  - `public LegacyToStringIdMap->add(string $string, int $legacy) : void` - adds a mapping from a custom legacy ID to custom string ID, needed for upgrading old saved data
+  - `public LegacyBlockStateMapper->addMapping(string $stringId, int $intId, int $meta, BlockStateData $stateData) : void` - adds a mapping from legacy block data to a modern blockstate, needed for upgrading old saved data
+  - `public BlockStateData->getState(string $name) : ?Tag`
+- The following internal API methods have signature changes:
+  - `BlockStateData->__construct()` now accepts `array<string, Tag`> for `$states` instead of `CompoundTag`
+  - `BlockStateData->getStates()` now returns `array<string, Tag>` instead of `CompoundTag` (allows reducing memory usage)
+- The following classes have been added:
+  - `UnsupportedItemTypeException`
+
+### `pocketmine\item`
+- `ItemFactory` has been removed.
+  - Vanilla item registration is now done via `VanillaItems`.
+  - The procedure for registering a custom item is the same as in ALPHA1, minus the `ItemFactory` step.
+- The following API methods have been added:
+  - `public ArmorTypeInfo->getToughness() : int`
+  - `public ArmorTypeInfo->isFireProof() : bool`
+  - `public Item->isFireProof() : bool`
+- The following API methods have signature changes:
+  - `ArmorTypeInfo->__construct()` now accepts optional parameters `int $toughness` and `bool $fireProof`
+- The following classes have been added:
+  - `HoneyBottle`
+- The following enums have new members:
+  - `ToolTier` has new member `NETHERITE`
+
+### `pocketmine\world`
+- The following API methods have signature changes:
+  - `SubChunk->__construct()` parameter `$blocks` has been renamed to `$blockLayers`.
+- The following classes have been added:
+  - `CopperWaxApplySound`
+  - `CopperWaxRemoveSound`
+
+# 5.0.0-ALPHA3
+Released 14th August 2022.
+
+## Core
+- Support for Bedrock 1.19.20.
+- Dropped support for Bedrock versions older than 1.19.20.
+- Improved performance of dropping block inventory contents when the block is destroyed.
+
+## Fixes
+- Fixed errors when loading air itemstacks from PM4 worlds. These weren't supposed to exist (vanilla doesn't save them), but they were present in older PM worlds due to a bug in older versions.
+- Fixed server crash when discovering unknown blocks in non-leveldb worlds during conversion.
+- Fixed crimson / warped planks being usable as furnace fuel.
+
+## Gameplay
+### Blocks
+- Added the following new blocks:
+  - Cauldron
+  - Chorus Flower
+  - Chorus Plant
+  - Froglight (pearlescent, verdant, ochre)
+  - Mangrove Roots
+  - Muddy Mangrove Roots
+  - Rooted Dirt
+  - Spore Blossom
+- Fixed lava setting entities on fire for an incorrect duration (Java vs Bedrock inconsistency).
+
+### Items
+- Glass bottles can now be filled with water by clicking on a water source block.
+
+## API
+### `pocketmine\block`
+#### Highlights
+- Introduced "type tags" concept, which allows marking certain blocks as having certain behaviours.
+  - The idea for this system was borrowed from the Minecraft Java tags system.
+  - It's still in very early concept stage, but is currently used for deciding which types of blocks plants can be placed on without needing to enumerate every single ID in every class, eliminating a bunch of boilerplate code and improving consistency.
+- All `Block` descendents now accept `BlockTypeInfo` in the constructor, instead of `BlockBreakInfo`.
+  - This allows for future additions without needing to change dozens of overridden constructors.
+- Dynamic type and state property serialization now each use a single, unified method (`describeType` and `describeState` respectively) which accept `RuntimeDataReader|RuntimeDataWriter`, instead of separate decode/encode methods.
+  - This simplifies implementing new blocks and avoids duplication of information.
+- `&$returnedItems` reference parameter is now used in some places to enable actions to return items to players without caring about whether they are in creative or anything else.
+  - This eliminates boilerplate code of deciding whether to set the player's held item or not, as well as automatically dropping any overflow items that don't fit into the inventory.
+  - This is currently used when filling/emptying cauldrons using buckets or glass bottles.
+- `BlockTypeIds` now exposes `newId()` static method to ease addition of custom blocks.
+
+#### Changes
+- The following API methods have signature changes:
+  - `Block->onInteract()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Block->onBreak()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Block->readStateFromWorld()` now returns `Block`.
+    - This allows blocks to replace themselves with a different block entirely based on world conditions.
+- The following new classes have been added:
+  - `BlockTypeInfo`
+  - `BlockTypeTags`
+- The following new API methods have been added:
+  - `protected Block->describeState(RuntimeDataReader|RuntimeDataWriter $w) : void` - describes to a runtime data reader/writer how to read/write the block's state properties
+  - `protected Block->describeType(RuntimeDataReader|RuntimeDataWriter $w) : void` - describes to a runtime data reader/writer how to read/write the block's dynamic type properties
+  - `public Block->getTypeTags() : array<string>`
+  - `public Block->hasTypeTag(string $tag) : bool`
+  - `public Spawnable->getRenderUpdateBugWorkaroundStateProperties(Block $block) : array<string, Tag>` - allows spawnable tiles to spoof block state properties to work around client-side rendering bugs without actually changing the block server-side
+  - `public static BlockBreakInfo::axe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : BlockBreakInfo`
+  - `public static BlockBreakInfo::pickaxe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : BlockBreakInfo`
+  - `public static BlockBreakInfo::shovel(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : BlockBreakInfo`
+  - `public static BlockBreakInfo::tier(float $hardness, int $toolType, ToolTier $toolTier, ?float $blastResistance = null) : BlockBreakInfo`
+  - `public static BlockTypeIds::newId() : int` - returns a new dynamic block type ID for use by custom blocks
+
+### `pocketmine\data`
+- The following classes have been renamed:
+  - `LegacyBlockStateMapper` -> `BlockIdMetaUpgrader`
+- The following API methods have been added:
+  - `public BlockDataUpgrader->getIdMetaUpgrader() : BlockIdMetaUpgrader`
+  - `public BlockIdMetaUpgrader->addIdMetaToStateMapping(string $stringId, int $meta, BlockStateData $stateData) : void`
+  - `public BlockIdMetaUpgrader->addIntIdToStringIdMapping(int $intId, string $stringId) : void`
+- The following API methods have been removed:
+  - `BlockIdMetaUpgrader->addMapping()` - use `addIdMetaToStateMapping()` (and `addIntIdToStringIdMapping()` if necessary) instead
+- `LegacyToStringMap` no longer throws exceptions when adding the same mapping twice if the addition would have no effect.
+
+### `pocketmine\item`
+#### Highlights
+- `&$returnedItems` reference parameter is now used in some places to enable actions to return items to players without caring about whether they are in creative or anything else.
+  - This eliminates boilerplate code of deciding whether to set the player's held item or not, as well as automatically dropping any overflow items that don't fit into the inventory.
+  - This is used for things like filling/emptying buckets and bottles, and equipping armor.
+
+#### Changes
+- The following new API methods have been added:
+  - `public Armor->clearCustomColor() : $this` - clears the custom color of an armor item
+  - `public static ItemTypeIds::newId() : int` - returns a new dynamic item type ID for use by custom items
+- The following API methods have signature changes:
+  - `Item->onAttackEntity()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Item->onClickAir()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Item->onDestroyBlock()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Item->onInteractBlock()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Item->onReleaseUsing()` now accepts `array<Item> &$returnedItems` reference parameter.
+
+# 5.0.0-ALPHA4
+Released 24th September 2022.
+
+## Core
+- Now targeting Minecraft: Bedrock 1.19.30.
+- All tests and static analysis are now being run on PHP 8.1 as well as PHP 8.0.
+- Silenced warning about Xdebug when it's loaded but disabled by `xdebug.mode` configuration.
+- A new `console.enable-input` option has been added to `pocketmine.yml`, which allows disabling the console reader in environments where it's not needed (e.g. a Docker container). This can be useful to save processor and memory resources.
+- Console reader polling is now done on the main thread. Since the console reader communication is now done via sockets, there's no longer any reason for it to have its own thread.
+- Crashdumps now include JIT mode information for use by the Crash Archive.
+- Improved handling of "UI" inventories in network `InventoryManager`. Their contents are now synced correctly.
+- Fixed cartography table recipes pretending to be smithing table recipes in `CraftingDataPacket`.
+- Fixed incorrect key being used for saving entity type IDs in save data.
+
+## API
+### General
+- Plugin dependents are now always disabled before their dependencies on shutdown, to ensure that the dependents can finish what they are doing correctly.
+
+### `pocketmine\block`
+- The following new API methods have been added:
+  - `public SignText->isGlowing() : bool`
+  - `public SignText->getBaseColor() : pocketmine\color\Color`
+- The following API methods have signature changes:
+  - `SignText::fromBlob()` now accepts two new optional parameters: `?Color $baseColor` and `bool $glowing`
+  - `SignText::__construct()` now accepts two new optional parameters: `?Color $baseColor` and `bool $glowing`
+- The following API methods have been removed:
+  - `TreeType::fromMagicNumber()`
+  - `TreeType->getMagicNumber()`
+
+### `pocketmine\command`
+- Command permissions are now always checked by the server when running a command.
+  - This only affects commands implemented by extending `Command`. Plugins using `PluginBase->onCommand()` are not affected by this change, since they already had permissions checked by the server anyway.
+  - Previously, direct inheritors of `Command` were responsible for checking permissions, which required developers to duplicate the same code in every command, and opened lots of potential for security vulnerabilities.
+  - If you want to do something on permission denied (e.g. sending a special message, or audit logging), you can do so by overriding `Command->testPermission()`, instead of baking the code directly into `Command->execute()`.
+  - If you don't want to use permissions at all, just create a permission with a default of `true` (or belonging to `pocketmine.group.user`) and assign that.
+
+### `pocketmine\data`
+#### Highlights
+- Introduced an experimental, mostly unified item (de)serializer registrar, `ItemSerializerDeserializerRegistrar`.
+  - This class includes helper methods to register symmetric serializer and deserializer callbacks into an `ItemSerializer` and `ItemDeserializer`.
+  - This halves the amount of code needed to register new items in the vast majority of cases.
+  - This is currently used to register all currently implemented items.
+
+#### Other changes
+- The following classes have been renamed:
+  - `BlockObjectToBlockStateSerializer` -> `BlockObjectToStateSerializer`
+  - `BlockStateToBlockObjectDeserializer` -> `BlockStateToObjectDeserializer`
+- The following classes have been removed:
+  - `CachingBlockStateDeserializer`
+  - `CachingBlockStateSerializer`
+  - `DelegatingBlockStateDeserializer`
+  - `DelegatingBlockStateSerializer`
+- The following new API methods have been added:
+  - `public BlockStateToObjectDeserializer->mapSimple(string $stringId, \Closure() : Block $getBlock) : void` - for symmetry with the serializer
+
+### `pocketmine\event`
+- `BlockFormEvent` now includes information about the block which caused the event.
+  - Added `public BlockFormEvent->getCausingBlock() : Block`
+
+### `pocketmine\inventory`
+- Introduced a new `TransactionBuilder` class, which considerably simplifies the process of constructing an `InventoryTransaction` from generic `setItem()` calls.
+  - This is currently used to build server-side transactions for evicting the contents of the crafting grid when closing the main inventory.
+  - This is planned for use with the new Minecraft Bedrock item stack request system.
+- Improved PHPStan type information available for `Inventory` and `BaseInventory`.
+
+### `pocketmine\item`
+- The following API methods have been changed:
+  - `Item->encodeType(RuntimeDataWriter $w) : void` -> `Item->describeType(RuntimeDataReader|RuntimeDataWriter $w) : void`
+- The following new classes have been added:
+  - `SuspiciousStew`
+  - `SuspiciousStewType`
+
+### `pocketmine\utils`
+- The following new API methods have been added:
+  - `public static Utils::getOpcacheJitMode() : int`
+
+### `pocketmine\world`
+- The following new classes have been added:
+  - `sound\DyeUseSound`
+  - `sound\InkSacUseSound`
+- The following API methods have changed signatures:
+  - `GlobalBlockStateHandlers::getSerializer()` now returns `BlockObjectToStateSerializer` directly instead of `BlockStateSerializer`.
+  - `GlobalBlockStateHandlers::getDeserializer()` now returns `BlockStateToObjectDeserializer` directly instead of `BlockStateDeserializer`.
+
+## Gameplay
+### General
+- Spectator players are no longer able to acquire blocks by block picking that they don't already have in their inventories. The behaviour is now the same as survival mode.
+
+### Blocks
+- Coral and coral fans now behave correctly when placed out of water (they no longer immediately die).
+- Added support for dyeing sign text and making it glow.
+- Fixed dead bush being able to be placed on some invalid blocks (e.g. stone).
+- TNT can now be ignited by fire charges.
+- Vines can now only be placed on the side of full-cube blocks.
+- Fixed sugarcane not being able to be placed on some blocks.
+
+### Items
+- Added the following new items:
+  - Fire Charge
+  - Suspicious Stew
+
+### Effects
+- Updated damage modifier amounts for Instant Damage to be more in line with vanilla.
+- Updated duration modifier amounts for Regeneration to be more like vanilla.

composer.json

@@ -34,14 +34,16 @@
       "adhocore/json-comment": "^1.1",
       "fgrosse/phpasn1": "^2.3",
       "netresearch/jsonmapper": "^4.0",
-      "pocketmine/bedrock-data": "~1.5.0+bedrock-1.18.0",
-      "pocketmine/bedrock-protocol": "~7.3.0+bedrock-1.18.0",
+      "pocketmine/bedrock-block-upgrade-schema": "dev-master@dev",
+      "pocketmine/bedrock-data": "dev-modern-world-support@dev",
+      "pocketmine/bedrock-item-upgrade-schema": "dev-master",
+      "pocketmine/bedrock-protocol": "~13.0.0+bedrock-1.19.30",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/classloader": "^0.2.0",
       "pocketmine/color": "^0.2.0",
       "pocketmine/errorhandler": "^0.6.0",
-      "pocketmine/locale-data": "~2.4.2",
+      "pocketmine/locale-data": "~2.8.0 <2.8.9",
       "pocketmine/log": "^0.4.0",
       "pocketmine/log-pthreads": "^0.4.0",
       "pocketmine/math": "^0.4.0",
@@ -53,9 +55,9 @@
       "webmozart/path-util": "^2.3"
    },
    "require-dev": {
-      "phpstan/phpstan": "1.3.3",
-      "phpstan/phpstan-phpunit": "^1.0.0",
-      "phpstan/phpstan-strict-rules": "^1.0.0",
+      "phpstan/phpstan": "1.8.5",
+      "phpstan/phpstan-phpunit": "^1.1.0",
+      "phpstan/phpstan-strict-rules": "^1.2.0",
       "phpunit/phpunit": "^9.2"
    },
    "autoload": {
@@ -79,7 +81,7 @@
       "sort-packages": true
    },
    "scripts": {
-      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/ConsoleScript.php --make tests/plugins/DevTools --out plugins/DevTools.phar",
+      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/ConsoleScript.php --make ./ --relative tests/plugins/DevTools --out plugins/DevTools.phar",
       "make-server": [
          "@composer install --no-dev --classmap-authoritative --ignore-platform-reqs",
          "@php -dphar.readonly=0 build/server-phar.php"

doxygen/doxygen.conf

@@ -1,4 +1,4 @@
-# Doxyfile 1.8.15
+# Doxyfile 1.9.3
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -93,14 +93,6 @@ ALLOW_UNICODE_NAMES    = NO
 
 OUTPUT_LANGUAGE        = English
 
-# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all generated output in the proper direction.
-# Possible values are: None, LTR, RTL and Context.
-# The default value is: None.
-
-OUTPUT_TEXT_DIRECTION  = None
-
 # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
 # descriptions after the members that are listed in the file and class
 # documentation (similar to Javadoc). Set to NO to disable this.
@@ -197,6 +189,16 @@ SHORT_NAMES            = NO
 
 JAVADOC_AUTOBRIEF      = NO
 
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
@@ -217,6 +219,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -240,25 +250,19 @@ TAB_SIZE               = 4
 # the documentation. An alias has the form:
 # name=value
 # For example adding
-# "sideeffect=@par Side Effects:\n"
+# "sideeffect=@par Side Effects:^^"
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines (in the resulting output). You can put ^^ in the value part of an
-# alias to insert a newline as if a physical newline was in the original file.
-# When you need a literal { or } or , in the value part of an alias you have to
-# escape them by means of a backslash (\), this can lead to conflicts with the
-# commands \{ and \} for these it is advised to use the version @{ and @} or use
-# a double escape (\\{ and \\})
+# "Side Effects:". Note that you cannot put \n's in the value part of an alias
+# to insert newlines (in the resulting output). You can put ^^ in the value part
+# of an alias to insert a newline as if a physical newline was in the original
+# file. When you need a literal { or } or , in the value part of an alias you
+# have to escape them by means of a backslash (\), this can lead to conflicts
+# with the commands \{ and \} for these it is advised to use the version @{ and
+# @} or use a double escape (\\{ and \\})
 
 ALIASES                =
 
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              =
-
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
@@ -299,19 +303,22 @@ OPTIMIZE_OUTPUT_SLICE  = NO
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
-# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
 # FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
 # tries to guess whether the code is fixed or free formatted code, this is the
-# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat
-# .inc files as Fortran files (default is PHP), and .f files as C (default is
-# Fortran), use: inc=Fortran f=C.
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
 #
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
 EXTENSION_MAPPING      =
 
@@ -329,7 +336,7 @@ MARKDOWN_SUPPORT       = YES
 # to that level are automatically included in the table of contents, even if
 # they do not have an id attribute.
 # Note: This feature currently applies only to Markdown headings.
-# Minimum value: 0, maximum value: 99, default value: 0.
+# Minimum value: 0, maximum value: 99, default value: 5.
 # This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
 
 TOC_INCLUDE_HEADINGS   = 0
@@ -445,6 +452,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which effectively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -465,6 +485,12 @@ EXTRACT_ALL            = NO
 
 EXTRACT_PRIVATE        = NO
 
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.
@@ -502,6 +528,13 @@ EXTRACT_LOCAL_METHODS  = YES
 
 EXTRACT_ANON_NSPACES   = YES
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -519,8 +552,8 @@ HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = NO
@@ -539,11 +572,18 @@ HIDE_IN_BODY_DOCS      = YES
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = NO
@@ -562,6 +602,12 @@ HIDE_SCOPE_NAMES       = NO
 
 HIDE_COMPOUND_REFERENCE= NO
 
+# If the SHOW_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
@@ -719,7 +765,8 @@ FILE_VERSION_FILTER    =
 # output files in an output format independent way. To create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option. You can
 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
+# will be used as the name of the layout file. See also section "Changing the
+# layout of pages" for information.
 #
 # Note that if you run doxygen from a directory containing a file called
 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
@@ -765,24 +812,35 @@ WARNINGS               = NO
 WARN_IF_UNDOCUMENTED   = NO
 
 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
+# potential errors in the documentation, such as documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
 # The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = YES
+
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation. If
-# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# value. If set to NO, doxygen will only warn about wrong parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = NO
 
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
 WARN_AS_ERROR          = NO
@@ -799,7 +857,10 @@ WARN_FORMAT            = "$file:$line: $text"
 
 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
 # messages should be written. If left blank the output is written to standard
-# error (stderr).
+# error (stderr). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
 
 WARN_LOGFILE           =
 
@@ -820,8 +881,8 @@ INPUT                  = ../src \
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
@@ -834,11 +895,15 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
-# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
+# *.hh, *.hxx, *.hpp, *.h++, *.l, *.cs, *.d, *.php, *.php4, *.php5, *.phtml,
+# *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C
+# comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.php
 
@@ -883,7 +948,7 @@ EXCLUDE_PATTERNS       = */bin/* \
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
+# ANamespace::AClass, ANamespace::*Test
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
@@ -1059,16 +1124,24 @@ USE_HTAGS              = NO
 VERBATIM_HEADERS       = YES
 
 # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
 # Note: The availability of this option depends on whether or not doxygen was
 # generated with the -Duse_libclang=ON option for CMake.
 # The default value is: NO.
 
 CLANG_ASSISTED_PARSING = NO
 
+# If the CLANG_ASSISTED_PARSING tag is set to YES and the CLANG_ADD_INC_PATHS
+# tag is set to YES then doxygen will add the directory of each input to the
+# include path.
+# The default value is: YES.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
 # If clang assisted parsing is enabled you can provide the compiler with command
 # line options that you would normally use when invoking the compiler. Note that
 # the include paths will already be set by doxygen for the files and directories
@@ -1078,10 +1151,13 @@ CLANG_ASSISTED_PARSING = NO
 CLANG_OPTIONS          =
 
 # If clang assisted parsing is enabled you can provide the clang parser with the
-# path to the compilation database (see:
-# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files
-# were built. This is equivalent to specifying the "-p" option to a clang tool,
-# such as clang-check. These options will then be passed to the parser.
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
 # Note: The availability of this option depends on whether or not doxygen was
 # generated with the -Duse_libclang=ON option for CMake.
 
@@ -1098,13 +1174,6 @@ CLANG_DATABASE_PATH    =
 
 ALPHABETICAL_INDEX     = YES
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
@@ -1204,7 +1273,7 @@ HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
+# this color. Hue is specified as an angle on a color-wheel, see
 # https://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
@@ -1214,7 +1283,7 @@ HTML_EXTRA_FILES       =
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
+# in the HTML output. For a value of 0 the output will use gray-scales only. A
 # value of 255 will produce the most vivid colors.
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1239,13 +1308,13 @@ HTML_COLORSTYLE_GAMMA  = 80
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_TIMESTAMP         = YES
+HTML_TIMESTAMP         = NO
 
 # If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
 # documentation will contain a main index with vertical navigation menus that
-# are dynamically created via Javascript. If disabled, the navigation index will
+# are dynamically created via JavaScript. If disabled, the navigation index will
 # consists of multiple levels of tabs that are statically embedded in every HTML
-# page. Disable this option to support browsers that do not have Javascript,
+# page. Disable this option to support browsers that do not have JavaScript,
 # like the Qt help browser.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1275,10 +1344,11 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: https://developer.apple.com/xcode/), introduced with OSX
-# 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
 # startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
 # genXcode/_index.html for more information.
@@ -1295,6 +1365,13 @@ GENERATE_DOCSET        = NO
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
+# This tag determines the URL of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
 # This tag specifies a string that should uniquely identify the documentation
 # set bundle. This should be a reverse domain-name style string, e.g.
 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
@@ -1320,8 +1397,12 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1351,7 +1432,7 @@ CHM_FILE               =
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1396,7 +1477,8 @@ QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: http://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1404,8 +1486,8 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1413,30 +1495,30 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           =
@@ -1479,16 +1561,28 @@ DISABLE_INDEX          = NO
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
+# further fine tune the look of the index (see "Fine-tuning the output"). As an
+# example, the default style sheet generated by doxygen has an example that
+# shows how to put an image at the root of the tree instead of the PROJECT_NAME.
+# Since the tree basically has the same information as the tab index, you could
+# consider setting DISABLE_INDEX to YES when enabling this option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = YES
 
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = NO
+
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.
 #
@@ -1513,6 +1607,24 @@ TREEVIEW_WIDTH         = 250
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
@@ -1533,8 +1645,14 @@ FORMULA_FONTSIZE       = 10
 
 FORMULA_TRANSPARENT    = YES
 
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# https://www.mathjax.org) which uses client side Javascript for the rendering
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
@@ -1544,11 +1662,29 @@ FORMULA_TRANSPARENT    = YES
 
 USE_MATHJAX            = YES
 
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
 # When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
 # Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) and SVG.
 # The default value is: HTML-CSS.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1561,22 +1697,29 @@ MATHJAX_FORMAT         = HTML-CSS
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
+# MathJax from https://www.mathjax.org before deployment. The default value is:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = https://cdn.mathjax.org/mathjax/latest
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see
+# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1604,7 +1747,7 @@ MATHJAX_CODEFILE       =
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
+# implemented using a web server instead of a web client using JavaScript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
@@ -1623,7 +1766,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1636,8 +1780,9 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
@@ -1708,10 +1853,11 @@ LATEX_CMD_NAME         = latex
 MAKEINDEX_CMD_NAME     = makeindex
 
 # The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
-# generate index for LaTeX.
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
 # Note: This tag is used in the generated output file (.tex).
 # See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
-# The default value is: \makeindex.
+# The default value is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_MAKEINDEX_CMD    = \makeindex
@@ -1745,29 +1891,31 @@ PAPER_TYPE             = a4
 
 EXTRA_PACKAGES         =
 
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
+# The LATEX_HEADER tag can be used to specify a user-defined LaTeX header for
+# the generated LaTeX document. The header should contain everything until the
+# first chapter. If it is left blank doxygen will generate a standard header. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
 #
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HEADER           =
 
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
+# The LATEX_FOOTER tag can be used to specify a user-defined LaTeX footer for
+# the generated LaTeX document. The footer should contain everything after the
+# last chapter. If it is left blank doxygen will generate a standard footer. See
 # LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
+# special commands can be used inside the footer. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. Note: Only use a user-defined footer if you know what you are
+# doing!
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_FOOTER           =
@@ -1800,9 +1948,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1810,8 +1960,7 @@ USE_PDFLATEX           = YES
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
 # command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
+# if errors occur, instead of asking the user for help.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1824,16 +1973,6 @@ LATEX_BATCHMODE        = NO
 
 LATEX_HIDE_INDICES     = NO
 
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
 # https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
@@ -1914,16 +2053,6 @@ RTF_STYLESHEET_FILE    =
 
 RTF_EXTENSIONS_FILE    =
 
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------
@@ -2020,15 +2149,6 @@ GENERATE_DOCBOOK       = NO
 
 DOCBOOK_OUTPUT         = docbook
 
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
@@ -2203,34 +2323,10 @@ EXTERNAL_GROUPS        = YES
 
 EXTERNAL_PAGES         = YES
 
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = NO
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            =
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
@@ -2287,11 +2383,14 @@ DOT_FONTSIZE           = 10
 
 DOT_FONTPATH           =
 
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 CLASS_GRAPH            = YES
 
@@ -2328,10 +2427,32 @@ UML_LOOK               = YES
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2398,6 +2519,13 @@ GRAPHICAL_HIERARCHY    = YES
 
 DIRECTORY_GRAPH        = YES
 
+# The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. For an explanation of the image formats see the section
 # output formats in the documentation of the dot tool (Graphviz (see:
@@ -2451,10 +2579,10 @@ MSCFILE_DIRS           =
 DIAFILE_DIRS           =
 
 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
+# path where java can find the plantuml.jar file or to the filename of jar file
+# to be used. If left blank, it is assumed PlantUML is not used or called during
+# a preprocessing step. Doxygen will generate a warning when it encounters a
+# \startuml command in this case and will not generate output for the diagram.
 
 PLANTUML_JAR_PATH      =
 
@@ -2516,14 +2644,18 @@ DOT_MULTI_TARGETS      = YES
 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
 # explaining the meaning of the various boxes and arrows in the dot generated
 # graphs.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc temporary
+# files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES

phpstan.neon.dist

@@ -1,4 +1,5 @@
 includes:
+	- tests/phpstan/analyse-for-current-php-version.neon.php
 	- tests/phpstan/configs/actual-problems.neon
 	- tests/phpstan/configs/gc-hacks.neon
 	- tests/phpstan/configs/impossible-generics.neon

resources/pocketmine.yml

@@ -168,15 +168,45 @@ timings:
   host: timings.pmmp.io
 
 console:
+  #Whether to accept commands via the console. If disabled, anything typed on the console will be ignored.
+  #Useful to save resources on headless servers where the console is never used (e.g. hosted server, Docker, etc.)
+  enable-input: true
   #Choose whether to enable server stats reporting on the console title.
   #NOTE: The title ticker will be disabled regardless if console colours are not enabled.
   title-tick: true
 
 aliases:
-  #Examples:
-  #showtheversion: version
+  ##This section allows you to add, remove or remap command aliases.
+  ##A single alias can call one or more other commands (or aliases).
+  ##Aliases defined here will override any command aliases declared by plugins or PocketMine-MP itself.
+
+  ##To remove an alias, set it to [], like so (note that prefixed aliases like "pocketmine:stop" will remain and can't
+  ##be removed):
+  #stop: []
+
+  ##Commands are not removed, only their aliases. You can still refer to a command using its full (prefixed)
+  ##name, even if all its aliases are overwritten. The full name is usually something like "pocketmine:commandname" or
+  ##"pluginname:commandname".
+  #abort: [pocketmine:stop]
+
+  ##To add an alias, list the command(s) that it calls:
+  #showtheversion: [version]
   #savestop: [save-all, stop]
 
+  ##To invoke another command with arguments, use $1 to pass the first argument, $2 for the second etc:
+  #giveadmin: [op $1] ## `giveadmin alex` -> `op alex`
+  #kill: [suicide, say "I tried to kill $1"] ## `kill alex` -> `suicide` + `say "I tried to kill alex"`
+  #giverandom: [give $1 $2, say "Someone has just received a $2!"] ## `giverandom alex diamond` -> `give alex diamond` + `say "Someone has just received a diamond!"`
+
+  ##To make arguments mandatory (so that the command fails if they are not provided), use $$, e.g. $$1, $$2:
+  #makeadmin: [op $$1] ## `makeadmin alex` -> `op alex`, `makeadmin` with no arguments = error
+
+  ##To pass through a range of arguments, put a - (hyphen) after the index:
+  #tpalias: [tp $1-] ## `tpalias 256 70 256` -> `tp 256 70 256` - this passes arguments 1 and everything after it to the `tp` command
+
+  ##To change an existing command alias and make it do something else:
+  #tp: [suicide]
+
 worlds:
   #These settings will override the generator set in server.properties and allows loading multiple worlds
   #Example:

src/CoreConstants.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -37,4 +37,6 @@ define('pocketmine\PATH', dirname(__DIR__) . '/');
 define('pocketmine\RESOURCE_PATH', dirname(__DIR__) . '/resources/');
 define('pocketmine\BEDROCK_DATA_PATH', dirname(__DIR__) . '/vendor/pocketmine/bedrock-data/');
 define('pocketmine\LOCALE_DATA_PATH', dirname(__DIR__) . '/vendor/pocketmine/locale-data/');
+define('pocketmine\BEDROCK_BLOCK_UPGRADE_SCHEMA_PATH', dirname(__DIR__) . '/vendor/pocketmine/bedrock-block-upgrade-schema/');
+define('pocketmine\BEDROCK_ITEM_UPGRADE_SCHEMA_PATH', dirname(__DIR__) . '/vendor/pocketmine/bedrock-item-upgrade-schema/');
 define('pocketmine\COMPOSER_AUTOLOADER_PATH', dirname(__DIR__) . '/vendor/autoload.php');

src/MemoryManager.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -69,9 +69,6 @@ use const JSON_UNESCAPED_SLASHES;
 use const SORT_NUMERIC;
 
 class MemoryManager{
-
-	private Server $server;
-
 	private int $memoryLimit;
 	private int $globalMemoryLimit;
 	private int $checkRate;
@@ -98,8 +95,9 @@ class MemoryManager{
 
 	private \Logger $logger;
 
-	public function __construct(Server $server){
-		$this->server = $server;
+	public function __construct(
+		private Server $server
+	){
 		$this->logger = new \PrefixedLogger($server->getLogger(), "Memory Manager");
 
 		$this->init($server->getConfigGroup());
@@ -508,8 +506,13 @@ class MemoryManager{
 				return "(error) ARRAY RECURSION LIMIT REACHED";
 			}
 			$data = [];
+			$numeric = 0;
 			foreach($from as $key => $value){
-				$data[$key] = self::continueDump($value, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize);
+				$data[$numeric] = [
+					"k" => self::continueDump($key, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize),
+					"v" => self::continueDump($value, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize),
+				];
+				$numeric++;
 			}
 		}elseif(is_string($from)){
 			$data = "(string) len(" . strlen($from) . ") " . substr(Utils::printable($from), 0, $maxStringSize);

src/PocketMine.php

@@ -37,6 +37,7 @@ namespace pocketmine {
 	use Webmozart\PathUtil\Path;
 	use function defined;
 	use function extension_loaded;
+	use function function_exists;
 	use function getcwd;
 	use function phpversion;
 	use function preg_match;
@@ -160,7 +161,7 @@ namespace pocketmine {
 		if(PHP_DEBUG !== 0){
 			$logger->warning("This PHP binary was compiled in debug mode. This has a major impact on performance.");
 		}
-		if(extension_loaded("xdebug")){
+		if(extension_loaded("xdebug") && (!function_exists('xdebug_info') || count(xdebug_info('mode')) !== 0)){
 			$logger->warning("Xdebug extension is enabled. This has a major impact on performance.");
 		}
 		if(((int) ini_get('zend.assertions')) !== -1){
@@ -176,10 +177,10 @@ namespace pocketmine {
 
 
 	--------------------------------------- ! WARNING ! ---------------------------------------
-	You're using PHP 8.0 with JIT enabled. This provides significant performance improvements.
+	You're using PHP with JIT enabled. This provides significant performance improvements.
 	HOWEVER, it is EXPERIMENTAL, and has already been seen to cause weird and unexpected bugs.
 	Proceed with caution.
-	If you want to report any bugs, make sure to mention that you are using PHP 8.0 with JIT.
+	If you want to report any bugs, make sure to mention that you have enabled PHP JIT.
 	To turn off JIT, change `opcache.jit` to `0` in your php.ini file.
 	-------------------------------------------------------------------------------------------
 

src/Server.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -31,7 +31,7 @@ use pocketmine\command\Command;
 use pocketmine\command\CommandSender;
 use pocketmine\command\SimpleCommandMap;
 use pocketmine\console\ConsoleCommandSender;
-use pocketmine\console\ConsoleReaderThread;
+use pocketmine\console\ConsoleReaderChildProcessDaemon;
 use pocketmine\crafting\CraftingManager;
 use pocketmine\crafting\CraftingManagerFromDataHelper;
 use pocketmine\crash\CrashDump;
@@ -88,7 +88,6 @@ use pocketmine\promise\PromiseResolver;
 use pocketmine\resourcepacks\ResourcePackManager;
 use pocketmine\scheduler\AsyncPool;
 use pocketmine\snooze\SleeperHandler;
-use pocketmine\snooze\SleeperNotifier;
 use pocketmine\stats\SendUsageTask;
 use pocketmine\timings\Timings;
 use pocketmine\timings\TimingsHandler;
@@ -132,6 +131,8 @@ use function get_class;
 use function ini_set;
 use function is_array;
 use function is_dir;
+use function is_int;
+use function is_object;
 use function is_resource;
 use function is_string;
 use function json_decode;
@@ -164,7 +165,6 @@ use function zlib_encode;
 use const DIRECTORY_SEPARATOR;
 use const PHP_EOL;
 use const PHP_INT_MAX;
-use const PTHREADS_INHERIT_NONE;
 use const ZLIB_ENCODING_GZIP;
 
 /**
@@ -222,11 +222,10 @@ class Server{
 
 	private int $sendUsageTicker = 0;
 
-	private \AttachableThreadedLogger $logger;
-
 	private MemoryManager $memoryManager;
 
-	private ConsoleReaderThread $console;
+	private ?ConsoleReaderChildProcessDaemon $console = null;
+	private ?ConsoleCommandSender $consoleSender = null;
 
 	private SimpleCommandMap $commandMap;
 
@@ -248,7 +247,6 @@ class Server{
 
 	private UuidInterface $serverID;
 
-	private \DynamicClassLoader $autoloader;
 	private string $dataPath;
 	private string $pluginPath;
 
@@ -572,6 +570,7 @@ class Server{
 			$playerPos = null;
 			$spawn = $world->getSpawnLocation();
 		}
+		/** @phpstan-var PromiseResolver<Player> $playerPromiseResolver */
 		$playerPromiseResolver = new PromiseResolver();
 		$world->requestChunkPopulation($spawn->getFloorX() >> Chunk::COORD_BIT_SIZE, $spawn->getFloorZ() >> Chunk::COORD_BIT_SIZE, null)->onCompletion(
 			function() use ($playerPromiseResolver, $class, $session, $playerInfo, $authenticated, $world, $playerPos, $spawn, $offlinePlayerData) : void{
@@ -765,7 +764,12 @@ class Server{
 		return self::$instance;
 	}
 
-	public function __construct(\DynamicClassLoader $autoloader, \AttachableThreadedLogger $logger, string $dataPath, string $pluginPath){
+	public function __construct(
+		private \DynamicClassLoader $autoloader,
+		private \AttachableThreadedLogger $logger,
+		string $dataPath,
+		string $pluginPath
+	){
 		if(self::$instance !== null){
 			throw new \LogicException("Only one server instance can exist at once");
 		}
@@ -773,8 +777,6 @@ class Server{
 		$this->startTime = microtime(true);
 
 		$this->tickSleeper = new SleeperHandler();
-		$this->autoloader = $autoloader;
-		$this->logger = $logger;
 
 		$this->signalHandler = new SignalHandler(function() : void{
 			$this->logger->info("Received signal interrupt, stopping the server");
@@ -860,7 +862,7 @@ class Server{
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error3()));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4("settings.enable-dev-builds")));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error5("https://github.com/pmmp/PocketMine-MP/releases")));
-					$this->forceShutdown();
+					$this->forceShutdownExit();
 
 					return;
 				}
@@ -962,7 +964,7 @@ class Server{
 
 			$this->commandMap = new SimpleCommandMap($this);
 
-			$this->craftingManager = CraftingManagerFromDataHelper::make(Path::join(\pocketmine\BEDROCK_DATA_PATH, "recipes.json"));
+			$this->craftingManager = CraftingManagerFromDataHelper::make(Path::join(\pocketmine\BEDROCK_DATA_PATH, "recipes"));
 
 			$this->resourceManager = new ResourcePackManager(Path::join($this->getDataPath(), "resource_packs"), $this->logger);
 
@@ -975,7 +977,7 @@ class Server{
 				$pluginGraylist = PluginGraylist::fromArray(yaml_parse(file_get_contents($graylistFile)));
 			}catch(\InvalidArgumentException $e){
 				$this->logger->emergency("Failed to load $graylistFile: " . $e->getMessage());
-				$this->forceShutdown();
+				$this->forceShutdownExit();
 				return;
 			}
 			$this->pluginManager = new PluginManager($this, $this->configGroup->getPropertyBool("plugins.legacy-data-dir", true) ? null : Path::join($this->getDataPath(), "plugin_data"), $pluginGraylist);
@@ -1002,16 +1004,32 @@ class Server{
 
 			register_shutdown_function([$this, "crashDump"]);
 
-			$this->pluginManager->loadPlugins($this->pluginPath);
-			$this->enablePlugins(PluginEnableOrder::STARTUP());
-
-			if(!$this->startupPrepareWorlds()){
+			$loadErrorCount = 0;
+			$this->pluginManager->loadPlugins($this->pluginPath, $loadErrorCount);
+			if($loadErrorCount > 0){
+				$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_plugin_someLoadErrors()));
+				$this->forceShutdownExit();
+				return;
+			}
+			if(!$this->enablePlugins(PluginEnableOrder::STARTUP())){
+				$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_plugin_someEnableErrors()));
+				$this->forceShutdownExit();
+				return;
+			}
+
+			if(!$this->startupPrepareWorlds()){
+				$this->forceShutdownExit();
+				return;
+			}
+
+			if(!$this->enablePlugins(PluginEnableOrder::POSTWORLD())){
+				$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_plugin_someEnableErrors()));
+				$this->forceShutdownExit();
 				return;
 			}
-			$this->enablePlugins(PluginEnableOrder::POSTWORLD());
 
 			if(!$this->startupPrepareNetworkInterfaces()){
-				$this->forceShutdown();
+				$this->forceShutdownExit();
 				return;
 			}
 
@@ -1031,17 +1049,9 @@ class Server{
 			$this->subscribeToBroadcastChannel(self::BROADCAST_CHANNEL_ADMINISTRATIVE, $consoleSender);
 			$this->subscribeToBroadcastChannel(self::BROADCAST_CHANNEL_USERS, $consoleSender);
 
-			$consoleNotifier = new SleeperNotifier();
-			$commandBuffer = new \Threaded();
-			$this->console = new ConsoleReaderThread($commandBuffer, $consoleNotifier);
-			$this->tickSleeper->addNotifier($consoleNotifier, function() use ($commandBuffer, $consoleSender) : void{
-				Timings::$serverCommand->startTiming();
-				while(($line = $commandBuffer->shift()) !== null){
-					$this->dispatchCommand($consoleSender, (string) $line);
-				}
-				Timings::$serverCommand->stopTiming();
-			});
-			$this->console->start(PTHREADS_INHERIT_NONE);
+			if($this->configGroup->getPropertyBool("console.enable-input", true)){
+				$this->console = new ConsoleReaderChildProcessDaemon($this->logger);
+			}
 
 			$this->tickProcessor();
 			$this->forceShutdown();
@@ -1072,13 +1082,21 @@ class Server{
 			return $generatorEntry->getGeneratorClass();
 		};
 
+		$anyWorldFailedToLoad = false;
+
 		foreach((array) $this->configGroup->getProperty("worlds", []) as $name => $options){
 			if($options === null){
 				$options = [];
 			}elseif(!is_array($options)){
+				//TODO: this probably should be an error
 				continue;
 			}
-			if(!$this->worldManager->loadWorld($name, true) && !$this->worldManager->isWorldGenerated($name)){
+			if(!$this->worldManager->loadWorld($name, true)){
+				if($this->worldManager->isWorldGenerated($name)){
+					//allow checking if other worlds are loadable, so the user gets all the errors in one go
+					$anyWorldFailedToLoad = true;
+					continue;
+				}
 				$creationOptions = WorldCreationOptions::create();
 				//TODO: error checking
 
@@ -1087,11 +1105,13 @@ class Server{
 
 				$generatorClass = $getGenerator($generatorName, $generatorOptions, $name);
 				if($generatorClass === null){
+					$anyWorldFailedToLoad = true;
 					continue;
 				}
 				$creationOptions->setGeneratorClass($generatorClass);
 				$creationOptions->setGeneratorOptions($generatorOptions);
 
+				$creationOptions->setDifficulty($this->getDifficulty());
 				if(isset($options["difficulty"]) && is_string($options["difficulty"])){
 					$creationOptions->setDifficulty(World::getDifficultyFromString($options["difficulty"]));
 				}
@@ -1114,33 +1134,39 @@ class Server{
 				$default = "world";
 				$this->configGroup->setConfigString("level-name", "world");
 			}
-			if(!$this->worldManager->loadWorld($default, true) && !$this->worldManager->isWorldGenerated($default)){
+			if(!$this->worldManager->loadWorld($default, true)){
+				if($this->worldManager->isWorldGenerated($default)){
+					$this->getLogger()->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
+
+					return false;
+				}
 				$generatorName = $this->configGroup->getConfigString("level-type");
 				$generatorOptions = $this->configGroup->getConfigString("generator-settings");
 				$generatorClass = $getGenerator($generatorName, $generatorOptions, $default);
-				if($generatorClass !== null){
-					$creationOptions = WorldCreationOptions::create()
-						->setGeneratorClass($generatorClass)
-						->setGeneratorOptions($generatorOptions);
-					$convertedSeed = Generator::convertSeed($this->configGroup->getConfigString("level-seed"));
-					if($convertedSeed !== null){
-						$creationOptions->setSeed($convertedSeed);
-					}
-					$this->worldManager->generateWorld($default, $creationOptions);
+
+				if($generatorClass === null){
+					$this->getLogger()->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
+					return false;
 				}
+				$creationOptions = WorldCreationOptions::create()
+					->setGeneratorClass($generatorClass)
+					->setGeneratorOptions($generatorOptions);
+				$convertedSeed = Generator::convertSeed($this->configGroup->getConfigString("level-seed"));
+				if($convertedSeed !== null){
+					$creationOptions->setSeed($convertedSeed);
+				}
+				$creationOptions->setDifficulty($this->getDifficulty());
+				$this->worldManager->generateWorld($default, $creationOptions);
 			}
 
 			$world = $this->worldManager->getWorldByName($default);
 			if($world === null){
-				$this->getLogger()->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
-				$this->forceShutdown();
-
-				return false;
+				throw new AssumptionFailedError("We just loaded/generated the default world, so it must exist");
 			}
 			$this->worldManager->setDefaultWorld($world);
 		}
 
-		return true;
+		return !$anyWorldFailedToLoad;
 	}
 
 	private function startupPrepareConnectableNetworkInterfaces(string $ip, int $port, bool $ipV6, bool $useQuery) : bool{
@@ -1379,16 +1405,21 @@ class Server{
 		}
 	}
 
-	public function enablePlugins(PluginEnableOrder $type) : void{
+	public function enablePlugins(PluginEnableOrder $type) : bool{
+		$allSuccess = true;
 		foreach($this->pluginManager->getPlugins() as $plugin){
 			if(!$plugin->isEnabled() && $plugin->getDescription()->getOrder()->equals($type)){
-				$this->pluginManager->enablePlugin($plugin);
+				if(!$this->pluginManager->enablePlugin($plugin)){
+					$allSuccess = false;
+				}
 			}
 		}
 
 		if($type->equals(PluginEnableOrder::POSTWORLD())){
 			$this->commandMap->registerServerAliases();
 		}
+
+		return $allSuccess;
 	}
 
 	/**
@@ -1418,6 +1449,11 @@ class Server{
 		}
 	}
 
+	private function forceShutdownExit() : void{
+		$this->forceShutdown();
+		Process::kill(Process::pid(), true);
+	}
+
 	public function forceShutdown() : void{
 		if($this->hasStopped){
 			return;
@@ -1428,7 +1464,7 @@ class Server{
 		}
 
 		if($this->isRunning){
-			$this->logger->emergency("Forcing server shutdown");
+			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_forcingShutdown()));
 		}
 		try{
 			if(!$this->isRunning()){
@@ -1468,7 +1504,7 @@ class Server{
 				$this->configGroup->save();
 			}
 
-			if(isset($this->console)){
+			if($this->console !== null){
 				$this->getLogger()->debug("Closing console");
 				$this->console->quit();
 			}
@@ -1606,13 +1642,15 @@ class Server{
 						"reportPaste" => base64_encode($dump->getEncodedData())
 					], 10, [], $postUrlError);
 
-					if($reply !== null && ($data = json_decode($reply->getBody())) !== null){
-						if(isset($data->crashId) && isset($data->crashUrl)){
+					if($reply !== null && is_object($data = json_decode($reply->getBody()))){
+						if(isset($data->crashId) && is_int($data->crashId) && isset($data->crashUrl) && is_string($data->crashUrl)){
 							$reportId = $data->crashId;
 							$reportUrl = $data->crashUrl;
 							$this->logger->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_crash_archive($reportUrl, (string) $reportId)));
-						}elseif(isset($data->error)){
+						}elseif(isset($data->error) && is_string($data->error)){
 							$this->logger->emergency("Automatic crash report submission failed: $data->error");
+						}else{
+							$this->logger->emergency("Invalid JSON response received from crash archive: " . $reply->getBody());
 						}
 					}else{
 						$this->logger->emergency("Failed to communicate with crash archive: $postUrlError");
@@ -1810,6 +1848,13 @@ class Server{
 
 		$this->getMemoryManager()->check();
 
+		if($this->console !== null){
+			while(($line = $this->console->readLine()) !== null){
+				$this->consoleSender ??= new ConsoleCommandSender($this, $this->language);
+				$this->dispatchCommand($this->consoleSender, $line);
+			}
+		}
+
 		Timings::$serverTick->stopTiming();
 
 		$now = microtime(true);

src/ServerConfigGroup.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -32,22 +32,16 @@ use function is_string;
 use function strtolower;
 
 final class ServerConfigGroup{
-
-	/** @var Config */
-	private $pocketmineYml;
-	/** @var Config */
-	private $serverProperties;
-
 	/**
 	 * @var mixed[]
 	 * @phpstan-var array<string, mixed>
 	 */
-	private $propertyCache = [];
+	private array $propertyCache = [];
 
-	public function __construct(Config $pocketmineYml, Config $serverProperties){
-		$this->pocketmineYml = $pocketmineYml;
-		$this->serverProperties = $serverProperties;
-	}
+	public function __construct(
+		private Config $pocketmineYml,
+		private Config $serverProperties
+	){}
 
 	/**
 	 * @param mixed  $defaultValue

src/VersionInfo.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -31,16 +31,15 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "4.1.0-BETA2";
+	public const BASE_VERSION = "5.0.0-ALPHA4";
 	public const IS_DEVELOPMENT_BUILD = false;
-	public const BUILD_CHANNEL = "beta";
+	public const BUILD_CHANNEL = "alpha";
 
 	private function __construct(){
 		//NOOP
 	}
 
-	/** @var string|null */
-	private static $gitHash = null;
+	private static ?string $gitHash = null;
 
 	public static function GIT_HASH() : string{
 		if(self::$gitHash === null){
@@ -79,8 +78,7 @@ final class VersionInfo{
 		return self::$buildNumber;
 	}
 
-	/** @var VersionString|null */
-	private static $fullVersion = null;
+	private static ?VersionString $fullVersion = null;
 
 	public static function VERSION() : VersionString{
 		if(self::$fullVersion === null){

src/block/ActivatorRail.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/Air.php

@@ -17,22 +17,16 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\math\AxisAlignedBB;
-
 /**
  * Air block
  */
-class Air extends Transparent{
-
-	public function canBeFlowedInto() : bool{
-		return true;
-	}
+class Air extends Flowable{
 
 	public function canBeReplaced() : bool{
 		return true;
@@ -41,15 +35,4 @@ class Air extends Transparent{
 	public function canBePlaced() : bool{
 		return false;
 	}
-
-	public function isSolid() : bool{
-		return false;
-	}
-
-	/**
-	 * @return AxisAlignedBB[]
-	 */
-	protected function recalculateCollisionBoxes() : array{
-		return [];
-	}
 }

src/block/Anvil.php

@@ -17,17 +17,19 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\block\inventory\AnvilInventory;
-use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\block\utils\Fallable;
 use pocketmine\block\utils\FallableTrait;
 use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
@@ -39,31 +41,30 @@ class Anvil extends Transparent implements Fallable{
 	use FallableTrait;
 	use HorizontalFacingTrait;
 
-	private int $damage = 0;
+	public const UNDAMAGED = 0;
+	public const SLIGHTLY_DAMAGED = 1;
+	public const VERY_DAMAGED = 2;
 
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) | ($this->damage << 2);
+	private int $damage = self::UNDAMAGED;
+
+	public function getRequiredTypeDataBits() : int{ return 2; }
+
+	protected function describeType(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->boundedInt(2, self::UNDAMAGED, self::VERY_DAMAGED, $this->damage);
 	}
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x3);
-		$this->damage = BlockDataSerializer::readBoundedInt("damage", $stateMeta >> 2, 0, 2);
-	}
+	public function getRequiredStateDataBits() : int{ return 2; }
 
-	public function getStateBitmask() : int{
-		return 0b1111;
-	}
-
-	protected function writeStateToItemMeta() : int{
-		return $this->damage << 2;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->horizontalFacing($this->facing);
 	}
 
 	public function getDamage() : int{ return $this->damage; }
 
 	/** @return $this */
 	public function setDamage(int $damage) : self{
-		if($damage < 0 || $damage > 2){
-			throw new \InvalidArgumentException("Damage must be in range 0-2");
+		if($damage < self::UNDAMAGED || $damage > self::VERY_DAMAGED){
+			throw new \InvalidArgumentException("Damage must be in range " . self::UNDAMAGED . " ... " . self::VERY_DAMAGED);
 		}
 		$this->damage = $damage;
 		return $this;
@@ -76,7 +77,11 @@ class Anvil extends Transparent implements Fallable{
 		return [AxisAlignedBB::one()->squash(Facing::axis(Facing::rotateY($this->facing, false)), 1 / 8)];
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$player->setCurrentWindow(new AnvilInventory($this->position));
 		}

src/block/Bamboo.php

@@ -17,17 +17,20 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\event\block\StructureGrowEvent;
 use pocketmine\item\Bamboo as ItemBamboo;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
@@ -53,18 +56,12 @@ class Bamboo extends Transparent{
 	protected bool $ready = false;
 	protected int $leafSize = self::NO_LEAVES;
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->thick = ($stateMeta & BlockLegacyMetadata::BAMBOO_FLAG_THICK) !== 0;
-		$this->leafSize = BlockDataSerializer::readBoundedInt("leafSize", ($stateMeta >> BlockLegacyMetadata::BAMBOO_LEAF_SIZE_SHIFT) & BlockLegacyMetadata::BAMBOO_LEAF_SIZE_MASK, self::NO_LEAVES, self::LARGE_LEAVES);
-		$this->ready = ($stateMeta & BlockLegacyMetadata::BAMBOO_FLAG_READY) !== 0;
-	}
+	public function getRequiredStateDataBits() : int{ return 4; }
 
-	public function writeStateToMeta() : int{
-		return ($this->thick ? BlockLegacyMetadata::BAMBOO_FLAG_THICK : 0) | ($this->leafSize << BlockLegacyMetadata::BAMBOO_LEAF_SIZE_SHIFT) | ($this->ready ? BlockLegacyMetadata::BAMBOO_FLAG_READY : 0);
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->boundedInt(2, self::NO_LEAVES, self::LARGE_LEAVES, $this->leafSize);
+		$w->bool($this->thick);
+		$w->bool($this->ready);
 	}
 
 	public function isThick() : bool{ return $this->thick; }
@@ -100,6 +97,10 @@ class Bamboo extends Transparent{
 		return [AxisAlignedBB::one()->trim(Facing::SOUTH, $inset)->trim(Facing::EAST, $inset)];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	private static function getOffsetSeed(int $x, int $y, int $z) : int{
 		$p1 = gmp_mul($z, 0x6ebfff5);
 		$p2 = gmp_mul($x, 0x2fc20f);
@@ -123,14 +124,11 @@ class Bamboo extends Transparent{
 	}
 
 	private function canBeSupportedBy(Block $block) : bool{
-		//TODO: tags would be better for this
 		return
-			$block instanceof Dirt ||
-			$block instanceof Grass ||
-			$block instanceof Gravel ||
-			$block instanceof Sand ||
-			$block instanceof Mycelium ||
-			$block instanceof Podzol;
+			$block->getTypeId() === BlockTypeIds::GRAVEL ||
+			$block->hasTypeTag(BlockTypeTags::DIRT) ||
+			$block->hasTypeTag(BlockTypeTags::MUD) ||
+			$block->hasTypeTag(BlockTypeTags::SAND);
 	}
 
 	private function seekToTop() : Bamboo{
@@ -142,7 +140,7 @@ class Bamboo extends Transparent{
 		return $top;
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer){
 			$top = $this->seekToTop();
 			if($top->grow(self::getMaxHeight($top->position->getFloorX(), $top->position->getFloorZ()), mt_rand(1, 2), $player)){
@@ -159,9 +157,10 @@ class Bamboo extends Transparent{
 	}
 
 	public function onNearbyBlockChange() : void{
-		$below = $this->position->getWorld()->getBlock($this->position->down());
+		$world = $this->position->getWorld();
+		$below = $world->getBlock($this->position->down());
 		if(!$this->canBeSupportedBy($below) && !$below->isSameType($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
+			$world->useBreakOn($this->position);
 		}
 	}
 
@@ -207,7 +206,7 @@ class Bamboo extends Transparent{
 			}
 		}
 
-		$tx = new BlockTransaction($this->position->getWorld());
+		$tx = new BlockTransaction($world);
 		foreach($newBlocks as $idx => $newBlock){
 			$tx->addBlock($this->position->subtract(0, $idx - $growAmount, 0), $newBlock);
 		}
@@ -237,4 +236,8 @@ class Bamboo extends Transparent{
 			$world->setBlock($this->position, $this);
 		}
 	}
+
+	public function asItem() : Item{
+		return VanillaItems::BAMBOO();
+	}
 }

src/block/BambooSapling.php

@@ -17,34 +17,32 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\event\block\StructureGrowEvent;
 use pocketmine\item\Bamboo as ItemBamboo;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 
 final class BambooSapling extends Flowable{
-
 	private bool $ready = false;
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->ready = ($stateMeta & BlockLegacyMetadata::SAPLING_FLAG_READY) !== 0;
-	}
+	public function getRequiredStateDataBits() : int{ return 1; }
 
-	protected function writeStateToMeta() : int{
-		return $this->ready ? BlockLegacyMetadata::SAPLING_FLAG_READY : 0;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->bool($this->ready);
 	}
 
-	public function getStateBitmask() : int{ return 0b1000; }
-
 	public function isReady() : bool{ return $this->ready; }
 
 	/** @return $this */
@@ -54,14 +52,11 @@ final class BambooSapling extends Flowable{
 	}
 
 	private function canBeSupportedBy(Block $block) : bool{
-		//TODO: tags would be better for this
 		return
-			$block instanceof Dirt ||
-			$block instanceof Grass ||
-			$block instanceof Gravel ||
-			$block instanceof Sand ||
-			$block instanceof Mycelium ||
-			$block instanceof Podzol;
+			$block->getTypeId() === BlockTypeIds::GRAVEL ||
+			$block->hasTypeTag(BlockTypeTags::DIRT) ||
+			$block->hasTypeTag(BlockTypeTags::MUD) ||
+			$block->hasTypeTag(BlockTypeTags::SAND);
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
@@ -71,7 +66,7 @@ final class BambooSapling extends Flowable{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer || $item instanceof ItemBamboo){
 			if($this->grow($player)){
 				$item->pop();
@@ -82,8 +77,9 @@ final class BambooSapling extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->position->getWorld()->getBlock($this->position->down()))){
-			$this->position->getWorld()->useBreakOn($this->position);
+		$world = $this->position->getWorld();
+		if(!$this->canBeSupportedBy($world->getBlock($this->position->down()))){
+			$world->useBreakOn($this->position);
 		}
 	}
 
@@ -125,6 +121,6 @@ final class BambooSapling extends Flowable{
 	}
 
 	public function asItem() : Item{
-		return VanillaBlocks::BAMBOO()->asItem();
+		return VanillaItems::BAMBOO();
 	}
 }

src/block/Barrel.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -25,7 +25,8 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Barrel as TileBarrel;
 use pocketmine\block\utils\AnyFacingTrait;
-use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
@@ -38,17 +39,11 @@ class Barrel extends Opaque{
 
 	protected bool $open = false;
 
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeFacing($this->facing) | ($this->open ? BlockLegacyMetadata::BARREL_FLAG_OPEN : 0);
-	}
+	public function getRequiredStateDataBits() : int{ return 4; }
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->facing = BlockDataSerializer::readFacing($stateMeta & 0x07);
-		$this->open = ($stateMeta & BlockLegacyMetadata::BARREL_FLAG_OPEN) === BlockLegacyMetadata::BARREL_FLAG_OPEN;
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->facing($this->facing);
+		$w->bool($this->open);
 	}
 
 	public function isOpen() : bool{
@@ -81,7 +76,7 @@ class Barrel extends Opaque{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$barrel = $this->position->getWorld()->getTile($this->position);
 			if($barrel instanceof TileBarrel){

src/block/BaseBanner.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -27,9 +27,10 @@ use pocketmine\block\tile\Banner as TileBanner;
 use pocketmine\block\utils\BannerPatternLayer;
 use pocketmine\block\utils\ColoredTrait;
 use pocketmine\block\utils\DyeColor;
-use pocketmine\data\bedrock\DyeColorIdMap;
+use pocketmine\block\utils\SupportType;
 use pocketmine\item\Banner as ItemBanner;
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
@@ -47,18 +48,20 @@ abstract class BaseBanner extends Transparent{
 	 */
 	protected array $patterns = [];
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->color = DyeColor::BLACK();
-		parent::__construct($idInfo, $name, $breakInfo);
+		parent::__construct($idInfo, $name, $typeInfo);
 	}
 
-	public function readStateFromWorld() : void{
+	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 		$tile = $this->position->getWorld()->getTile($this->position);
 		if($tile instanceof TileBanner){
 			$this->color = $tile->getBaseColor();
 			$this->setPatterns($tile->getPatterns());
 		}
+
+		return $this;
 	}
 
 	public function writeStateToWorld() : void{
@@ -107,6 +110,10 @@ abstract class BaseBanner extends Transparent{
 		return [];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($item instanceof ItemBanner){
 			$this->color = $item->getColor();
@@ -119,15 +126,11 @@ abstract class BaseBanner extends Transparent{
 	abstract protected function getSupportingFace() : int;
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide($this->getSupportingFace())->getId() === BlockLegacyIds::AIR){
+		if($this->getSide($this->getSupportingFace())->getTypeId() === BlockTypeIds::AIR){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	protected function writeStateToItemMeta() : int{
-		return DyeColorIdMap::getInstance()->toInvertedId($this->color);
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		$drop = $this->asItem();
 		if($drop instanceof ItemBanner && count($this->patterns) > 0){
@@ -144,4 +147,8 @@ abstract class BaseBanner extends Transparent{
 		}
 		return $result;
 	}
+
+	public function asItem() : Item{
+		return VanillaItems::BANNER()->setColor($this->color);
+	}
 }

src/block/BaseCake.php

@@ -0,0 +1,89 @@
+<?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\block;
+
+use pocketmine\block\utils\SupportType;
+use pocketmine\entity\effect\EffectInstance;
+use pocketmine\entity\FoodSource;
+use pocketmine\entity\Living;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+abstract class BaseCake extends Transparent implements FoodSource{
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getTypeId() !== BlockTypeIds::AIR){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::AIR){ //Replace with common break method
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player !== null){
+			return $player->consumeObject($this);
+		}
+
+		return false;
+	}
+
+	public function getFoodRestore() : int{
+		return 2;
+	}
+
+	public function getSaturationRestore() : float{
+		return 0.4;
+	}
+
+	public function requiresHunger() : bool{
+		return true;
+	}
+
+	/**
+	 * @return EffectInstance[]
+	 */
+	public function getAdditionalEffects() : array{
+		return [];
+	}
+
+	abstract public function getResidue() : Block;
+
+	public function onConsume(Living $consumer) : void{
+		$this->position->getWorld()->setBlock($this->position, $this->getResidue());
+	}
+}

src/block/BaseCoral.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -25,32 +25,27 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\CoralTypeTrait;
+use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
+use function mt_rand;
 
 abstract class BaseCoral extends Transparent{
 	use CoralTypeTrait;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
-		parent::__construct($idInfo, $name, $breakInfo);
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
+		parent::__construct($idInfo, $name, $typeInfo);
 		$this->coralType = CoralType::TUBE();
 	}
 
 	public function onNearbyBlockChange() : void{
 		if(!$this->dead){
-			$world = $this->position->getWorld();
+			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(40, 200));
+		}
+	}
 
-			$hasWater = false;
-			foreach($this->position->sides() as $vector3){
-				if($world->getBlock($vector3) instanceof Water){
-					$hasWater = true;
-					break;
-				}
-			}
-
-			//TODO: check water inside the block itself (not supported on the API yet)
-			if(!$hasWater){
-				$world->setBlock($this->position, $this->setDead(true));
-			}
+	public function onScheduledUpdate() : void{
+		if(!$this->dead && !$this->isCoveredWithWater()){
+			$this->position->getWorld()->setBlock($this->position, $this->setDead(true));
 		}
 	}
 
@@ -64,5 +59,24 @@ abstract class BaseCoral extends Transparent{
 
 	public function isSolid() : bool{ return false; }
 
+	protected function isCoveredWithWater() : bool{
+		$world = $this->position->getWorld();
+
+		$hasWater = false;
+		foreach($this->position->sides() as $vector3){
+			if($world->getBlock($vector3) instanceof Water){
+				$hasWater = true;
+				break;
+			}
+		}
+
+		//TODO: check water inside the block itself (not supported on the API yet)
+		return $hasWater;
+	}
+
 	protected function recalculateCollisionBoxes() : array{ return []; }
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
 }

src/block/BaseFire.php

@@ -0,0 +1,63 @@
+<?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\block;
+
+use pocketmine\entity\Entity;
+use pocketmine\entity\projectile\Arrow;
+use pocketmine\event\entity\EntityCombustByBlockEvent;
+use pocketmine\event\entity\EntityDamageByBlockEvent;
+use pocketmine\event\entity\EntityDamageEvent;
+use pocketmine\item\Item;
+
+abstract class BaseFire extends Flowable{
+
+	public function hasEntityCollision() : bool{
+		return true;
+	}
+
+	public function canBeReplaced() : bool{
+		return true;
+	}
+
+	public function onEntityInside(Entity $entity) : bool{
+		$ev = new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_FIRE, $this->getFireDamage());
+		$entity->attack($ev);
+
+		$ev = new EntityCombustByBlockEvent($this, $entity, 8);
+		if($entity instanceof Arrow){
+			$ev->cancel();
+		}
+		$ev->call();
+		if(!$ev->isCancelled()){
+			$entity->setOnFire($ev->getDuration());
+		}
+		return true;
+	}
+
+	abstract protected function getFireDamage() : int;
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+}

src/block/BaseRail.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -38,7 +38,7 @@ use function in_array;
 abstract class BaseRail extends Flowable{
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$blockReplace->getSide(Facing::DOWN)->isTransparent()){
+		if($blockReplace->getSide(Facing::DOWN)->getSupportType(Facing::UP)->hasEdgeSupport()){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
@@ -162,6 +162,7 @@ abstract class BaseRail extends Flowable{
 		$thisConnections = $this->getConnectedDirections();
 		$changed = false;
 
+		$world = $this->position->getWorld();
 		do{
 			$possible = $this->getPossibleConnectionDirections($thisConnections);
 			$continue = false;
@@ -189,7 +190,7 @@ abstract class BaseRail extends Flowable{
 				if(isset($otherPossible[$otherSide])){
 					$otherConnections[] = $otherSide;
 					$other->setConnections($otherConnections);
-					$this->position->getWorld()->setBlock($other->position, $other);
+					$world->setBlock($other->position, $other);
 
 					$changed = true;
 					$thisConnections[] = $thisSide;
@@ -202,7 +203,7 @@ abstract class BaseRail extends Flowable{
 
 		if($changed){
 			$this->setConnections($thisConnections);
-			$this->position->getWorld()->setBlock($this->position, $this);
+			$world->setBlock($this->position, $this);
 		}
 	}
 
@@ -220,12 +221,13 @@ abstract class BaseRail extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->isTransparent()){
-			$this->position->getWorld()->useBreakOn($this->position);
+		$world = $this->position->getWorld();
+		if(!$this->getSide(Facing::DOWN)->getSupportType(Facing::UP)->hasEdgeSupport()){
+			$world->useBreakOn($this->position);
 		}else{
 			foreach($this->getCurrentShapeConnections() as $connection){
-				if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0 && $this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND)->isTransparent()){
-					$this->position->getWorld()->useBreakOn($this->position);
+				if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0 && !$this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND)->getSupportType(Facing::UP)->hasEdgeSupport()){
+					$world->useBreakOn($this->position);
 					break;
 				}
 			}

src/block/BaseSign.php

@@ -17,41 +17,62 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\block\tile\Sign as TileSign;
+use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SignText;
+use pocketmine\block\utils\SupportType;
+use pocketmine\block\utils\WoodType;
+use pocketmine\block\utils\WoodTypeTrait;
+use pocketmine\color\Color;
 use pocketmine\event\block\SignChangeEvent;
+use pocketmine\item\Dye;
 use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\utils\TextFormat;
 use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\DyeUseSound;
+use pocketmine\world\sound\InkSacUseSound;
 use function array_map;
 use function assert;
 use function strlen;
 
 abstract class BaseSign extends Transparent{
+	use WoodTypeTrait;
+
 	protected SignText $text;
 	protected ?int $editorEntityRuntimeId = null;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
-		parent::__construct($idInfo, $name, $breakInfo);
+	/** @var \Closure() : Item */
+	private \Closure $asItemCallback;
+
+	/**
+	 * @param \Closure() : Item $asItemCallback
+	 */
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo, WoodType $woodType, \Closure $asItemCallback){
+		$this->woodType = $woodType;
+		parent::__construct($idInfo, $name, $typeInfo);
 		$this->text = new SignText();
+		$this->asItemCallback = $asItemCallback;
 	}
 
-	public function readStateFromWorld() : void{
+	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 		$tile = $this->position->getWorld()->getTile($this->position);
 		if($tile instanceof TileSign){
 			$this->text = $tile->getText();
 			$this->editorEntityRuntimeId = $tile->getEditorEntityRuntimeId();
 		}
+
+		return $this;
 	}
 
 	public function writeStateToWorld() : void{
@@ -77,10 +98,14 @@ abstract class BaseSign extends Transparent{
 		return [];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	abstract protected function getSupportingFace() : int;
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide($this->getSupportingFace())->getId() === BlockLegacyIds::AIR){
+		if($this->getSide($this->getSupportingFace())->getTypeId() === BlockTypeIds::AIR){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
@@ -92,6 +117,55 @@ abstract class BaseSign extends Transparent{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
+	private function doSignChange(SignText $newText, Player $player, Item $item) : bool{
+		$ev = new SignChangeEvent($this, $player, $newText);
+		$ev->call();
+		if(!$ev->isCancelled()){
+			$this->text = $ev->getNewText();
+			$this->position->getWorld()->setBlock($this->position, $this);
+			$item->pop();
+			return true;
+		}
+
+		return false;
+	}
+
+	private function changeSignGlowingState(bool $glowing, Player $player, Item $item) : bool{
+		if($this->text->isGlowing() !== $glowing && $this->doSignChange(new SignText($this->text->getLines(), $this->text->getBaseColor(), $glowing), $player, $item)){
+			$this->position->getWorld()->addSound($this->position, new InkSacUseSound());
+			return true;
+		}
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player === null){
+			return false;
+		}
+		$dyeColor = $item instanceof Dye ? $item->getColor() : match($item->getTypeId()){
+			ItemTypeIds::BONE_MEAL => DyeColor::WHITE(),
+			ItemTypeIds::LAPIS_LAZULI => DyeColor::BLUE(),
+			ItemTypeIds::COCOA_BEANS => DyeColor::BROWN(),
+			default => null
+		};
+		if($dyeColor !== null){
+			$color = $dyeColor->equals(DyeColor::BLACK()) ? new Color(0, 0, 0) : $dyeColor->getRgbValue();
+			if($color->toARGB() === $this->text->getBaseColor()->toARGB()){
+				return false;
+			}
+
+			if($this->doSignChange(new SignText($this->text->getLines(), $color, $this->text->isGlowing()), $player, $item)){
+				$this->position->getWorld()->addSound($this->position, new DyeUseSound());
+				return true;
+			}
+		}elseif($item->getTypeId() === ItemTypeIds::INK_SAC){
+			return $this->changeSignGlowingState(false, $player, $item);
+		}elseif($item->getTypeId() === ItemTypeIds::GLOW_INK_SAC){
+			return $this->changeSignGlowingState(true, $player, $item);
+		}
+		return false;
+	}
+
 	/**
 	 * Returns an object containing information about the sign text.
 	 */
@@ -134,4 +208,8 @@ abstract class BaseSign extends Transparent{
 
 		return false;
 	}
+
+	public function asItem() : Item{
+		return ($this->asItemCallback)();
+	}
 }

src/block/Beacon.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/Bed.php

@@ -17,18 +17,19 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\block\tile\Bed as TileBed;
-use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\block\utils\ColoredTrait;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\HorizontalFacingTrait;
-use pocketmine\data\bedrock\DyeColorIdMap;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\entity\Entity;
 use pocketmine\entity\Living;
 use pocketmine\item\Item;
@@ -48,34 +49,28 @@ class Bed extends Transparent{
 	protected bool $occupied = false;
 	protected bool $head = false;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->color = DyeColor::RED();
-		parent::__construct($idInfo, $name, $breakInfo);
+		parent::__construct($idInfo, $name, $typeInfo);
 	}
 
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) |
-			($this->occupied ? BlockLegacyMetadata::BED_FLAG_OCCUPIED : 0) |
-			($this->head ? BlockLegacyMetadata::BED_FLAG_HEAD : 0);
+	public function getRequiredStateDataBits() : int{ return 4; }
+
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->horizontalFacing($this->facing);
+		$w->bool($this->occupied);
+		$w->bool($this->head);
 	}
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
-		$this->occupied = ($stateMeta & BlockLegacyMetadata::BED_FLAG_OCCUPIED) !== 0;
-		$this->head = ($stateMeta & BlockLegacyMetadata::BED_FLAG_HEAD) !== 0;
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1111;
-	}
-
-	public function readStateFromWorld() : void{
+	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 		//read extra state information from the tile - this is an ugly hack
 		$tile = $this->position->getWorld()->getTile($this->position);
 		if($tile instanceof TileBed){
 			$this->color = $tile->getColor();
 		}
+
+		return $this;
 	}
 
 	public function writeStateToWorld() : void{
@@ -94,6 +89,10 @@ class Bed extends Transparent{
 		return [AxisAlignedBB::one()->trim(Facing::UP, 7 / 16)];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	public function isHeadPart() : bool{
 		return $this->head;
 	}
@@ -127,7 +126,7 @@ class Bed extends Transparent{
 		return null;
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$other = $this->getOtherHalf();
 			$playerPos = $player->getPosition();
@@ -166,7 +165,7 @@ class Bed extends Transparent{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(($other = $this->getOtherHalf()) !== null && $other->occupied !== $this->occupied){
+		if(!$this->head && ($other = $this->getOtherHalf()) !== null && $other->occupied !== $this->occupied){
 			$this->occupied = $other->occupied;
 			$this->position->getWorld()->setBlock($this->position, $this);
 		}
@@ -181,12 +180,11 @@ class Bed extends Transparent{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if(!$down->isTransparent()){
+		if($this->canBeSupportedBy($this->getSide(Facing::DOWN))){
 			$this->facing = $player !== null ? $player->getHorizontalFacing() : Facing::NORTH;
 
 			$next = $this->getSide($this->getOtherHalfSide());
-			if($next->canBeReplaced() && !$next->getSide(Facing::DOWN)->isTransparent()){
+			if($next->canBeReplaced() && $this->canBeSupportedBy($next->getSide(Facing::DOWN))){
 				$nextState = clone $this;
 				$nextState->head = true;
 				$tx->addBlock($blockReplace->position, $this)->addBlock($next->position, $nextState);
@@ -205,10 +203,6 @@ class Bed extends Transparent{
 		return [];
 	}
 
-	protected function writeStateToItemMeta() : int{
-		return DyeColorIdMap::getInstance()->toId($this->color);
-	}
-
 	public function getAffectedBlocks() : array{
 		if(($other = $this->getOtherHalf()) !== null){
 			return [$this, $other];
@@ -216,4 +210,10 @@ class Bed extends Transparent{
 
 		return parent::getAffectedBlocks();
 	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		return !$block->getSupportType(Facing::UP)->equals(SupportType::NONE());
+	}
+
+	public function getMaxStackSize() : int{ return 1; }
 }

src/block/Bedrock.php

@@ -17,26 +17,22 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class Bedrock extends Opaque{
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 
+class Bedrock extends Opaque{
 	private bool $burnsForever = false;
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->burnsForever = ($stateMeta & BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN) !== 0;
-	}
+	public function getRequiredStateDataBits() : int{ return 1; }
 
-	protected function writeStateToMeta() : int{
-		return $this->burnsForever ? BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN : 0;
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->bool($this->burnsForever);
 	}
 
 	public function burnsForever() : bool{

src/block/Beetroot.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -30,7 +30,7 @@ use function mt_rand;
 class Beetroot extends Crops{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if($this->age >= 7){
+		if($this->age >= self::MAX_AGE){
 			return [
 				VanillaItems::BEETROOT(),
 				VanillaItems::BEETROOT_SEEDS()->setCount(mt_rand(0, 3))
@@ -42,7 +42,7 @@ class Beetroot extends Crops{
 		];
 	}
 
-	public function getPickedItem(bool $addUserData = false) : Item{
+	public function asItem() : Item{
 		return VanillaItems::BEETROOT_SEEDS();
 	}
 }

src/block/Bell.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -25,14 +25,15 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Bell as TileBell;
 use pocketmine\block\utils\BellAttachmentType;
-use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\block\utils\HorizontalFacingTrait;
-use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\utils\AssumptionFailedError;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\sound\BellRingSound;
 
@@ -41,41 +42,42 @@ final class Bell extends Transparent{
 
 	private BellAttachmentType $attachmentType;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->attachmentType = BellAttachmentType::FLOOR();
-		parent::__construct($idInfo, $name, $breakInfo);
+		parent::__construct($idInfo, $name, $typeInfo);
 	}
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->setFacing(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03));
+	public function getRequiredStateDataBits() : int{ return 4; }
 
-		$attachmentType = [
-			BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR => BellAttachmentType::FLOOR(),
-			BlockLegacyMetadata::BELL_ATTACHMENT_CEILING => BellAttachmentType::CEILING(),
-			BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL => BellAttachmentType::ONE_WALL(),
-			BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS => BellAttachmentType::TWO_WALLS()
-		][($stateMeta >> 2) & 0b11] ?? null;
-		if($attachmentType === null){
-			throw new InvalidBlockStateException("No such attachment type");
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->bellAttachmentType($this->attachmentType);
+		$w->horizontalFacing($this->facing);
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		if($this->attachmentType->equals(BellAttachmentType::FLOOR())){
+			return [
+				AxisAlignedBB::one()->squash(Facing::axis($this->facing), 1 / 4)->trim(Facing::UP, 3 / 16)
+			];
 		}
-		$this->setAttachmentType($attachmentType);
-	}
-
-	public function writeStateToMeta() : int{
-		$attachmentTypeMeta = [
-			BellAttachmentType::FLOOR()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR,
-			BellAttachmentType::CEILING()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_CEILING,
-			BellAttachmentType::ONE_WALL()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL,
-			BellAttachmentType::TWO_WALLS()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS
-		][$this->getAttachmentType()->id()] ?? null;
-		if($attachmentTypeMeta === null){
-			throw new AssumptionFailedError("Mapping should cover all cases");
+		if($this->attachmentType->equals(BellAttachmentType::CEILING())){
+			return [
+				AxisAlignedBB::one()->contract(1 / 4, 0, 1 / 4)->trim(Facing::DOWN, 1 / 4)
+			];
 		}
-		return BlockDataSerializer::writeLegacyHorizontalFacing($this->getFacing()) | ($attachmentTypeMeta << 2);
+
+		$box = AxisAlignedBB::one()
+			->squash(Facing::axis(Facing::rotateY($this->facing, true)), 1 / 4)
+			->trim(Facing::UP, 1 / 16)
+			->trim(Facing::DOWN, 1 / 4);
+
+		return [
+			$this->attachmentType->equals(BellAttachmentType::ONE_WALL()) ? $box->trim($this->facing, 3 / 16) : $box
+		];
 	}
 
-	public function getStateBitmask() : int{
-		return 0b1111;
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
 	}
 
 	public function getAttachmentType() : BellAttachmentType{ return $this->attachmentType; }
@@ -130,7 +132,7 @@ final class Bell extends Transparent{
 		}
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$faceHit = Facing::opposite($player->getHorizontalFacing());
 			if($this->attachmentType->equals(BellAttachmentType::CEILING())){
@@ -151,10 +153,11 @@ final class Bell extends Transparent{
 	}
 
 	public function ring(int $faceHit) : void{
-		$this->position->getWorld()->addSound($this->position, new BellRingSound());
-		$tile = $this->position->getWorld()->getTile($this->position);
+		$world = $this->position->getWorld();
+		$world->addSound($this->position, new BellRingSound());
+		$tile = $world->getTile($this->position);
 		if($tile instanceof TileBell){
-			$this->position->getWorld()->broadcastPacketToViewers($this->position, $tile->createFakeUpdatePacket($faceHit));
+			$world->broadcastPacketToViewers($this->position, $tile->createFakeUpdatePacket($faceHit));
 		}
 	}
 }

src/block/Block.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -28,11 +28,14 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Spawnable;
 use pocketmine\block\tile\Tile;
-use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\entity\Entity;
+use pocketmine\entity\projectile\Projectile;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\ItemBlock;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\RayTraceResult;
@@ -43,18 +46,17 @@ use pocketmine\world\BlockTransaction;
 use pocketmine\world\format\Chunk;
 use pocketmine\world\Position;
 use pocketmine\world\World;
-use function assert;
 use function count;
-use function dechex;
+use function get_class;
 use const PHP_INT_MAX;
 
 class Block{
-	public const INTERNAL_METADATA_BITS = 4;
-	public const INTERNAL_METADATA_MASK = ~(~0 << self::INTERNAL_METADATA_BITS);
+	public const INTERNAL_STATE_DATA_BITS = 9;
+	public const INTERNAL_STATE_DATA_MASK = ~(~0 << self::INTERNAL_STATE_DATA_BITS);
 
 	protected BlockIdentifier $idInfo;
 	protected string $fallbackName;
-	protected BlockBreakInfo $breakInfo;
+	protected BlockTypeInfo $typeInfo;
 	protected Position $position;
 
 	/** @var AxisAlignedBB[]|null */
@@ -63,13 +65,10 @@ class Block{
 	/**
 	 * @param string          $name English name of the block type (TODO: implement translations)
 	 */
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
-		if(($idInfo->getVariant() & $this->getStateBitmask()) !== 0){
-			throw new \InvalidArgumentException("Variant 0x" . dechex($idInfo->getVariant()) . " collides with state bitmask 0x" . dechex($this->getStateBitmask()));
-		}
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->idInfo = $idInfo;
 		$this->fallbackName = $name;
-		$this->breakInfo = $breakInfo;
+		$this->typeInfo = $typeInfo;
 		$this->position = new Position(0, 0, 0, null);
 	}
 
@@ -85,49 +84,94 @@ class Block{
 		return $this->fallbackName;
 	}
 
-	public function getId() : int{
-		return $this->idInfo->getBlockId();
+	/**
+	 * @internal
+	 */
+	public function getStateId() : int{
+		return ($this->getTypeId() << self::INTERNAL_STATE_DATA_BITS) | $this->computeStateData();
+	}
+
+	public function asItem() : Item{
+		return new ItemBlock($this);
+	}
+
+	public function getRequiredTypeDataBits() : int{ return 0; }
+
+	public function getRequiredStateDataBits() : int{ return 0; }
+
+	/**
+	 * @internal
+	 */
+	final public function decodeTypeData(int $data) : void{
+		$typeBits = $this->getRequiredTypeDataBits();
+		$givenBits = $typeBits;
+		$reader = new RuntimeDataReader($givenBits, $data);
+
+		$this->describeType($reader);
+		$readBits = $reader->getOffset();
+		if($typeBits !== $readBits){
+			throw new \LogicException(get_class($this) . ": Exactly $typeBits bits of type data were provided, but $readBits were read");
+		}
 	}
 
 	/**
 	 * @internal
 	 */
-	public function getFullId() : int{
-		return ($this->getId() << self::INTERNAL_METADATA_BITS) | $this->getMeta();
-	}
+	final public function decodeStateData(int $data) : void{
+		$typeBits = $this->getRequiredTypeDataBits();
+		$stateBits = $this->getRequiredStateDataBits();
+		$givenBits = $typeBits + $stateBits;
+		$reader = new RuntimeDataReader($givenBits, $data);
+		$this->decodeTypeData($reader->readInt($typeBits));
 
-	public function asItem() : Item{
-		return ItemFactory::getInstance()->get(
-			$this->idInfo->getItemId(),
-			$this->idInfo->getVariant() | $this->writeStateToItemMeta()
-		);
-	}
-
-	public function getMeta() : int{
-		$stateMeta = $this->writeStateToMeta();
-		assert(($stateMeta & ~$this->getStateBitmask()) === 0);
-		return $this->idInfo->getVariant() | $stateMeta;
-	}
-
-	protected function writeStateToItemMeta() : int{
-		return 0;
+		$this->describeState($reader);
+		$readBits = $reader->getOffset() - $typeBits;
+		if($stateBits !== $readBits){
+			throw new \LogicException(get_class($this) . ": Exactly $stateBits bits of state data were provided, but $readBits were read");
+		}
 	}
 
 	/**
-	 * Returns a bitmask used to extract state bits from block metadata.
+	 * @internal
 	 */
-	public function getStateBitmask() : int{
-		return 0;
-	}
+	final public function computeTypeData() : int{
+		$typeBits = $this->getRequiredTypeDataBits();
+		$requiredBits = $typeBits;
+		$writer = new RuntimeDataWriter($requiredBits);
 
-	protected function writeStateToMeta() : int{
-		return 0;
+		$this->describeType($writer);
+		$writtenBits = $writer->getOffset();
+		if($typeBits !== $writtenBits){
+			throw new \LogicException(get_class($this) . ": Exactly $typeBits bits of type data were expected, but $writtenBits were written");
+		}
+
+		return $writer->getValue();
 	}
 
 	/**
-	 * @throws InvalidBlockStateException
+	 * @internal
 	 */
-	public function readStateFromData(int $id, int $stateMeta) : void{
+	final public function computeStateData() : int{
+		$typeBits = $this->getRequiredTypeDataBits();
+		$stateBits = $this->getRequiredStateDataBits();
+		$requiredBits = $typeBits + $stateBits;
+		$writer = new RuntimeDataWriter($requiredBits);
+		$writer->int($typeBits, $this->computeTypeData());
+
+		$this->describeState($writer);
+		$writtenBits = $writer->getOffset() - $typeBits;
+		if($stateBits !== $writtenBits){
+			throw new \LogicException(get_class($this) . ": Exactly $stateBits bits of state data were expected, but $writtenBits were written");
+		}
+
+		return $writer->getValue();
+	}
+
+	protected function describeType(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		//NOOP
+	}
+
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
 		//NOOP
 	}
 
@@ -137,22 +181,28 @@ class Block{
 	 *
 	 * Clears any cached precomputed objects, such as bounding boxes. Remove any outdated precomputed things such as
 	 * AABBs and force recalculation.
+	 *
+	 * A replacement block may be returned. This is useful if the block type changed due to reading of world data (e.g.
+	 * data from a block entity).
 	 */
-	public function readStateFromWorld() : void{
+	public function readStateFromWorld() : Block{
 		$this->collisionBoxes = null;
+
+		return $this;
 	}
 
 	public function writeStateToWorld() : void{
-		$this->position->getWorld()->getOrLoadChunkAtPosition($this->position)->setFullBlock($this->position->x & Chunk::COORD_MASK, $this->position->y, $this->position->z & Chunk::COORD_MASK, $this->getFullId());
+		$world = $this->position->getWorld();
+		$world->getOrLoadChunkAtPosition($this->position)->setFullBlock($this->position->x & Chunk::COORD_MASK, $this->position->y, $this->position->z & Chunk::COORD_MASK, $this->getStateId());
 
 		$tileType = $this->idInfo->getTileClass();
-		$oldTile = $this->position->getWorld()->getTile($this->position);
+		$oldTile = $world->getTile($this->position);
 		if($oldTile !== null){
 			if($tileType === null || !($oldTile instanceof $tileType)){
 				$oldTile->close();
 				$oldTile = null;
 			}elseif($oldTile instanceof Spawnable){
-				$oldTile->setDirty(); //destroy old network cache
+				$oldTile->clearSpawnCompoundCache(); //destroy old network cache
 			}
 		}
 		if($oldTile === null && $tileType !== null){
@@ -160,8 +210,8 @@ class Block{
 			 * @var Tile $tile
 			 * @see Tile::__construct()
 			 */
-			$tile = new $tileType($this->position->getWorld(), $this->position->asVector3());
-			$this->position->getWorld()->addTile($tile);
+			$tile = new $tileType($world, $this->position->asVector3());
+			$world->addTile($tile);
 		}
 	}
 
@@ -170,14 +220,11 @@ class Block{
 	 * powered/unpowered, etc.
 	 */
 	public function getTypeId() : int{
-		return ($this->idInfo->getBlockId() << Block::INTERNAL_METADATA_BITS) | $this->idInfo->getVariant();
+		return $this->idInfo->getBlockTypeId();
 	}
 
 	/**
 	 * Returns whether the given block has an equivalent type to this one. This compares the type IDs.
-	 *
-	 * Note: This ignores additional IDs used to represent additional states. This means that, for example, a lit
-	 * furnace and unlit furnace are considered the same type.
 	 */
 	public function isSameType(Block $other) : bool{
 		return $this->getTypeId() === $other->getTypeId();
@@ -187,7 +234,26 @@ class Block{
 	 * Returns whether the given block has the same type and properties as this block.
 	 */
 	public function isSameState(Block $other) : bool{
-		return $this->getFullId() === $other->getFullId();
+		return $this->getStateId() === $other->getStateId();
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getTypeTags() : array{
+		return $this->typeInfo->getTypeTags();
+	}
+
+	/**
+	 * Returns whether this block type has the given type tag. Type tags are used as a dynamic way to tag blocks as
+	 * having certain properties, allowing type checks which are more dynamic than hardcoding a bunch of IDs or a bunch
+	 * of instanceof checks.
+	 *
+	 * For example, grass blocks, dirt, farmland, podzol and mycelium are all dirt-like blocks, and support the
+	 * placement of blocks like flowers, so they have a common tag which allows them to be identified as such.
+	 */
+	public function hasTypeTag(string $tag) : bool{
+		return $this->typeInfo->hasTypeTag($tag);
 	}
 
 	/**
@@ -221,17 +287,20 @@ class Block{
 	 * Returns an object containing information about the destruction requirements of this block.
 	 */
 	public function getBreakInfo() : BlockBreakInfo{
-		return $this->breakInfo;
+		return $this->typeInfo->getBreakInfo();
 	}
 
 	/**
 	 * Do the actions needed so the block is broken with the Item
+	 *
+	 * @param Item[] &$returnedItems Items to be added to the target's inventory (or dropped, if full)
 	 */
-	public function onBreak(Item $item, ?Player $player = null) : bool{
-		if(($t = $this->position->getWorld()->getTile($this->position)) !== null){
+	public function onBreak(Item $item, ?Player $player = null, array &$returnedItems = []) : bool{
+		$world = $this->position->getWorld();
+		if(($t = $world->getTile($this->position)) !== null){
 			$t->onBlockDestroyed();
 		}
-		$this->position->getWorld()->setBlock($this->position, VanillaBlocks::AIR());
+		$world->setBlock($this->position, VanillaBlocks::AIR());
 		return true;
 	}
 
@@ -266,8 +335,10 @@ class Block{
 
 	/**
 	 * Do actions when interacted by Item. Returns if it has done anything
+	 *
+	 * @param Item[] &$returnedItems Items to be added to the target's inventory (or dropped, if the inventory is full)
 	 */
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		return false;
 	}
 
@@ -360,7 +431,7 @@ class Block{
 	 * @return Item[]
 	 */
 	public function getDrops(Item $item) : array{
-		if($this->breakInfo->isToolCompatible($item)){
+		if($this->getBreakInfo()->isToolCompatible($item)){
 			if($this->isAffectedBySilkTouch() && $item->hasEnchantment(VanillaEnchantments::SILK_TOUCH())){
 				return $this->getSilkTouchDrops($item);
 			}
@@ -402,7 +473,7 @@ class Block{
 	 * Returns how much XP will be dropped by breaking this block with the given item.
 	 */
 	public function getXpDropForTool(Item $item) : int{
-		if($item->hasEnchantment(VanillaEnchantments::SILK_TOUCH()) || !$this->breakInfo->isToolCompatible($item)){
+		if($item->hasEnchantment(VanillaEnchantments::SILK_TOUCH()) || !$this->getBreakInfo()->isToolCompatible($item)){
 			return 0;
 		}
 
@@ -455,6 +526,10 @@ class Block{
 		return 64;
 	}
 
+	public function isFireProofAsItem() : bool{
+		return false;
+	}
+
 	/**
 	 * Returns the chance that the block will catch fire from nearby fire sources. Higher values lead to faster catching
 	 * fire.
@@ -544,7 +619,7 @@ class Block{
 	 * @return string
 	 */
 	public function __toString(){
-		return "Block[" . $this->getName() . "] (" . $this->getId() . ":" . $this->getMeta() . ")";
+		return "Block[" . $this->getName() . "] (" . $this->getTypeId() . ":" . $this->computeStateData() . ")";
 	}
 
 	/**
@@ -579,6 +654,13 @@ class Block{
 		return null;
 	}
 
+	/**
+	 * Called when a projectile collides with one of this block's collision boxes.
+	 */
+	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
+		//NOOP
+	}
+
 	/**
 	 * @return AxisAlignedBB[]
 	 */
@@ -610,6 +692,10 @@ class Block{
 		return [AxisAlignedBB::one()];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::FULL();
+	}
+
 	public function isFullCube() : bool{
 		$bb = $this->getCollisionBoxes();
 

src/block/BlockBreakInfo.php

@@ -17,13 +17,14 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
+use pocketmine\item\ToolTier;
 use function get_class;
 
 class BlockBreakInfo{
@@ -38,21 +39,36 @@ class BlockBreakInfo{
 	 */
 	public const INCOMPATIBLE_TOOL_MULTIPLIER = 5.0;
 
-	private float $hardness;
 	private float $blastResistance;
-	private int $toolType;
-	private int $toolHarvestLevel;
 
 	/**
 	 * @param float|null $blastResistance default 5x hardness
 	 */
-	public function __construct(float $hardness, int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0, ?float $blastResistance = null){
-		$this->hardness = $hardness;
-		$this->toolType = $toolType;
-		$this->toolHarvestLevel = $toolHarvestLevel;
+	public function __construct(
+		private float $hardness,
+		private int $toolType = BlockToolType::NONE,
+		private int $toolHarvestLevel = 0,
+		?float $blastResistance = null
+	){
 		$this->blastResistance = $blastResistance ?? $hardness * 5;
 	}
 
+	public static function tier(float $hardness, int $toolType, ToolTier $toolTier, ?float $blastResistance = null) : self{
+		return new self($hardness, $toolType, $toolTier->getHarvestLevel(), $blastResistance);
+	}
+
+	public static function pickaxe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
+		return new self($hardness, BlockToolType::PICKAXE, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
+	}
+
+	public static function shovel(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
+		return new self($hardness, BlockToolType::SHOVEL, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
+	}
+
+	public static function axe(float $hardness, ?ToolTier $toolTier = null, ?float $blastResistance = null) : self{
+		return new self($hardness, BlockToolType::AXE, $toolTier?->getHarvestLevel() ?? 0, $blastResistance);
+	}
+
 	public static function instant(int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0) : self{
 		return new self(0.0, $toolType, $toolHarvestLevel, 0.0);
 	}

src/block/BlockIdentifier.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -27,45 +27,22 @@ use pocketmine\block\tile\Tile;
 use pocketmine\utils\Utils;
 
 class BlockIdentifier{
-
-	private int $blockId;
-	private int $variant;
-	private ?int $itemId;
-	/** @phpstan-var class-string<Tile>|null */
-	private ?string $tileClass;
-
 	/**
 	 * @phpstan-param class-string<Tile>|null $tileClass
 	 */
-	public function __construct(int $blockId, int $variant, ?int $itemId = null, ?string $tileClass = null){
-		$this->blockId = $blockId;
-		$this->variant = $variant;
-		$this->itemId = $itemId;
-
+	public function __construct(
+		private int $blockTypeId,
+		private ?string $tileClass = null
+	){
+		if($blockTypeId < 0){
+			throw new \InvalidArgumentException("Block type ID may not be negative");
+		}
 		if($tileClass !== null){
 			Utils::testValidInstance($tileClass, Tile::class);
 		}
-		$this->tileClass = $tileClass;
 	}
 
-	public function getBlockId() : int{
-		return $this->blockId;
-	}
-
-	/**
-	 * @return int[]
-	 */
-	public function getAllBlockIds() : array{
-		return [$this->blockId];
-	}
-
-	public function getVariant() : int{
-		return $this->variant;
-	}
-
-	public function getItemId() : int{
-		return $this->itemId ?? ($this->blockId > 255 ? 255 - $this->blockId : $this->blockId);
-	}
+	public function getBlockTypeId() : int{ return $this->blockTypeId; }
 
 	/**
 	 * @phpstan-return class-string<Tile>|null

src/block/BlockIdentifierFlattened.php

@@ -1,59 +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);
-
-namespace pocketmine\block;
-
-use function count;
-
-class BlockIdentifierFlattened extends BlockIdentifier{
-
-	/** @var int[] */
-	private array $additionalIds;
-
-	/**
-	 * @param int[] $additionalIds
-	 */
-	public function __construct(int $blockId, array $additionalIds, int $variant, ?int $itemId = null, ?string $tileClass = null){
-		if(count($additionalIds) === 0){
-			throw new \InvalidArgumentException("Expected at least 1 additional ID");
-		}
-		parent::__construct($blockId, $variant, $itemId, $tileClass);
-
-		$this->additionalIds = $additionalIds;
-	}
-
-	public function getAdditionalId(int $index) : int{
-		if(!isset($this->additionalIds[$index])){
-			throw new \InvalidArgumentException("No such ID at index $index");
-		}
-		return $this->additionalIds[$index];
-	}
-
-	public function getSecondId() : int{
-		return $this->getAdditionalId(0);
-	}
-
-	public function getAllBlockIds() : array{
-		return [$this->getBlockId(), ...$this->additionalIds];
-	}
-}

src/block/BlockLegacyIdHelper.php

@@ -17,232 +17,273 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\block\BlockIdentifier as BID;
-use pocketmine\block\BlockLegacyIds as Ids;
+use pocketmine\block\BlockTypeIds as Ids;
 use pocketmine\block\tile\Sign as TileSign;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\TreeType;
-use pocketmine\item\ItemIds;
+use pocketmine\block\utils\WoodType;
+use pocketmine\item\VanillaItems;
 use pocketmine\utils\AssumptionFailedError;
 
 final class BlockLegacyIdHelper{
 
-	public static function getWoodenFloorSignIdentifier(TreeType $treeType) : BID{
+	public static function getWoodenPlanksIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_PLANKS,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_PLANKS,
+			WoodType::BIRCH()->id() => Ids::BIRCH_PLANKS,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_PLANKS,
+			WoodType::ACACIA()->id() => Ids::ACACIA_PLANKS,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_PLANKS,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_PLANKS,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_PLANKS,
+			WoodType::WARPED()->id() => Ids::WARPED_PLANKS,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getWoodenFenceIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_FENCE,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_FENCE,
+			WoodType::BIRCH()->id() => Ids::BIRCH_FENCE,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_FENCE,
+			WoodType::ACACIA()->id() => Ids::ACACIA_FENCE,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_FENCE,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_FENCE,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_FENCE,
+			WoodType::WARPED()->id() => Ids::WARPED_FENCE,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getWoodenSlabIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_SLAB,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_SLAB,
+			WoodType::BIRCH()->id() => Ids::BIRCH_SLAB,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_SLAB,
+			WoodType::ACACIA()->id() => Ids::ACACIA_SLAB,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_SLAB,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_SLAB,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_SLAB,
+			WoodType::WARPED()->id() => Ids::WARPED_SLAB,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getLogIdentifier(WoodType $treeType) : BID{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_LOG,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_LOG,
+			WoodType::BIRCH()->id() => Ids::BIRCH_LOG,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_LOG,
+			WoodType::ACACIA()->id() => Ids::ACACIA_LOG,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_LOG,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_LOG,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_STEM,
+			WoodType::WARPED()->id() => Ids::WARPED_STEM,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getAllSidedLogIdentifier(WoodType $treeType) : BID{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_WOOD,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_WOOD,
+			WoodType::BIRCH()->id() => Ids::BIRCH_WOOD,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_WOOD,
+			WoodType::ACACIA()->id() => Ids::ACACIA_WOOD,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_WOOD,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_WOOD,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_HYPHAE,
+			WoodType::WARPED()->id() => Ids::WARPED_HYPHAE,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getLeavesIdentifier(TreeType $treeType) : BID{
+		return new BID(match($treeType->id()){
+			TreeType::OAK()->id() => Ids::OAK_LEAVES,
+			TreeType::SPRUCE()->id() => Ids::SPRUCE_LEAVES,
+			TreeType::BIRCH()->id() => Ids::BIRCH_LEAVES,
+			TreeType::JUNGLE()->id() => Ids::JUNGLE_LEAVES,
+			TreeType::ACACIA()->id() => Ids::ACACIA_LEAVES,
+			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_LEAVES,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	public static function getSaplingIdentifier(TreeType $treeType) : BID{
+		return new BID(match($treeType->id()){
+			TreeType::OAK()->id() => Ids::OAK_SAPLING,
+			TreeType::SPRUCE()->id() => Ids::SPRUCE_SAPLING,
+			TreeType::BIRCH()->id() => Ids::BIRCH_SAPLING,
+			TreeType::JUNGLE()->id() => Ids::JUNGLE_SAPLING,
+			TreeType::ACACIA()->id() => Ids::ACACIA_SAPLING,
+			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_SAPLING,
+			default => throw new AssumptionFailedError("All tree types should be covered")
+		});
+	}
+
+	/**
+	 * @return BID[]|\Closure[]
+	 * @phpstan-return array{BID, BID, \Closure() : \pocketmine\item\Item}
+	 */
+	public static function getWoodenSignInfo(WoodType $treeType) : array{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BID(Ids::SIGN_POST, 0, ItemIds::SIGN, TileSign::class);
-			case TreeType::SPRUCE()->id():
-				return new BID(Ids::SPRUCE_STANDING_SIGN, 0, ItemIds::SPRUCE_SIGN, TileSign::class);
-			case TreeType::BIRCH()->id():
-				return new BID(Ids::BIRCH_STANDING_SIGN, 0, ItemIds::BIRCH_SIGN, TileSign::class);
-			case TreeType::JUNGLE()->id():
-				return new BID(Ids::JUNGLE_STANDING_SIGN, 0, ItemIds::JUNGLE_SIGN, TileSign::class);
-			case TreeType::ACACIA()->id():
-				return new BID(Ids::ACACIA_STANDING_SIGN,0, ItemIds::ACACIA_SIGN, TileSign::class);
-			case TreeType::DARK_OAK()->id():
-				return new BID(Ids::DARKOAK_STANDING_SIGN, 0, ItemIds::DARKOAK_SIGN, TileSign::class);
+			case WoodType::OAK()->id():
+				return [
+					new BID(Ids::OAK_SIGN, TileSign::class),
+					new BID(Ids::OAK_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::OAK_SIGN()
+				];
+			case WoodType::SPRUCE()->id():
+				return [
+					new BID(Ids::SPRUCE_SIGN, TileSign::class),
+					new BID(Ids::SPRUCE_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::SPRUCE_SIGN()
+				];
+			case WoodType::BIRCH()->id():
+				return [
+					new BID(Ids::BIRCH_SIGN, TileSign::class),
+					new BID(Ids::BIRCH_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::BIRCH_SIGN()
+				];
+			case WoodType::JUNGLE()->id():
+				return [
+					new BID(Ids::JUNGLE_SIGN, TileSign::class),
+					new BID(Ids::JUNGLE_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::JUNGLE_SIGN()
+				];
+			case WoodType::ACACIA()->id():
+				return [
+					new BID(Ids::ACACIA_SIGN, TileSign::class),
+					new BID(Ids::ACACIA_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::ACACIA_SIGN()
+				];
+			case WoodType::DARK_OAK()->id():
+				return [
+					new BID(Ids::DARK_OAK_SIGN, TileSign::class),
+					new BID(Ids::DARK_OAK_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::DARK_OAK_SIGN()
+				];
+			case WoodType::MANGROVE()->id():
+				return [
+					new BID(Ids::MANGROVE_SIGN, TileSign::class),
+					new BID(Ids::MANGROVE_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::MANGROVE_SIGN()
+				];
+			case WoodType::CRIMSON()->id():
+				return [
+					new BID(Ids::CRIMSON_SIGN, TileSign::class),
+					new BID(Ids::CRIMSON_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::CRIMSON_SIGN()
+				];
+			case WoodType::WARPED()->id():
+				return [
+					new BID(Ids::WARPED_SIGN, TileSign::class),
+					new BID(Ids::WARPED_WALL_SIGN, TileSign::class),
+					fn() => VanillaItems::WARPED_SIGN()
+				];
+
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenWallSignIdentifier(TreeType $treeType) : BID{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BID(Ids::WALL_SIGN, 0, ItemIds::SIGN, TileSign::class);
-			case TreeType::SPRUCE()->id():
-				return new BID(Ids::SPRUCE_WALL_SIGN, 0, ItemIds::SPRUCE_SIGN, TileSign::class);
-			case TreeType::BIRCH()->id():
-				return new BID(Ids::BIRCH_WALL_SIGN, 0, ItemIds::BIRCH_SIGN, TileSign::class);
-			case TreeType::JUNGLE()->id():
-				return new BID(Ids::JUNGLE_WALL_SIGN, 0, ItemIds::JUNGLE_SIGN, TileSign::class);
-			case TreeType::ACACIA()->id():
-				return new BID(Ids::ACACIA_WALL_SIGN, 0, ItemIds::ACACIA_SIGN, TileSign::class);
-			case TreeType::DARK_OAK()->id():
-				return new BID(Ids::DARKOAK_WALL_SIGN, 0, ItemIds::DARKOAK_SIGN, TileSign::class);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
+	public static function getWoodenTrapdoorIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_TRAPDOOR,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_TRAPDOOR,
+			WoodType::BIRCH()->id() => Ids::BIRCH_TRAPDOOR,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_TRAPDOOR,
+			WoodType::ACACIA()->id() => Ids::ACACIA_TRAPDOOR,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_TRAPDOOR,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_TRAPDOOR,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_TRAPDOOR,
+			WoodType::WARPED()->id() => Ids::WARPED_TRAPDOOR,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 
-	public static function getWoodenTrapdoorIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::WOODEN_TRAPDOOR, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::SPRUCE_TRAPDOOR, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::BIRCH_TRAPDOOR, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::JUNGLE_TRAPDOOR, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::ACACIA_TRAPDOOR, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::DARK_OAK_TRAPDOOR, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
+	public static function getWoodenButtonIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_BUTTON,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_BUTTON,
+			WoodType::BIRCH()->id() => Ids::BIRCH_BUTTON,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_BUTTON,
+			WoodType::ACACIA()->id() => Ids::ACACIA_BUTTON,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_BUTTON,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_BUTTON,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_BUTTON,
+			WoodType::WARPED()->id() => Ids::WARPED_BUTTON,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 
-	public static function getWoodenButtonIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::WOODEN_BUTTON, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::SPRUCE_BUTTON, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::BIRCH_BUTTON, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::JUNGLE_BUTTON, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::ACACIA_BUTTON, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::DARK_OAK_BUTTON, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
+	public static function getWoodenPressurePlateIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_PRESSURE_PLATE,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_PRESSURE_PLATE,
+			WoodType::BIRCH()->id() => Ids::BIRCH_PRESSURE_PLATE,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_PRESSURE_PLATE,
+			WoodType::ACACIA()->id() => Ids::ACACIA_PRESSURE_PLATE,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_PRESSURE_PLATE,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_PRESSURE_PLATE,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_PRESSURE_PLATE,
+			WoodType::WARPED()->id() => Ids::WARPED_PRESSURE_PLATE,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 
-	public static function getWoodenPressurePlateIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::WOODEN_PRESSURE_PLATE, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::SPRUCE_PRESSURE_PLATE, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::BIRCH_PRESSURE_PLATE, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::JUNGLE_PRESSURE_PLATE, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::ACACIA_PRESSURE_PLATE, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::DARK_OAK_PRESSURE_PLATE, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
+	public static function getWoodenDoorIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_DOOR,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_DOOR,
+			WoodType::BIRCH()->id() => Ids::BIRCH_DOOR,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_DOOR,
+			WoodType::ACACIA()->id() => Ids::ACACIA_DOOR,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_DOOR,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_DOOR,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_DOOR,
+			WoodType::WARPED()->id() => Ids::WARPED_DOOR,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 
-	public static function getWoodenDoorIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BID(Ids::OAK_DOOR_BLOCK, 0, ItemIds::OAK_DOOR);
-			case TreeType::SPRUCE()->id():
-				return new BID(Ids::SPRUCE_DOOR_BLOCK, 0, ItemIds::SPRUCE_DOOR);
-			case TreeType::BIRCH()->id():
-				return new BID(Ids::BIRCH_DOOR_BLOCK, 0, ItemIds::BIRCH_DOOR);
-			case TreeType::JUNGLE()->id():
-				return new BID(Ids::JUNGLE_DOOR_BLOCK, 0, ItemIds::JUNGLE_DOOR);
-			case TreeType::ACACIA()->id():
-				return new BID(Ids::ACACIA_DOOR_BLOCK, 0, ItemIds::ACACIA_DOOR);
-			case TreeType::DARK_OAK()->id():
-				return new BID(Ids::DARK_OAK_DOOR_BLOCK, 0, ItemIds::DARK_OAK_DOOR);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
+	public static function getWoodenFenceGateIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_FENCE_GATE,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_FENCE_GATE,
+			WoodType::BIRCH()->id() => Ids::BIRCH_FENCE_GATE,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_FENCE_GATE,
+			WoodType::ACACIA()->id() => Ids::ACACIA_FENCE_GATE,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_FENCE_GATE,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_FENCE_GATE,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_FENCE_GATE,
+			WoodType::WARPED()->id() => Ids::WARPED_FENCE_GATE,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 
-	public static function getWoodenFenceIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::OAK_FENCE_GATE, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::SPRUCE_FENCE_GATE, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::BIRCH_FENCE_GATE, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::JUNGLE_FENCE_GATE, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::ACACIA_FENCE_GATE, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::DARK_OAK_FENCE_GATE, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
-	}
-
-	public static function getWoodenStairsIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::OAK_STAIRS, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::SPRUCE_STAIRS, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::BIRCH_STAIRS, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::JUNGLE_STAIRS, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::ACACIA_STAIRS, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::DARK_OAK_STAIRS, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
-	}
-
-	public static function getStrippedLogIdentifier(TreeType $treeType) : BlockIdentifier{
-		switch($treeType->id()){
-			case TreeType::OAK()->id():
-				return new BlockIdentifier(Ids::STRIPPED_OAK_LOG, 0);
-			case TreeType::SPRUCE()->id():
-				return new BlockIdentifier(Ids::STRIPPED_SPRUCE_LOG, 0);
-			case TreeType::BIRCH()->id():
-				return new BlockIdentifier(Ids::STRIPPED_BIRCH_LOG, 0);
-			case TreeType::JUNGLE()->id():
-				return new BlockIdentifier(Ids::STRIPPED_JUNGLE_LOG, 0);
-			case TreeType::ACACIA()->id():
-				return new BlockIdentifier(Ids::STRIPPED_ACACIA_LOG, 0);
-			case TreeType::DARK_OAK()->id():
-				return new BlockIdentifier(Ids::STRIPPED_DARK_OAK_LOG, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all wood types");
-	}
-
-	public static function getGlazedTerracottaIdentifier(DyeColor $color) : BlockIdentifier{
-		switch($color->id()){
-			case DyeColor::WHITE()->id():
-				return new BlockIdentifier(Ids::WHITE_GLAZED_TERRACOTTA, 0);
-			case DyeColor::ORANGE()->id():
-				return new BlockIdentifier(Ids::ORANGE_GLAZED_TERRACOTTA, 0);
-			case DyeColor::MAGENTA()->id():
-				return new BlockIdentifier(Ids::MAGENTA_GLAZED_TERRACOTTA, 0);
-			case DyeColor::LIGHT_BLUE()->id():
-				return new BlockIdentifier(Ids::LIGHT_BLUE_GLAZED_TERRACOTTA, 0);
-			case DyeColor::YELLOW()->id():
-				return new BlockIdentifier(Ids::YELLOW_GLAZED_TERRACOTTA, 0);
-			case DyeColor::LIME()->id():
-				return new BlockIdentifier(Ids::LIME_GLAZED_TERRACOTTA, 0);
-			case DyeColor::PINK()->id():
-				return new BlockIdentifier(Ids::PINK_GLAZED_TERRACOTTA, 0);
-			case DyeColor::GRAY()->id():
-				return new BlockIdentifier(Ids::GRAY_GLAZED_TERRACOTTA, 0);
-			case DyeColor::LIGHT_GRAY()->id():
-				return new BlockIdentifier(Ids::SILVER_GLAZED_TERRACOTTA, 0);
-			case DyeColor::CYAN()->id():
-				return new BlockIdentifier(Ids::CYAN_GLAZED_TERRACOTTA, 0);
-			case DyeColor::PURPLE()->id():
-				return new BlockIdentifier(Ids::PURPLE_GLAZED_TERRACOTTA, 0);
-			case DyeColor::BLUE()->id():
-				return new BlockIdentifier(Ids::BLUE_GLAZED_TERRACOTTA, 0);
-			case DyeColor::BROWN()->id():
-				return new BlockIdentifier(Ids::BROWN_GLAZED_TERRACOTTA, 0);
-			case DyeColor::GREEN()->id():
-				return new BlockIdentifier(Ids::GREEN_GLAZED_TERRACOTTA, 0);
-			case DyeColor::RED()->id():
-				return new BlockIdentifier(Ids::RED_GLAZED_TERRACOTTA, 0);
-			case DyeColor::BLACK()->id():
-				return new BlockIdentifier(Ids::BLACK_GLAZED_TERRACOTTA, 0);
-		}
-		throw new AssumptionFailedError("Switch should cover all colours");
-	}
-
-	public static function getStoneSlabIdentifier(int $stoneSlabId, int $meta) : BlockIdentifierFlattened{
-		$id = [
-			1 => [Ids::STONE_SLAB, Ids::DOUBLE_STONE_SLAB],
-			2 => [Ids::STONE_SLAB2, Ids::DOUBLE_STONE_SLAB2],
-			3 => [Ids::STONE_SLAB3, Ids::DOUBLE_STONE_SLAB3],
-			4 => [Ids::STONE_SLAB4, Ids::DOUBLE_STONE_SLAB4]
-		][$stoneSlabId] ?? null;
-		if($id === null){
-			throw new \InvalidArgumentException("Stone slab type should be 1, 2, 3 or 4");
-		}
-		return new BlockIdentifierFlattened($id[0], [$id[1]], $meta);
+	public static function getWoodenStairsIdentifier(WoodType $treeType) : BlockIdentifier{
+		return new BID(match($treeType->id()){
+			WoodType::OAK()->id() => Ids::OAK_STAIRS,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_STAIRS,
+			WoodType::BIRCH()->id() => Ids::BIRCH_STAIRS,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_STAIRS,
+			WoodType::ACACIA()->id() => Ids::ACACIA_STAIRS,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_STAIRS,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_STAIRS,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_STAIRS,
+			WoodType::WARPED()->id() => Ids::WARPED_STAIRS,
+			default => throw new AssumptionFailedError("All wood types should be covered")
+		});
 	}
 }

src/block/BlockLegacyIds.php

@@ -1,501 +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);
-
-namespace pocketmine\block;
-
-final class BlockLegacyIds{
-
-	private function __construct(){
-		//NOOP
-	}
-
-	public const AIR = 0;
-	public const STONE = 1;
-	public const GRASS = 2;
-	public const DIRT = 3;
-	public const COBBLESTONE = 4;
-	public const PLANKS = 5, WOODEN_PLANKS = 5;
-	public const SAPLING = 6;
-	public const BEDROCK = 7;
-	public const FLOWING_WATER = 8;
-	public const STILL_WATER = 9, WATER = 9;
-	public const FLOWING_LAVA = 10;
-	public const LAVA = 11, STILL_LAVA = 11;
-	public const SAND = 12;
-	public const GRAVEL = 13;
-	public const GOLD_ORE = 14;
-	public const IRON_ORE = 15;
-	public const COAL_ORE = 16;
-	public const LOG = 17;
-	public const LEAVES = 18;
-	public const SPONGE = 19;
-	public const GLASS = 20;
-	public const LAPIS_ORE = 21;
-	public const LAPIS_BLOCK = 22;
-	public const DISPENSER = 23;
-	public const SANDSTONE = 24;
-	public const NOTEBLOCK = 25, NOTE_BLOCK = 25;
-	public const BED_BLOCK = 26;
-	public const GOLDEN_RAIL = 27, POWERED_RAIL = 27;
-	public const DETECTOR_RAIL = 28;
-	public const STICKY_PISTON = 29;
-	public const COBWEB = 30, WEB = 30;
-	public const TALLGRASS = 31, TALL_GRASS = 31;
-	public const DEADBUSH = 32, DEAD_BUSH = 32;
-	public const PISTON = 33;
-	public const PISTONARMCOLLISION = 34, PISTON_ARM_COLLISION = 34;
-	public const WOOL = 35;
-	public const ELEMENT_0 = 36;
-	public const DANDELION = 37, YELLOW_FLOWER = 37;
-	public const POPPY = 38, RED_FLOWER = 38;
-	public const BROWN_MUSHROOM = 39;
-	public const RED_MUSHROOM = 40;
-	public const GOLD_BLOCK = 41;
-	public const IRON_BLOCK = 42;
-	public const DOUBLE_STONE_SLAB = 43;
-	public const STONE_SLAB = 44;
-	public const BRICK_BLOCK = 45;
-	public const TNT = 46;
-	public const BOOKSHELF = 47;
-	public const MOSSY_COBBLESTONE = 48, MOSS_STONE = 48;
-	public const OBSIDIAN = 49;
-	public const TORCH = 50;
-	public const FIRE = 51;
-	public const MOB_SPAWNER = 52, MONSTER_SPAWNER = 52;
-	public const OAK_STAIRS = 53, WOODEN_STAIRS = 53;
-	public const CHEST = 54;
-	public const REDSTONE_WIRE = 55;
-	public const DIAMOND_ORE = 56;
-	public const DIAMOND_BLOCK = 57;
-	public const CRAFTING_TABLE = 58, WORKBENCH = 58;
-	public const WHEAT_BLOCK = 59;
-	public const FARMLAND = 60;
-	public const FURNACE = 61;
-	public const BURNING_FURNACE = 62, LIT_FURNACE = 62;
-	public const SIGN_POST = 63, STANDING_SIGN = 63;
-	public const OAK_DOOR_BLOCK = 64, WOODEN_DOOR_BLOCK = 64;
-	public const LADDER = 65;
-	public const RAIL = 66;
-	public const COBBLESTONE_STAIRS = 67, STONE_STAIRS = 67;
-	public const WALL_SIGN = 68;
-	public const LEVER = 69;
-	public const STONE_PRESSURE_PLATE = 70;
-	public const IRON_DOOR_BLOCK = 71;
-	public const WOODEN_PRESSURE_PLATE = 72;
-	public const REDSTONE_ORE = 73;
-	public const GLOWING_REDSTONE_ORE = 74, LIT_REDSTONE_ORE = 74;
-	public const UNLIT_REDSTONE_TORCH = 75;
-	public const LIT_REDSTONE_TORCH = 76, REDSTONE_TORCH = 76;
-	public const STONE_BUTTON = 77;
-	public const SNOW_LAYER = 78;
-	public const ICE = 79;
-	public const SNOW = 80, SNOW_BLOCK = 80;
-	public const CACTUS = 81;
-	public const CLAY_BLOCK = 82;
-	public const REEDS_BLOCK = 83, SUGARCANE_BLOCK = 83;
-	public const JUKEBOX = 84;
-	public const FENCE = 85;
-	public const PUMPKIN = 86;
-	public const NETHERRACK = 87;
-	public const SOUL_SAND = 88;
-	public const GLOWSTONE = 89;
-	public const PORTAL = 90;
-	public const JACK_O_LANTERN = 91, LIT_PUMPKIN = 91;
-	public const CAKE_BLOCK = 92;
-	public const REPEATER_BLOCK = 93, UNPOWERED_REPEATER = 93;
-	public const POWERED_REPEATER = 94;
-	public const INVISIBLEBEDROCK = 95, INVISIBLE_BEDROCK = 95;
-	public const TRAPDOOR = 96, WOODEN_TRAPDOOR = 96;
-	public const MONSTER_EGG = 97;
-	public const STONEBRICK = 98, STONE_BRICK = 98, STONE_BRICKS = 98;
-	public const BROWN_MUSHROOM_BLOCK = 99;
-	public const RED_MUSHROOM_BLOCK = 100;
-	public const IRON_BARS = 101;
-	public const GLASS_PANE = 102;
-	public const MELON_BLOCK = 103;
-	public const PUMPKIN_STEM = 104;
-	public const MELON_STEM = 105;
-	public const VINE = 106, VINES = 106;
-	public const FENCE_GATE = 107, OAK_FENCE_GATE = 107;
-	public const BRICK_STAIRS = 108;
-	public const STONE_BRICK_STAIRS = 109;
-	public const MYCELIUM = 110;
-	public const LILY_PAD = 111, WATERLILY = 111, WATER_LILY = 111;
-	public const NETHER_BRICK_BLOCK = 112;
-	public const NETHER_BRICK_FENCE = 113;
-	public const NETHER_BRICK_STAIRS = 114;
-	public const NETHER_WART_PLANT = 115;
-	public const ENCHANTING_TABLE = 116, ENCHANTMENT_TABLE = 116;
-	public const BREWING_STAND_BLOCK = 117;
-	public const CAULDRON_BLOCK = 118;
-	public const END_PORTAL = 119;
-	public const END_PORTAL_FRAME = 120;
-	public const END_STONE = 121;
-	public const DRAGON_EGG = 122;
-	public const REDSTONE_LAMP = 123;
-	public const LIT_REDSTONE_LAMP = 124;
-	public const DROPPER = 125;
-	public const ACTIVATOR_RAIL = 126;
-	public const COCOA = 127, COCOA_BLOCK = 127;
-	public const SANDSTONE_STAIRS = 128;
-	public const EMERALD_ORE = 129;
-	public const ENDER_CHEST = 130;
-	public const TRIPWIRE_HOOK = 131;
-	public const TRIPWIRE = 132, TRIP_WIRE = 132;
-	public const EMERALD_BLOCK = 133;
-	public const SPRUCE_STAIRS = 134;
-	public const BIRCH_STAIRS = 135;
-	public const JUNGLE_STAIRS = 136;
-	public const COMMAND_BLOCK = 137;
-	public const BEACON = 138;
-	public const COBBLESTONE_WALL = 139, STONE_WALL = 139;
-	public const FLOWER_POT_BLOCK = 140;
-	public const CARROTS = 141, CARROT_BLOCK = 141;
-	public const POTATOES = 142, POTATO_BLOCK = 142;
-	public const WOODEN_BUTTON = 143;
-	public const MOB_HEAD_BLOCK = 144, SKULL_BLOCK = 144;
-	public const ANVIL = 145;
-	public const TRAPPED_CHEST = 146;
-	public const LIGHT_WEIGHTED_PRESSURE_PLATE = 147;
-	public const HEAVY_WEIGHTED_PRESSURE_PLATE = 148;
-	public const COMPARATOR_BLOCK = 149, UNPOWERED_COMPARATOR = 149;
-	public const POWERED_COMPARATOR = 150;
-	public const DAYLIGHT_DETECTOR = 151, DAYLIGHT_SENSOR = 151;
-	public const REDSTONE_BLOCK = 152;
-	public const NETHER_QUARTZ_ORE = 153, QUARTZ_ORE = 153;
-	public const HOPPER_BLOCK = 154;
-	public const QUARTZ_BLOCK = 155;
-	public const QUARTZ_STAIRS = 156;
-	public const DOUBLE_WOODEN_SLAB = 157;
-	public const WOODEN_SLAB = 158;
-	public const STAINED_CLAY = 159, STAINED_HARDENED_CLAY = 159, TERRACOTTA = 159;
-	public const STAINED_GLASS_PANE = 160;
-	public const LEAVES2 = 161;
-	public const LOG2 = 162;
-	public const ACACIA_STAIRS = 163;
-	public const DARK_OAK_STAIRS = 164;
-	public const SLIME = 165, SLIME_BLOCK = 165;
-	public const GLOW_STICK = 166;
-	public const IRON_TRAPDOOR = 167;
-	public const PRISMARINE = 168;
-	public const SEALANTERN = 169, SEA_LANTERN = 169;
-	public const HAY_BALE = 170, HAY_BLOCK = 170;
-	public const CARPET = 171;
-	public const HARDENED_CLAY = 172;
-	public const COAL_BLOCK = 173;
-	public const PACKED_ICE = 174;
-	public const DOUBLE_PLANT = 175;
-	public const STANDING_BANNER = 176;
-	public const WALL_BANNER = 177;
-	public const DAYLIGHT_DETECTOR_INVERTED = 178, DAYLIGHT_SENSOR_INVERTED = 178;
-	public const RED_SANDSTONE = 179;
-	public const RED_SANDSTONE_STAIRS = 180;
-	public const DOUBLE_STONE_SLAB2 = 181;
-	public const STONE_SLAB2 = 182;
-	public const SPRUCE_FENCE_GATE = 183;
-	public const BIRCH_FENCE_GATE = 184;
-	public const JUNGLE_FENCE_GATE = 185;
-	public const DARK_OAK_FENCE_GATE = 186;
-	public const ACACIA_FENCE_GATE = 187;
-	public const REPEATING_COMMAND_BLOCK = 188;
-	public const CHAIN_COMMAND_BLOCK = 189;
-	public const HARD_GLASS_PANE = 190;
-	public const HARD_STAINED_GLASS_PANE = 191;
-	public const CHEMICAL_HEAT = 192;
-	public const SPRUCE_DOOR_BLOCK = 193;
-	public const BIRCH_DOOR_BLOCK = 194;
-	public const JUNGLE_DOOR_BLOCK = 195;
-	public const ACACIA_DOOR_BLOCK = 196;
-	public const DARK_OAK_DOOR_BLOCK = 197;
-	public const GRASS_PATH = 198;
-	public const FRAME_BLOCK = 199, ITEM_FRAME_BLOCK = 199;
-	public const CHORUS_FLOWER = 200;
-	public const PURPUR_BLOCK = 201;
-	public const COLORED_TORCH_RG = 202;
-	public const PURPUR_STAIRS = 203;
-	public const COLORED_TORCH_BP = 204;
-	public const UNDYED_SHULKER_BOX = 205;
-	public const END_BRICKS = 206;
-	public const FROSTED_ICE = 207;
-	public const END_ROD = 208;
-	public const END_GATEWAY = 209;
-
-	public const MAGMA = 213;
-	public const NETHER_WART_BLOCK = 214;
-	public const RED_NETHER_BRICK = 215;
-	public const BONE_BLOCK = 216;
-
-	public const SHULKER_BOX = 218;
-	public const PURPLE_GLAZED_TERRACOTTA = 219;
-	public const WHITE_GLAZED_TERRACOTTA = 220;
-	public const ORANGE_GLAZED_TERRACOTTA = 221;
-	public const MAGENTA_GLAZED_TERRACOTTA = 222;
-	public const LIGHT_BLUE_GLAZED_TERRACOTTA = 223;
-	public const YELLOW_GLAZED_TERRACOTTA = 224;
-	public const LIME_GLAZED_TERRACOTTA = 225;
-	public const PINK_GLAZED_TERRACOTTA = 226;
-	public const GRAY_GLAZED_TERRACOTTA = 227;
-	public const SILVER_GLAZED_TERRACOTTA = 228;
-	public const CYAN_GLAZED_TERRACOTTA = 229;
-
-	public const BLUE_GLAZED_TERRACOTTA = 231;
-	public const BROWN_GLAZED_TERRACOTTA = 232;
-	public const GREEN_GLAZED_TERRACOTTA = 233;
-	public const RED_GLAZED_TERRACOTTA = 234;
-	public const BLACK_GLAZED_TERRACOTTA = 235;
-	public const CONCRETE = 236;
-	public const CONCRETEPOWDER = 237, CONCRETE_POWDER = 237;
-	public const CHEMISTRY_TABLE = 238;
-	public const UNDERWATER_TORCH = 239;
-	public const CHORUS_PLANT = 240;
-	public const STAINED_GLASS = 241;
-
-	public const PODZOL = 243;
-	public const BEETROOT_BLOCK = 244;
-	public const STONECUTTER = 245;
-	public const GLOWINGOBSIDIAN = 246, GLOWING_OBSIDIAN = 246;
-	public const NETHERREACTOR = 247, NETHER_REACTOR = 247;
-	public const INFO_UPDATE = 248;
-	public const INFO_UPDATE2 = 249;
-	public const MOVINGBLOCK = 250, MOVING_BLOCK = 250;
-	public const OBSERVER = 251;
-	public const STRUCTURE_BLOCK = 252;
-	public const HARD_GLASS = 253;
-	public const HARD_STAINED_GLASS = 254;
-	public const RESERVED6 = 255;
-
-	public const PRISMARINE_STAIRS = 257;
-	public const DARK_PRISMARINE_STAIRS = 258;
-	public const PRISMARINE_BRICKS_STAIRS = 259;
-	public const STRIPPED_SPRUCE_LOG = 260;
-	public const STRIPPED_BIRCH_LOG = 261;
-	public const STRIPPED_JUNGLE_LOG = 262;
-	public const STRIPPED_ACACIA_LOG = 263;
-	public const STRIPPED_DARK_OAK_LOG = 264;
-	public const STRIPPED_OAK_LOG = 265;
-	public const BLUE_ICE = 266;
-	public const ELEMENT_1 = 267;
-	public const ELEMENT_2 = 268;
-	public const ELEMENT_3 = 269;
-	public const ELEMENT_4 = 270;
-	public const ELEMENT_5 = 271;
-	public const ELEMENT_6 = 272;
-	public const ELEMENT_7 = 273;
-	public const ELEMENT_8 = 274;
-	public const ELEMENT_9 = 275;
-	public const ELEMENT_10 = 276;
-	public const ELEMENT_11 = 277;
-	public const ELEMENT_12 = 278;
-	public const ELEMENT_13 = 279;
-	public const ELEMENT_14 = 280;
-	public const ELEMENT_15 = 281;
-	public const ELEMENT_16 = 282;
-	public const ELEMENT_17 = 283;
-	public const ELEMENT_18 = 284;
-	public const ELEMENT_19 = 285;
-	public const ELEMENT_20 = 286;
-	public const ELEMENT_21 = 287;
-	public const ELEMENT_22 = 288;
-	public const ELEMENT_23 = 289;
-	public const ELEMENT_24 = 290;
-	public const ELEMENT_25 = 291;
-	public const ELEMENT_26 = 292;
-	public const ELEMENT_27 = 293;
-	public const ELEMENT_28 = 294;
-	public const ELEMENT_29 = 295;
-	public const ELEMENT_30 = 296;
-	public const ELEMENT_31 = 297;
-	public const ELEMENT_32 = 298;
-	public const ELEMENT_33 = 299;
-	public const ELEMENT_34 = 300;
-	public const ELEMENT_35 = 301;
-	public const ELEMENT_36 = 302;
-	public const ELEMENT_37 = 303;
-	public const ELEMENT_38 = 304;
-	public const ELEMENT_39 = 305;
-	public const ELEMENT_40 = 306;
-	public const ELEMENT_41 = 307;
-	public const ELEMENT_42 = 308;
-	public const ELEMENT_43 = 309;
-	public const ELEMENT_44 = 310;
-	public const ELEMENT_45 = 311;
-	public const ELEMENT_46 = 312;
-	public const ELEMENT_47 = 313;
-	public const ELEMENT_48 = 314;
-	public const ELEMENT_49 = 315;
-	public const ELEMENT_50 = 316;
-	public const ELEMENT_51 = 317;
-	public const ELEMENT_52 = 318;
-	public const ELEMENT_53 = 319;
-	public const ELEMENT_54 = 320;
-	public const ELEMENT_55 = 321;
-	public const ELEMENT_56 = 322;
-	public const ELEMENT_57 = 323;
-	public const ELEMENT_58 = 324;
-	public const ELEMENT_59 = 325;
-	public const ELEMENT_60 = 326;
-	public const ELEMENT_61 = 327;
-	public const ELEMENT_62 = 328;
-	public const ELEMENT_63 = 329;
-	public const ELEMENT_64 = 330;
-	public const ELEMENT_65 = 331;
-	public const ELEMENT_66 = 332;
-	public const ELEMENT_67 = 333;
-	public const ELEMENT_68 = 334;
-	public const ELEMENT_69 = 335;
-	public const ELEMENT_70 = 336;
-	public const ELEMENT_71 = 337;
-	public const ELEMENT_72 = 338;
-	public const ELEMENT_73 = 339;
-	public const ELEMENT_74 = 340;
-	public const ELEMENT_75 = 341;
-	public const ELEMENT_76 = 342;
-	public const ELEMENT_77 = 343;
-	public const ELEMENT_78 = 344;
-	public const ELEMENT_79 = 345;
-	public const ELEMENT_80 = 346;
-	public const ELEMENT_81 = 347;
-	public const ELEMENT_82 = 348;
-	public const ELEMENT_83 = 349;
-	public const ELEMENT_84 = 350;
-	public const ELEMENT_85 = 351;
-	public const ELEMENT_86 = 352;
-	public const ELEMENT_87 = 353;
-	public const ELEMENT_88 = 354;
-	public const ELEMENT_89 = 355;
-	public const ELEMENT_90 = 356;
-	public const ELEMENT_91 = 357;
-	public const ELEMENT_92 = 358;
-	public const ELEMENT_93 = 359;
-	public const ELEMENT_94 = 360;
-	public const ELEMENT_95 = 361;
-	public const ELEMENT_96 = 362;
-	public const ELEMENT_97 = 363;
-	public const ELEMENT_98 = 364;
-	public const ELEMENT_99 = 365;
-	public const ELEMENT_100 = 366;
-	public const ELEMENT_101 = 367;
-	public const ELEMENT_102 = 368;
-	public const ELEMENT_103 = 369;
-	public const ELEMENT_104 = 370;
-	public const ELEMENT_105 = 371;
-	public const ELEMENT_106 = 372;
-	public const ELEMENT_107 = 373;
-	public const ELEMENT_108 = 374;
-	public const ELEMENT_109 = 375;
-	public const ELEMENT_110 = 376;
-	public const ELEMENT_111 = 377;
-	public const ELEMENT_112 = 378;
-	public const ELEMENT_113 = 379;
-	public const ELEMENT_114 = 380;
-	public const ELEMENT_115 = 381;
-	public const ELEMENT_116 = 382;
-	public const ELEMENT_117 = 383;
-	public const ELEMENT_118 = 384;
-	public const SEAGRASS = 385;
-	public const CORAL = 386;
-	public const CORAL_BLOCK = 387;
-	public const CORAL_FAN = 388;
-	public const CORAL_FAN_DEAD = 389;
-	public const CORAL_FAN_HANG = 390;
-	public const CORAL_FAN_HANG2 = 391;
-	public const CORAL_FAN_HANG3 = 392;
-	public const KELP = 393;
-	public const DRIED_KELP_BLOCK = 394;
-	public const ACACIA_BUTTON = 395;
-	public const BIRCH_BUTTON = 396;
-	public const DARK_OAK_BUTTON = 397;
-	public const JUNGLE_BUTTON = 398;
-	public const SPRUCE_BUTTON = 399;
-	public const ACACIA_TRAPDOOR = 400;
-	public const BIRCH_TRAPDOOR = 401;
-	public const DARK_OAK_TRAPDOOR = 402;
-	public const JUNGLE_TRAPDOOR = 403;
-	public const SPRUCE_TRAPDOOR = 404;
-	public const ACACIA_PRESSURE_PLATE = 405;
-	public const BIRCH_PRESSURE_PLATE = 406;
-	public const DARK_OAK_PRESSURE_PLATE = 407;
-	public const JUNGLE_PRESSURE_PLATE = 408;
-	public const SPRUCE_PRESSURE_PLATE = 409;
-	public const CARVED_PUMPKIN = 410;
-	public const SEA_PICKLE = 411;
-	public const CONDUIT = 412;
-
-	public const TURTLE_EGG = 414;
-	public const BUBBLE_COLUMN = 415;
-	public const BARRIER = 416;
-	public const STONE_SLAB3 = 417;
-	public const BAMBOO = 418;
-	public const BAMBOO_SAPLING = 419;
-	public const SCAFFOLDING = 420;
-	public const STONE_SLAB4 = 421;
-	public const DOUBLE_STONE_SLAB3 = 422;
-	public const DOUBLE_STONE_SLAB4 = 423;
-	public const GRANITE_STAIRS = 424;
-	public const DIORITE_STAIRS = 425;
-	public const ANDESITE_STAIRS = 426;
-	public const POLISHED_GRANITE_STAIRS = 427;
-	public const POLISHED_DIORITE_STAIRS = 428;
-	public const POLISHED_ANDESITE_STAIRS = 429;
-	public const MOSSY_STONE_BRICK_STAIRS = 430;
-	public const SMOOTH_RED_SANDSTONE_STAIRS = 431;
-	public const SMOOTH_SANDSTONE_STAIRS = 432;
-	public const END_BRICK_STAIRS = 433;
-	public const MOSSY_COBBLESTONE_STAIRS = 434;
-	public const NORMAL_STONE_STAIRS = 435;
-	public const SPRUCE_STANDING_SIGN = 436;
-	public const SPRUCE_WALL_SIGN = 437;
-	public const SMOOTH_STONE = 438;
-	public const RED_NETHER_BRICK_STAIRS = 439;
-	public const SMOOTH_QUARTZ_STAIRS = 440;
-	public const BIRCH_STANDING_SIGN = 441;
-	public const BIRCH_WALL_SIGN = 442;
-	public const JUNGLE_STANDING_SIGN = 443;
-	public const JUNGLE_WALL_SIGN = 444;
-	public const ACACIA_STANDING_SIGN = 445;
-	public const ACACIA_WALL_SIGN = 446;
-	public const DARKOAK_STANDING_SIGN = 447;
-	public const DARKOAK_WALL_SIGN = 448;
-	public const LECTERN = 449;
-	public const GRINDSTONE = 450;
-	public const BLAST_FURNACE = 451;
-	public const STONECUTTER_BLOCK = 452;
-	public const SMOKER = 453;
-	public const LIT_SMOKER = 454;
-	public const CARTOGRAPHY_TABLE = 455;
-	public const FLETCHING_TABLE = 456;
-	public const SMITHING_TABLE = 457;
-	public const BARREL = 458;
-	public const LOOM = 459;
-
-	public const BELL = 461;
-	public const SWEET_BERRY_BUSH = 462;
-	public const LANTERN = 463;
-	public const CAMPFIRE = 464;
-	public const LAVA_CAULDRON = 465;
-	public const JIGSAW = 466;
-	public const WOOD = 467;
-	public const COMPOSTER = 468;
-	public const LIT_BLAST_FURNACE = 469;
-
-}

src/block/BlockLegacyMetadata.php

@@ -1,301 +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);
-
-namespace pocketmine\block;
-
-/**
- * Constants for legacy metadata for various blocks.
- */
-final class BlockLegacyMetadata{
-
-	private function __construct(){
-		//NOOP
-	}
-
-	public const ANVIL_NORMAL = 0;
-	public const ANVIL_SLIGHTLY_DAMAGED = 4;
-	public const ANVIL_VERY_DAMAGED = 8;
-
-	public const BAMBOO_FLAG_THICK = 0x01;
-	public const BAMBOO_FLAG_READY = 0x08;
-
-	public const BAMBOO_LEAF_SIZE_SHIFT = 1;
-	public const BAMBOO_LEAF_SIZE_MASK = 0x03;
-
-	public const BARREL_FLAG_OPEN = 0x08;
-
-	public const BED_FLAG_HEAD = 0x08;
-	public const BED_FLAG_OCCUPIED = 0x04;
-
-	public const BEDROCK_FLAG_INFINIBURN = 0x01;
-
-	public const BELL_ATTACHMENT_FLOOR = 0;
-	public const BELL_ATTACHMENT_CEILING = 1;
-	public const BELL_ATTACHMENT_ONE_WALL = 2;
-	public const BELL_ATTACHMENT_TWO_WALLS = 3;
-
-	public const BREWING_STAND_FLAG_EAST = 0x01;
-	public const BREWING_STAND_FLAG_SOUTHWEST = 0x02;
-	public const BREWING_STAND_FLAG_NORTHWEST = 0x04;
-
-	public const BUTTON_FLAG_POWERED = 0x08;
-
-	public const CHEMISTRY_COMPOUND_CREATOR = 0;
-	public const CHEMISTRY_MATERIAL_REDUCER = 4;
-	public const CHEMISTRY_ELEMENT_CONSTRUCTOR = 8;
-	public const CHEMISTRY_LAB_TABLE = 12;
-
-	public const COLORED_TORCH_BP_BLUE = 0;
-	public const COLORED_TORCH_BP_PURPLE = 8;
-	public const COLORED_TORCH_RG_RED = 0;
-	public const COLORED_TORCH_RG_GREEN = 8;
-
-	public const CORAL_BLOCK_FLAG_DEAD = 0x8;
-
-	public const CORAL_FAN_EAST_WEST = 0;
-	public const CORAL_FAN_NORTH_SOUTH = 1;
-	public const CORAL_FAN_TYPE_MASK = 0x7;
-
-	public const CORAL_FAN_HANG_FLAG_DEAD = 0x2;
-
-	public const CORAL_FAN_HANG_TUBE = 0;
-	public const CORAL_FAN_HANG_BRAIN = 1;
-	public const CORAL_FAN_HANG2_BUBBLE = 0;
-	public const CORAL_FAN_HANG2_FIRE = 1;
-	public const CORAL_FAN_HANG3_HORN = 0;
-	public const CORAL_FAN_HANG_TYPE_MASK = 0x1;
-
-	public const CORAL_VARIANT_TUBE = 0;
-	public const CORAL_VARIANT_BRAIN = 1;
-	public const CORAL_VARIANT_BUBBLE = 2;
-	public const CORAL_VARIANT_FIRE = 3;
-	public const CORAL_VARIANT_HORN = 4;
-
-	public const DIRT_FLAG_COARSE = 0x1;
-
-	public const DOOR_FLAG_TOP = 0x08;
-	public const DOOR_BOTTOM_FLAG_OPEN = 0x04;
-	public const DOOR_TOP_FLAG_RIGHT = 0x01;
-	public const DOOR_TOP_FLAG_POWERED = 0x02;
-
-	public const DOUBLE_PLANT_SUNFLOWER = 0;
-	public const DOUBLE_PLANT_LILAC = 1;
-	public const DOUBLE_PLANT_TALLGRASS = 2;
-	public const DOUBLE_PLANT_LARGE_FERN = 3;
-	public const DOUBLE_PLANT_ROSE_BUSH = 4;
-	public const DOUBLE_PLANT_PEONY = 5;
-
-	public const DOUBLE_PLANT_FLAG_TOP = 0x08;
-
-	public const END_PORTAL_FRAME_FLAG_EYE = 0x04;
-
-	public const FENCE_GATE_FLAG_OPEN = 0x04;
-	public const FENCE_GATE_FLAG_IN_WALL = 0x08;
-
-	public const FLOWER_POPPY = 0;
-	public const FLOWER_BLUE_ORCHID = 1;
-	public const FLOWER_ALLIUM = 2;
-	public const FLOWER_AZURE_BLUET = 3;
-	public const FLOWER_RED_TULIP = 4;
-	public const FLOWER_ORANGE_TULIP = 5;
-	public const FLOWER_WHITE_TULIP = 6;
-	public const FLOWER_PINK_TULIP = 7;
-	public const FLOWER_OXEYE_DAISY = 8;
-	public const FLOWER_CORNFLOWER = 9;
-	public const FLOWER_LILY_OF_THE_VALLEY = 10;
-
-	public const FLOWER_POT_FLAG_OCCUPIED = 0x01;
-
-	public const HOPPER_FLAG_POWERED = 0x08;
-
-	public const INFESTED_STONE = 0;
-	public const INFESTED_COBBLESTONE = 1;
-	public const INFESTED_STONE_BRICK = 2;
-	public const INFESTED_STONE_BRICK_MOSSY = 3;
-	public const INFESTED_STONE_BRICK_CRACKED = 4;
-	public const INFESTED_STONE_BRICK_CHISELED = 5;
-
-	public const ITEM_FRAME_FLAG_HAS_MAP = 0x04;
-
-	public const LANTERN_FLAG_HANGING = 0x01;
-
-	public const LEAVES_FLAG_NO_DECAY = 0x04;
-	public const LEAVES_FLAG_CHECK_DECAY = 0x08;
-
-	public const LECTERN_FLAG_POWERED = 0x04;
-
-	public const LEVER_FLAG_POWERED = 0x08;
-
-	public const LIQUID_FLAG_FALLING = 0x08;
-
-	public const MUSHROOM_BLOCK_ALL_PORES = 0;
-	public const MUSHROOM_BLOCK_CAP_NORTHWEST_CORNER = 1;
-	public const MUSHROOM_BLOCK_CAP_NORTH_SIDE = 2;
-	public const MUSHROOM_BLOCK_CAP_NORTHEAST_CORNER = 3;
-	public const MUSHROOM_BLOCK_CAP_WEST_SIDE = 4;
-	public const MUSHROOM_BLOCK_CAP_TOP_ONLY = 5;
-	public const MUSHROOM_BLOCK_CAP_EAST_SIDE = 6;
-	public const MUSHROOM_BLOCK_CAP_SOUTHWEST_CORNER = 7;
-	public const MUSHROOM_BLOCK_CAP_SOUTH_SIDE = 8;
-	public const MUSHROOM_BLOCK_CAP_SOUTHEAST_CORNER = 9;
-	public const MUSHROOM_BLOCK_STEM = 10;
-	//11, 12 and 13 appear the same as 0
-	public const MUSHROOM_BLOCK_ALL_CAP = 14;
-	public const MUSHROOM_BLOCK_ALL_STEM = 15;
-
-	public const NETHER_PORTAL_AXIS_X = 1;
-	public const NETHER_PORTAL_AXIS_Z = 2;
-
-	public const NETHER_REACTOR_INACTIVE = 0;
-	public const NETHER_REACTOR_ACTIVE = 1;
-	public const NETHER_REACTOR_USED = 2;
-
-	public const PRESSURE_PLATE_FLAG_POWERED = 0x01;
-
-	public const PRISMARINE_NORMAL = 0;
-	public const PRISMARINE_DARK = 1;
-	public const PRISMARINE_BRICKS = 2;
-
-	public const PURPUR_NORMAL = 0;
-	public const PURPUR_PILLAR = 2;
-
-	public const QUARTZ_NORMAL = 0;
-	public const QUARTZ_CHISELED = 1;
-	public const QUARTZ_PILLAR = 2;
-	public const QUARTZ_SMOOTH = 3;
-
-	public const RAIL_STRAIGHT_NORTH_SOUTH = 0;
-	public const RAIL_STRAIGHT_EAST_WEST = 1;
-	public const RAIL_ASCENDING_EAST = 2;
-	public const RAIL_ASCENDING_WEST = 3;
-	public const RAIL_ASCENDING_NORTH = 4;
-	public const RAIL_ASCENDING_SOUTH = 5;
-	public const RAIL_CURVE_SOUTHEAST = 6;
-	public const RAIL_CURVE_SOUTHWEST = 7;
-	public const RAIL_CURVE_NORTHWEST = 8;
-	public const RAIL_CURVE_NORTHEAST = 9;
-
-	public const REDSTONE_COMPARATOR_FLAG_SUBTRACT = 0x04;
-	public const REDSTONE_COMPARATOR_FLAG_POWERED = 0x08;
-
-	public const REDSTONE_RAIL_FLAG_POWERED = 0x08;
-
-	public const SANDSTONE_NORMAL = 0;
-	public const SANDSTONE_CHISELED = 1;
-	public const SANDSTONE_CUT = 2;
-	public const SANDSTONE_SMOOTH = 3;
-
-	public const SAPLING_FLAG_READY = 0x08;
-
-	public const SEA_PICKLE_FLAG_NOT_UNDERWATER = 0x04;
-
-	public const SKULL_FLAG_NO_DROPS = 0x08;
-
-	public const SLAB_FLAG_UPPER = 0x08;
-
-	public const SPONGE_FLAG_WET = 0x01;
-
-	public const STAIR_FLAG_UPSIDE_DOWN = 0x04;
-
-	public const STONE_NORMAL = 0;
-	public const STONE_GRANITE = 1;
-	public const STONE_POLISHED_GRANITE = 2;
-	public const STONE_DIORITE = 3;
-	public const STONE_POLISHED_DIORITE = 4;
-	public const STONE_ANDESITE = 5;
-	public const STONE_POLISHED_ANDESITE = 6;
-
-	public const STONE_BRICK_NORMAL = 0;
-	public const STONE_BRICK_MOSSY = 1;
-	public const STONE_BRICK_CRACKED = 2;
-	public const STONE_BRICK_CHISELED = 3;
-
-	public const STONE_SLAB_SMOOTH_STONE = 0;
-	public const STONE_SLAB_SANDSTONE = 1;
-	public const STONE_SLAB_FAKE_WOODEN = 2;
-	public const STONE_SLAB_COBBLESTONE = 3;
-	public const STONE_SLAB_BRICK = 4;
-	public const STONE_SLAB_STONE_BRICK = 5;
-	public const STONE_SLAB_QUARTZ = 6;
-	public const STONE_SLAB_NETHER_BRICK = 7;
-	public const STONE_SLAB2_RED_SANDSTONE = 0;
-	public const STONE_SLAB2_PURPUR = 1;
-	public const STONE_SLAB2_PRISMARINE = 2;
-	public const STONE_SLAB2_DARK_PRISMARINE = 3;
-	public const STONE_SLAB2_PRISMARINE_BRICKS = 4;
-	public const STONE_SLAB2_MOSSY_COBBLESTONE = 5;
-	public const STONE_SLAB2_SMOOTH_SANDSTONE = 6;
-	public const STONE_SLAB2_RED_NETHER_BRICK = 7;
-	public const STONE_SLAB3_END_STONE_BRICK = 0;
-	public const STONE_SLAB3_SMOOTH_RED_SANDSTONE = 1;
-	public const STONE_SLAB3_POLISHED_ANDESITE = 2;
-	public const STONE_SLAB3_ANDESITE = 3;
-	public const STONE_SLAB3_DIORITE = 4;
-	public const STONE_SLAB3_POLISHED_DIORITE = 5;
-	public const STONE_SLAB3_GRANITE = 6;
-	public const STONE_SLAB3_POLISHED_GRANITE = 7;
-	public const STONE_SLAB4_MOSSY_STONE_BRICK = 0;
-	public const STONE_SLAB4_SMOOTH_QUARTZ = 1;
-	public const STONE_SLAB4_STONE = 2;
-	public const STONE_SLAB4_CUT_SANDSTONE = 3;
-	public const STONE_SLAB4_CUT_RED_SANDSTONE = 4;
-
-	public const TALLGRASS_NORMAL = 1;
-	public const TALLGRASS_FERN = 2;
-
-	public const TNT_FLAG_UNSTABLE = 0x01;
-	public const TNT_FLAG_UNDERWATER = 0x02;
-
-	public const TRAPDOOR_FLAG_UPPER = 0x04;
-	public const TRAPDOOR_FLAG_OPEN = 0x08;
-
-	public const TRIPWIRE_FLAG_TRIGGERED = 0x01;
-	public const TRIPWIRE_FLAG_SUSPENDED = 0x02;
-	public const TRIPWIRE_FLAG_CONNECTED = 0x04;
-	public const TRIPWIRE_FLAG_DISARMED = 0x08;
-
-	public const TRIPWIRE_HOOK_FLAG_CONNECTED = 0x04;
-	public const TRIPWIRE_HOOK_FLAG_POWERED = 0x08;
-
-	public const VINE_FLAG_SOUTH = 0x01;
-	public const VINE_FLAG_WEST = 0x02;
-	public const VINE_FLAG_NORTH = 0x04;
-	public const VINE_FLAG_EAST = 0x08;
-
-	public const WALL_COBBLESTONE = 0;
-	public const WALL_MOSSY_COBBLESTONE = 1;
-	public const WALL_GRANITE = 2;
-	public const WALL_DIORITE = 3;
-	public const WALL_ANDESITE = 4;
-	public const WALL_SANDSTONE = 5;
-	public const WALL_BRICK = 6;
-	public const WALL_STONE_BRICK = 7;
-	public const WALL_MOSSY_STONE_BRICK = 8;
-	public const WALL_NETHER_BRICK = 9;
-	public const WALL_END_STONE_BRICK = 10;
-	public const WALL_PRISMARINE = 11;
-	public const WALL_RED_SANDSTONE = 12;
-	public const WALL_RED_NETHER_BRICK = 13;
-
-	public const WOOD_FLAG_STRIPPED = 0x8;
-}

src/block/BlockToolType.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/BlockTypeIds.php

@@ -0,0 +1,718 @@
+<?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\block;
+
+/**
+ * Enum of all the block runtime IDs used by PocketMine-MP. These IDs are specific to PocketMine-MP and have no
+ * relevance to any Minecraft vanilla things.
+ *
+ * WARNING: DO NOT STORE THESE IDS. They can and will change without warning.
+ * They should ONLY be used to IDENTIFY blocks at runtime.
+ */
+final class BlockTypeIds{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	public const AIR = 10000;
+
+	public const ACACIA_BUTTON = 10001;
+	public const ACACIA_DOOR = 10002;
+	public const ACACIA_FENCE = 10003;
+	public const ACACIA_FENCE_GATE = 10004;
+	public const ACACIA_LEAVES = 10005;
+	public const ACACIA_LOG = 10006;
+	public const ACACIA_PLANKS = 10007;
+	public const ACACIA_PRESSURE_PLATE = 10008;
+	public const ACACIA_SAPLING = 10009;
+	public const ACACIA_SIGN = 10010;
+	public const ACACIA_SLAB = 10011;
+	public const ACACIA_STAIRS = 10012;
+	public const ACACIA_TRAPDOOR = 10013;
+	public const ACACIA_WALL_SIGN = 10014;
+	public const ACACIA_WOOD = 10015;
+	public const ACTIVATOR_RAIL = 10016;
+	public const ALL_SIDED_MUSHROOM_STEM = 10017;
+	public const ALLIUM = 10018;
+	public const ANDESITE = 10019;
+	public const ANDESITE_SLAB = 10020;
+	public const ANDESITE_STAIRS = 10021;
+	public const ANDESITE_WALL = 10022;
+	public const ANVIL = 10023;
+	public const AZURE_BLUET = 10024;
+	public const BAMBOO = 10025;
+	public const BAMBOO_SAPLING = 10026;
+	public const BANNER = 10027;
+	public const BARREL = 10028;
+	public const BARRIER = 10029;
+	public const BEACON = 10030;
+	public const BED = 10031;
+	public const BEDROCK = 10032;
+	public const BEETROOTS = 10033;
+	public const BELL = 10034;
+	public const BIRCH_BUTTON = 10035;
+	public const BIRCH_DOOR = 10036;
+	public const BIRCH_FENCE = 10037;
+	public const BIRCH_FENCE_GATE = 10038;
+	public const BIRCH_LEAVES = 10039;
+	public const BIRCH_LOG = 10040;
+	public const BIRCH_PLANKS = 10041;
+	public const BIRCH_PRESSURE_PLATE = 10042;
+	public const BIRCH_SAPLING = 10043;
+	public const BIRCH_SIGN = 10044;
+	public const BIRCH_SLAB = 10045;
+	public const BIRCH_STAIRS = 10046;
+	public const BIRCH_TRAPDOOR = 10047;
+	public const BIRCH_WALL_SIGN = 10048;
+	public const BIRCH_WOOD = 10049;
+
+	public const BLAST_FURNACE = 10051;
+
+	public const BLUE_ICE = 10053;
+	public const BLUE_ORCHID = 10054;
+	public const BLUE_TORCH = 10055;
+	public const BONE_BLOCK = 10056;
+	public const BOOKSHELF = 10057;
+	public const BREWING_STAND = 10058;
+	public const BRICK_SLAB = 10059;
+	public const BRICK_STAIRS = 10060;
+	public const BRICK_WALL = 10061;
+	public const BRICKS = 10062;
+
+	public const BROWN_MUSHROOM = 10064;
+	public const BROWN_MUSHROOM_BLOCK = 10065;
+	public const CACTUS = 10066;
+	public const CAKE = 10067;
+	public const CARPET = 10068;
+	public const CARROTS = 10069;
+	public const CARVED_PUMPKIN = 10070;
+	public const CHEMICAL_HEAT = 10071;
+	public const CHEST = 10072;
+	public const CHISELED_QUARTZ = 10073;
+	public const CHISELED_RED_SANDSTONE = 10074;
+	public const CHISELED_SANDSTONE = 10075;
+	public const CHISELED_STONE_BRICKS = 10076;
+	public const CLAY = 10077;
+	public const COAL = 10078;
+	public const COAL_ORE = 10079;
+	public const COBBLESTONE = 10080;
+	public const COBBLESTONE_SLAB = 10081;
+	public const COBBLESTONE_STAIRS = 10082;
+	public const COBBLESTONE_WALL = 10083;
+	public const COBWEB = 10084;
+	public const COCOA_POD = 10085;
+	public const COMPOUND_CREATOR = 10086;
+	public const CONCRETE = 10087;
+	public const CONCRETE_POWDER = 10088;
+	public const CORAL = 10089;
+	public const CORAL_BLOCK = 10090;
+	public const CORAL_FAN = 10091;
+	public const CORNFLOWER = 10092;
+	public const CRACKED_STONE_BRICKS = 10093;
+	public const CRAFTING_TABLE = 10094;
+	public const CUT_RED_SANDSTONE = 10095;
+	public const CUT_RED_SANDSTONE_SLAB = 10096;
+	public const CUT_SANDSTONE = 10097;
+	public const CUT_SANDSTONE_SLAB = 10098;
+
+	public const DANDELION = 10100;
+	public const DARK_OAK_BUTTON = 10101;
+	public const DARK_OAK_DOOR = 10102;
+	public const DARK_OAK_FENCE = 10103;
+	public const DARK_OAK_FENCE_GATE = 10104;
+	public const DARK_OAK_LEAVES = 10105;
+	public const DARK_OAK_LOG = 10106;
+	public const DARK_OAK_PLANKS = 10107;
+	public const DARK_OAK_PRESSURE_PLATE = 10108;
+	public const DARK_OAK_SAPLING = 10109;
+	public const DARK_OAK_SIGN = 10110;
+	public const DARK_OAK_SLAB = 10111;
+	public const DARK_OAK_STAIRS = 10112;
+	public const DARK_OAK_TRAPDOOR = 10113;
+	public const DARK_OAK_WALL_SIGN = 10114;
+	public const DARK_OAK_WOOD = 10115;
+	public const DARK_PRISMARINE = 10116;
+	public const DARK_PRISMARINE_SLAB = 10117;
+	public const DARK_PRISMARINE_STAIRS = 10118;
+	public const DAYLIGHT_SENSOR = 10119;
+	public const DEAD_BUSH = 10120;
+	public const DETECTOR_RAIL = 10121;
+	public const DIAMOND = 10122;
+	public const DIAMOND_ORE = 10123;
+	public const DIORITE = 10124;
+	public const DIORITE_SLAB = 10125;
+	public const DIORITE_STAIRS = 10126;
+	public const DIORITE_WALL = 10127;
+	public const DIRT = 10128;
+	public const DOUBLE_TALLGRASS = 10129;
+	public const DRAGON_EGG = 10130;
+	public const DRIED_KELP = 10131;
+	public const DYED_SHULKER_BOX = 10132;
+	public const ELEMENT_ACTINIUM = 10133;
+	public const ELEMENT_ALUMINUM = 10134;
+	public const ELEMENT_AMERICIUM = 10135;
+	public const ELEMENT_ANTIMONY = 10136;
+	public const ELEMENT_ARGON = 10137;
+	public const ELEMENT_ARSENIC = 10138;
+	public const ELEMENT_ASTATINE = 10139;
+	public const ELEMENT_BARIUM = 10140;
+	public const ELEMENT_BERKELIUM = 10141;
+	public const ELEMENT_BERYLLIUM = 10142;
+	public const ELEMENT_BISMUTH = 10143;
+	public const ELEMENT_BOHRIUM = 10144;
+	public const ELEMENT_BORON = 10145;
+	public const ELEMENT_BROMINE = 10146;
+	public const ELEMENT_CADMIUM = 10147;
+	public const ELEMENT_CALCIUM = 10148;
+	public const ELEMENT_CALIFORNIUM = 10149;
+	public const ELEMENT_CARBON = 10150;
+	public const ELEMENT_CERIUM = 10151;
+	public const ELEMENT_CESIUM = 10152;
+	public const ELEMENT_CHLORINE = 10153;
+	public const ELEMENT_CHROMIUM = 10154;
+	public const ELEMENT_COBALT = 10155;
+	public const ELEMENT_CONSTRUCTOR = 10156;
+	public const ELEMENT_COPERNICIUM = 10157;
+	public const ELEMENT_COPPER = 10158;
+	public const ELEMENT_CURIUM = 10159;
+	public const ELEMENT_DARMSTADTIUM = 10160;
+	public const ELEMENT_DUBNIUM = 10161;
+	public const ELEMENT_DYSPROSIUM = 10162;
+	public const ELEMENT_EINSTEINIUM = 10163;
+	public const ELEMENT_ERBIUM = 10164;
+	public const ELEMENT_EUROPIUM = 10165;
+	public const ELEMENT_FERMIUM = 10166;
+	public const ELEMENT_FLEROVIUM = 10167;
+	public const ELEMENT_FLUORINE = 10168;
+	public const ELEMENT_FRANCIUM = 10169;
+	public const ELEMENT_GADOLINIUM = 10170;
+	public const ELEMENT_GALLIUM = 10171;
+	public const ELEMENT_GERMANIUM = 10172;
+	public const ELEMENT_GOLD = 10173;
+	public const ELEMENT_HAFNIUM = 10174;
+	public const ELEMENT_HASSIUM = 10175;
+	public const ELEMENT_HELIUM = 10176;
+	public const ELEMENT_HOLMIUM = 10177;
+	public const ELEMENT_HYDROGEN = 10178;
+	public const ELEMENT_INDIUM = 10179;
+	public const ELEMENT_IODINE = 10180;
+	public const ELEMENT_IRIDIUM = 10181;
+	public const ELEMENT_IRON = 10182;
+	public const ELEMENT_KRYPTON = 10183;
+	public const ELEMENT_LANTHANUM = 10184;
+	public const ELEMENT_LAWRENCIUM = 10185;
+	public const ELEMENT_LEAD = 10186;
+	public const ELEMENT_LITHIUM = 10187;
+	public const ELEMENT_LIVERMORIUM = 10188;
+	public const ELEMENT_LUTETIUM = 10189;
+	public const ELEMENT_MAGNESIUM = 10190;
+	public const ELEMENT_MANGANESE = 10191;
+	public const ELEMENT_MEITNERIUM = 10192;
+	public const ELEMENT_MENDELEVIUM = 10193;
+	public const ELEMENT_MERCURY = 10194;
+	public const ELEMENT_MOLYBDENUM = 10195;
+	public const ELEMENT_MOSCOVIUM = 10196;
+	public const ELEMENT_NEODYMIUM = 10197;
+	public const ELEMENT_NEON = 10198;
+	public const ELEMENT_NEPTUNIUM = 10199;
+	public const ELEMENT_NICKEL = 10200;
+	public const ELEMENT_NIHONIUM = 10201;
+	public const ELEMENT_NIOBIUM = 10202;
+	public const ELEMENT_NITROGEN = 10203;
+	public const ELEMENT_NOBELIUM = 10204;
+	public const ELEMENT_OGANESSON = 10205;
+	public const ELEMENT_OSMIUM = 10206;
+	public const ELEMENT_OXYGEN = 10207;
+	public const ELEMENT_PALLADIUM = 10208;
+	public const ELEMENT_PHOSPHORUS = 10209;
+	public const ELEMENT_PLATINUM = 10210;
+	public const ELEMENT_PLUTONIUM = 10211;
+	public const ELEMENT_POLONIUM = 10212;
+	public const ELEMENT_POTASSIUM = 10213;
+	public const ELEMENT_PRASEODYMIUM = 10214;
+	public const ELEMENT_PROMETHIUM = 10215;
+	public const ELEMENT_PROTACTINIUM = 10216;
+	public const ELEMENT_RADIUM = 10217;
+	public const ELEMENT_RADON = 10218;
+	public const ELEMENT_RHENIUM = 10219;
+	public const ELEMENT_RHODIUM = 10220;
+	public const ELEMENT_ROENTGENIUM = 10221;
+	public const ELEMENT_RUBIDIUM = 10222;
+	public const ELEMENT_RUTHENIUM = 10223;
+	public const ELEMENT_RUTHERFORDIUM = 10224;
+	public const ELEMENT_SAMARIUM = 10225;
+	public const ELEMENT_SCANDIUM = 10226;
+	public const ELEMENT_SEABORGIUM = 10227;
+	public const ELEMENT_SELENIUM = 10228;
+	public const ELEMENT_SILICON = 10229;
+	public const ELEMENT_SILVER = 10230;
+	public const ELEMENT_SODIUM = 10231;
+	public const ELEMENT_STRONTIUM = 10232;
+	public const ELEMENT_SULFUR = 10233;
+	public const ELEMENT_TANTALUM = 10234;
+	public const ELEMENT_TECHNETIUM = 10235;
+	public const ELEMENT_TELLURIUM = 10236;
+	public const ELEMENT_TENNESSINE = 10237;
+	public const ELEMENT_TERBIUM = 10238;
+	public const ELEMENT_THALLIUM = 10239;
+	public const ELEMENT_THORIUM = 10240;
+	public const ELEMENT_THULIUM = 10241;
+	public const ELEMENT_TIN = 10242;
+	public const ELEMENT_TITANIUM = 10243;
+	public const ELEMENT_TUNGSTEN = 10244;
+	public const ELEMENT_URANIUM = 10245;
+	public const ELEMENT_VANADIUM = 10246;
+	public const ELEMENT_XENON = 10247;
+	public const ELEMENT_YTTERBIUM = 10248;
+	public const ELEMENT_YTTRIUM = 10249;
+	public const ELEMENT_ZERO = 10250;
+	public const ELEMENT_ZINC = 10251;
+	public const ELEMENT_ZIRCONIUM = 10252;
+	public const EMERALD = 10253;
+	public const EMERALD_ORE = 10254;
+	public const ENCHANTING_TABLE = 10255;
+	public const END_PORTAL_FRAME = 10256;
+	public const END_ROD = 10257;
+	public const END_STONE = 10258;
+	public const END_STONE_BRICK_SLAB = 10259;
+	public const END_STONE_BRICK_STAIRS = 10260;
+	public const END_STONE_BRICK_WALL = 10261;
+	public const END_STONE_BRICKS = 10262;
+	public const ENDER_CHEST = 10263;
+	public const FAKE_WOODEN_SLAB = 10264;
+	public const FARMLAND = 10265;
+	public const FERN = 10266;
+	public const FIRE = 10267;
+	public const FLETCHING_TABLE = 10268;
+	public const FLOWER_POT = 10269;
+	public const FROSTED_ICE = 10270;
+	public const FURNACE = 10271;
+	public const GLASS = 10272;
+	public const GLASS_PANE = 10273;
+	public const GLOWING_OBSIDIAN = 10274;
+	public const GLOWSTONE = 10275;
+	public const GOLD = 10276;
+	public const GOLD_ORE = 10277;
+	public const GRANITE = 10278;
+	public const GRANITE_SLAB = 10279;
+	public const GRANITE_STAIRS = 10280;
+	public const GRANITE_WALL = 10281;
+	public const GRASS = 10282;
+	public const GRASS_PATH = 10283;
+	public const GRAVEL = 10284;
+
+	public const GREEN_TORCH = 10287;
+	public const HARDENED_CLAY = 10288;
+	public const HARDENED_GLASS = 10289;
+	public const HARDENED_GLASS_PANE = 10290;
+	public const HAY_BALE = 10291;
+	public const HOPPER = 10292;
+	public const ICE = 10293;
+	public const INFESTED_CHISELED_STONE_BRICK = 10294;
+	public const INFESTED_COBBLESTONE = 10295;
+	public const INFESTED_CRACKED_STONE_BRICK = 10296;
+	public const INFESTED_MOSSY_STONE_BRICK = 10297;
+	public const INFESTED_STONE = 10298;
+	public const INFESTED_STONE_BRICK = 10299;
+	public const INFO_UPDATE = 10300;
+	public const INFO_UPDATE2 = 10301;
+	public const INVISIBLE_BEDROCK = 10302;
+	public const IRON = 10303;
+	public const IRON_BARS = 10304;
+	public const IRON_DOOR = 10305;
+	public const IRON_ORE = 10306;
+	public const IRON_TRAPDOOR = 10307;
+	public const ITEM_FRAME = 10308;
+	public const JUKEBOX = 10309;
+	public const JUNGLE_BUTTON = 10310;
+	public const JUNGLE_DOOR = 10311;
+	public const JUNGLE_FENCE = 10312;
+	public const JUNGLE_FENCE_GATE = 10313;
+	public const JUNGLE_LEAVES = 10314;
+	public const JUNGLE_LOG = 10315;
+	public const JUNGLE_PLANKS = 10316;
+	public const JUNGLE_PRESSURE_PLATE = 10317;
+	public const JUNGLE_SAPLING = 10318;
+	public const JUNGLE_SIGN = 10319;
+	public const JUNGLE_SLAB = 10320;
+	public const JUNGLE_STAIRS = 10321;
+	public const JUNGLE_TRAPDOOR = 10322;
+	public const JUNGLE_WALL_SIGN = 10323;
+	public const JUNGLE_WOOD = 10324;
+	public const LAB_TABLE = 10325;
+	public const LADDER = 10326;
+	public const LANTERN = 10327;
+	public const LAPIS_LAZULI = 10328;
+	public const LAPIS_LAZULI_ORE = 10329;
+	public const LARGE_FERN = 10330;
+	public const LAVA = 10331;
+	public const LECTERN = 10332;
+	public const LEGACY_STONECUTTER = 10333;
+	public const LEVER = 10334;
+
+	public const LILAC = 10337;
+	public const LILY_OF_THE_VALLEY = 10338;
+	public const LILY_PAD = 10339;
+
+	public const LIT_PUMPKIN = 10341;
+	public const LOOM = 10342;
+
+	public const MAGMA = 10344;
+	public const MATERIAL_REDUCER = 10345;
+	public const MELON = 10346;
+	public const MELON_STEM = 10347;
+	public const MOB_HEAD = 10348;
+	public const MONSTER_SPAWNER = 10349;
+	public const MOSSY_COBBLESTONE = 10350;
+	public const MOSSY_COBBLESTONE_SLAB = 10351;
+	public const MOSSY_COBBLESTONE_STAIRS = 10352;
+	public const MOSSY_COBBLESTONE_WALL = 10353;
+	public const MOSSY_STONE_BRICK_SLAB = 10354;
+	public const MOSSY_STONE_BRICK_STAIRS = 10355;
+	public const MOSSY_STONE_BRICK_WALL = 10356;
+	public const MOSSY_STONE_BRICKS = 10357;
+	public const MUSHROOM_STEM = 10358;
+	public const MYCELIUM = 10359;
+	public const NETHER_BRICK_FENCE = 10360;
+	public const NETHER_BRICK_SLAB = 10361;
+	public const NETHER_BRICK_STAIRS = 10362;
+	public const NETHER_BRICK_WALL = 10363;
+	public const NETHER_BRICKS = 10364;
+	public const NETHER_PORTAL = 10365;
+	public const NETHER_QUARTZ_ORE = 10366;
+	public const NETHER_REACTOR_CORE = 10367;
+	public const NETHER_WART = 10368;
+	public const NETHER_WART_BLOCK = 10369;
+	public const NETHERRACK = 10370;
+	public const NOTE_BLOCK = 10371;
+	public const OAK_BUTTON = 10372;
+	public const OAK_DOOR = 10373;
+	public const OAK_FENCE = 10374;
+	public const OAK_FENCE_GATE = 10375;
+	public const OAK_LEAVES = 10376;
+	public const OAK_LOG = 10377;
+	public const OAK_PLANKS = 10378;
+	public const OAK_PRESSURE_PLATE = 10379;
+	public const OAK_SAPLING = 10380;
+	public const OAK_SIGN = 10381;
+	public const OAK_SLAB = 10382;
+	public const OAK_STAIRS = 10383;
+	public const OAK_TRAPDOOR = 10384;
+	public const OAK_WALL_SIGN = 10385;
+	public const OAK_WOOD = 10386;
+	public const OBSIDIAN = 10387;
+
+	public const ORANGE_TULIP = 10389;
+	public const OXEYE_DAISY = 10390;
+	public const PACKED_ICE = 10391;
+	public const PEONY = 10392;
+
+	public const PINK_TULIP = 10394;
+	public const PODZOL = 10395;
+	public const POLISHED_ANDESITE = 10396;
+	public const POLISHED_ANDESITE_SLAB = 10397;
+	public const POLISHED_ANDESITE_STAIRS = 10398;
+	public const POLISHED_DIORITE = 10399;
+	public const POLISHED_DIORITE_SLAB = 10400;
+	public const POLISHED_DIORITE_STAIRS = 10401;
+	public const POLISHED_GRANITE = 10402;
+	public const POLISHED_GRANITE_SLAB = 10403;
+	public const POLISHED_GRANITE_STAIRS = 10404;
+	public const POPPY = 10405;
+	public const POTATOES = 10406;
+	public const POWERED_RAIL = 10407;
+	public const PRISMARINE = 10408;
+	public const PRISMARINE_BRICKS = 10409;
+	public const PRISMARINE_BRICKS_SLAB = 10410;
+	public const PRISMARINE_BRICKS_STAIRS = 10411;
+	public const PRISMARINE_SLAB = 10412;
+	public const PRISMARINE_STAIRS = 10413;
+	public const PRISMARINE_WALL = 10414;
+	public const PUMPKIN = 10415;
+	public const PUMPKIN_STEM = 10416;
+
+	public const PURPLE_TORCH = 10418;
+	public const PURPUR = 10419;
+	public const PURPUR_PILLAR = 10420;
+	public const PURPUR_SLAB = 10421;
+	public const PURPUR_STAIRS = 10422;
+	public const QUARTZ = 10423;
+	public const QUARTZ_PILLAR = 10424;
+	public const QUARTZ_SLAB = 10425;
+	public const QUARTZ_STAIRS = 10426;
+	public const RAIL = 10427;
+
+	public const RED_MUSHROOM = 10429;
+	public const RED_MUSHROOM_BLOCK = 10430;
+	public const RED_NETHER_BRICK_SLAB = 10431;
+	public const RED_NETHER_BRICK_STAIRS = 10432;
+	public const RED_NETHER_BRICK_WALL = 10433;
+	public const RED_NETHER_BRICKS = 10434;
+	public const RED_SAND = 10435;
+	public const RED_SANDSTONE = 10436;
+	public const RED_SANDSTONE_SLAB = 10437;
+	public const RED_SANDSTONE_STAIRS = 10438;
+	public const RED_SANDSTONE_WALL = 10439;
+	public const RED_TORCH = 10440;
+	public const RED_TULIP = 10441;
+	public const REDSTONE = 10442;
+	public const REDSTONE_COMPARATOR = 10443;
+	public const REDSTONE_LAMP = 10444;
+	public const REDSTONE_ORE = 10445;
+	public const REDSTONE_REPEATER = 10446;
+	public const REDSTONE_TORCH = 10447;
+	public const REDSTONE_WIRE = 10448;
+	public const RESERVED6 = 10449;
+	public const ROSE_BUSH = 10450;
+	public const SAND = 10451;
+	public const SANDSTONE = 10452;
+	public const SANDSTONE_SLAB = 10453;
+	public const SANDSTONE_STAIRS = 10454;
+	public const SANDSTONE_WALL = 10455;
+	public const SEA_LANTERN = 10456;
+	public const SEA_PICKLE = 10457;
+	public const SHULKER_BOX = 10458;
+	public const SLIME = 10459;
+	public const SMOKER = 10460;
+	public const SMOOTH_QUARTZ = 10461;
+	public const SMOOTH_QUARTZ_SLAB = 10462;
+	public const SMOOTH_QUARTZ_STAIRS = 10463;
+	public const SMOOTH_RED_SANDSTONE = 10464;
+	public const SMOOTH_RED_SANDSTONE_SLAB = 10465;
+	public const SMOOTH_RED_SANDSTONE_STAIRS = 10466;
+	public const SMOOTH_SANDSTONE = 10467;
+	public const SMOOTH_SANDSTONE_SLAB = 10468;
+	public const SMOOTH_SANDSTONE_STAIRS = 10469;
+	public const SMOOTH_STONE = 10470;
+	public const SMOOTH_STONE_SLAB = 10471;
+	public const SNOW = 10472;
+	public const SNOW_LAYER = 10473;
+	public const SOUL_SAND = 10474;
+	public const SPONGE = 10475;
+	public const SPRUCE_BUTTON = 10476;
+	public const SPRUCE_DOOR = 10477;
+	public const SPRUCE_FENCE = 10478;
+	public const SPRUCE_FENCE_GATE = 10479;
+	public const SPRUCE_LEAVES = 10480;
+	public const SPRUCE_LOG = 10481;
+	public const SPRUCE_PLANKS = 10482;
+	public const SPRUCE_PRESSURE_PLATE = 10483;
+	public const SPRUCE_SAPLING = 10484;
+	public const SPRUCE_SIGN = 10485;
+	public const SPRUCE_SLAB = 10486;
+	public const SPRUCE_STAIRS = 10487;
+	public const SPRUCE_TRAPDOOR = 10488;
+	public const SPRUCE_WALL_SIGN = 10489;
+	public const SPRUCE_WOOD = 10490;
+	public const STAINED_CLAY = 10491;
+	public const STAINED_GLASS = 10492;
+	public const STAINED_GLASS_PANE = 10493;
+	public const STAINED_HARDENED_GLASS = 10494;
+	public const STAINED_HARDENED_GLASS_PANE = 10495;
+	public const STONE = 10496;
+	public const STONE_BRICK_SLAB = 10497;
+	public const STONE_BRICK_STAIRS = 10498;
+	public const STONE_BRICK_WALL = 10499;
+	public const STONE_BRICKS = 10500;
+	public const STONE_BUTTON = 10501;
+	public const STONE_PRESSURE_PLATE = 10502;
+	public const STONE_SLAB = 10503;
+	public const STONE_STAIRS = 10504;
+	public const STONECUTTER = 10505;
+
+	public const SUGARCANE = 10518;
+	public const SUNFLOWER = 10519;
+	public const SWEET_BERRY_BUSH = 10520;
+	public const TALL_GRASS = 10521;
+	public const TNT = 10522;
+	public const TORCH = 10523;
+	public const TRAPPED_CHEST = 10524;
+	public const TRIPWIRE = 10525;
+	public const TRIPWIRE_HOOK = 10526;
+	public const UNDERWATER_TORCH = 10527;
+	public const VINES = 10528;
+	public const WALL_BANNER = 10529;
+	public const WALL_CORAL_FAN = 10530;
+	public const WATER = 10531;
+	public const WEIGHTED_PRESSURE_PLATE_HEAVY = 10532;
+	public const WEIGHTED_PRESSURE_PLATE_LIGHT = 10533;
+	public const WHEAT = 10534;
+
+	public const WHITE_TULIP = 10536;
+	public const WOOL = 10537;
+
+	public const GLAZED_TERRACOTTA = 10539;
+	public const AMETHYST = 10540;
+	public const ANCIENT_DEBRIS = 10541;
+	public const BASALT = 10542;
+	public const POLISHED_BASALT = 10543;
+	public const SMOOTH_BASALT = 10544;
+	public const BLACKSTONE = 10545;
+	public const BLACKSTONE_SLAB = 10546;
+	public const BLACKSTONE_STAIRS = 10547;
+	public const BLACKSTONE_WALL = 10548;
+	public const POLISHED_BLACKSTONE = 10549;
+	public const POLISHED_BLACKSTONE_BUTTON = 10550;
+	public const POLISHED_BLACKSTONE_PRESSURE_PLATE = 10551;
+	public const POLISHED_BLACKSTONE_SLAB = 10552;
+	public const POLISHED_BLACKSTONE_STAIRS = 10553;
+	public const POLISHED_BLACKSTONE_WALL = 10554;
+	public const CHISELED_POLISHED_BLACKSTONE = 10555;
+	public const POLISHED_BLACKSTONE_BRICKS = 10556;
+	public const POLISHED_BLACKSTONE_BRICK_SLAB = 10557;
+	public const POLISHED_BLACKSTONE_BRICK_STAIRS = 10558;
+	public const POLISHED_BLACKSTONE_BRICK_WALL = 10559;
+	public const CRACKED_POLISHED_BLACKSTONE_BRICKS = 10560;
+	public const LIGHT = 10561;
+	public const RAW_COPPER = 10562;
+	public const RAW_GOLD = 10563;
+	public const RAW_IRON = 10564;
+	public const CALCITE = 10565;
+	public const DEEPSLATE = 10566;
+	public const DEEPSLATE_BRICKS = 10567;
+	public const DEEPSLATE_BRICK_SLAB = 10568;
+	public const DEEPSLATE_BRICK_STAIRS = 10569;
+	public const DEEPSLATE_BRICK_WALL = 10570;
+	public const CRACKED_DEEPSLATE_BRICKS = 10571;
+	public const DEEPSLATE_TILES = 10572;
+	public const DEEPSLATE_TILE_SLAB = 10573;
+	public const DEEPSLATE_TILE_STAIRS = 10574;
+	public const DEEPSLATE_TILE_WALL = 10575;
+	public const CRACKED_DEEPSLATE_TILES = 10576;
+	public const COBBLED_DEEPSLATE = 10577;
+	public const COBBLED_DEEPSLATE_SLAB = 10578;
+	public const COBBLED_DEEPSLATE_STAIRS = 10579;
+	public const COBBLED_DEEPSLATE_WALL = 10580;
+	public const POLISHED_DEEPSLATE = 10581;
+	public const POLISHED_DEEPSLATE_SLAB = 10582;
+	public const POLISHED_DEEPSLATE_STAIRS = 10583;
+	public const POLISHED_DEEPSLATE_WALL = 10584;
+	public const QUARTZ_BRICKS = 10585;
+	public const CHISELED_DEEPSLATE = 10586;
+	public const CHISELED_NETHER_BRICKS = 10587;
+	public const CRACKED_NETHER_BRICKS = 10588;
+	public const TUFF = 10589;
+	public const SOUL_TORCH = 10590;
+	public const SOUL_LANTERN = 10591;
+	public const SOUL_SOIL = 10592;
+	public const SOUL_FIRE = 10593;
+	public const SHROOMLIGHT = 10594;
+	public const MANGROVE_PLANKS = 10595;
+	public const CRIMSON_PLANKS = 10596;
+	public const WARPED_PLANKS = 10597;
+	public const MANGROVE_FENCE = 10598;
+	public const CRIMSON_FENCE = 10599;
+	public const WARPED_FENCE = 10600;
+	public const MANGROVE_SLAB = 10601;
+	public const CRIMSON_SLAB = 10602;
+	public const WARPED_SLAB = 10603;
+	public const MANGROVE_LOG = 10604;
+	public const CRIMSON_STEM = 10605;
+	public const WARPED_STEM = 10606;
+	public const MANGROVE_WOOD = 10607;
+	public const CRIMSON_HYPHAE = 10608;
+	public const WARPED_HYPHAE = 10609;
+	public const MANGROVE_TRAPDOOR = 10610;
+	public const CRIMSON_TRAPDOOR = 10611;
+	public const WARPED_TRAPDOOR = 10612;
+	public const MANGROVE_BUTTON = 10613;
+	public const CRIMSON_BUTTON = 10614;
+	public const WARPED_BUTTON = 10615;
+	public const MANGROVE_PRESSURE_PLATE = 10616;
+	public const CRIMSON_PRESSURE_PLATE = 10617;
+	public const WARPED_PRESSURE_PLATE = 10618;
+	public const MANGROVE_DOOR = 10619;
+	public const CRIMSON_DOOR = 10620;
+	public const WARPED_DOOR = 10621;
+	public const MANGROVE_FENCE_GATE = 10622;
+	public const CRIMSON_FENCE_GATE = 10623;
+	public const WARPED_FENCE_GATE = 10624;
+	public const MANGROVE_STAIRS = 10625;
+	public const CRIMSON_STAIRS = 10626;
+	public const WARPED_STAIRS = 10627;
+	public const MANGROVE_SIGN = 10628;
+	public const CRIMSON_SIGN = 10629;
+	public const WARPED_SIGN = 10630;
+	public const MANGROVE_WALL_SIGN = 10631;
+	public const CRIMSON_WALL_SIGN = 10632;
+	public const WARPED_WALL_SIGN = 10633;
+	public const TINTED_GLASS = 10634;
+	public const HONEYCOMB = 10635;
+	public const DEEPSLATE_COAL_ORE = 10636;
+	public const DEEPSLATE_DIAMOND_ORE = 10637;
+	public const DEEPSLATE_EMERALD_ORE = 10638;
+	public const DEEPSLATE_LAPIS_LAZULI_ORE = 10639;
+	public const DEEPSLATE_REDSTONE_ORE = 10640;
+	public const DEEPSLATE_IRON_ORE = 10641;
+	public const DEEPSLATE_GOLD_ORE = 10642;
+	public const DEEPSLATE_COPPER_ORE = 10643;
+	public const COPPER_ORE = 10644;
+	public const NETHER_GOLD_ORE = 10645;
+	public const MUD = 10646;
+	public const MUD_BRICKS = 10647;
+	public const MUD_BRICK_SLAB = 10648;
+	public const MUD_BRICK_STAIRS = 10649;
+	public const MUD_BRICK_WALL = 10650;
+	public const PACKED_MUD = 10651;
+	public const WARPED_WART_BLOCK = 10652;
+	public const CRYING_OBSIDIAN = 10653;
+	public const GILDED_BLACKSTONE = 10654;
+	public const LIGHTNING_ROD = 10655;
+	public const COPPER = 10656;
+	public const CUT_COPPER = 10657;
+	public const CUT_COPPER_SLAB = 10658;
+	public const CUT_COPPER_STAIRS = 10659;
+	public const CANDLE = 10660;
+	public const DYED_CANDLE = 10661;
+	public const CAKE_WITH_CANDLE = 10662;
+	public const CAKE_WITH_DYED_CANDLE = 10663;
+	public const WITHER_ROSE = 10664;
+	public const HANGING_ROOTS = 10665;
+	public const CARTOGRAPHY_TABLE = 10666;
+	public const SMITHING_TABLE = 10667;
+	public const NETHERITE = 10668;
+	public const SPORE_BLOSSOM = 10669;
+	public const CAULDRON = 10670;
+	public const WATER_CAULDRON = 10671;
+	public const LAVA_CAULDRON = 10672;
+	public const POTION_CAULDRON = 10673;
+	public const POWDER_SNOW_CAULDRON = 10674;
+	public const CHORUS_FLOWER = 10675;
+	public const CHORUS_PLANT = 10676;
+	public const MANGROVE_ROOTS = 10677;
+	public const MUDDY_MANGROVE_ROOTS = 10678;
+	public const FROGLIGHT = 10679;
+
+	public const FIRST_UNUSED_BLOCK_ID = 10680;
+
+	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
+
+	/**
+	 * Returns a new runtime block type ID, e.g. for use by a custom block.
+	 */
+	public static function newId() : int{
+		return self::$nextDynamicId++;
+	}
+}

src/block/BlockTypeInfo.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\block;
+
+use function array_fill_keys;
+use function array_keys;
+
+final class BlockTypeInfo{
+	/**
+	 * @var true[]
+	 * @phpstan-var array<string, true>
+	 */
+	private array $typeTags;
+
+	/**
+	 * @param string[] $typeTags
+	 */
+	public function __construct(
+		private BlockBreakInfo $breakInfo,
+		array $typeTags = []
+	){
+		$this->typeTags = array_fill_keys($typeTags, true);
+	}
+
+	public function getBreakInfo() : BlockBreakInfo{ return $this->breakInfo; }
+
+	/** @return string[] */
+	public function getTypeTags() : array{ return array_keys($this->typeTags); }
+
+	public function hasTypeTag(string $tag) : bool{ return isset($this->typeTags[$tag]); }
+}

src/block/BlockTypeTags.php

@@ -0,0 +1,32 @@
+<?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\block;
+
+final class BlockTypeTags{
+
+	public const DIRT = "dirt";
+	public const MUD = "mud";
+	public const SAND = "sand";
+	public const POTTABLE_PLANTS = "pottable";
+}

src/block/BlueIce.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/BoneBlock.php

@@ -17,14 +17,14 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\PillarRotationInMetadataTrait;
+use pocketmine\block\utils\PillarRotationTrait;
 
 class BoneBlock extends Opaque{
-	use PillarRotationInMetadataTrait;
+	use PillarRotationTrait;
 }

src/block/Bookshelf.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/BrewingStand.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -25,6 +25,9 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\BrewingStand as TileBrewingStand;
 use pocketmine\block\utils\BrewingStandSlot;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
@@ -41,33 +44,10 @@ class BrewingStand extends Transparent{
 	 */
 	protected array $slots = [];
 
-	protected function writeStateToMeta() : int{
-		$flags = 0;
-		foreach([
-			BlockLegacyMetadata::BREWING_STAND_FLAG_EAST => BrewingStandSlot::EAST(),
-			BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST => BrewingStandSlot::NORTHWEST(),
-			BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST => BrewingStandSlot::SOUTHWEST(),
-		] as $flag => $slot){
-			$flags |= (array_key_exists($slot->id(), $this->slots) ? $flag : 0);
-		}
-		return $flags;
-	}
+	public function getRequiredStateDataBits() : int{ return 3; }
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->slots = [];
-		foreach([
-			BlockLegacyMetadata::BREWING_STAND_FLAG_EAST => BrewingStandSlot::EAST(),
-			BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST => BrewingStandSlot::NORTHWEST(),
-			BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST => BrewingStandSlot::SOUTHWEST(),
-		] as $flag => $slot){
-			if(($stateMeta & $flag) !== 0){
-				$this->slots[$slot->id()] = $slot;
-			}
-		}
-	}
-
-	public function getStateBitmask() : int{
-		return 0b111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->brewingStandSlots($this->slots);
 	}
 
 	protected function recalculateCollisionBoxes() : array{
@@ -83,6 +63,10 @@ class BrewingStand extends Transparent{
 		];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	public function hasSlot(BrewingStandSlot $slot) : bool{
 		return array_key_exists($slot->id(), $this->slots);
 	}
@@ -113,7 +97,7 @@ class BrewingStand extends Transparent{
 		return $this;
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$stand = $this->position->getWorld()->getTile($this->position);
 			if($stand instanceof TileBrewingStand && $stand->canOpenWith($item->getCustomName())){
@@ -125,10 +109,11 @@ class BrewingStand extends Transparent{
 	}
 
 	public function onScheduledUpdate() : void{
-		$brewing = $this->position->getWorld()->getTile($this->position);
+		$world = $this->position->getWorld();
+		$brewing = $world->getTile($this->position);
 		if($brewing instanceof TileBrewingStand){
 			if($brewing->onUpdate()){
-				$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, 1);
+				$world->scheduleDelayedBlockUpdate($this->position, 1);
 			}
 
 			$changed = false;
@@ -141,7 +126,7 @@ class BrewingStand extends Transparent{
 			}
 
 			if($changed){
-				$this->position->getWorld()->setBlock($this->position, $this);
+				$world->setBlock($this->position, $this);
 			}
 		}
 	}

src/block/BrownMushroom.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/BrownMushroomBlock.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/Button.php

@@ -17,14 +17,15 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
 use pocketmine\block\utils\AnyFacingTrait;
-use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
@@ -38,18 +39,11 @@ abstract class Button extends Flowable{
 
 	protected bool $pressed = false;
 
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeFacing($this->facing) | ($this->pressed ? BlockLegacyMetadata::BUTTON_FLAG_POWERED : 0);
-	}
+	public function getRequiredStateDataBits() : int{ return 4; }
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		//TODO: in PC it's (6 - facing) for every meta except 0 (down)
-		$this->facing = BlockDataSerializer::readFacing($stateMeta & 0x07);
-		$this->pressed = ($stateMeta & BlockLegacyMetadata::BUTTON_FLAG_POWERED) !== 0;
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->facing($this->facing);
+		$w->bool($this->pressed);
 	}
 
 	public function isPressed() : bool{ return $this->pressed; }
@@ -61,19 +55,22 @@ abstract class Button extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		//TODO: check valid target block
-		$this->facing = $face;
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		if($this->canBeSupportedBy($blockClicked, $face)){
+			$this->facing = $face;
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+		return false;
 	}
 
 	abstract protected function getActivationTime() : int;
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if(!$this->pressed){
 			$this->pressed = true;
-			$this->position->getWorld()->setBlock($this->position, $this);
-			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, $this->getActivationTime());
-			$this->position->getWorld()->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOnSound());
+			$world = $this->position->getWorld();
+			$world->setBlock($this->position, $this);
+			$world->scheduleDelayedBlockUpdate($this->position, $this->getActivationTime());
+			$world->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOnSound());
 		}
 
 		return true;
@@ -82,8 +79,19 @@ abstract class Button extends Flowable{
 	public function onScheduledUpdate() : void{
 		if($this->pressed){
 			$this->pressed = false;
-			$this->position->getWorld()->setBlock($this->position, $this);
-			$this->position->getWorld()->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOffSound());
+			$world = $this->position->getWorld();
+			$world->setBlock($this->position, $this);
+			$world->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOffSound());
 		}
 	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	private function canBeSupportedBy(Block $support, int $face) : bool{
+		return $support->getSupportType($face)->hasCenterSupport();
+	}
 }

src/block/Cactus.php

@@ -17,13 +17,15 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\entity\Entity;
 use pocketmine\event\block\BlockGrowEvent;
 use pocketmine\event\entity\EntityDamageByBlockEvent;
@@ -36,27 +38,22 @@ use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 
 class Cactus extends Transparent{
+	public const MAX_AGE = 15;
 
 	protected int $age = 0;
 
-	protected function writeStateToMeta() : int{
-		return $this->age;
-	}
+	public function getRequiredStateDataBits() : int{ return 4; }
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 15);
-	}
-
-	public function getStateBitmask() : int{
-		return 0b1111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->boundedInt(4, 0, self::MAX_AGE, $this->age);
 	}
 
 	public function getAge() : int{ return $this->age; }
 
 	/** @return $this */
 	public function setAge(int $age) : self{
-		if($age < 0 || $age > 15){
-			throw new \InvalidArgumentException("Age must be in range 0-15");
+		if($age < 0 || $age > self::MAX_AGE){
+			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
 		}
 		$this->age = $age;
 		return $this;
@@ -70,25 +67,33 @@ class Cactus extends Transparent{
 	 * @return AxisAlignedBB[]
 	 */
 	protected function recalculateCollisionBoxes() : array{
-		static $shrinkSize = 1 / 16;
+		$shrinkSize = 1 / 16;
 		return [AxisAlignedBB::one()->contract($shrinkSize, 0, $shrinkSize)->trim(Facing::UP, $shrinkSize)];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	public function onEntityInside(Entity $entity) : bool{
 		$ev = new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_CONTACT, 1);
 		$entity->attack($ev);
 		return true;
 	}
 
+	private function canBeSupportedBy(Block $block) : bool{
+		return $block->isSameType($this) || $block->hasTypeTag(BlockTypeTags::SAND);
+	}
+
 	public function onNearbyBlockChange() : void{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->getId() !== BlockLegacyIds::SAND && !$down->isSameType($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
+		$world = $this->position->getWorld();
+		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+			$world->useBreakOn($this->position);
 		}else{
 			foreach(Facing::HORIZONTAL as $side){
 				$b = $this->getSide($side);
 				if($b->isSolid()){
-					$this->position->getWorld()->useBreakOn($this->position);
+					$world->useBreakOn($this->position);
 					break;
 				}
 			}
@@ -101,35 +106,35 @@ class Cactus extends Transparent{
 
 	public function onRandomTick() : void{
 		if(!$this->getSide(Facing::DOWN)->isSameType($this)){
-			if($this->age === 15){
+			$world = $this->position->getWorld();
+			if($this->age === self::MAX_AGE){
 				for($y = 1; $y < 3; ++$y){
-					if(!$this->position->getWorld()->isInWorld($this->position->x, $this->position->y + $y, $this->position->z)){
+					if(!$world->isInWorld($this->position->x, $this->position->y + $y, $this->position->z)){
 						break;
 					}
-					$b = $this->position->getWorld()->getBlockAt($this->position->x, $this->position->y + $y, $this->position->z);
-					if($b->getId() === BlockLegacyIds::AIR){
+					$b = $world->getBlockAt($this->position->x, $this->position->y + $y, $this->position->z);
+					if($b->getTypeId() === BlockTypeIds::AIR){
 						$ev = new BlockGrowEvent($b, VanillaBlocks::CACTUS());
 						$ev->call();
 						if($ev->isCancelled()){
 							break;
 						}
-						$this->position->getWorld()->setBlock($b->position, $ev->getNewState());
+						$world->setBlock($b->position, $ev->getNewState());
 					}else{
 						break;
 					}
 				}
 				$this->age = 0;
-				$this->position->getWorld()->setBlock($this->position, $this);
+				$world->setBlock($this->position, $this);
 			}else{
 				++$this->age;
-				$this->position->getWorld()->setBlock($this->position, $this);
+				$world->setBlock($this->position, $this);
 			}
 		}
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->getId() === BlockLegacyIds::SAND || $down->isSameType($this)){
+		if($this->canBeSupportedBy($this->getSide(Facing::DOWN))){
 			foreach(Facing::HORIZONTAL as $side){
 				if($this->getSide($side)->isSolid()){
 					return false;

src/block/Cake.php

@@ -17,37 +17,30 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\BlockDataSerializer;
-use pocketmine\entity\effect\EffectInstance;
-use pocketmine\entity\FoodSource;
-use pocketmine\entity\Living;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
 use pocketmine\item\Item;
+use pocketmine\item\ItemBlock;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
-class Cake extends Transparent implements FoodSource{
+class Cake extends BaseCake{
+	public const MAX_BITES = 6;
 
 	protected int $bites = 0;
 
-	protected function writeStateToMeta() : int{
-		return $this->bites;
-	}
+	public function getRequiredStateDataBits() : int{ return 3; }
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->bites = BlockDataSerializer::readBoundedInt("bites", $stateMeta, 0, 6);
-	}
-
-	public function getStateBitmask() : int{
-		return 0b111;
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$w->boundedInt(3, 0, self::MAX_BITES, $this->bites);
 	}
 
 	/**
@@ -66,72 +59,39 @@ class Cake extends Transparent implements FoodSource{
 
 	/** @return $this */
 	public function setBites(int $bites) : self{
-		if($bites < 0 || $bites > 6){
-			throw new \InvalidArgumentException("Bites must be in range 0-6");
+		if($bites < 0 || $bites > self::MAX_BITES){
+			throw new \InvalidArgumentException("Bites must be in range 0 ... " . self::MAX_BITES);
 		}
 		$this->bites = $bites;
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->getId() !== BlockLegacyIds::AIR){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($item instanceof ItemBlock){
+			$block = $item->getBlock();
+			$resultBlock = null;
+			if($block->getTypeId() === BlockTypeIds::CANDLE){
+				$resultBlock = VanillaBlocks::CAKE_WITH_CANDLE();
+			}elseif($block instanceof DyedCandle){
+				$resultBlock = VanillaBlocks::CAKE_WITH_DYED_CANDLE()->setColor($block->getColor());
+			}
+
+			if($resultBlock !== null){
+				$this->position->getWorld()->setBlock($this->position, $resultBlock);
+				$item->pop();
+				return true;
+			}
 		}
 
-		return false;
+		return parent::onInteract($item, $face, $clickVector, $player, $returnedItems);
 	}
 
-	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){ //Replace with common break method
-			$this->position->getWorld()->setBlock($this->position, VanillaBlocks::AIR());
-		}
-	}
-
-	public function getDropsForCompatibleTool(Item $item) : array{
-		return [];
-	}
-
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($player !== null){
-			return $player->consumeObject($this);
-		}
-
-		return false;
-	}
-
-	public function getFoodRestore() : int{
-		return 2;
-	}
-
-	public function getSaturationRestore() : float{
-		return 0.4;
-	}
-
-	public function requiresHunger() : bool{
-		return true;
-	}
-
-	/**
-	 * @return Block
-	 */
-	public function getResidue(){
+	public function getResidue() : Block{
 		$clone = clone $this;
 		$clone->bites++;
-		if($clone->bites > 6){
+		if($clone->bites > self::MAX_BITES){
 			$clone = VanillaBlocks::AIR();
 		}
 		return $clone;
 	}
-
-	/**
-	 * @return EffectInstance[]
-	 */
-	public function getAdditionalEffects() : array{
-		return [];
-	}
-
-	public function onConsume(Living $consumer) : void{
-		$this->position->getWorld()->setBlock($this->position, $this->getResidue());
-	}
 }

src/block/CakeWithCandle.php

@@ -0,0 +1,78 @@
+<?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\block;
+
+use pocketmine\block\utils\CandleTrait;
+use pocketmine\entity\Living;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+
+class CakeWithCandle extends BaseCake{
+	use CandleTrait {
+		onInteract as onInteractCandle;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [
+			AxisAlignedBB::one()
+				->contract(1 / 16, 0, 1 / 16)
+				->trim(Facing::UP, 0.5) //TODO: not sure if the candle affects height
+		];
+	}
+
+	public function getCandle() : Candle{
+		return VanillaBlocks::CANDLE();
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($this->onInteractCandle($item, $face, $clickVector, $player, $returnedItems)){
+			return true;
+		}
+
+		return parent::onInteract($item, $face, $clickVector, $player, $returnedItems);
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [$this->getCandle()->asItem()];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaBlocks::CAKE()->getPickedItem($addUserData);
+	}
+
+	public function getResidue() : Block{
+		return VanillaBlocks::CAKE()->setBites(1);
+	}
+
+	public function onConsume(Living $consumer) : void{
+		parent::onConsume($consumer);
+		$this->position->getWorld()->dropItem($this->position->add(0.5, 0.5, 0.5), $this->getCandle()->asItem());
+	}
+}

src/block/CakeWithDyedCandle.php

@@ -0,0 +1,40 @@
+<?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\block;
+
+use pocketmine\block\utils\ColoredTrait;
+use pocketmine\block\utils\DyeColor;
+
+class CakeWithDyedCandle extends CakeWithCandle{
+	use ColoredTrait;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
+		$this->color = DyeColor::WHITE();
+		parent::__construct($idInfo, $name, $typeInfo);
+	}
+
+	public function getCandle() : Candle{
+		return VanillaBlocks::DYED_CANDLE()->setColor($this->color);
+	}
+}

src/block/Candle.php

@@ -0,0 +1,126 @@
+<?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\block;
+
+use pocketmine\block\utils\CandleTrait;
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
+use pocketmine\item\Item;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\BlockTransaction;
+
+class Candle extends Transparent{
+	use CandleTrait {
+		describeState as encodeLitState;
+		getLightLevel as getBaseLightLevel;
+	}
+
+	public const MIN_COUNT = 1;
+	public const MAX_COUNT = 4;
+
+	private int $count = self::MIN_COUNT;
+
+	public function getRequiredStateDataBits() : int{
+		return 3;
+	}
+
+	protected function describeState(RuntimeDataReader|RuntimeDataWriter $w) : void{
+		$this->encodeLitState($w);
+		$w->boundedInt(2, self::MIN_COUNT, self::MAX_COUNT, $this->count);
+	}
+
+	public function getCount() : int{ return $this->count; }
+
+	/** @return $this */
+	public function setCount(int $count) : self{
+		if($count < self::MIN_COUNT || $count > self::MAX_COUNT){
+			throw new \InvalidArgumentException("Count must be in range " . self::MIN_COUNT . " ... " . self::MAX_COUNT);
+		}
+		$this->count = $count;
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return $this->getBaseLightLevel() * $this->count;
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [
+			(match($this->count){
+				1 => AxisAlignedBB::one()
+					->squash(Axis::X, 7 / 16)
+					->squash(Axis::Z, 7 / 16),
+				2 => AxisAlignedBB::one()
+					->squash(Axis::X, 5 / 16)
+					->trim(Facing::NORTH, 7 / 16) //0.3 thick on the Z axis
+					->trim(Facing::SOUTH, 6 / 16),
+				3 => AxisAlignedBB::one()
+					->trim(Facing::WEST, 5 / 16)
+					->trim(Facing::EAST, 6 / 16)
+					->trim(Facing::NORTH, 6 / 16)
+					->trim(Facing::SOUTH, 5 / 16),
+				4 => AxisAlignedBB::one()
+					->squash(Axis::X, 5 / 16)
+					->trim(Facing::NORTH, 5 / 16)
+					->trim(Facing::SOUTH, 6 / 16),
+				default => throw new AssumptionFailedError("Unreachable")
+			})->trim(Facing::UP, 10 / 16)
+		];
+	}
+
+	protected function getCandleIfCompatibleType(Block $block) : ?Candle{
+		return $block instanceof Candle && $block->isSameType($this) ? $block : null;
+	}
+
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
+		$candle = $this->getCandleIfCompatibleType($blockReplace);
+		return $candle !== null ? $candle->count < self::MAX_COUNT : parent::canBePlacedAt($blockReplace, $clickVector, $face, $isClickedBlock);
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $blockReplace->getSide(Facing::DOWN);
+		if(!$down->getSupportType(Facing::UP)->hasCenterSupport()){
+			return false;
+		}
+		$existing = $this->getCandleIfCompatibleType($blockReplace);
+		if($existing !== null){
+			if($existing->count >= self::MAX_COUNT){
+				return false;
+			}
+
+			$this->count = $existing->count + 1;
+			$this->lit = $existing->lit;
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [$this->asItem()->setCount($this->count)];
+	}
+}

src/block/Carpet.php

@@ -17,13 +17,13 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorInMetadataTrait;
+use pocketmine\block\utils\ColoredTrait;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
@@ -33,11 +33,11 @@ use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 
 class Carpet extends Flowable{
-	use ColorInMetadataTrait;
+	use ColoredTrait;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $breakInfo);
+		parent::__construct($idInfo, $name, $typeInfo);
 	}
 
 	public function isSolid() : bool{
@@ -53,7 +53,7 @@ class Carpet extends Flowable{
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$down = $this->getSide(Facing::DOWN);
-		if($down->getId() !== BlockLegacyIds::AIR){
+		if($down->getTypeId() !== BlockTypeIds::AIR){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
@@ -61,7 +61,7 @@ class Carpet extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){
+		if($this->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::AIR){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}

src/block/Carrot.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -31,11 +31,11 @@ class Carrot extends Crops{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::CARROT()->setCount($this->age >= 7 ? mt_rand(1, 4) : 1)
+			VanillaItems::CARROT()->setCount($this->age >= self::MAX_AGE ? mt_rand(1, 4) : 1)
 		];
 	}
 
-	public function getPickedItem(bool $addUserData = false) : Item{
+	public function asItem() : Item{
 		return VanillaItems::CARROT();
 	}
 }

src/block/CartographyTable.php

@@ -0,0 +1,44 @@
+<?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\block;
+
+use pocketmine\block\inventory\CartographyTableInventory;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+
+final class CartographyTable extends Opaque{
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player !== null){
+			$player->setCurrentWindow(new CartographyTableInventory($this->position));
+		}
+
+		return true;
+	}
+
+	public function getFuelTime() : int{
+		return 300;
+	}
+}

src/block/CarvedPumpkin.php

@@ -17,29 +17,16 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacingTrait;
 
 class CarvedPumpkin extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
 	use HorizontalFacingTrait;
-
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
-	}
-
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing);
-	}
-
-	public function getStateBitmask() : int{
-		return 0b11;
-	}
 }

src/block/Cauldron.php

@@ -0,0 +1,104 @@
+<?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\block;
+
+use pocketmine\block\tile\Cauldron as TileCauldron;
+use pocketmine\block\utils\SupportType;
+use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
+use pocketmine\item\Potion;
+use pocketmine\item\PotionType;
+use pocketmine\item\SplashPotion;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use function assert;
+
+final class Cauldron extends Transparent{
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		assert($tile instanceof TileCauldron);
+
+		//empty cauldrons don't use this information
+		$tile->setCustomWaterColor(null);
+		$tile->setPotionItem(null);
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		$result = [
+			AxisAlignedBB::one()->trim(Facing::UP, 11 / 16) //bottom of the cauldron
+		];
+
+		foreach(Facing::HORIZONTAL as $f){ //add the frame parts around the bowl
+			$result[] = AxisAlignedBB::one()->trim($f, 14 / 16);
+		}
+		return $result;
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return $facing === Facing::UP ? SupportType::EDGE() : SupportType::NONE();
+	}
+
+	/**
+	 * @param Item[] &$returnedItems
+	 */
+	private function fill(int $amount, FillableCauldron $result, Item $usedItem, Item $returnedItem, array &$returnedItems) : void{
+		$this->position->getWorld()->setBlock($this->position, $result->setFillLevel($amount));
+		$this->position->getWorld()->addSound($this->position->add(0.5, 0.5, 0.5), $result->getFillSound());
+
+		$usedItem->pop();
+		$returnedItems[] = $returnedItem;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($item->getTypeId() === ItemTypeIds::WATER_BUCKET){
+			$this->fill(FillableCauldron::MAX_FILL_LEVEL, VanillaBlocks::WATER_CAULDRON(), $item, VanillaItems::BUCKET(), $returnedItems);
+		}elseif($item->getTypeId() === ItemTypeIds::LAVA_BUCKET){
+			$this->fill(FillableCauldron::MAX_FILL_LEVEL, VanillaBlocks::LAVA_CAULDRON(), $item, VanillaItems::BUCKET(), $returnedItems);
+		}elseif($item->getTypeId() === ItemTypeIds::POWDER_SNOW_BUCKET){
+			//TODO: powder snow cauldron
+		}elseif($item instanceof Potion || $item instanceof SplashPotion){ //TODO: lingering potion
+			if($item->getType()->equals(PotionType::WATER())){
+				$this->fill(WaterCauldron::WATER_BOTTLE_FILL_AMOUNT, VanillaBlocks::WATER_CAULDRON(), $item, VanillaItems::GLASS_BOTTLE(), $returnedItems);
+			}else{
+				$this->fill(PotionCauldron::POTION_FILL_AMOUNT, VanillaBlocks::POTION_CAULDRON()->setPotionItem($item), $item, VanillaItems::GLASS_BOTTLE(), $returnedItems);
+			}
+		}
+
+		return true;
+	}
+
+	public function onNearbyBlockChange() : void{
+		$world = $this->position->getWorld();
+		if($world->getBlock($this->position->up())->getTypeId() === BlockTypeIds::WATER){
+			$cauldron = VanillaBlocks::WATER_CAULDRON()->setFillLevel(FillableCauldron::MAX_FILL_LEVEL);
+			$world->setBlock($this->position, $cauldron);
+			$world->addSound($this->position->add(0.5, 0.5, 0.5), $cauldron->getFillSound());
+		}
+	}
+}

src/block/ChemicalHeat.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 

src/block/ChemistryTable.php

@@ -17,17 +17,15 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
@@ -35,19 +33,7 @@ final class ChemistryTable extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
 	use HorizontalFacingTrait;
 
-	public function readStateFromData(int $id, int $stateMeta) : void{
-		$this->facing = Facing::opposite(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x3));
-	}
-
-	protected function writeStateToMeta() : int{
-		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::opposite($this->facing));
-	}
-
-	public function getStateBitmask() : int{
-		return 0b0011;
-	}
-
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		//TODO
 		return false;
 	}

src/block/Chest.php

@@ -17,7 +17,7 @@
  * @link http://www.pocketmine.net/
  *
  *
-*/
+ */
 
 declare(strict_types=1);
 
@@ -25,7 +25,8 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Chest as TileChest;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\NormalHorizontalFacingInMetadataTrait;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\SupportType;
 use pocketmine\event\block\ChestPairEvent;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
@@ -35,7 +36,7 @@ use pocketmine\player\Player;
 
 class Chest extends Transparent{
 	use FacesOppositePlacingPlayerTrait;
-	use NormalHorizontalFacingInMetadataTrait;
+	use HorizontalFacingTrait;
 
 	/**
 	 * @return AxisAlignedBB[]
@@ -45,14 +46,18 @@ class Chest extends Transparent{
 		return [AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05)];
 	}
 
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
 	public function onPostPlace() : void{
-		$tile = $this->position->getWorld()->getTile($this->position);
+		$world = $this->position->getWorld();
+		$tile = $world->getTile($this->position);
 		if($tile instanceof TileChest){
 			foreach([false, true] as $clockwise){
 				$side = Facing::rotateY($this->facing, $clockwise);
 				$c = $this->getSide($side);
 				if($c instanceof Chest && $c->isSameType($this) && $c->facing === $this->facing){
-					$world = $this->position->getWorld();
 					$pair = $world->getTile($c->position);
 					if($pair instanceof TileChest && !$pair->isPaired()){
 						[$left, $right] = $clockwise ? [$c, $this] : [$this, $c];
@@ -69,7 +74,7 @@ class Chest extends Transparent{
 		}
 	}
 
-	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 
 			$chest = $this->position->getWorld()->getTile($this->position);

src/block/ChorusFlower.php

@@ -0,0 +1,236 @@
+<?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\block;
+
+use pocketmine\data\runtime\RuntimeDataReader;
+use pocketmine\data\runtime\RuntimeDataWriter;
+use pocketmine\entity\projectile\Projectile;
+use pocketmine\event\block\StructureGrowEvent;
+use pocketmine\item\Item;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\RayTraceResult;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\Position;
+use pocketmine\world\sound\ChorusFlowerDieSound;
+use pocketmine\world\sound\ChorusFlowerGrowSound;
+use pocketmine\world\World;
+use function array_rand;
+use function mt_rand;
+
+final class ChorusFlower extends Flowable{
+	public const MIN_AGE = 0;
+	public const MAX_AGE = 5;
+
+	private const MAX_STEM_HEIGHT = 5;
+
+	private int $age = self::MIN_AGE;
+
+	public function getRequiredStateDataBits() : int{ return 3; }
+
+	protected function describeState(RuntimeDataWriter|RuntimeDataReader $w) : void{
+		$w->boundedInt(3, self::MIN_AGE, self::MAX_AGE, $this->age);
+	}
+
+	public function getAge() : int{ return $this->age; }
+
+	/** @return $this */
+	public function setAge(int $age) : self{
+		if($age < self::MIN_AGE || $age > self::MAX_AGE){
+			throw new \InvalidArgumentException("Age must be in the range " . self::MIN_AGE . " ... " . self::MAX_AGE);
+		}
+		$this->age = $age;
+		return $this;
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()];
+	}
+
+	private function canBeSupportedAt(Position $position) : bool{
+		$world = $position->getWorld();
+		$down = $world->getBlock($position->down());
+
+		if($down->getTypeId() === BlockTypeIds::END_STONE || $down->getTypeId() === BlockTypeIds::CHORUS_PLANT){
+			return true;
+		}
+
+		$plantAdjacent = false;
+		foreach($position->sidesAroundAxis(Axis::Y) as $sidePosition){
+			$block = $world->getBlock($sidePosition);
+
+			if($block->getTypeId() === BlockTypeIds::CHORUS_PLANT){
+				if($plantAdjacent){ //at most one plant may be horizontally adjacent
+					return false;
+				}
+				$plantAdjacent = true;
+			}elseif($block->getTypeId() !== BlockTypeIds::AIR){
+				return false;
+			}
+		}
+
+		return $plantAdjacent;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->canBeSupportedAt($blockReplace->getPosition())){
+			return false;
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canBeSupportedAt($this->position)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
+		$this->position->getWorld()->useBreakOn($this->position);
+	}
+
+	public function ticksRandomly() : bool{ return $this->age < self::MAX_AGE; }
+
+	/**
+	 * @phpstan-return array{int, bool}
+	 */
+	private function scanStem() : array{
+		$world = $this->position->getWorld();
+
+		$stemHeight = 0;
+		$endStoneBelow = false;
+		for($yOffset = 0; $yOffset < self::MAX_STEM_HEIGHT; $yOffset++, $stemHeight++){
+			$down = $world->getBlock($this->position->down($yOffset + 1));
+
+			if($down->getTypeId() !== BlockTypeIds::CHORUS_PLANT){
+				if($down->getTypeId() === BlockTypeIds::END_STONE){
+					$endStoneBelow = true;
+				}
+				break;
+			}
+		}
+
+		return [$stemHeight, $endStoneBelow];
+	}
+
+	private function allHorizontalBlocksEmpty(World $world, Vector3 $position, ?int $except) : bool{
+		foreach($position->sidesAroundAxis(Axis::Y) as $facing => $sidePosition){
+			if($facing === $except){
+				continue;
+			}
+			if($world->getBlock($sidePosition)->getTypeId() !== BlockTypeIds::AIR){
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	private function canGrowUpwards(int $stemHeight, bool $endStoneBelow) : bool{
+		$world = $this->position->getWorld();
+
+		$up = $this->position->up();
+		if(
+			//the space above must be empty and writable
+			!$world->isInWorld($up->x, $up->y, $up->z) ||
+			$world->getBlock($up)->getTypeId() !== BlockTypeIds::AIR ||
+			(
+				//the space above that must be empty, but doesn't need to be writable
+				$world->isInWorld($up->x, $up->y + 1, $up->z) &&
+				$world->getBlock($up->up())->getTypeId() !== BlockTypeIds::AIR
+			)
+		){
+			return false;
+		}
+
+		if($this->getSide(Facing::DOWN)->getTypeId() !== BlockTypeIds::AIR){
+			if($stemHeight >= self::MAX_STEM_HEIGHT){
+				return false;
+			}
+
+			if($stemHeight > 1 && $stemHeight > mt_rand(0, $endStoneBelow ? 4 : 3)){ //chance decreases for each added block of chorus plant
+				return false;
+			}
+		}
+
+		return $this->allHorizontalBlocksEmpty($world, $up, null);
+	}
+
+	private function grow(int $facing, int $ageChange, ?BlockTransaction $tx) : BlockTransaction{
+		if($tx === null){
+			$tx = new BlockTransaction($this->position->getWorld());
+		}
+		$tx->addBlock($this->position->getSide($facing), (clone $this)->setAge($this->getAge() + $ageChange));
+
+		return $tx;
+	}
+
+	public function onRandomTick() : void{
+		$world = $this->position->getWorld();
+
+		if($this->age >= self::MAX_AGE){
+			return;
+		}
+
+		$tx = null;
+
+		[$stemHeight, $endStoneBelow] = $this->scanStem();
+		if($this->canGrowUpwards($stemHeight, $endStoneBelow)){
+			$tx = $this->grow(Facing::UP, 0, $tx);
+		}else{
+			$facingVisited = [];
+			for($attempts = 0, $maxAttempts = mt_rand(0, $endStoneBelow ? 4 : 3); $attempts < $maxAttempts; $attempts++){
+				$facing = Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)];
+				if(isset($facingVisited[$facing])){
+					continue;
+				}
+				$facingVisited[$facing] = true;
+
+				$sidePosition = $this->position->getSide($facing);
+				if(
+					$world->getBlock($sidePosition)->getTypeId() === BlockTypeIds::AIR &&
+					$world->getBlock($sidePosition->down())->getTypeId() === BlockTypeIds::AIR &&
+					$this->allHorizontalBlocksEmpty($world, $sidePosition, Facing::opposite($facing))
+				){
+					$tx = $this->grow($facing, 1, $tx);
+				}
+			}
+		}
+
+		if($tx !== null){
+			$tx->addBlock($this->position, VanillaBlocks::CHORUS_PLANT());
+			$ev = new StructureGrowEvent($this, $tx, null);
+			$ev->call();
+			if(!$ev->isCancelled() && $tx->apply()){
+				$world->addSound($this->position->add(0.5, 0.5, 0.5), new ChorusFlowerGrowSound());
+			}
+		}else{
+			$world->addSound($this->position->add(0.5, 0.5, 0.5), new ChorusFlowerDieSound());
+			$this->position->getWorld()->setBlock($this->position, $this->setAge(self::MAX_AGE));
+		}
+	}
+}

src/block/ChorusPlant.php

@@ -0,0 +1,102 @@
+<?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\block;
+
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\Position;
+use function mt_rand;
+
+final class ChorusPlant extends Flowable{
+
+	protected function recalculateCollisionBoxes() : array{
+		$bb = AxisAlignedBB::one();
+		foreach($this->getAllSides() as $facing => $block){
+			$id = $block->getTypeId();
+			if($id !== BlockTypeIds::END_STONE && $id !== BlockTypeIds::CHORUS_FLOWER && !$block->isSameType($this)){
+				$bb->trim($facing, 2 / 16);
+			}
+		}
+
+		return [$bb];
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		return $block->isSameType($this) || $block->getTypeId() === BlockTypeIds::END_STONE;
+	}
+
+	private function canStay(Position $position) : bool{
+		$world = $position->getWorld();
+
+		$down = $world->getBlock($position->down());
+		$verticalAir = $down->getTypeId() === BlockTypeIds::AIR || $world->getBlock($position->up())->getTypeId() === BlockTypeIds::AIR;
+
+		foreach($position->sidesAroundAxis(Axis::Y) as $sidePosition){
+			$block = $world->getBlock($sidePosition);
+
+			if($block->getTypeId() === BlockTypeIds::CHORUS_PLANT){
+				if(!$verticalAir){
+					return false;
+				}
+
+				if($this->canBeSupportedBy($block->getSide(Facing::DOWN))){
+					return true;
+				}
+			}
+		}
+
+		if($this->canBeSupportedBy($down)){
+			return true;
+		}
+
+		return false;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->canStay($blockReplace->getPosition())){
+			return false;
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canStay($this->position)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		if(mt_rand(0, 1) === 1){
+			return [VanillaItems::CHORUS_FRUIT()];
+		}
+
+		return [];
+	}
+}