Release 5.4.0

this needs to be dealt with before release otherwise we'll be stuck with FortuneDropHelper::grass()
this is the obvious solution and should have been done some time ago - stuff like flammability was already a problem for double tall grass anyway

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

@@ -53,7 +53,7 @@ jobs:
         run: echo NAME=$(echo "${GITHUB_REPOSITORY,,}") >> $GITHUB_OUTPUT
 
       - name: Build image for tag
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v4.1.1
         with:
           push: true
           context: ./pocketmine-mp
@@ -66,7 +66,7 @@ jobs:
 
       - name: Build image for major tag
         if: steps.channel.outputs.CHANNEL == 'stable'
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v4.1.1
         with:
           push: true
           context: ./pocketmine-mp
@@ -79,7 +79,7 @@ jobs:
 
       - name: Build image for minor tag
         if: steps.channel.outputs.CHANNEL == 'stable'
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v4.1.1
         with:
           push: true
           context: ./pocketmine-mp
@@ -92,7 +92,7 @@ jobs:
 
       - name: Build image for latest tag
         if: steps.channel.outputs.CHANNEL == 'stable'
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v4.1.1
         with:
           push: true
           context: ./pocketmine-mp

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

@@ -13,7 +13,7 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.24.0
+        uses: shivammathur/setup-php@2.25.5
         with:
           php-version: 8.1
 

.github/workflows/draft-release.yml

@@ -18,7 +18,7 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.24.0
+        uses: shivammathur/setup-php@2.25.5
         with:
           php-version: 8.1
 

.github/workflows/main.yml

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

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

@@ -1,50 +0,0 @@
-<?php
-
-/*
- *
- *  ____            _        _   __  __ _                  __  __ ____
- * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
- * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
- * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
- * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * @author PocketMine Team
- * @link http://www.pocketmine.net/
- *
- *
-*/
-
-declare(strict_types=1);
-
-const VERSIONS = [
-	"8.1",
-	"8.2"
-];
-
-$workflowFile = file_get_contents(__DIR__ . '/main.yml');
-$newWorkflowFile = $workflowFile;
-foreach(VERSIONS as $v){
-	$releaseInfo = file_get_contents("https://secure.php.net/releases?json&version=$v");
-	if($releaseInfo === false){
-		throw new \RuntimeException("Failed to contact php.net API");
-	}
-	$data = json_decode($releaseInfo, true);
-	if(!is_array($data) || !isset($data["version"]) || !is_string($data["version"]) || preg_match('/^\d+\.\d+\.\d+(-[A-Za-z\d]+)?$/', $data["version"]) === 0){
-		throw new \RuntimeException("Invalid data returned by API");
-	}
-	$updated = preg_replace("/$v\.\d+/", $data["version"], $newWorkflowFile);
-	if($updated !== $newWorkflowFile){
-		echo "Updated $v revision to " . $data["version"] . "\n";
-	}
-	$newWorkflowFile = $updated;
-}
-
-if($workflowFile !== $newWorkflowFile){
-	echo "Writing modified workflow file\n";
-	file_put_contents(__DIR__ . '/main.yml', $newWorkflowFile);
-}

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

@@ -8,6 +8,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    concurrency: update-updater-api # only one job can run at a time, to avoid git conflicts when updating the repository
 
     steps:
       - name: Install jq

.idea/codeStyles/Project.xml

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

CONTRIBUTING.md

@@ -28,10 +28,8 @@ Take a look at the table below if you can't find the class or function you're lo
 |:----------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------|
 | [pmmp/BedrockProtocol](https://github.com/pmmp/BedrockProtocol) | `pocketmine\network\mcpe\protocol`                                                                                                       |
 | [pmmp/BinaryUtils](https://github.com/pmmp/BinaryUtils)         | `pocketmine\utils\BinaryDataException`</br>`pocketmine\utils\BinaryStream`</br>`pocketmine\utils\Binary`                                 |
-| [pmmp/ClassLoader](https://github.com/pmmp/`ClassLoader`)       | `BaseClassLoader`</br>`ClassLoader`</br>`DynamicClassLoader`                                                                             |
 | [pmmp/Color](https://github.com/pmmp/Color)                     | `pocketmine\color`                                                                                                                       |
 | [pmmp/ErrorHandler](https://github.com/pmmp/ErrorHandler)       | `pocketmine\errorhandler`                                                                                                                |
-| [pmmp/LogPthreads](https://github.com/pmmp/LogPthreads)         | `ThreadedLoggerAttachment`</br>`ThreadedLogger`</br>`AttachableThreadedLogger`                                                           |
 | [pmmp/Log](https://github.com/pmmp/Log)                         | `AttachableLogger`</br>`BufferedLogger`</br>`GlobalLogger`</br>`LogLevel`</br>`Logger`</br>`PrefixedLogger`</br>`SimpleLogger`           |
 | [pmmp/Math](https://github.com/pmmp/Math)                       | `pocketmine\math`                                                                                                                        |
 | [pmmp/NBT](https://github.com/pmmp/NBT)                         | `pocketmine\nbt`                                                                                                                         |

README.md

@@ -4,8 +4,8 @@
 			<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" />
+			<source srcset="https://raw.githubusercontent.com/pmmp/PocketMine-MP/stable/.github/readme/pocketmine-dark-rgb.gif" media="(prefers-color-scheme: dark)">
+			<img src="https://raw.githubusercontent.com/pmmp/PocketMine-MP/stable/.github/readme/pocketmine-rgb.gif" loading="eager" />
 		</picture>
 	</a><br>
 	<b>A highly customisable, open source server software for Minecraft: Bedrock Edition written in PHP</b>
@@ -26,7 +26,7 @@
 - [Docker image](https://github.com/pmmp/PocketMine-MP/pkgs/container/pocketmine-mp)
 - [Plugin repository](https://poggit.pmmp.io/plugins)
 
-## Discussion/Help
+## Community & Support
 - [Forums](https://forums.pmmp.io/)
 - [Discord](https://discord.gg/bmSAZBG)
 - [StackOverflow](https://stackoverflow.com/tags/pocketmine)

build/generate-block-serializer-consts.php

@@ -44,6 +44,7 @@ use function fwrite;
 use function is_string;
 use function ksort;
 use function mb_strtoupper;
+use function preg_replace;
 use function sort;
 use function strrpos;
 use function strtoupper;
@@ -138,7 +139,7 @@ function generateBlockStateNames(BlockPaletteReport $data) : void{
 
 	fwrite($output, generateClassHeader(BlockStateNames::class));
 	foreach(Utils::stringifyKeys($data->seenStateValues) as $state => $values){
-		$constName = mb_strtoupper($state, 'US-ASCII');
+		$constName = mb_strtoupper(preg_replace("/^minecraft:/", "mc_", $state) ?? throw new AssumptionFailedError("This regex is not invalid"), 'US-ASCII');
 		fwrite($output, "\tpublic const $constName = \"$state\";\n");
 	}
 
@@ -158,7 +159,7 @@ function generateBlockStringValues(BlockPaletteReport $data) : void{
 				continue;
 			}
 			$anyWritten = true;
-			$constName = mb_strtoupper($stateName . "_" . $value, 'US-ASCII');
+			$constName = mb_strtoupper(preg_replace("/^minecraft:/", "mc_", $stateName) . "_" . $value, 'US-ASCII');
 			fwrite($output, "\tpublic const $constName = \"$value\";\n");
 		}
 		if($anyWritten){

build/generate-item-type-names.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\build\generate_item_serializer_ids;
 
+use pocketmine\data\bedrock\item\BlockItemIdMap;
 use pocketmine\errorhandler\ErrorToExceptionHandler;
 use pocketmine\network\mcpe\convert\ItemTypeDictionaryFromDataHelper;
 use pocketmine\network\mcpe\protocol\serializer\ItemTypeDictionary;
@@ -45,10 +46,10 @@ function constifyMcId(string $id) : string{
 	return strtoupper(explode(":", $id, 2)[1]);
 }
 
-function generateItemIds(ItemTypeDictionary $dictionary) : void{
+function generateItemIds(ItemTypeDictionary $dictionary, BlockItemIdMap $blockItemIdMap) : void{
 	$ids = [];
 	foreach($dictionary->getEntries() as $entry){
-		if($entry->getNumericId() < 256){ //blockitems are serialized via BlockStateSerializer
+		if($entry->getStringId() === "minecraft:air" || $blockItemIdMap->lookupBlockId($entry->getStringId()) !== null){ //blockitems are serialized via BlockStateSerializer
 			continue;
 		}
 		$ids[$entry->getStringId()] = $entry->getStringId();
@@ -92,6 +93,7 @@ if($raw === false){
 }
 
 $dictionary = ItemTypeDictionaryFromDataHelper::loadFromString($raw);
-generateItemIds($dictionary);
+$blockItemIdMap = BlockItemIdMap::getInstance();
+generateItemIds($dictionary, $blockItemIdMap);
 
 echo "Done. Don't forget to run CS fixup after generating code.\n";

build/generate-runtime-enum-serializers.php

@@ -27,11 +27,12 @@ use pocketmine\block\utils\BellAttachmentType;
 use pocketmine\block\utils\CopperOxidation;
 use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\DirtType;
+use pocketmine\block\utils\DripleafState;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\FroglightType;
 use pocketmine\block\utils\LeverFacing;
+use pocketmine\block\utils\MobHeadType;
 use pocketmine\block\utils\MushroomBlockType;
-use pocketmine\block\utils\SkullType;
 use pocketmine\block\utils\SlabType;
 use pocketmine\item\MedicineType;
 use pocketmine\item\PotionType;
@@ -145,12 +146,13 @@ $enumsUsed = [
 	CopperOxidation::getAll(),
 	CoralType::getAll(),
 	DirtType::getAll(),
+	DripleafState::getAll(),
 	DyeColor::getAll(),
 	FroglightType::getAll(),
 	LeverFacing::getAll(),
 	MedicineType::getAll(),
 	MushroomBlockType::getAll(),
-	SkullType::getAll(),
+	MobHeadType::getAll(),
 	SlabType::getAll(),
 	SuspiciousStewType::getAll(),
 	PotionType::getAll()

changelogs/4.20.md

@@ -71,3 +71,9 @@ Released 6th May 2023.
 ## Fixes
 - Fixed players being forced into flight mode in every game mode.
   - Moral of the story: do not assume anything in Mojang internals does what its name suggests...
+
+# 4.20.5
+Released 30th May 2023.
+
+## Fixes
+- Fixed server crash due to a bug in upstream dependency [`netresearch/jsonmapper`](https://github.com/cweiske/JsonMapper).

changelogs/4.21.md

@@ -69,3 +69,9 @@ Released 17th May 2023.
 - Registered but ineligible ticking chunks are no longer rechecked every tick.
     - This was causing wasted cycles during async worker backlog.
     - The internal system must call `markTickingChunkForRecheck()` whenever a ticking chunk's eligibility for ticking has potentially changed, rather than just when it has changed from a yes to a no.
+
+# 4.21.1
+Released 30th May 2023.
+
+## Fixes
+- Fixed server crash due to a bug in upstream dependency [`netresearch/jsonmapper`](https://github.com/cweiske/JsonMapper).

changelogs/4.22.md

@@ -0,0 +1,58 @@
+# 4.22.0
+Released 7th June 2023.
+
+**For Minecraft: Bedrock Edition 1.20.0**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.0.
+
+**Plugin compatibility:** Plugins for previous 4.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## Interim releases
+If you're upgrading from 4.20.x directly to 4.22.x, please also read the following changelogs, as the interim releases contain important changes:
+- [4.21.0](https://github.com/pmmp/PocketMine-MP/blob/4.22.0/changelogs/4.21.md#4210) - PHP 8.1 minimum version, minor performance improvements
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.0.
+- Removed support for older versions.
+
+## Fixes
+- Removed deprecated `ReflectionProperty::setAccessible()` calls.
+- Fixed jukebox music not stopping when destroyed by an explosion.
+
+# 4.22.1
+Released 9th June 2023.
+
+## Fixes
+- Replaced workaround for an old teleporting client bug:
+  - This workaround broke due to an additional client bug introduced by 1.20, causing players to become frozen to observers when teleported.
+  - The original client bug has still not been fixed, meaning a new workaround was needed, but no perfect solution could be found.
+  - The new workaround involves broadcasting teleport movements as regular movements, which causes unwanted interpolation between the old and new positions, but otherwise works correctly. This solution is not ideal, but it is the best we can do for now.
+  - See issues [#4394](https://github.com/pmmp/PocketMine-MP/issues/4394) and [#5810](https://github.com/pmmp/PocketMine-MP/issues/5810) for more details.
+
+# 4.22.2
+Released 1st July 2023.
+
+## Changes
+- Added obsoletion warnings to the server log at the end of the startup sequence.
+
+## Fixes
+- Fixed players being disconnected en masse with "Not authenticated" messages.
+  - This occurred due to a check intended to disable the old authentication key after July 1st.
+  - We expected that the new key would have been deployed by Mojang by now, but it seems like that has not yet happened.
+  - Due to the lack of a hard date for the key changeover, we guessed that July 1st would be a safe bet, but this appears to have backfired.
+  - This version will accept both old and new keys indefinitely.
+  - A security release will be published to remove the old key after the transition occurs.
+
+# 4.22.3
+Released 11th July 2023.
+
+## Fixes
+- Fixed mishandling of NBT leading to a server crash when editing signs.
+- Fixed an edge case crash that could occur in `AsyncTask->__destruct()` when thread-local storage referenced other `AsyncTask` objects.
+
+## Internals
+- Added a concurrency lock to prevent the `update-updater-api` GitHub Action from running for multiple releases at the same time (which would have caused one of them to fail due to git conflicts).

changelogs/4.23.md

@@ -0,0 +1,51 @@
+# 4.23.0
+Released 12th July 2023.
+
+**For Minecraft: Bedrock Edition 1.20.10**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.10.
+
+**Plugin compatibility:** Plugins for previous 4.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.10.
+- Removed support for older versions.
+
+## Fixes
+- Fixed Docker image build failure due to outdated `build/php` submodule.
+
+# 4.23.1
+Released 14th July 2023.
+
+## Fixes
+- Hardened validation of JWT signing keys in `LoginPacket`.
+- Fixed server crash due to a bug in upstream dependency [`netresearch/jsonmapper`](https://github.com/cweiske/JsonMapper).
+
+# 4.23.2
+Released 18th July 2023.
+
+## Fixes
+- Fixed login errors due to a new `sandboxId` field appearing in the Xbox Live authentication data in `LoginPacket`. All clients, regardless of version, are affected by this change.
+
+# 4.23.3
+Released 24th July 2023.
+
+## Documentation
+- Fixed typo in `ChunkSelector::selectChunks()` documentation.
+
+## Fixes
+- Fixed the server not stopping properly during crash conditions on *nix platforms.
+- Fixed `HORSE_EQUIP` and `SMITHING_TABLE_TEMPLATE` container UI types not being handled by `ItemStackContainerIdTranslator`. This bug prevented plugins from implementing missing inventory types.
+- Player emotes no longer broadcast messages to other players. This was unintended behaviour caused by a client-side behavioural change.
+- Shulker boxes no longer support the placement of torches or other similar blocks.
+- Fire can now be placed on upper slabs and the top of upside-down stairs.
+
+# 4.23.4
+Released 1st August 2023.
+
+## Fixes
+- Fixed exponentially increasing lag when many hundreds of non-mergeable dropped items occupied the same space. This disproportionately affected SkyBlock servers due to large cactus farms using water to collect items together. 

changelogs/5.0-beta.md

@@ -194,3 +194,22 @@ Released 17th May 2023.
 - `RuntimeBlockMapping` has been renamed to `BlockTranslator`.
 - Singletons in the `pocketmine\network\mcpe\convert` package have been centralized under `TypeConverter`. In the future, this will be injected where needed, allowing different converters to be used for different sessions (useful for multiversion).
 - Overriding of serializers and deserializers of items and blocks is now consistently disallowed. Due to the lack of a good reason to allow overriding built-in blocks and items, this is no longer allowed.
+
+# 5.0.0-BETA4
+Released 23rd May 2023.
+
+## General
+- [`ext-pmmpthread` version 6.0.0](https://github.com/pmmp/ext-pmmpthread/releases/6.0.0) (renamed from `ext-pthreads`) is now required. This version has API changes compared to pthreads v5. Please read the linked changelog for details.
+- [`pocketmine/snooze` version 0.5.0](https://github.com/pmmp/Snooze/releases/0.5.0) is now required.
+- `pocketmine/classloader` and `pocketmine/log-pthreads` packages have been removed. The relevant classes from these packages are now included in-house in the `pocketmine/thread` namespace.
+  - `BaseClassLoader` is replaced with `pocketmine\thread\ThreadSafeClassLoader`
+  - `ThreadedLogger` is replaced by `pocketmine\thread\ThreadSafeLogger`
+  - `AttachableThreadedLogger` is replaced by `pocketmine\thread\AttachableThreadSafeLogger`
+  - `ThreadedLoggerAttachment` is replaced by `pocketmine\thread\ThreadSafeLoggerAttachment`
+
+## Fixes
+- Fixed crash on unknown blocks due to late initialization of properties in `UnknownBlock`.
+
+## API changes
+### `pocketmine\scheduler`
+- `AsyncTask->setResult()` now works with thread-safe objects. This was previously not possible due to limitations in the `pthreads` extension.

changelogs/5.0.md

@@ -0,0 +1,791 @@
+# 5.0.0
+Released 1st June 2023.
+
+**For Minecraft: Bedrock Edition 1.19.80**
+
+5.0.0 is a major feature update to PocketMine-MP, including support for Bedrock worlds from 1.13 onwards, a large array of new blocks and items, and various changes to the plugin API.
+
+It is **not** compatible with plugins written for 4.x.y, and plugins may require code changes to work with it.
+
+**As this changelog is quite large, its accuracy and completeness cannot be guaranteed.**
+Make sure you're looking at the [latest revision](https://github.com/pmmp/PocketMine-MP/blob/stable/changelogs/5.0.md), as it may be amended after release.
+
+## Core
+- Worlds are now saved according to the Bedrock 1.19.80 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.
+- Commands are now enabled by default in worlds exported from PocketMine-MP to Bedrock.
+
+## Build system
+- `build/generate-block-serializer-consts.php` has been added to generate `BlockTypeNames`, `BlockStateNames` and `BlockStateStringValues` in the `pocketmine\data\bedrock\block` package.
+- `build/generate-item-type-names.php` has been added to generate `ItemTypeNames` in the `pocketmine\data\bedrock\item` package.
+- `build/generate-runtime-enum-serializers.php` has been added to generate `RuntimeEnumSerializer`, `RuntimeEnumSerializerTrait`, and `RuntimeEnumSizeCalculatorTrait` in `pocketmine\data\runtime` package.
+
+## Localization
+- Localized disconnect messages are now used in the following cases:
+  - Server full
+  - Player not on the server whitelist
+  - Player on the server ban list
+  - Invalid skin
+  - Invalid username
+  - Kicked using `/kick`
+  - Banned using `/ban`
+  - Failure to find a safe spawn position
+- Session open, session close and session player name discovery messages are now localized.
+- All permissions now have localized descriptions. These are not currently used by PocketMine-MP, but may be useful for plugins.
+
+## Performance
+- Improved performance of dropping block inventory contents when the block is destroyed.
+- Improved light propagation performance by 10-15%.
+- [`ext-pmmpthread` version 6.0.0](https://github.com/pmmp/ext-pmmpthread/releases/tag/6.0.0) is now used, featuring significant performance improvements for thread-safe objects and various threading use-cases.
+
+## 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)
+  - `generate-bedrock-data-from-packets.php` - generates various files for [BedrockData](https://github.com/pmmp/BedrockData)
+    - This script accepts a txt file containing base64-encoded packet dumps.
+    - This script has been in use for several years, but has only now been open-sourced.
+    - It's used to generate data such as crafting recipes, creative inventory data, and various other blobs of data needed to support the current version of Minecraft: Bedrock Edition.
+
+## Gameplay
+### Blocks
+- Added the following new blocks:
+  - Amethyst Block
+  - Ancient Debris
+  - Azalea Leaves
+  - Basalt
+  - Blackstone blocks, slabs, stairs, and walls
+  - Cakes with Candle & Dyed Candle
+  - Calcite
+  - Candle & Dyed Candle
+  - Cartography Table (not currently usable due to maps not being implemented)
+  - Cauldron
+  - Cave Vines
+  - Chain
+  - Chiseled Deepslate
+  - Chiseled Nether Bricks
+  - Chiseled Polished Blackstone
+  - Chorus Flower
+  - Chorus Plant
+  - Cobbled Deepslate blocks, slabs, stairs, and walls
+  - Copper Ore
+  - Copper block (random oxidation not yet implemented)
+  - Crached Deepslate Tiles
+  - Cracked Deepslate Bricks
+  - Cracked Nether Bricks
+  - Cracked Polished Blackstone Bricks
+  - Crimson buttons, doors, fences, fence gates, hyphae, planks, pressure plates, signs, slabs, stairs, stems, and trapdoors
+  - Crying Obsidian
+  - Cut Copper block, stairs and slabs (random oxidation not yet implemented)
+  - 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
+  - Flowering Azalea Leaves
+  - Froglight (pearlescent, verdant, ochre)
+  - Gilded Blackstone
+  - Glow Item Frame
+  - Hanging Roots
+  - Honeycomb Block
+  - Light Block
+  - Lightning Rod
+  - Mangrove Leaves
+  - Mangrove Roots
+  - Mangrove buttons, doors, fences, fence gates, logs, planks, pressure plates, signs, slabs, stairs, trapdoors, and wood
+  - Mud Bricks blocks, slabs, stairs, and walls
+  - Muddy Mangrove Roots
+  - Nether Gold Ore
+  - Netherite Block
+  - Polished Basalt
+  - Polished Blackstone Bricks blocks, slabs, stairs, and walls
+  - Polished Blackstone blocks, buttons, pressure plates, slabs, stairs, and walls
+  - Polished Deepslate blocks, slabs, stairs, and walls
+  - Quartz Bricks
+  - Reinforced Deepslate
+  - Rooted Dirt
+  - Sculk
+  - Shroomlight
+  - Smithing Table
+  - Smooth Basalt
+  - Soul Fire
+  - Soul Lantern
+  - Soul Soil
+  - Soul Torch
+  - Spore Blossom
+  - Tinted Glass
+  - Tuff
+  - Twisting Vines
+  - Warped Wart Block
+  - Warped buttons, doors, fences, fence gates, hyphae, planks, pressure plates, signs, slabs, stairs, stems, and trapdoors
+  - Weeping Vines
+  - Wither Rose
+- Added support for basalt generators
+- Added support for dyeing sign text and making it glow.
+- All-sided logs ("wood", for want of a better name) can now be placed in X, Y, and Z orientations.
+- Coral and coral fans now behave correctly when placed out of water (they no longer immediately die).
+- Fixed dead bush being able to be placed on some invalid blocks (e.g. stone).
+- Fixed lava setting entities on fire for an incorrect duration (Java vs Bedrock inconsistency).
+- Fixed sugarcane not being able to be placed on some blocks.
+- 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.
+- Stripping logs by right-clicking them with an axe is now supported.
+- TNT can now be ignited by fire charges.
+- Vines can now only be placed on the side of full-cube blocks.
+- Walls now connect when placed, following the pre-1.16 logic. (1.16 logic is planned to be implemented, but currently low priority.)
+- Anvils are now damaged when they hit the ground after falling.
+- Added missing sounds for anvils hitting the ground after falling.
+- Anvils now damage entities when they fall on top of them.
+
+### Items
+- Added the following new items:
+  - Amethyst Shard
+  - Antidote (from Education Edition)
+  - Copper Ingot
+  - Disc Fragment (5)
+  - Echo Shard
+  - Elixir (from Education Edition)
+  - Eye Drops (from Education Edition)
+  - Fire Charge
+  - Glow Berries
+  - Glow Ink Sac
+  - Honey Bottle
+  - Honeycomb
+  - Mangrove Boat (incomplete)
+  - Music Disc (5)
+  - Music Disc (Otherside)
+  - Music Disc (Pigstep)
+  - Netherite Axe
+  - Netherite Boots
+  - Netherite Chestplate
+  - Netherite Helmet
+  - Netherite Ingot
+  - Netherite Leggings
+  - Netherite Pickaxe
+  - Netherite Scrap
+  - Netherite Shovel
+  - Netherite Sword
+  - Phantom Membrane
+  - Raw Copper
+  - Raw Gold
+  - Raw Iron
+  - Spyglass
+  - Suspicious Stew
+  - Tonic (from Education Edition)
+- Glass bottles can now be filled with water by clicking on a water source block.
+- Implemented Swift Sneak enchantment.
+- Armour durability is now only reduced when the wearer receives a type of damage that the armour can protect against.
+- Bells now ring when hit by a projectile.
+
+### Worlds
+- World height of -64 to 319 is now supported.
+- Added support for 3D biomes. This isn't used by PocketMine-MP yet, but is necessary to be able to fully load 1.18 worlds.
+
+## API
+### General
+- Union and mixed native parameter, return and property types are now used where appropriate.
+- 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.
+
+### Dependencies
+- [`ext-pmmpthread` version 6.0.0](https://github.com/pmmp/ext-pmmpthread/releases/6.0.0) (renamed from `ext-pthreads`) is now required. This version features major API changes and improvements. Please read the [upgrading guide](https://github.com/pmmp/ext-pmmpthread/blob/fork/docs/UPGRADING_4.x_to_6.0.md) for details.
+- [`pocketmine/snooze` version 0.5.0](https://github.com/pmmp/Snooze/releases/0.5.0) is now required.
+- [`pocketmine/raklib` version 0.15.0](https://github.com/pmmp/RakLib/releases/0.15.0) is now required.
+- [`pocketmine/raklib-ipc` version 0.2.0](https://github.com/pmmp/RakLibIpc/releases/0.2.0) is now required.
+- `pocketmine/classloader` and `pocketmine/log-pthreads` packages have been removed. The relevant classes from these packages are now included in-house in the `pocketmine/thread` namespace.
+  - `BaseClassLoader` is replaced with `pocketmine\thread\ThreadSafeClassLoader`
+  - `ThreadedLogger` is replaced by `pocketmine\thread\ThreadSafeLogger`
+  - `AttachableThreadedLogger` is replaced by `pocketmine\thread\AttachableThreadSafeLogger`
+  - `ThreadedLoggerAttachment` is replaced by `pocketmine\thread\ThreadSafeLoggerAttachment`
+- `webmozart/path-util` has been removed (replaced by [`symfony/filesystem`](https://github.com/symfony/filesystem)).
+
+### `pocketmine\block`
+#### Highlights
+- 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**. **Do not store them in configs or databases**, as they are subject to
+    change without warning.
+  - Block type IDs are **specific to PocketMine-MP** and have no relation to the IDs used by Minecraft.
+  - Block type IDs cannot be negative
+  - Block type IDs must not be reused, even if overriding an already defined block
+- 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:
+  - Block-item state properties - retained by items when the block is broken (colour, wet/dry, coral type, etc.) - handled by `Block->describeBlockItemState()`
+  - Block-only state data - discarded when the block is broken (facing direction, lit/unlit, powered/unpowered, etc.) - handled by `Block->describeBlockOnlyState()`
+- Chunks now store dynamic state ID derived from the runtime type ID and runtime (PocketMine-MP defined) state data.
+- 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.
+- `&$returnedItems` reference parameter is now used in some places such as `Block->onInteract()` 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.
+- Dependency between `RuntimeBlockStateRegistry` (previously `BlockFactory`) and `VanillaBlocks` has been inverted.
+  - Now, blocks types are defined in `VanillaBlocks`
+  - `RuntimeBlockStateRegistry` automatically registers states for blocks defined in `VanillaBlocks`.
+  - Manual registration in `RuntimeBlockStateRegistry` is still required for custom blocks (see section below about registering new blocks).
+- `RuntimeBlockStateRegistry` now has only one purpose - to map internal blockstate IDs to `Block` objects when reading blocks from chunks. It should not be used by plugins unless registering new blocks.
+  - 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 `RuntimeBlockStateRegistry::fromStateId()` to get a `Block` instance
+  - Prefer using `StringToItemParser` wherever possible for configs and databases (see `lookupAliases()` and `lookupBlockAliases()`).
+
+#### Registering new blocks
+##### In a plugin
+To add a vanilla block in a plugin which isn't yet supported by PocketMine-MP, do the following:
+
+1. Get a new type ID using `BlockTypeIds::newId()` - _you'll want to keep this in a property somewhere if you want to
+   compare using `getTypeId()` later_
+2. Set up the block type somewhere - _this can be anywhere you like, e.g. a plugin main class property, but using
+   a `RegistryTrait` class is recommended - you'll need this later to create new instances of the block_
+3. Register the block in `RuntimeBlockStateRegistry` - _this informs the server of all the block's possible states so
+   that it can be read from chunks at runtime_
+4. Register a deserializer for the block's Minecraft ID in `BlockStateToObjectDeserializer` - _needed for the block to
+   be recognized when loaded from disk_
+5. Register a serializer for the block in `BlockObjectToStateSerializer` - _needed for the block to be saved to disk,
+   and to be sent over the network_
+6. Optionally, register a string alias for the block in `StringToItemParser` - _so that it can be given via `/give`_
+
+To see a demo of how to do this in a plugin, see [this example plugin](https://github.com/pmmp/RegisterBlocksDemoPM5).
+
+Registering custom blocks follows a similar process, but requires additional steps to modify `BlockStateDictionary`
+which won't be covered here.
+Since this is not currently officially supported by PocketMine-MP, this won't be covered here.
+
+This is admittedly rather more of a hassle than in PM4, but this system offers significantly more flexibility than the
+old system.
+
+##### As a PocketMine-MP core contribution
+To register a new vanilla block into the core, the process is slightly different:
+
+1. Instead of using `BlockTypeIds::newId()`, add a new constant for the block to `BlockTypeIds`
+2. Register the new block in `VanillaBlocks` - `RuntimeBlockStateRegistry` will automagically take notice of all blocks
+   defined in `VanillaBlocks`
+3. Follow steps 4 onwards above
+
+#### Change list
+- The following classes have been removed:
+  - `BlockIdentifierFlattened`
+  - `BlockLegacyIdHelper`
+  - `BlockLegacyIds`
+  - `BlockLegacyMetadata`
+  - `utils\BlockDataSerializer`
+  - `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
+- The following classes have been renamed:
+  - `BlockFactory` -> `RuntimeBlockStateRegistry` - this class is now exclusively used for mapping state IDs to block instances for runtime chunk block reading
+  - `Skull` -> `MobHead`
+  - `utils\SkullType` -> `utils\MobHeadType`
+  - `utils\TreeType` -> `pocketmine\world\generator\object\TreeType`
+- The following classes have been added:
+  - `BaseCake`
+  - `BaseFire`
+  - `BlockTypeIds` - list of type IDs, one for each entry in `VanillaBlocks`
+  - `BlockTypeInfo`
+  - `BlockTypeTags`
+  - `CakeWithCandle`
+  - `CakeWithDyedCandle`
+  - `Candle`
+  - `CartographyTable`
+  - `Chain`
+  - `CopperOre`
+  - `CopperSlab`
+  - `CopperStairs`
+  - `Copper`
+  - `DyedCandle`
+  - `GildedBlackstone`
+  - `GoldOre`
+  - `HangingRoots`
+  - `IronOre`
+  - `Light`
+  - `LightningRod`
+  - `NetherGoldOre`
+  - `Sculk`
+  - `SmithingTable`
+  - `SoulFire`
+  - `WitherRose`
+  - `utils\CandleTrait`
+  - `utils\CopperOxidation`
+  - `utils\CopperTrait`
+  - `utils\SaplingType` - enum of all sapling types
+  - `utils\WallConnectionType` - enum of all possible wall connection types
+  - `utils\WoodTypeTrait`
+  - `utils\WoodType` - enum of all possible wood types, used for wood material blocks like planks and logs
+- 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->getStateBitmask()`
+  - `Block->readStateFromData()`
+  - `Block->writeStateToItemMeta()`
+  - `Block->writeStateToMeta()`
+  - `BlockFactory->get()` - see notes above about `RuntimeBlockStateRegistry`
+  - `BlockIdentifier->getAllBlockIds()`
+  - `BlockIdentifier->getBlockId()`
+  - `BlockIdentifier->getItemId()`
+  - `BlockIdentifier->getVariant()`
+  - `Door->isPowered()`
+  - `Door->setPowered()`
+  - `MobHead->isNoDrops()` (previously `Skull->isNoDrops()`)
+  - `MobHead->setNoDrops()` (previously `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
+  - `utils\MobHeadType->getMagicNumber()` (previously `utils\SkullType->getMagicNumber()`)
+  - `utils\MobHeadType::fromMagicNumber()` (previously `utils\SkullType::fromMagicNumber()`)
+- The following constants have been removed:
+  - `Block::INTERNAL_METADATA_BITS`
+  - `Block::INTERNAL_METADATA_MASK`
+- The following API methods have been renamed:
+  - `Block->getFullId()` -> `Block->getStateId()`
+  - `Block->isSameType()` -> `Block->hasSameTypeId()`
+  - `MobHead->getSkullType()` -> `MobHead->getMobHeadType()` (previously `Skull->getSkullType()`)
+  - `MobHead->setSkullType()` -> `MobHead->setMobHeadType()` (previously `Skull->setSkullType()`)
+- The following API methods have signature changes:
+  - `Block->onBreak()` now accepts `array<Item> &$returnedItems` reference parameter.
+  - `Block->onInteract()` 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.
+  - `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`
+  - `Leaves->__construct()` now accepts `LeavesType $leavesType` instead of `TreeType $treeType`
+  - `RuntimeBlockStateRegistry->register()` no longer accepts an `$override` parameter.
+  - `Sapling::__construct()` now accepts `SaplingType $saplingType` instead of `TreeType $treeType`
+  - `utils\SignText::__construct()` now accepts two new optional parameters: `?Color $baseColor` and `bool $glowing`
+  - `utils\SignText::fromBlob()` now accepts two new optional parameters: `?Color $baseColor` and `bool $glowing`
+- The following API methods have been added:
+  - `protected Block->describeBlockOnlyState(RuntimeDataDescriber $w) : void` - describes state properties which are discarded when the block is broken or block-picked, such as facing, powered, etc.
+  - `public Block->describeBlockItemState(RuntimeDataDescriber $w) : void` - describes state properties which are kept by the item when the block is broken or block-picked, such as dye color
+  - `public Block->generateStatePermutations() : \Generator<int, Block, void, void>` - yields all possible states this block type can be in (used for `RuntimeBlockStateRegistry`)
+  - `public Block->getTypeTags() : array<string>`
+  - `public Block->hasTypeTag(string $tag) : bool`
+  - `public Block->isFireProofAsItem() : bool`
+  - `public Block->onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void`
+  - `public BlockIdentifier->getBlockTypeId() : int` - returns the block's type ID according to `BlockTypeIds`
+  - `public Furnace->getFurnaceType() : utils\FurnaceType`
+  - `public GlazedTerracotta->getColor() : utils\DyeColor` (from `ColoredTrait`) - this was previously unsupported due to legacy limitations
+  - `public GlazedTerracotta->setColor(utils\DyeColor $color) : $this` (from `ColoredTrait`) - this was previously unsupported due to legacy limitations
+  - `public Leaves->getLeavesType() : utils\LeavesType` - returns the type of leaves
+  - `public Wall->getConnection(int $face) : utils\WallConnectionType`
+  - `public Wall->getConnections() : array<int, utils\WallConnectionType>` - returns the wall's connections and their types (see `utils\WallConnectionType`)
+  - `public Wall->isPost() : bool`
+  - `public Wall->setConnection(int $face, ?utils\WallConnectionType $type) : $this`
+  - `public Wall->setConnections()` - sets the wall's connections and their types (see `utils\WallConnectionType`)
+  - `public Wall->setPost(bool $post) : $this`
+  - `public Wood->isStripped() : bool`
+  - `public Wood->setStripped(bool $stripped) : $this`
+  - `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 tile\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 utils\SignText->getBaseColor() : \pocketmine\color\Color`
+  - `public utils\SignText->isGlowing() : bool`
+- 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`
+- The following API interface requirements have been added (BC breaking):
+  - `public utils\Fallable->getFallDamagePerBlock() : float` (default implementation provided by `utils\FallableTrait`)
+  - `public utils\Fallable->getLandSound() : ?Sound` (default implementation provided by `utils\FallableTrait`)
+  - `public utils\Fallable->getMaxFallDamage() : float` (default implementation provided by `utils\FallableTrait`)
+  - `public utils\Fallable->onHitGround(FallingBlock $blockEntity) : bool` (default implementation provided by `utils\FallableTrait`)
+
+### `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.
+- `SimpleCommandMap` now requires all commands to have a permission set when registered.
+  - If you actually want to allow everyone to use your command (not advised), you can add a new permission to the `pocketmine.group.user` group, or use `default: true` for `plugin.yml` permissions.
+- The following API methods have changed behaviour:
+  - `Command->testPermissionSilent()` now returns `false` if there are no permissions associated with the command. This is to prevent commands with no permissions being usable by everyone, which has previously been a source of security issues.
+- The following API methods have been added:
+  - `public Command->getPermissions() : list<string>` - returns a list of permissions which grant usage access to this command. A user with one or more of these permissions will be able to invoke the command's `execute()` method
+  - `public Command->setPermissions(list<string> $permissions) : void` - sets the permissions which grant usage access to this command. This should be used instead of `setPermission()` with `;` separators (which is now deprecated)
+
+### `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`
+- The following classes have been added:
+  - `ExactRecipeIngredient` - matches an exact item
+  - `MetaWildcardRecipeIngredient` - matches an item with the given legacy Minecraft ID, but any metadata value
+  - `RecipeIngredient` interface
+  - `TagWildcardRecipeIngredient` - matches an item based on its Minecraft tags, e.g. `minecraft:wooden_tier`
+- 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()` `$type` parameter is now mandatory.
+  - `ShapelessRecipe->__construct()` now accepts `RecipeIngredient` instead of `Item`
+  - `ShapelessRecipe->getIngredientList()` now returns `RecipeIngredient[]` instead of `Item[]`
+
+### `pocketmine\data`
+- New packages `bedrock\block` and `bedrock\item` have been added. These packages contain all the necessary code for loading and saving Bedrock blocks and items from disk.
+- New package `runtime` has been added. This package contains code for serializing runtime data for blocks and items.
+- `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
+
+### `pocketmine\entity`
+- `Entity` now declares new abstract methods which must be implemented by subclasses:
+  - `public Entity->getInitialDragMultiplier() : float`
+  - `public Entity->getInitialGravity() : float`
+- The following new API methods have been added:
+  - `public Living->getDisplayName() : string`
+- The following API methods have changed signatures:
+  - `EntityFactory->register()` no longer accepts a `$legacyMcpeSaveId` parameter (now handled by internal conversions instead).
+- The following API methods have been renamed:
+  - `Entity->isImmobile()` -> `Entity->hasNoClientPredictions()`
+  - `Entity->setImmobile()` -> `Entity->setNoClientPredictions()`
+- The following internal fields have been renamed:
+  - `Entity->immobile` -> `Entity->noClientPredictions`
+- The following classes have been removed:
+  - `EntityLegacyIds`
+
+### `pocketmine\event`
+- The following classes have inheritance changes:
+  - `block\BlockPlaceEvent` no longer extends `BlockEvent`, and therefore no longer has `getBlock()`. Use `getTransaction()` instead (may contain multiple blocks).
+- `BlockFormEvent` now includes information about the block which caused the event.
+
+- The following new classes have been added:
+  - `world\WorldDisplayNameChangeEvent` - called when a world's display name is changed
+- The following classes have been renamed:
+  - `entity\ExplosionPrimeEvent` -> `entity\EntityPreExplodeEvent`
+- The following API methods have been added:
+  - `public block\BlockFormEvent->getCausingBlock() : Block`
+  - `public block\BlockGrowEvent->getPlayer() : ?Player` - returns the player that triggered the block growth, or `null` if it was not triggered by a player
+  - `public block\BlockPlaceEvent->getTransaction() : BlockTransaction` - returns the transaction containing a list of changed block positions and the blockstates they will be changed to
+  - `public server\DataPacketSendEvent->setPackets(list<ClientboundPacket> $packets) : void`
+- The following API methods have changed signatures:
+  - `block\BlockPlaceEvent->__construct()` now accepts `BlockTransaction $transaction` instead of `Block $blockPlace, Block $blockReplace`
+  - `entity\EntityPreExplodeEvent->__construct()` has the `$force` parameter renamed to `$radius`
+  - `entity\EntityPreExplodeEvent->getForce() : float` -> `entity\EntityPreExplodeEvent->getRadius() : float`
+  - `entity\EntityPreExplodeEvent->setForce(float $force) : void` -> `entity\EntityPreExplodeEvent->setRadius(float $radius) : void`
+- The following API methods have been removed:
+  - `block\BlockPlaceEvent->getBlockReplaced()` - this information is now provided in the `BlockTransaction` object returned by `BlockPlaceEvent->getTransaction()`
+- The following new API constants have been added:
+  - `entity\EntityDamageEvent::CAUSE_FALLING_BLOCK`
+  - `entity\EntityDamageEvent::MODIFIER_ARMOR_HELMET`
+
+### `pocketmine\event\player`
+- `PlayerPreLoginEvent`, `PlayerDuplicateLoginEvent` and `PlayerKickEvent` now supports setting separate log reasons (disconnect reason) and disconnect screen messages.
+- The following classes have been removed:
+  - `PlayerCommandPreprocessEvent`
+- The following API methods have changed signatures:
+  - `PlayerDuplicateLoginEvent->getDisconnectMessage()` now returns `Translatable|string` instead of `string`
+  - `PlayerDuplicateLoginEvent->setDisconnectMessage()` now accepts `Translatable|string` instead of `string`
+  - `PlayerKickEvent->getReason()` now returns `Translatable|string` instead of `string`
+  - `PlayerKickEvent->setReason()` now accepts `Translatable|string` instead of `string`
+  - `PlayerLoginEvent->getKickMessage()` now returns `Translatable|string` instead of `string`
+  - `PlayerLoginEvent->setKickMessage()` now accepts `Translatable|string` instead of `string`
+  - `PlayerPreLoginEvent->getFinalKickMessage()` now returns `Translatable|string` instead of `string`
+  - `PlayerPreLoginEvent->getKickMessage()` now returns `Translatable|string|null` instead of `string|null`
+  - `PlayerPreLoginEvent->setKickFlag()` (previously `setKickReason()`) now accepts `Translatable|string $disconnectReason, Translatable|string|null $disconnectScreenMessage = null` instead of `Translatable|string $message`
+  - `PlayerPreLoginEvent->setKickReason()` now accepts `Translatable|string` for the `$message` parameter instead of `string`
+  - `PlayerQuitEvent->getQuitReason()` now returns `Translatable|string` instead of `string`
+- The following API methods have been removed:
+  - `PlayerChatEvent->getFormat()` (use `PlayerChatEvent->getChatFormatter()` instead)
+  - `PlayerChatEvent->setFormat()` (use `PlayerChatEvent->setChatFormatter()` instead)
+  - `PlayerDuplicateLoginEvent->getDisconnectMessage()` - replaced by `getDisconnectReason()` and `getDisconnectScreenMessage()`
+  - `PlayerDuplicateLoginEvent->setDisconnectMessage()` - replaced by `setDisconnectReason()` and `setDisconnectScreenMessage()`
+  - `PlayerKickEvent->getReason()` - replaced by `getDisconnectReason()` and `getDisconnectScreenMessage()`
+  - `PlayerKickEvent->setReason()` - replaced by `setDisconnectReason()` and `setDisconnectScreenMessage()`
+- The following new API methods have been added:
+  - `public PlayerChatEvent->getChatFormatter() : \pocketmine\player\chat\ChatFormatter` - returns the chat formatter to be used for this event
+  - `public PlayerChatEvent->setChatFormatter(\pocketmine\player\chat\ChatFormatter $formatter) : void` - sets the chat formatter to be used for this event
+  - `public PlayerDeathEvent->getDeathScreenMessage() : Translatable|string` - returns the message to be displayed on the death screen
+  - `public PlayerDeathEvent->setDeathScreenMessage(Translatable|string $deathScreenMessage) : void` - sets the message to be displayed on the death screen
+  - `public PlayerDuplicateLoginEvent->getDisconnectReason() : Translatable|string` - returns the reason for the disconnection displayed in the console and server log
+  - `public PlayerDuplicateLoginEvent->getDisconnectScreenMessage() : Translatable|string|null` - returns the message to be displayed on the disconnect screen (the message in `getDisconnectReason()` is used if null is returned)
+  - `public PlayerDuplicateLoginEvent->setDisconnectReason(Translatable|string $disconnectReason) : void` - sets the reason for the disconnection displayed in the console and server log
+  - `public PlayerDuplicateLoginEvent->setDisconnectScreenMessage(Translatable|string|null $disconnectScreenMessage) : void` - sets the message to be displayed on the disconnect screen (the message in `setDisconnectReason()` is used if null is passed)
+  - `public PlayerKickEvent->getDisconnectReason() : Translatable|string` - returns the reason for the disconnection displayed in the console and server log
+  - `public PlayerKickEvent->getDisconnectScreenMessage() : Translatable|string|null` - returns the message to be displayed on the disconnect screen (the message in `getDisconnectReason()` is used if null is returned)
+  - `public PlayerKickEvent->setDisconnectReason(Translatable|string $disconnectReason) : void` - sets the reason for the disconnection displayed in the console and server log
+  - `public PlayerKickEvent->setDisconnectScreenMessage(Translatable|string|null $disconnectScreenMessage) : void` - sets the message to be displayed on the disconnect screen (the message in `setDisconnectReason()` is used if null is passed)
+  - `public PlayerPreLoginEvent->getDisconnectScreenMessage(int $flag) : Translatable|string|null` - returns the message to be displayed on the disconnect screen for the specified kick flag, if set
+  - `public PlayerPreLoginEvent->getFinalDisconnectScreenMessage() : Translatable|string|null` - returns the message to be displayed on the disconnect screen, taking into account the kick flags set
+- The following classes have inheritance changes:
+  - `PlayerPreLoginEvent` no longer implements `Cancellable`. This caused unexpected behaviour for most plugin devs due to default-ignoring cancelled events, forcing people to usually have to use `@handleCancelled` to handle the event when they wanted to use it.
+- The following API constants have been renamed:
+  - `PlayerPreLoginEvent::KICK_REASON_BANNED` -> `PlayerPreLoginEvent::KICK_FLAG_BANNED`
+  - `PlayerPreLoginEvent::KICK_REASON_PLUGIN` -> `PlayerPreLoginEvent::KICK_FLAG_PLUGIN`
+  - `PlayerPreLoginEvent::KICK_REASON_PRIORITY` -> `PlayerPreLoginEvent::KICK_FLAG_PRIORITY`
+  - `PlayerPreLoginEvent::KICK_REASON_SERVER_FULL` -> `PlayerPreLoginEvent::KICK_FLAG_SERVER_FULL`
+  - `PlayerPreLoginEvent::KICK_REASON_SERVER_WHITELISTED` -> `PlayerPreLoginEvent::KICK_FLAG_SERVER_WHITELISTED`
+- The following API methods have been renamed:
+  - `PlayerPreLoginEvent->clearAllKickReasons()` -> `PlayerPreLoginEvent->clearAllKickFlags()`
+  - `PlayerPreLoginEvent->clearKickReason()` -> `PlayerPreLoginEvent->clearKickFlag()`
+  - `PlayerPreLoginEvent->getFinalKickMessage()` -> `PlayerPreLoginEvent->getFinalDisconnectReason()` (now used for logs only, if a disconnect screen message is set for the highest priority flag)
+  - `PlayerPreLoginEvent->getKickMessage()` -> `PlayerPreLoginEvent->getDisconnectReason()` (now used for logs only, if a disconnect screen message is set for the flag)
+  - `PlayerPreLoginEvent->getKickReasons()` -> `PlayerPreLoginEvent->getKickFlags()`
+  - `PlayerPreLoginEvent->isKickReasonSet()` -> `PlayerPreLoginEvent->isKickFlagSet()`
+  - `PlayerPreLoginEvent->setKickReason()` -> `PlayerPreLoginEvent->setKickFlag()`
+
+### `pocketmine\item`
+#### Highlights
+- `ItemFactory` has been removed. Vanilla item registration is now done via `VanillaItems`.
+  - 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 `SavedItemStackData`
+    2. Pass the itemstack data to `GlobalItemDataHandlers::getDeserializer()` to get an `Item` instance
+- 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.
+- `&$returnedItems` reference parameter is now used in some places (e.g. `onInteractBlock()`) 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.
+- Blocks which previously had separate items, such as mob heads and beds, no longer do. Their item form can be acquired using `Block->asItem()` in the same way as every other block. This is facilitated by the new serializer system.
+
+#### Implementing new items
+##### In a plugin
+This follows a similar process to registering blocks.
+
+1. Get a new type ID using `ItemTypeIds::newId()` - _you'll want to keep this in a property somewhere if you want to
+   compare using `getTypeId()` later_
+2. Set up the item type somewhere - _this can be anywhere you like, e.g. a plugin main class property, but using
+   a `RegistryTrait` class is recommended - you'll need this later to create new instances of the item_
+3. Register a deserializer in `ItemDeserializer` - _needed for the item to be recognized when loaded from disk_
+4. Register a serializer in `ItemSerializer` - _needed for the item to be saved to disk, and to be sent over the
+   network_
+5. Optionally, register a string alias for the item in `StringToItemParser` - _so that it can be given via `/give`_
+
+To see a demo of how to do this in a plugin, see [this example plugin](https://github.com/pmmp/RegisterBlocksDemoPM5).
+
+Again, it's acknowledged this is rather more cumbersome than it should be, but this is an ongoing process.
+
+##### As a PocketMine-MP core contribution
+
+To register a new vanilla item into the core, the process is slightly different:
+
+1. Instead of using `ItemTypeIds::newId()`, add a new constant for the block to `ItemTypeIds`
+2. Register the new item in `VanillaItems`
+3. Follow steps 3 onwards from the plugin instructions above
+
+#### 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.
+  - In addition, `jsonSerialize()` required the item to know about the method by which it will be serialized (since there is no way to inject context), 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.
+  - `Item::legacyJsonDeserialize()` (previously `Item::jsonDeserialize()`) is retained to allow loading legacy data, although it may be removed in the future.
+- The following classes have been removed:
+  - `Bed`
+  - `ItemFactory`
+  - `ItemIds`
+  - `Skull`
+- The following classes have been added:
+  - `BoatType` - enum of all boat types
+  - `CoralFan`
+  - `HoneyBottle`
+  - `MedicineType`
+  - `Medicine`
+  - `Spyglass`
+  - `SuspiciousStewType`
+  - `SuspiciousStew`
+- The following API methods have been added:
+  - `protected Item->describeState(RuntimeDataDescriber $w) : void` 
+  - `public Armor->clearCustomColor() : $this` - clears the custom color of an armor item
+  - `public ArmorTypeInfo->getToughness() : int`
+  - `public ArmorTypeInfo->isFireProof() : bool`
+  - `public Boat->getType() : BoatType`
+  - `public Dye->setColor(\pocketmine\block\utils\DyeColor $color) : $this`
+  - `public Item->getStateId() : int` - returns a runtime numeric state ID for comparisons including information such as coral type, dye color, etc. - DO NOT save this to disk or databases
+  - `public Item->getTypeId() : int` - returns a runtime numeric type ID for comparisons - DO NOT save this to disk or databases
+  - `public Item->isFireProof() : bool`
+  - `public ItemIdentifer->getTypeId() : int`
+  - `public Potion->setType(PotionType $type) : $this`
+  - `public SplashPotion->setType(PotionType $type) : $this`
+  - `public StringToItemParser->lookupAliases(Item $item) : list<string>` - returns a list of all registered aliases for the given item
+  - `public StringToItemParser->lookupBlockAliases(Block $block) : list<string>` - returns a list of all registered aliases for the given block
+  - `public static ItemIdentifier::fromBlock(Block $block) : self`
+- The following API methods have been removed:
+  - `Boat->getWoodType()`
+  - `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
+  - `ItemIdentifier->getId()`
+  - `ItemIdentifier->getMeta()`
+- The following API methods have been renamed:
+  - `Item::jsonDeserialize()` -> `Item::legacyJsonDeserialize()`
+- The following API methods have signature changes:
+  - `ArmorTypeInfo->__construct()` now accepts optional parameters `int $toughness` and `bool $fireProof`
+  - `BoatType::__construct()` now accepts `BoatType $boatType` instead of `TreeType $woodType`.
+  - `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.
+  - `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
+- The following API methods have behaviour changes:
+  - `Item->equals()`'s `$checkDamage` parameter is now ignored, as tool damage is now stored as an NBT tag. This parameter wasn't removed due to being followed by a second `bool` parameter, which would potentially end up in the wrong place and silently cause bugs in updated plugins.
+  - `Item->equals()`'s `$checkTags` parameter will now cause tool and armor damage to be checked if true.
+- The following enums have new members:
+  - `ToolTier` has new member `NETHERITE`
+
+### `pocketmine\network`
+- The following API methods have changed signatures:
+  - `NetworkSessionManager->close()` now accepts an additional `Translatable|string|null $disconnectScreenMessage` parameter.
+- The following API methods have changed signatures:
+  - `query\QueryInfo->getPlayerList()` now returns `list<string>` instead of `list<Player>`
+  - `query\QueryInfo->setPlayerList()` now accepts `list<string>` instead of `list<Player>`
+
+### `pocketmine\player`
+- The following API methods have changed signatures:
+  - `Player->disconnect()` now accepts `Translatable|string` for `$reason` instead of `string` (to allow localized disconnect messages)
+  - `Player->disconnect()` now accepts an additional `Translatable|string|null $disconnectScreenMessage` parameter, which is the message to be displayed on the disconnect screen (the message in `$reason` is used if null is passed)
+  - `Player->kick()` now accepts `Translatable|string` for `$reason` instead of `string` (to allow localized kick messages)
+  - `Player->kick()` now accepts an additional `Translatable|string|null $disconnectScreenMessage` parameter, which is the message to be displayed on the disconnect screen (the message in `$reason` is used if null is passed)
+  - `Player->sendJukeboxPopup()` now accepts `Translatable|string` instead of `string, string[]`
+- The following classes have been removed:
+  - `PlayerChunkLoader` - deprecated in 4.19.0 (this was technically internal, but never marked as such)
+
+### `pocketmine\player\chat`
+- The following new classes have been added:
+  - `ChatFormatter` - interface implemented by chat formatters - this is far more powerful than the old API
+  - `LegacyRawChatFormatter` - implements the same behaviour previously used by `PlayerChatEvent->setFormat()`
+  - `StandardChatFormatter` - formats chat messages in the vanilla Minecraft style
+
+### `pocketmine\scheduler`
+- `AsyncTask->setResult()` now works with thread-safe objects. This was previously not possible due to limitations in the `pthreads` extension.
+
+### `pocketmine\world`
+- The following API methods have been added:
+  - `public World->setDisplayName(string $name) : void`
+- The following API methods have changed signatures:
+  - `Explosion->__construct()` has the `$size` parameter renamed to `$radius`
+- The following public properties have been renamed:
+  - `Explosion->size` -> `Explosion->radius`
+
+### `pocketmine\world\format`
+- Chunks are now considered dirty (modified) by default, unless loaded from a `WorldProvider` by `World`. Previously, chunks were considered unmodified by default, which allowed several pathways to bugs.
+- The following classes have been added:
+  - `io\GlobalBlockStateHandlers` - gives access to block data serializer, deserializer, and upgraders
+  - `io\GlobalItemDataHandlers` - gives access to item data serializer, deserializer, and upgraders
+  - `io\LoadedChunkData` - represents a chunk loaded from disk, along with information such as whether the chunk was upgraded and what fixes it requires
+- The following new API methods have been added:
+  - `public SubChunk->getBiomeArray() : PalettedBlockArray`
+- The following classes have been removed:
+  - `BiomeArray` - `PalettedBlockArray` is now used for 3D biome data
+- The following API methods have changed signatures:
+  - `Chunk->getBiomeId()` now accepts `int $x, int $y, int $z` instead of `int $x, int $z`
+  - `Chunk->setBiomeId()` now accepts `int $x, int $y, int $z` instead of `int $x, int $z`
+  - `Chunk->__construct()` no longer accepts `BiomeArray` as a parameter (contained in each subchunk instead)
+  - `SubChunk->__construct()` now accepts `int $emptyBlockId, list<PalettedBlockArray> $blockLayers, PalettedBlockArray $biomes, ?LightArray $blockLight, ?LightArray $skyLight` instead of `int, list<PalettedBlockArray>, ?LightArray, ?LightArray`
+  - `io\WorldProvider->loadChunk()` now returns `LoadedChunkData` instead of `ChunkData`
+  - `io\WorldProvider->getAllChunks()` now yields `LoadedChunkData` instead of `ChunkData`
+  - `io\ChunkData->__construct()` now accepts `array<int, SubChunk>, bool $populated` instead of `Chunk $chunk`
+- The following API methods have been renamed:
+  - `Chunk->getFullBlock()` -> `Chunk->getBlockStateId()`
+  - `Chunk->setFullBlock()` -> `Chunk->setBlockStateId()`
+  - `SubChunk->getFullBlock()` -> `SubChunk->getBlockStateId()`
+  - `SubChunk->setFullBlock()` -> `SubChunk->setBlockStateId()`
+- The following API interface requirements have been added:
+  - `public io\data\WorldData->setDisplayName(string $value) : void`
+
+### `pocketmine\world\generator\object`
+- The following API methods have been removed:
+  - `TreeType::fromMagicNumber()`
+  - `TreeType->getMagicNumber()`
+
+### `pocketmine\world\sound`
+- The following classes have been added:
+  - `CopperWaxApplySound`
+  - `CopperWaxRemoveSound`
+  - `DyeUseSound`
+  - `InkSacUseSound`
+- The following enums have new members:
+  - `NoteInstrument` has new members `BELL`, `FLUTE`, `CHIME`, `XYLOPHONE`, `IRON_XYLOPHONE`, `COW_BELL`, `DIDGERIDOO`, `BIT`, `BANJO`, `PLING`
+- The following API methods have been removed:
+  - `NoteInstrument::fromMagicNumber()`
+  - `NoteInstrument->getMagicNumber()`
+
+## Internals
+- All external usages of `KnownTranslationKeys` are now removed. All localized messages are now sent using `Translatable` objects (usually from `KnownTranslationFactory`).
+- All usages of NBT keys now use class constants instead of hardcoded strings (except for an occasional overlooked one).
+- Built-in commands now declare their names inside the class constructor, rather than accepting them as parameters. This improves code consistency.
+- Commands now use an array for permissions internally, instead of a string separated by `;`.
+- Make use of `Item->canStackWith()` instead of `Item->equals()` wherever possible, to make the code more readable.
+- Moved command timings to `Timings`.
+- Overriding of serializers and deserializers of items and blocks is now consistently disallowed. Since overriding stuff is non-cooperative, it doesn't make any sense in plugins, which must coexist with other plugins. If you want to modify the functionality of built-in stuff, you have several alternative options:
+    - Use existing API (e.g. events, API methods) - most uses of overrides in PM4 and earlier were abuses that could have been done with events
+    - Submit feature proposals or pull requests for new API to be added (e.g. new events)
+    - Register completely custom items, and reuse behaviour from the item you want to mimic
+    - Fork PocketMine-MP and alter the code directly - this way your plugins aren't pretending to be cooperative with other plugins
+- `level.dat`, block, item, entity, tile and chunk data are now tagged with a version ID as per `VersionInfo::WORLD_DATA_VERSION`. This allows the server to apply fixes to older worlds if necessary.
+- Protocol creative inventory entries are now cached in `CreativeInventoryCache` to improve performance of initial join and game mode changes.
+- Singletons in the `pocketmine\network\mcpe\convert` package have been centralized under `TypeConverter`. In the future, this will be injected where needed, allowing different converters to be used for different sessions (useful for multiversion).
+- `BlockStateDictionary` memory usage is now reduced from 9 MB to 3.5 MB using various techniques, including string reuse and binary-encoded states.
+- `NetworkSession` disconnect APIs now accept `Translatable|string` instead of `string` to allow localized disconnect messages.
+- `NetworkSession` disconnect methods have been altered to allow specifying a different disconnect reason and disconnection screen message.
+- `RuntimeBlockMapping` has been renamed to `BlockTranslator`.
+
+# 5.0.1
+Released 3rd June 2023.
+
+## Changes
+- [`ext-pmmpthread` version 6.0.1](https://github.com/pmmp/ext-pmmpthread/releases/tag/6.0.1) is now required (for bug fixes).
+
+## Fixes
+- Fixed server crash when breaking blocks placed in the same session (mishandled default block states).
+- Fixed spore blossoms not dropping when broken.
+- Fixed jukebox music not stopping when destroyed by an explosion.
+
+## Documentation
+- Added documentation for `BlockSpreadEvent->__construct()` parameters.

changelogs/5.1.md

@@ -0,0 +1,52 @@
+# 5.1.0
+Released 7th June 2023.
+
+**For Minecraft: Bedrock Edition 1.20.0**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.0.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.0.
+- Removed support for older versions.
+
+# 5.1.1
+Released 7th June 2023.
+
+## Fixes
+- Fixed blockstates being saved with the wrong version ID for 1.20.0.
+
+# 5.1.2
+Released 9th June 2023.
+
+**This release includes changes from the following releases:**
+- [4.22.1](https://github.com/pmmp/PocketMine-MP/blob/4.22.1/changelogs/4.22.md#4221) - Teleportation client bug workarounds
+
+This release contains no other changes.
+
+# 5.1.3
+Released 1st July 2023.
+
+**This release includes changes from the following releases:**
+- [4.22.2](https://github.com/pmmp/PocketMine-MP/blob/4.22.2/changelogs/4.22.md#4222) - Authentication time bomb fix
+
+## General
+- Updated logos to new RGB-style logo. Thanks to @MrCakeSlayer and @HBIDamian for their efforts.
+- Improved error messages generated by the world system when some version tags are missing from `level.dat` in Bedrock worlds.
+- Outsourced Composer dependencies now only receive patch updates automatically (pinned using the `~` constraint).
+  - Minor and major updates now require manually updating `composer.json`, to ensure that the plugin API is not broken by libraries getting randomly updated from one patch release to the next.
+
+## Documentation
+- Updated doc comment for `Player->setGamemode()` to remove outdated information.
+- Added documentation for the `$clickVector` parameter of `Block->onInteract()` to specify that it is relative to the block's position.
+- Added missing `@required` tag for `BlockStateUpgradeSchemaModelBlockRemap->newState`.
+
+## Fixes
+- Fixed blue candles not appearing in the creative inventory.
+- Fixed server crash when block-picking candle cakes.
+- `World->useItemOn()` now ensures that the `$clickVector` components are always in the range of 0-1. Previously, any invalid values were accepted, potentially leading to a crash.

changelogs/5.2.md

@@ -0,0 +1,79 @@
+# 5.2.0
+Released 4th July 2023.
+
+**For Minecraft: Bedrock Edition 1.20.0**
+
+This is a minor technical update, including changes to AsyncTask error handling and support for BedrockBlockUpgradeSchema version 3.0.0.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## Core
+- [BedrockBlockUpgradeSchema version 3.0.0](https://github.com/pmmp/BedrockBlockUpgradeSchema/releases/tag/3.0.0) is now supported.
+- [`ext-pmmpthread` version 6.0.4](https://github.com/pmmp/ext-pmmpthread/releases/tag/6.0.4) is now required (bug fixes required to support technical changes in this release).
+
+## Performance
+- Improved performance of `AsyncPool->submitTask()` and `AsyncPool->submitTaskToWorker()`.
+- Added new timings for `AsyncTask->onProgressUpdate()` and `AsyncTask->onCompletion()`.
+
+## Gameplay
+### Blocks
+- Added the following new blocks:
+  - Cherry Button
+  - Cherry Door
+  - Cherry Fence
+  - Cherry Fence Gate
+  - Cherry Leaves
+  - Cherry Log
+  - Cherry Planks
+  - Cherry Pressure Plate
+  - Cherry Sign
+  - Cherry Slab
+  - Cherry Stairs
+  - Cherry Trapdoor
+  - Cherry Wood
+  - Glow Lichen
+  - Piglin Head
+
+## Tools
+- `generate-block-upgrade-schema.php` now supports generating schemas a la BedrockBlockUpgradeSchema version 3.0.0, using `newFlattenedName` to reduce schema size.
+- Improved property remapping detection in `generate-block-upgrade-schema.php`. It now detects related properties with more confidence (even when multiple properties were change), and no longer considers unrelated properties as mapped (e.g. `mapped_type` and `deprecated` in 1.9->1.10).
+
+## API
+### `pocketmine\data\bedrock\block`
+- The following new API methods have been added:
+  - `public BlockStateData->toVanillaNbt() : CompoundTag` - returns the NBT for the blockstate without any PMMP extra metadata (`toNbt()` will normally include a `PMMPDataVersion` tag).
+
+### `pocketmine\data\runtime`
+- The following new API methods have been added:
+  - `public RuntimeDataDescriber->facingFlags(list<int> $faces) : void`
+
+### `pocketmine\scheduler`
+- `AsyncTask->onRun()` no longer tolerates uncaught exceptions.
+  - This means that any uncaught exceptions thrown from `AsyncTask->onRun()` will now crash the worker thread, and by extension, the server.
+  - This change makes it easier to debug errors by detecting them earlier.
+- The following API methods have been deprecated:
+  - `AsyncTask->onError()`
+
+## Internals
+- `AsyncTask->progressUpdates` is now lazily initialized when a task publishes a progress update.
+  - This was previously not possible due to technical limitations of the `ext-pmmpthread` extension.
+  - This change improves performance of `AsyncPool->submitTask()` and `AsyncPool->submitTaskToWorker()`, as well as reducing the amount of work needed to check for progress updates on tick.
+- Errors in `AsyncWorker` now cascade and crash the whole server.
+  - This makes it easier to debug errors by detecting them earlier.
+  - This includes all types of unexpected errors, such as OOM, uncaught exceptions, etc.
+  - This change is not expected to affect normal server operation, as worker threads are not expected to crash under normal circumstances.
+- `AsyncTask::$threadLocalStorage` now uses a plain `array` instead of `ArrayObject`. The `ArrayObject` was a workaround for `ext-pthreads` to prevent thread-locals getting copied to the worker thread, and is no longer necessary.
+- Regenerated `pocketmine\data\bedrock\item\ItemTypeNames` for Bedrock 1.20 (BC breaking, some item names have changed).
+- Fixed `build/generate-item-type-names.php` not including some newer blockitems, such as doors and hanging signs.
+
+# 5.2.1
+Released 11th July 2023.
+
+**This release includes changes from the following releases:**
+- [4.22.3](https://github.com/pmmp/PocketMine-MP/blob/4.22.3/changelogs/4.22.md#4223) - Fixes for some crash issues
+
+This release contains no other changes.

changelogs/5.3.md

@@ -0,0 +1,81 @@
+# 5.3.0
+Released 12th July 2023.
+
+**For Minecraft: Bedrock Edition 1.20.10**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.10.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## Interim releases
+If you're upgrading directly from 5.1.x to 5.3.x, please also read the following changelogs, as the interim releases contain important changes:
+- [5.2.0](https://github.com/pmmp/PocketMine-MP/blob/5.2.0/changelogs/5.2.md#520)
+
+## Included releases
+**This release includes changes from the following releases:**
+- [4.23.0](https://github.com/pmmp/PocketMine-MP/blob/4.23.0/changelogs/4.23.md#4230) - Support for Minecraft: Bedrock Edition 1.20.10
+
+## Internals
+- `BlockTypeNames`, `BlockStateNames`, `BlockStateStringValues` and `ItemTypeNames` in the `pocketmine\data\bedrock` package have BC-breaking changes to accommodate Bedrock 1.20.10.
+
+# 5.3.1
+Released 14th July 2023.
+
+## Included releases
+**This release includes changes from the following releases:**
+- [4.23.1](https://github.com/pmmp/PocketMine-MP/blob/4.23.1/changelogs/4.23.md#4231) - Security fixes
+
+## General
+- Updated `build/php` submodule to pmmp/PHP-Binaries@e0c918d1379465964acefd562d9e48f87cfc2c9e.
+
+# 5.3.2
+Released 18th July 2023.
+
+## Included releases
+**This release includes changes from the following releases:**
+- [4.23.2](https://github.com/pmmp/PocketMine-MP/blob/4.23.2/changelogs/4.23.md#4232) - Fix for `sandboxId`-related login errors
+
+## Documentation
+- Fixed documentation error in `StringToTParser`.
+
+## Fixes
+- Fixed turtle helmet not being able to be unequipped.
+
+## Internals
+- Armor pieces are no longer set back into the armor inventory if no change was made. This reduces the number of slot updates sent to clients, as well as avoiding unnecessary updates for armor pieces which have Unbreaking enchantments.
+
+# 5.3.3
+Released 24th July 2023.
+
+## Included releases
+**This release includes changes from the following releases:**
+- [4.23.3](https://github.com/pmmp/PocketMine-MP/blob/4.23.3/changelogs/4.23.md#4233) - Various bug fixes
+
+## Fixes
+- Added a workaround for PM4 worlds with chunks corrupted by [Refaltor77/CustomItemAPI](https://github.com/Refaltor77/CustomItemAPI).
+  - While this was not the fault of PocketMine-MP itself, a significant number of users were affected by this problem.
+  - This error was not detected by PM4 due to missing validation of certain data which should not have existed in 1.12.
+  - An error will now be logged when this corruption is detected, but the affected chunks should otherwise load normally.
+- Relaxed validation of expected 3D biome array counts per chunk in LevelDB worlds.
+  - Vanilla Bedrock currently saves 24 palettes (and only 24 are required), but it saved 25, 32, or 64 biome palettes per chunk in older versions.
+  - Core validation for these padding biomes was very strict, enforcing exact compliance with vanilla.
+  - Since only 24 palettes are actually required, the remaining palettes may now be omitted irrespective of the chunk version.
+  - An error will still be logged when this mistake is detected, but the affected chunks will otherwise load normally.
+- Fixed `/kill` not working on players who had (re)spawned in the 3 seconds immediately after (re)spawning (due to `noDamageTicks`).
+- Fixed `/kill` not working correctly for players with high levels of Health Boost or other health-altering effects.
+- Fixed netherite items being destroyed by lava.
+- Fireproof entities no longer display the burning animation when in fire or lava. This does not apply to creative players, who are immortal rather than being fireproof.
+- Fixed frosted ice melting in certain conditions which didn't match vanilla Bedrock.
+
+# 5.3.4
+Released 1st August 2023.
+
+## Included releases
+This release includes changes from the following releases:
+- [4.23.4](https://github.com/pmmp/PocketMine-MP/blob/4.23.4/changelogs/4.23.md#4234) - Item entity lag fix
+
+This release contains no other significant changes.

changelogs/5.4.md

@@ -0,0 +1,83 @@
+# 5.4.0
+Released 1st August 2023.
+
+**For Minecraft: Bedrock Edition 1.20.10**
+
+This is a minor feature update, including a handful of new gameplay features, new plugin APIs and improvements to error reporting.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Improved error reporting for async task and thread crashes.
+- Players may now have different creative inventories.
+
+## Gameplay
+### General
+- Added support for 1.5-block height sneaking.
+- Fixed missing player arm swing and sounds when punching the air.
+
+### Blocks
+- Implemented the following new blocks:
+  - Big Dripleaf Head
+  - Big Dripleaf Stem
+  - Small Dripleaf
+- Acacia saplings now grow into acacia trees.
+- Fixed melon and pumpkin stems not attaching to the correct block when growing.
+- Various blocks now drop more items when mined with a compatible tool enchanted with Fortune.
+
+### Items
+- Implemented Strong Slowness potion.
+- Implemented Fortune enchantment.
+
+## API
+### `pocketmine\block`
+- The following new classes have been added:
+  - `utils\FortuneDropHelper` - utility methods for calculating the drop counts for Fortune-affected blocks
+- The following new API methods have been added:
+  - `protected Block->getAdjacentSupportType(int $facing) : utils\SupportType` - returns the type of support provided by the block in the given direction on the adjacent face
+
+### `pocketmine\entity`
+- The following new API constants have been added:
+  - `Living::DEFAULT_KNOCKBACK_FORCE`
+  - `Living::DEFAULT_KNOCKBACK_VERTICAL_LIMIT`
+
+### `pocketmine\entity\animation`
+- `ConsumingItemAnimation` now accepts `Living` instances instead of just `Human`.
+
+### `pocketmine\event`
+- The following new classes have been added:
+  - `PlayerMissSwingEvent` - called when the player attempts the attack action (left click on desktop) without any target
+    - This is possible thanks to the introduction of new flags in `PlayerAuthInputPacket` in Bedrock 1.20.10
+- The following new API methods have been added:
+  - `public EntityDamageByEntityEvent->getVerticalKnockBackLimit() : float`
+  - `public EntityDamageByEntityEvent->setVerticalKnockBackLimit(float $verticalKnockBackLimit) : void` - sets the max vertical velocity that can result from the victim being knocked back
+
+### `pocketmine\player`
+- The following new API methods have been added:
+  - `public Player->getCreativeInventory() : pocketmine\inventory\CreativeInventory`
+  - `public Player->setCreativeInventory(pocketmine\inventory\CreativeInventory $inventory) : void`
+  - `public Player->missSwing() : void` - performs actions associated with the attack action when there is no target (see `PlayerMissSwingEvent`)
+
+### `pocketmine\scheduler`
+- Cancellation functionality has been removed from `AsyncTask`, as it didn't make any sense and wasn't used by anything for what it was intended for.
+  - It broke sequential task execution - later tasks might depend on state from earlier tasks
+  - It didn't actually cancel the task anyway - at best, it prevented it from running, but couldn't interrupt it (though interrupting a task does not make sense either)
+- The following API methods have been deprecated, and their functionality has been removed:
+  - `AsyncTask->hasCancelledRun()`
+  - `AsyncTask->cancelRun()`
+
+## Internals
+- Uncaught exceptions and fatal errors in `AsyncTask`, threads extending `pocketmine\thread\Thread`, and `pocketmine\thread\Worker` are now recorded in crashdumps, making it significantly easier to debug errors in these areas.
+- JWT signature DER <-> raw conversions are now handled in-house using code in `JwtUtils`
+  - Due to the simplicity of the conversion and only requiring a tiny subset of the ASN.1 spec, it didn't make much sense to introduce another dependency.
+  - `fgrosse/phpasn1` is no longer required. This package was abandoned by its author and only used by PocketMine-MP for this one purpose.
+- Various usages of `Closure::fromCallable()` have been replaced by PHP 8.1 first-class callable syntax.
+- Blocks requiring support shifted to a "can be supported at" model, rather than "can be supported by".
+  - This model reduces repeated logic when placing and performing nearby block updates (no need to hardcode facing everywhere).
+  - In addition, this change facilitates the use of the newly introduced `Block->getAdjacentSupportType()` API method, reducing boilerplate support-type checking code.
+- Bell block code has been simplified and cleaned up.
+- `TallGrass` and `DoubleTallGrass` now use a shared `TallGrassTrait` to reduce code duplication.

composer.json

@@ -22,7 +22,7 @@
       "ext-openssl": "*",
       "ext-pcre": "*",
       "ext-phar": "*",
-      "ext-pthreads": "^5.1",
+      "ext-pmmpthread": "^6.0.4",
       "ext-reflection": "*",
       "ext-simplexml": "*",
       "ext-sockets": "*",
@@ -31,34 +31,31 @@
       "ext-zip": "*",
       "ext-zlib": ">=1.2.11",
       "composer-runtime-api": "^2.0",
-      "adhocore/json-comment": "^1.1",
-      "fgrosse/phpasn1": "^2.3",
-      "netresearch/jsonmapper": "^4.0",
-      "pocketmine/bedrock-block-upgrade-schema": "~2.1.0+bedrock-1.19.80",
-      "pocketmine/bedrock-data": "~2.2.0+bedrock-1.19.80",
-      "pocketmine/bedrock-item-upgrade-schema": "~1.2.0+bedrock-1.19.80",
-      "pocketmine/bedrock-protocol": "~21.0.0+bedrock-1.19.80",
+      "adhocore/json-comment": "~1.2.0",
+      "pocketmine/netresearch-jsonmapper": "~v4.2.1000",
+      "pocketmine/bedrock-block-upgrade-schema": "~3.1.0+bedrock-1.20.10",
+      "pocketmine/bedrock-data": "~2.4.0+bedrock-1.20.10",
+      "pocketmine/bedrock-item-upgrade-schema": "~1.4.0+bedrock-1.20.10",
+      "pocketmine/bedrock-protocol": "~23.0.2+bedrock-1.20.10",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
-      "pocketmine/classloader": "^0.3.0",
       "pocketmine/color": "^0.3.0",
       "pocketmine/errorhandler": "^0.6.0",
       "pocketmine/locale-data": "~2.19.0",
       "pocketmine/log": "^0.4.0",
-      "pocketmine/log-pthreads": "^0.5.0",
       "pocketmine/math": "^0.4.0",
       "pocketmine/nbt": "^0.3.2",
       "pocketmine/raklib": "^0.15.0",
       "pocketmine/raklib-ipc": "^0.2.0",
-      "pocketmine/snooze": "^0.4.0",
-      "ramsey/uuid": "^4.1",
-      "symfony/filesystem": "^5.4"
+      "pocketmine/snooze": "^0.5.0",
+      "ramsey/uuid": "~4.7.0",
+      "symfony/filesystem": "~6.3.0"
    },
    "require-dev": {
-      "phpstan/phpstan": "1.10.15",
+      "phpstan/phpstan": "1.10.16",
       "phpstan/phpstan-phpunit": "^1.1.0",
       "phpstan/phpstan-strict-rules": "^1.2.0",
-      "phpunit/phpunit": "^9.2"
+      "phpunit/phpunit": "^10.1"
    },
    "autoload": {
       "psr-4": {

phpstan.neon.dist

@@ -44,7 +44,7 @@ parameters:
 		- tests/phpstan/stubs/JsonMapper.stub
 		- tests/phpstan/stubs/leveldb.stub
 		- tests/phpstan/stubs/phpasn1.stub
-		- tests/phpstan/stubs/pthreads.stub
+		- tests/phpstan/stubs/pmmpthread.stub
 	reportUnmatchedIgnoredErrors: false #no other way to silence platform-specific non-warnings
 	staticReflectionClassNamePatterns:
 		- "#^COM$#"

src/MemoryManager.php

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

src/PocketMine.php

@@ -26,6 +26,7 @@ namespace pocketmine {
 	use Composer\InstalledVersions;
 	use pocketmine\errorhandler\ErrorToExceptionHandler;
 	use pocketmine\thread\ThreadManager;
+	use pocketmine\thread\ThreadSafeClassLoader;
 	use pocketmine\utils\Filesystem;
 	use pocketmine\utils\MainLogger;
 	use pocketmine\utils\Process;
@@ -103,7 +104,7 @@ namespace pocketmine {
 			"openssl" => "OpenSSL",
 			"pcre" => "PCRE",
 			"phar" => "Phar",
-			"pthreads" => "pthreads",
+			"pmmpthread" => "pmmpthread",
 			"reflection" => "Reflection",
 			"sockets" => "Sockets",
 			"spl" => "SPL",
@@ -118,12 +119,9 @@ namespace pocketmine {
 			}
 		}
 
-		if(($pthreads_version = phpversion("pthreads")) !== false){
-			if(substr_count($pthreads_version, ".") < 2){
-				$pthreads_version = "0.$pthreads_version";
-			}
-			if(version_compare($pthreads_version, "5.1.0") < 0 || version_compare($pthreads_version, "6.0.0") >= 0){
-				$messages[] = "pthreads ^5.0.0 is required, while you have $pthreads_version.";
+		if(($pmmpthread_version = phpversion("pmmpthread")) !== false){
+			if(version_compare($pmmpthread_version, "6.0.4") < 0 || version_compare($pmmpthread_version, "7.0.0") >= 0){
+				$messages[] = "pmmpthread ^6.0.4 is required, while you have $pmmpthread_version.";
 			}
 		}
 
@@ -330,7 +328,7 @@ JIT_WARNING
 			/*
 			 * We now use the Composer autoloader, but this autoloader is still for loading plugins.
 			 */
-			$autoloader = new \BaseClassLoader();
+			$autoloader = new ThreadSafeClassLoader();
 			$autoloader->register(false);
 
 			new Server($autoloader, $logger, $dataPath, $pluginPath);
@@ -338,12 +336,12 @@ JIT_WARNING
 			$logger->info("Stopping other threads");
 
 			$killer = new ServerKiller(8);
-			$killer->start(PTHREADS_INHERIT_NONE);
+			$killer->start();
 			usleep(10000); //Fixes ServerKiller not being able to start on single-core machines
 
 			if(ThreadManager::getInstance()->stopAll() > 0){
 				$logger->debug("Some threads could not be stopped, performing a force-kill");
-				Process::kill(Process::pid(), true);
+				Process::kill(Process::pid());
 			}
 		}while(false);
 

src/Server.php

@@ -92,6 +92,9 @@ use pocketmine\resourcepacks\ResourcePackManager;
 use pocketmine\scheduler\AsyncPool;
 use pocketmine\snooze\SleeperHandler;
 use pocketmine\stats\SendUsageTask;
+use pocketmine\thread\log\AttachableThreadSafeLogger;
+use pocketmine\thread\ThreadCrashException;
+use pocketmine\thread\ThreadSafeClassLoader;
 use pocketmine\timings\Timings;
 use pocketmine\timings\TimingsHandler;
 use pocketmine\updater\UpdateChecker;
@@ -413,11 +416,11 @@ class Server{
 		return $this->configGroup->getConfigString("motd", self::DEFAULT_SERVER_NAME);
 	}
 
-	public function getLoader() : \DynamicClassLoader{
+	public function getLoader() : ThreadSafeClassLoader{
 		return $this->autoloader;
 	}
 
-	public function getLogger() : \AttachableThreadedLogger{
+	public function getLogger() : AttachableThreadSafeLogger{
 		return $this->logger;
 	}
 
@@ -759,8 +762,8 @@ class Server{
 	}
 
 	public function __construct(
-		private \DynamicClassLoader $autoloader,
-		private \AttachableThreadedLogger $logger,
+		private ThreadSafeClassLoader $autoloader,
+		private AttachableThreadSafeLogger $logger,
 		string $dataPath,
 		string $pluginPath
 	){
@@ -1007,7 +1010,7 @@ class Server{
 
 			$this->playerDataProvider = new DatFilePlayerDataProvider(Path::join($this->dataPath, "players"));
 
-			register_shutdown_function([$this, "crashDump"]);
+			register_shutdown_function($this->crashDump(...));
 
 			$loadErrorCount = 0;
 			$this->pluginManager->loadPlugins($this->pluginPath, $loadErrorCount);
@@ -1425,7 +1428,7 @@ class Server{
 
 	private function forceShutdownExit() : void{
 		$this->forceShutdown();
-		Process::kill(Process::pid(), true);
+		Process::kill(Process::pid());
 	}
 
 	public function forceShutdown() : void{
@@ -1493,7 +1496,7 @@ class Server{
 		}catch(\Throwable $e){
 			$this->logger->logException($e);
 			$this->logger->emergency("Crashed while crashing, killing process");
-			@Process::kill(Process::pid(), true);
+			@Process::kill(Process::pid());
 		}
 
 	}
@@ -1514,23 +1517,38 @@ class Server{
 			$trace = $e->getTrace();
 		}
 
-		$errstr = $e->getMessage();
-		$errfile = $e->getFile();
-		$errline = $e->getLine();
+		//If this is a thread crash, this logs where the exception came from on the main thread, as opposed to the
+		//crashed thread. This is intentional, and might be useful for debugging
+		//Assume that the thread already logged the original exception with the correct stack trace
+		$this->logger->logException($e, $trace);
+
+		if($e instanceof ThreadCrashException){
+			$info = $e->getCrashInfo();
+			$type = $info->getType();
+			$errstr = $info->getMessage();
+			$errfile = $info->getFile();
+			$errline = $info->getLine();
+			$printableTrace = $info->getTrace();
+			$thread = $info->getThreadName();
+		}else{
+			$type = get_class($e);
+			$errstr = $e->getMessage();
+			$errfile = $e->getFile();
+			$errline = $e->getLine();
+			$printableTrace = Utils::printableTraceWithMetadata($trace);
+			$thread = "Main";
+		}
 
 		$errstr = preg_replace('/\s+/', ' ', trim($errstr));
 
-		$errfile = Filesystem::cleanPath($errfile);
-
-		$this->logger->logException($e, $trace);
-
 		$lastError = [
-			"type" => get_class($e),
+			"type" => $type,
 			"message" => $errstr,
-			"fullFile" => $e->getFile(),
-			"file" => $errfile,
+			"fullFile" => $errfile,
+			"file" => Filesystem::cleanPath($errfile),
 			"line" => $errline,
-			"trace" => $trace
+			"trace" => $printableTrace,
+			"thread" => $thread
 		];
 
 		global $lastExceptionError, $lastError;
@@ -1647,7 +1665,7 @@ class Server{
 			echo "--- Waiting $spacing seconds to throttle automatic restart (you can kill the process safely now) ---" . PHP_EOL;
 			sleep($spacing);
 		}
-		@Process::kill(Process::pid(), true);
+		@Process::kill(Process::pid());
 		exit(1);
 	}
 

src/VersionInfo.php

@@ -31,9 +31,24 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "5.0.0-BETA3";
+	public const BASE_VERSION = "5.4.0";
 	public const IS_DEVELOPMENT_BUILD = false;
-	public const BUILD_CHANNEL = "beta";
+	public const BUILD_CHANNEL = "stable";
+
+	/**
+	 * PocketMine-MP-specific version ID for world data. Used to determine what fixes need to be applied to old world
+	 * data (e.g. stuff saved wrongly by past versions).
+	 * This version supplements the Minecraft vanilla world version.
+	 *
+	 * This should be bumped if any **non-Mojang** BC-breaking change or bug fix is made to world save data of any kind
+	 * (entities, tiles, blocks, biomes etc.). For example, if PM accidentally saved a block with its facing value
+	 * swapped, we would bump this, but not if Mojang did the same change.
+	 */
+	public const WORLD_DATA_VERSION = 1;
+	/**
+	 * Name of the NBT tag used to store the world data version.
+	 */
+	public const TAG_WORLD_DATA_VERSION = "PMMPDataVersion"; //TAG_Long
 
 	private function __construct(){
 		//NOOP

src/block/BaseBigDripleaf.php

@@ -0,0 +1,136 @@
+<?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\HorizontalFacingTrait;
+use pocketmine\block\utils\SupportType;
+use pocketmine\event\block\StructureGrowEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+abstract class BaseBigDripleaf extends Transparent{
+	use HorizontalFacingTrait;
+
+	abstract protected function isHead() : bool;
+
+	private function canBeSupportedBy(Block $block, bool $head) : bool{
+		//TODO: Moss block
+		return
+			($block instanceof BaseBigDripleaf && $block->isHead() === $head) ||
+			$block->getTypeId() === BlockTypeIds::CLAY ||
+			$block->hasTypeTag(BlockTypeTags::DIRT) ||
+			$block->hasTypeTag(BlockTypeTags::MUD);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(
+			(!$this->isHead() && !$this->getSide(Facing::UP) instanceof BaseBigDripleaf) ||
+			!$this->canBeSupportedBy($this->getSide(Facing::DOWN), false)
+		){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$block = $blockReplace->getSide(Facing::DOWN);
+		if(!$this->canBeSupportedBy($block, true)){
+			return false;
+		}
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+		if($block instanceof BaseBigDripleaf){
+			$this->facing = $block->getFacing();
+			$tx->addBlock($block->getPosition(), VanillaBlocks::BIG_DRIPLEAF_STEM()->setFacing($this->facing));
+		}
+		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 Fertilizer && $this->grow($player)){
+			$item->pop();
+			return true;
+		}
+		return false;
+	}
+
+	private function seekToHead() : ?BaseBigDripleaf{
+		if($this->isHead()){
+			return $this;
+		}
+		$step = 1;
+		while(($next = $this->getSide(Facing::UP, $step)) instanceof BaseBigDripleaf){
+			if($next->isHead()){
+				return $next;
+			}
+			$step++;
+		}
+		return null;
+	}
+
+	private function grow(?Player $player) : bool{
+		$head = $this->seekToHead();
+		if($head === null){
+			return false;
+		}
+		$pos = $head->getPosition();
+		$up = $pos->up();
+		$world = $pos->getWorld();
+		if(
+			!$world->isInWorld($up->getFloorX(), $up->getFloorY(), $up->getFloorZ()) ||
+			$world->getBlock($up)->getTypeId() !== BlockTypeIds::AIR
+		){
+			return false;
+		}
+
+		$tx = new BlockTransaction($world);
+
+		$tx->addBlock($pos, VanillaBlocks::BIG_DRIPLEAF_STEM()->setFacing($head->getFacing()));
+		$tx->addBlock($up, VanillaBlocks::BIG_DRIPLEAF_HEAD()->setFacing($head->getFacing()));
+
+		$ev = new StructureGrowEvent($head, $tx, $player);
+		$ev->call();
+
+		if(!$ev->isCancelled()){
+			return $tx->apply();
+		}
+		return false;
+	}
+
+	public function getFlameEncouragement() : int{
+		return 15;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+}

src/block/BaseRail.php

@@ -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)->getSupportType(Facing::UP)->hasEdgeSupport()){
+		if($blockReplace->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport()){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
@@ -222,7 +222,7 @@ abstract class BaseRail extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		$world = $this->position->getWorld();
-		if(!$this->getSide(Facing::DOWN)->getSupportType(Facing::UP)->hasEdgeSupport()){
+		if(!$this->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport()){
 			$world->useBreakOn($this->position);
 		}else{
 			foreach($this->getCurrentShapeConnections() as $connection){

src/block/Bed.php

@@ -177,11 +177,11 @@ class Bed extends Transparent{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			$this->facing = $player !== null ? $player->getHorizontalFacing() : Facing::NORTH;
 
 			$next = $this->getSide($this->getOtherHalfSide());
-			if($next->canBeReplaced() && $this->canBeSupportedBy($next->getSide(Facing::DOWN))){
+			if($next->canBeReplaced() && $this->canBeSupportedAt($next)){
 				$nextState = clone $this;
 				$nextState->head = true;
 				$tx->addBlock($blockReplace->position, $this)->addBlock($next->position, $nextState);
@@ -208,8 +208,8 @@ class Bed extends Transparent{
 		return parent::getAffectedBlocks();
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return !$block->getSupportType(Facing::UP)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block) : bool{
+		return !$block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::NONE());
 	}
 
 	public function getMaxStackSize() : int{ return 1; }

src/block/Beetroot.php

@@ -23,9 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
 
 class Beetroot extends Crops{
 
@@ -33,7 +33,7 @@ class Beetroot extends Crops{
 		if($this->age >= self::MAX_AGE){
 			return [
 				VanillaItems::BEETROOT(),
-				VanillaItems::BEETROOT_SEEDS()->setCount(mt_rand(0, 3))
+				VanillaItems::BEETROOT_SEEDS()->setCount(FortuneDropHelper::binomial($item, 0))
 			];
 		}
 

src/block/Bell.php

@@ -35,6 +35,7 @@ use pocketmine\math\Facing;
 use pocketmine\math\RayTraceResult;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\sound\BellRingSound;
 
@@ -87,46 +88,44 @@ final class Bell extends Transparent{
 		return $this;
 	}
 
-	private function canBeSupportedBy(Block $block, int $face) : bool{
-		return !$block->getSupportType($face)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return !$block->getAdjacentSupportType($face)->equals(SupportType::NONE());
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
+			return false;
+		}
 		if($face === Facing::UP){
-			if(!$this->canBeSupportedBy($tx->fetchBlock($this->position->down()), Facing::UP)){
-				return false;
-			}
 			if($player !== null){
 				$this->setFacing(Facing::opposite($player->getHorizontalFacing()));
 			}
 			$this->setAttachmentType(BellAttachmentType::FLOOR());
 		}elseif($face === Facing::DOWN){
-			if(!$this->canBeSupportedBy($tx->fetchBlock($this->position->up()), Facing::DOWN)){
-				return false;
-			}
 			$this->setAttachmentType(BellAttachmentType::CEILING());
 		}else{
 			$this->setFacing($face);
-			if($this->canBeSupportedBy($tx->fetchBlock($this->position->getSide(Facing::opposite($face))), $face)){
-				$this->setAttachmentType(BellAttachmentType::ONE_WALL());
-			}else{
-				return false;
-			}
-			if($this->canBeSupportedBy($tx->fetchBlock($this->position->getSide($face)), Facing::opposite($face))){
-				$this->setAttachmentType(BellAttachmentType::TWO_WALLS());
-			}
+			$this->setAttachmentType(
+				$this->canBeSupportedAt($blockReplace, $face) ?
+					BellAttachmentType::TWO_WALLS() :
+					BellAttachmentType::ONE_WALL()
+			);
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(
-			($this->attachmentType->equals(BellAttachmentType::CEILING()) && !$this->canBeSupportedBy($this->getSide(Facing::UP), Facing::DOWN)) ||
-			($this->attachmentType->equals(BellAttachmentType::FLOOR()) && !$this->canBeSupportedBy($this->getSide(Facing::DOWN), Facing::UP)) ||
-			($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) && !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)) ||
-			($this->attachmentType->equals(BellAttachmentType::TWO_WALLS()) && (!$this->canBeSupportedBy($this->getSide($this->facing), Facing::opposite($this->facing)) || !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)))
-		){
-			$this->position->getWorld()->useBreakOn($this->position);
+		foreach(match($this->attachmentType){
+			BellAttachmentType::CEILING() => [Facing::UP],
+			BellAttachmentType::FLOOR() => [Facing::DOWN],
+			BellAttachmentType::ONE_WALL() => [Facing::opposite($this->facing)],
+			BellAttachmentType::TWO_WALLS() => [$this->facing, Facing::opposite($this->facing)],
+			default => throw new AssumptionFailedError("All cases of BellAttachmentType must be handled")
+		} as $supportBlockDirection){
+			if(!$this->canBeSupportedAt($this, $supportBlockDirection)){
+				$this->position->getWorld()->useBreakOn($this->position);
+				break;
+			}
 		}
 	}
 
@@ -159,13 +158,11 @@ final class Bell extends Transparent{
 	}
 
 	private function isValidFaceToRing(int $faceHit) : bool{
-		return (
-			$this->attachmentType->equals(BellAttachmentType::CEILING()) ||
-			($this->attachmentType->equals(BellAttachmentType::FLOOR()) && Facing::axis($faceHit) === Facing::axis($this->facing)) ||
-			(
-				($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) || $this->attachmentType->equals(BellAttachmentType::TWO_WALLS())) &&
-				($faceHit === Facing::rotateY($this->facing, false) || $faceHit === Facing::rotateY($this->facing, true))
-			)
-		);
+		return match($this->attachmentType){
+			BellAttachmentType::CEILING() => true,
+			BellAttachmentType::FLOOR() => Facing::axis($faceHit) === Facing::axis($this->facing),
+			BellAttachmentType::ONE_WALL(), BellAttachmentType::TWO_WALLS() => $faceHit === Facing::rotateY($this->facing, false) || $faceHit === Facing::rotateY($this->facing, true),
+			default => throw new AssumptionFailedError("All cases of BellAttachmentType must be handled")
+		};
 	}
 }

src/block/BigDripleafHead.php

@@ -0,0 +1,132 @@
+<?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\DripleafState;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\entity\Entity;
+use pocketmine\entity\projectile\Projectile;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\RayTraceResult;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\sound\DripleafTiltDownSound;
+use pocketmine\world\sound\DripleafTiltUpSound;
+
+class BigDripleafHead extends BaseBigDripleaf{
+
+	protected DripleafState $leafState;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
+		$this->leafState = DripleafState::STABLE();
+		parent::__construct($idInfo, $name, $typeInfo);
+	}
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		parent::describeBlockOnlyState($w);
+		$w->dripleafState($this->leafState);
+	}
+
+	protected function isHead() : bool{
+		return true;
+	}
+
+	public function getLeafState() : DripleafState{
+		return $this->leafState;
+	}
+
+	/** @return $this */
+	public function setLeafState(DripleafState $leafState) : self{
+		$this->leafState = $leafState;
+		return $this;
+	}
+
+	public function hasEntityCollision() : bool{
+		return true;
+	}
+
+	private function setTiltAndScheduleTick(DripleafState $tilt) : void{
+		$this->position->getWorld()->setBlock($this->position, $this->setLeafState($tilt));
+		$delay = $tilt->getScheduledUpdateDelayTicks();
+		if($delay !== null){
+			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, $delay);
+		}
+	}
+
+	private function getLeafTopOffset() : float{
+		return match($this->leafState){
+			DripleafState::STABLE(), DripleafState::UNSTABLE() => 1 / 16,
+			DripleafState::PARTIAL_TILT() => 3 / 16,
+			default => 0
+		};
+	}
+
+	public function onEntityInside(Entity $entity) : bool{
+		if(!$entity instanceof Projectile && $this->leafState->equals(DripleafState::STABLE())){
+			//the entity must be standing on top of the leaf - do not collapse if the entity is standing underneath
+			$intersection = AxisAlignedBB::one()
+				->offset($this->position->x, $this->position->y, $this->position->z)
+				->trim(Facing::DOWN, 1 - $this->getLeafTopOffset());
+			if($entity->getBoundingBox()->intersectsWith($intersection)){
+				$this->setTiltAndScheduleTick(DripleafState::UNSTABLE());
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
+		if(!$this->leafState->equals(DripleafState::FULL_TILT())){
+			$this->setTiltAndScheduleTick(DripleafState::FULL_TILT());
+			$this->position->getWorld()->addSound($this->position, new DripleafTiltDownSound());
+		}
+	}
+
+	public function onScheduledUpdate() : void{
+		if(!$this->leafState->equals(DripleafState::STABLE())){
+			if($this->leafState->equals(DripleafState::FULL_TILT())){
+				$this->position->getWorld()->setBlock($this->position, $this->setLeafState(DripleafState::STABLE()));
+				$this->position->getWorld()->addSound($this->position, new DripleafTiltUpSound());
+			}else{
+				$this->setTiltAndScheduleTick(match($this->leafState->id()){
+					DripleafState::UNSTABLE()->id() => DripleafState::PARTIAL_TILT(),
+					DripleafState::PARTIAL_TILT()->id() => DripleafState::FULL_TILT(),
+					default => throw new AssumptionFailedError("All types should be covered")
+				});
+				$this->position->getWorld()->addSound($this->position, new DripleafTiltDownSound());
+			}
+		}
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		if(!$this->leafState->equals(DripleafState::FULL_TILT())){
+			return [
+				AxisAlignedBB::one()
+					->trim(Facing::DOWN, 11 / 16)
+					->trim(Facing::UP, $this->getLeafTopOffset())
+			];
+		}
+		return [];
+	}
+}

src/block/BigDripleafStem.php

@@ -0,0 +1,41 @@
+<?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;
+
+class BigDripleafStem extends BaseBigDripleaf{
+
+	protected function isHead() : bool{
+		return false;
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+
+	public function asItem() : Item{
+		return VanillaBlocks::BIG_DRIPLEAF_HEAD()->asItem();
+	}
+}

src/block/Block.php

@@ -41,6 +41,7 @@ use pocketmine\item\Item;
 use pocketmine\item\ItemBlock;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\RayTraceResult;
 use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
@@ -58,6 +59,11 @@ class Block{
 	public const INTERNAL_STATE_DATA_BITS = 8;
 	public const INTERNAL_STATE_DATA_MASK = ~(~0 << self::INTERNAL_STATE_DATA_BITS);
 
+	/**
+	 * @internal
+	 */
+	public const EMPTY_STATE_ID = (BlockTypeIds::AIR << self::INTERNAL_STATE_DATA_BITS) | (BlockTypeIds::AIR & self::INTERNAL_STATE_DATA_MASK);
+
 	protected BlockIdentifier $idInfo;
 	protected string $fallbackName;
 	protected BlockTypeInfo $typeInfo;
@@ -68,7 +74,8 @@ class Block{
 
 	private int $requiredBlockItemStateDataBits;
 	private int $requiredBlockOnlyStateDataBits;
-	private int $defaultBlockOnlyStateData;
+
+	private Block $defaultState;
 
 	/**
 	 * @param string $name English name of the block type (TODO: implement translations)
@@ -87,7 +94,9 @@ class Block{
 		$this->describeBlockOnlyState($calculator);
 		$this->requiredBlockOnlyStateDataBits = $calculator->getBitsUsed();
 
-		$this->defaultBlockOnlyStateData = $this->encodeBlockOnlyState();
+		$defaultState = clone $this;
+		$this->defaultState = $defaultState;
+		$defaultState->defaultState = $defaultState;
 	}
 
 	public function __clone(){
@@ -140,7 +149,13 @@ class Block{
 	 * {@link RuntimeBlockStateRegistry::fromStateId()}.
 	 */
 	public function getStateId() : int{
-		return ($this->getTypeId() << self::INTERNAL_STATE_DATA_BITS) | $this->encodeFullState();
+		$typeId = $this->getTypeId();
+		//TODO: this XOR mask improves hashtable distribution, but it's only effective if the number of unique block
+		//type IDs is larger than the number of available state data bits. We should probably hash (e.g. using xxhash)
+		//the type ID to create a better mask.
+		//Alternatively, we could hash the whole state ID, but this is currently problematic, since we currently need
+		//to be able to recover the state data from the state ID because of UnknownBlock.
+		return ($typeId << self::INTERNAL_STATE_DATA_BITS) | ($this->encodeFullState() ^ ($typeId & self::INTERNAL_STATE_DATA_MASK));
 	}
 
 	/**
@@ -182,10 +197,11 @@ class Block{
 	 * Returns the block as an item.
 	 * Block-only state such as facing, powered/unpowered, open/closed, etc., is discarded.
 	 * Block-item state such as colour, wood type, etc. is preserved.
+	 * Complex state properties stored in the tile data (e.g. inventory) are discarded.
 	 */
 	public function asItem() : Item{
-		$normalized = clone $this;
-		$normalized->decodeBlockOnlyState($this->defaultBlockOnlyStateData);
+		$normalized = clone $this->defaultState;
+		$normalized->decodeBlockItemState($this->encodeBlockItemState());
 		return new ItemBlock($normalized);
 	}
 
@@ -452,7 +468,8 @@ 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)
+	 * @param Vector3 $clickVector    Exact position where the click occurred, relative to the block's integer position
+	 * @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, array &$returnedItems = []) : bool{
 		return false;
@@ -847,6 +864,10 @@ class Block{
 		return SupportType::FULL();
 	}
 
+	protected function getAdjacentSupportType(int $facing) : SupportType{
+		return $this->getSide($facing)->getSupportType(Facing::opposite($facing));
+	}
+
 	public function isFullCube() : bool{
 		$bb = $this->getCollisionBoxes();
 

src/block/BlockTypeIds.php

@@ -24,11 +24,14 @@ 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.
+ * Every block in {@link VanillaBlocks} has a corresponding constant in this class. These constants can be used to
+ * identify and compare block types efficiently using {@link Block::getTypeId()}.
  *
- * WARNING: DO NOT STORE THESE IDS. They can and will change without warning.
- * They should ONLY be used to IDENTIFY blocks at runtime.
+ * Type ID is also used internally as part of block state ID, which is used to store blocks and their simple properties
+ * in a memory-efficient way in chunks at runtime.
+ *
+ * WARNING: These are NOT a replacement for Minecraft legacy IDs. Do **NOT** hardcode their values, or store them in
+ * configs or databases. They will change without warning.
  */
 final class BlockTypeIds{
 
@@ -714,8 +717,27 @@ final class BlockTypeIds{
 	public const FLOWERING_AZALEA_LEAVES = 10687;
 	public const REINFORCED_DEEPSLATE = 10688;
 	public const CAVE_VINES = 10689;
+	public const GLOW_LICHEN = 10690;
+	public const CHERRY_BUTTON = 10691;
+	public const CHERRY_DOOR = 10692;
+	public const CHERRY_FENCE = 10693;
+	public const CHERRY_FENCE_GATE = 10694;
+	public const CHERRY_LEAVES = 10695;
+	public const CHERRY_LOG = 10696;
+	public const CHERRY_PLANKS = 10697;
+	public const CHERRY_PRESSURE_PLATE = 10698;
+	public const CHERRY_SAPLING = 10699;
+	public const CHERRY_SIGN = 10700;
+	public const CHERRY_SLAB = 10701;
+	public const CHERRY_STAIRS = 10702;
+	public const CHERRY_TRAPDOOR = 10703;
+	public const CHERRY_WALL_SIGN = 10704;
+	public const CHERRY_WOOD = 10705;
+	public const SMALL_DRIPLEAF = 10706;
+	public const BIG_DRIPLEAF_HEAD = 10707;
+	public const BIG_DRIPLEAF_STEM = 10708;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10690;
+	public const FIRST_UNUSED_BLOCK_ID = 10709;
 
 	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
 

src/block/Button.php

@@ -52,7 +52,7 @@ abstract class Button extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::opposite($face)), $face)){
+		if($this->canBeSupportedAt($blockReplace, $face)){
 			$this->facing = $face;
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
@@ -83,12 +83,12 @@ abstract class Button extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)){
+		if(!$this->canBeSupportedAt($this, $this->facing)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $support, int $face) : bool{
-		return $support->getSupportType($face)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return $block->getAdjacentSupportType(Facing::opposite($face))->hasCenterSupport();
 	}
 }

src/block/CakeWithCandle.php

@@ -64,7 +64,7 @@ class CakeWithCandle extends BaseCake{
 	}
 
 	public function getPickedItem(bool $addUserData = false) : Item{
-		return VanillaBlocks::CAKE()->getPickedItem($addUserData);
+		return VanillaBlocks::CAKE()->asItem();
 	}
 
 	public function getResidue() : Block{

src/block/Candle.php

@@ -104,8 +104,7 @@ class Candle extends Transparent{
 	}
 
 	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()){
+		if(!$blockReplace->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport()){
 			return false;
 		}
 		$existing = $this->getCandleIfCompatibleType($blockReplace);

src/block/Carrot.php

@@ -23,15 +23,15 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
 
 class Carrot extends Crops{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::CARROT()->setCount($this->age >= self::MAX_AGE ? mt_rand(1, 4) : 1)
+			VanillaItems::CARROT()->setCount($this->age >= self::MAX_AGE ? FortuneDropHelper::binomial($item, 1) : 1)
 		];
 	}
 

src/block/CarvedPumpkin.php

@@ -24,9 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 
 class CarvedPumpkin extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 }

src/block/CaveVines.php

@@ -87,18 +87,18 @@ class CaveVines extends Flowable{
 		return $this->berries ? 14 : 0;
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::DOWN)->equals(SupportType::FULL()) || $block->hasSameTypeId($this);
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::UP)->equals(SupportType::FULL()) || $block->hasSameTypeId($this);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::UP))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide(Facing::UP))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 		$this->age = mt_rand(0, self::MAX_AGE);

src/block/ChemistryTable.php

@@ -24,14 +24,12 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\item\Item;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 final class ChemistryTable extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		//TODO

src/block/Chest.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Chest as TileChest;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\event\block\ChestPairEvent;
 use pocketmine\item\Item;
@@ -36,7 +35,6 @@ use pocketmine\player\Player;
 
 class Chest extends Transparent{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	/**
 	 * @return AxisAlignedBB[]

src/block/CoalOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,7 @@ class CoalOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::COAL()
+			VanillaItems::COAL()->setCount(FortuneDropHelper::weighted($item, min: 1, maxBase: 1))
 		];
 	}
 

src/block/CopperOre.php

@@ -23,13 +23,16 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 
 final class CopperOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		return [VanillaItems::RAW_COPPER()];
+		return [
+			VanillaItems::RAW_COPPER()->setCount(FortuneDropHelper::weighted($item, min: 2, maxBase: 5)),
+		];
 	}
 
 	public function isAffectedBySilkTouch() : bool{ return true; }

src/block/Coral.php

@@ -32,7 +32,7 @@ use pocketmine\world\BlockTransaction;
 final class Coral extends BaseCoral{
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($tx->fetchBlock($blockReplace->getPosition()->down()))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
@@ -40,14 +40,14 @@ final class Coral extends BaseCoral{
 
 	public function onNearbyBlockChange() : void{
 		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedBy($world->getBlock($this->position->down()))){
+		if(!$this->canBeSupportedAt($this)){
 			$world->useBreakOn($this->position);
 		}else{
 			parent::onNearbyBlockChange();
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}
 }

src/block/DiamondOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,7 @@ class DiamondOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::DIAMOND()
+			VanillaItems::DIAMOND()->setCount(FortuneDropHelper::weighted($item, min: 1, maxBase: 1))
 		];
 	}
 

src/block/Door.php

@@ -106,7 +106,7 @@ class Door extends Transparent{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN)) && !$this->getSide(Facing::DOWN) instanceof Door){ //Replace with common break method
+		if(!$this->canBeSupportedAt($this) && !$this->getSide(Facing::DOWN) instanceof Door){ //Replace with common break method
 			$this->position->getWorld()->useBreakOn($this->position); //this will delete both halves if they exist
 		}
 	}
@@ -114,8 +114,7 @@ class Door extends Transparent{
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face === Facing::UP){
 			$blockUp = $this->getSide(Facing::UP);
-			$blockDown = $this->getSide(Facing::DOWN);
-			if(!$blockUp->canBeReplaced() || !$this->canBeSupportedBy($blockDown)){
+			if(!$blockUp->canBeReplaced() || !$this->canBeSupportedAt($blockReplace)){
 				return false;
 			}
 
@@ -172,7 +171,7 @@ class Door extends Transparent{
 		return parent::getAffectedBlocks();
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->hasEdgeSupport();
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport();
 	}
 }

src/block/DoubleTallGrass.php

@@ -23,19 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\TallGrassTrait;
 use pocketmine\item\Item;
-use pocketmine\item\VanillaItems;
-use function mt_rand;
 
 class DoubleTallGrass extends DoublePlant{
+	use TallGrassTrait {
+		getDropsForIncompatibleTool as traitGetDropsForIncompatibleTool;
+	}
 
 	public function canBeReplaced() : bool{
 		return true;
 	}
 
 	public function getDropsForIncompatibleTool(Item $item) : array{
-		if($this->top && mt_rand(0, 7) === 0){
-			return [VanillaItems::WHEAT_SEEDS()];
+		if($this->top){
+			return $this->traitGetDropsForIncompatibleTool($item);
 		}
 		return [];
 	}

src/block/EmeraldOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,7 @@ class EmeraldOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::EMERALD()
+			VanillaItems::EMERALD()->setCount(FortuneDropHelper::weighted($item, min: 1, maxBase: 1))
 		];
 	}
 

src/block/EndPortalFrame.php

@@ -24,14 +24,12 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 
 class EndPortalFrame extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	protected bool $eye = false;
 

src/block/EnderChest.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\inventory\EnderChestInventory;
 use pocketmine\block\tile\EnderChest as TileEnderChest;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
@@ -36,7 +35,6 @@ use pocketmine\player\Player;
 
 class EnderChest extends Transparent{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	public function getLightLevel() : int{
 		return 7;

src/block/Fire.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\BlockBurnEvent;
 use pocketmine\event\block\BlockSpreadEvent;
@@ -58,12 +59,16 @@ class Fire extends BaseFire{
 		return 1;
 	}
 
+	private function canBeSupportedBy(Block $block) : bool{
+		return $block->getSupportType(Facing::UP)->equals(SupportType::FULL());
+	}
+
 	public function onNearbyBlockChange() : void{
 		$world = $this->position->getWorld();
 		$down = $this->getSide(Facing::DOWN);
 		if(SoulFire::canBeSupportedBy($down)){
 			$world->setBlock($this->position, VanillaBlocks::SOUL_FIRE());
-		}elseif($down->isTransparent() && !$this->hasAdjacentFlammableBlocks()){
+		}elseif(!$this->canBeSupportedBy($this->getSide(Facing::DOWN)) && !$this->hasAdjacentFlammableBlocks()){
 			$world->setBlock($this->position, VanillaBlocks::AIR());
 		}else{
 			$world->scheduleDelayedBlockUpdate($this->position, mt_rand(30, 40));

src/block/FloorCoralFan.php

@@ -53,7 +53,7 @@ final class FloorCoralFan extends BaseCoral{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($tx->fetchBlock($blockReplace->getPosition()->down()))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 		if($player !== null){
@@ -75,15 +75,15 @@ final class FloorCoralFan extends BaseCoral{
 
 	public function onNearbyBlockChange() : void{
 		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedBy($world->getBlock($this->position->down()))){
+		if(!$this->canBeSupportedAt($this)){
 			$world->useBreakOn($this->position);
 		}else{
 			parent::onNearbyBlockChange();
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}
 
 	public function asItem() : Item{

src/block/FlowerPot.php

@@ -90,7 +90,7 @@ class FlowerPot extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 
@@ -98,13 +98,13 @@ class FlowerPot extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/FrostedIce.php

@@ -48,12 +48,7 @@ class FrostedIce extends Ice{
 	}
 
 	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		if(!$this->checkAdjacentBlocks(2)){
-			$world->useBreakOn($this->position);
-		}else{
-			$world->scheduleDelayedBlockUpdate($this->position, mt_rand(20, 40));
-		}
+		$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(20, 40));
 	}
 
 	public function onRandomTick() : void{

src/block/Furnace.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Furnace as TileFurnace;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\crafting\FurnaceType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
@@ -35,7 +34,6 @@ use function mt_rand;
 
 class Furnace extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	protected FurnaceType $furnaceType;
 

src/block/GildedBlackstone.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -30,7 +31,7 @@ use function mt_rand;
 final class GildedBlackstone extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if(mt_rand(1, 10) === 1){
+		if(FortuneDropHelper::bonusChanceDivisor($item, 10, 3)){
 			return [VanillaItems::GOLD_NUGGET()->setCount(mt_rand(2, 5))];
 		}
 

src/block/GlazedTerracotta.php

@@ -26,12 +26,10 @@ namespace pocketmine\block;
 use pocketmine\block\utils\ColoredTrait;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 
 class GlazedTerracotta extends Opaque{
 	use ColoredTrait;
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
 		$this->color = DyeColor::BLACK();

src/block/GlowLichen.php

@@ -0,0 +1,284 @@
+<?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\data\runtime\RuntimeDataDescriber;
+use pocketmine\event\block\BlockSpreadEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\World;
+use function array_key_first;
+use function count;
+use function shuffle;
+
+class GlowLichen extends Transparent{
+
+	/** @var int[] */
+	protected array $faces = [];
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->facingFlags($this->faces);
+	}
+
+	/** @return int[] */
+	public function getFaces() : array{ return $this->faces; }
+
+	public function hasFace(int $face) : bool{
+		return isset($this->faces[$face]);
+	}
+
+	/**
+	 * @param int[] $faces
+	 * @return $this
+	 */
+	public function setFaces(array $faces) : self{
+		$uniqueFaces = [];
+		foreach($faces as $face){
+			Facing::validate($face);
+			$uniqueFaces[$face] = $face;
+		}
+		$this->faces = $uniqueFaces;
+		return $this;
+	}
+
+	/** @return $this */
+	public function setFace(int $face, bool $value) : self{
+		Facing::validate($face);
+		if($value){
+			$this->faces[$face] = $face;
+		}else{
+			unset($this->faces[$face]);
+		}
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return 7;
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
+	public function canBeReplaced() : bool{
+		return true;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->faces = $blockReplace instanceof GlowLichen ? $blockReplace->faces : [];
+		$availableFaces = $this->getAvailableFaces();
+
+		if(count($availableFaces) === 0){
+			return false;
+		}
+
+		$opposite = Facing::opposite($face);
+		$placedFace = isset($availableFaces[$opposite]) ? $opposite : array_key_first($availableFaces);
+		$this->faces[$placedFace] = $placedFace;
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		$changed = false;
+
+		foreach($this->faces as $face){
+			if(!$this->getAdjacentSupportType($face)->equals(SupportType::FULL())){
+				unset($this->faces[$face]);
+				$changed = true;
+			}
+		}
+
+		if($changed){
+			$world = $this->position->getWorld();
+			if(count($this->faces) === 0){
+				$world->useBreakOn($this->position);
+			}else{
+				$world->setBlock($this->position, $this);
+			}
+		}
+	}
+
+	private function getSpreadBlock(Block $replace, int $spreadFace) : ?Block{
+		if($replace instanceof self && $replace->hasSameTypeId($this)){
+			if($replace->hasFace($spreadFace)){
+				return null;
+			}
+			$result = $replace;
+		}elseif($replace->getTypeId() === BlockTypeIds::AIR){
+			$result = VanillaBlocks::GLOW_LICHEN();
+		}else{
+			//TODO: if this is a water block, generate a waterlogged block
+			return null;
+		}
+		return $result->setFace($spreadFace, true);
+	}
+
+	private function spread(World $world, Vector3 $replacePos, int $spreadFace) : bool{
+		$supportBlock = $world->getBlock($replacePos->getSide($spreadFace));
+		$supportFace = Facing::opposite($spreadFace);
+
+		if(!$supportBlock->getSupportType($supportFace)->equals(SupportType::FULL())){
+			return false;
+		}
+
+		$replacedBlock = $supportBlock->getSide($supportFace);
+		$replacementBlock = $this->getSpreadBlock($replacedBlock, Facing::opposite($supportFace));
+		if($replacementBlock === null){
+			return false;
+		}
+
+		$ev = new BlockSpreadEvent($replacedBlock, $this, $replacementBlock);
+		$ev->call();
+		if(!$ev->isCancelled()){
+			$world->setBlock($replacedBlock->getPosition(), $ev->getNewState());
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @phpstan-return \Generator<int, int, void, void>
+	 */
+	private static function getShuffledSpreadFaces(int $sourceFace) : \Generator{
+		$skipAxis = Facing::axis($sourceFace);
+
+		$faces = Facing::ALL;
+		shuffle($faces);
+		foreach($faces as $spreadFace){
+			if(Facing::axis($spreadFace) !== $skipAxis){
+				yield $spreadFace;
+			}
+		}
+	}
+
+	private function spreadAroundSupport(int $sourceFace) : bool{
+		$world = $this->position->getWorld();
+
+		$supportPos = $this->position->getSide($sourceFace);
+		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
+			$replacePos = $supportPos->getSide($spreadFace);
+			if($this->spread($world, $replacePos, Facing::opposite($spreadFace))){
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private function spreadAdjacentToSupport(int $sourceFace) : bool{
+		$world = $this->position->getWorld();
+
+		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
+			$replacePos = $this->position->getSide($spreadFace);
+			if($this->spread($world, $replacePos, $sourceFace)){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private function spreadWithinSelf(int $sourceFace) : bool{
+		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
+			if(!$this->hasFace($spreadFace) && $this->spread($this->position->getWorld(), $this->position, $spreadFace)){
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($item instanceof Fertilizer && count($this->faces) > 0){
+			$shuffledFaces = $this->faces;
+			shuffle($shuffledFaces);
+
+			$spreadMethods = [
+				$this->spreadAroundSupport(...),
+				$this->spreadAdjacentToSupport(...),
+				$this->spreadWithinSelf(...),
+			];
+			shuffle($spreadMethods);
+
+			foreach($shuffledFaces as $sourceFace){
+				foreach($spreadMethods as $spreadMethod){
+					if($spreadMethod($sourceFace)){
+						$item->pop();
+						break 2;
+					}
+				}
+			}
+
+			return true;
+		}
+		return false;
+	}
+
+	public function getDrops(Item $item) : array{
+		if(($item->getBlockToolType() & BlockToolType::SHEARS) !== 0){
+			return $this->getDropsForCompatibleTool($item);
+		}
+
+		return [];
+	}
+
+	public function getFlameEncouragement() : int{
+		return 15;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
+
+	/**
+	 * @return array<int, int> $faces
+	 */
+	private function getAvailableFaces() : array{
+		$faces = [];
+		foreach(Facing::ALL as $face){
+			if(!$this->hasFace($face) && $this->getAdjacentSupportType($face)->equals(SupportType::FULL())){
+				$faces[$face] = $face;
+			}
+		}
+		return $faces;
+	}
+}

src/block/Glowstone.php

@@ -23,9 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
+use function min;
 
 class Glowstone extends Transparent{
 
@@ -35,7 +36,7 @@ class Glowstone extends Transparent{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::GLOWSTONE_DUST()->setCount(mt_rand(2, 4))
+			VanillaItems::GLOWSTONE_DUST()->setCount(min(4, FortuneDropHelper::discrete($item, 2, 4)))
 		];
 	}
 

src/block/Gravel.php

@@ -25,15 +25,15 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\Fallable;
 use pocketmine\block\utils\FallableTrait;
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
 
 class Gravel extends Opaque implements Fallable{
 	use FallableTrait;
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if(mt_rand(1, 10) === 1){
+		if(FortuneDropHelper::bonusChanceDivisor($item, 10, 3)){
 			return [
 				VanillaItems::FLINT()
 			];

src/block/ItemFrame.php

@@ -163,18 +163,18 @@ class ItemFrame extends Flowable{
 		return true;
 	}
 
-	private function canBeSupportedBy(Block $block, int $face) : bool{
-		return !$block->getSupportType($face)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return !$block->getAdjacentSupportType($face)->equals(SupportType::NONE());
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)){
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing))){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide(Facing::opposite($face)), $face)){
+		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}
 

src/block/Ladder.php

@@ -70,7 +70,7 @@ class Ladder extends Transparent{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::opposite($face)), $face) && Facing::axis($face) !== Axis::Y){
+		if($this->canBeSupportedAt($blockReplace, Facing::opposite($face)) && Facing::axis($face) !== Axis::Y){
 			$this->facing = $face;
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
@@ -79,12 +79,12 @@ class Ladder extends Transparent{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)), $this->facing)){ //Replace with common break method
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing))){ //Replace with common break method
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block, int $face) : bool{
-		return $block->getSupportType($face)->equals(SupportType::FULL());
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return $block->getAdjacentSupportType($face)->equals(SupportType::FULL());
 	}
 }

src/block/Lantern.php

@@ -77,22 +77,23 @@ class Lantern extends Transparent{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide(Facing::UP), Facing::DOWN) && !$this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN), Facing::UP)){
+		$downSupport = $this->canBeSupportedAt($blockReplace, Facing::DOWN);
+		if(!$downSupport && !$this->canBeSupportedAt($blockReplace, Facing::UP)){
 			return false;
 		}
 
-		$this->hanging = ($face === Facing::DOWN || !$this->canBeSupportedBy($this->position->getWorld()->getBlock($blockReplace->getPosition()->down()), Facing::UP));
+		$this->hanging = $face === Facing::DOWN || !$downSupport;
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
 	public function onNearbyBlockChange() : void{
 		$face = $this->hanging ? Facing::UP : Facing::DOWN;
-		if(!$this->canBeSupportedBy($this->getSide($face), Facing::opposite($face))){
+		if(!$this->canBeSupportedAt($this, $face)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block, int $face) : bool{
-		return $block->getSupportType($face)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return $block->getAdjacentSupportType($face)->hasCenterSupport();
 	}
 }

src/block/LapisOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,7 @@ class LapisOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::LAPIS_LAZULI()->setCount(mt_rand(4, 8))
+			VanillaItems::LAPIS_LAZULI()->setCount(FortuneDropHelper::weighted($item, min: 4, maxBase: 9))
 		];
 	}
 

src/block/Leaves.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\block\utils\LeavesType;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -138,7 +139,8 @@ class Leaves extends Transparent{
 		}
 
 		$drops = [];
-		if(mt_rand(1, 20) === 1){ //Saplings
+		if(FortuneDropHelper::bonusChanceDivisor($item, 20, 4)){ //Saplings
+			// TODO: according to the wiki, the jungle saplings have a different drop rate
 			$sapling = (match($this->leavesType){
 				LeavesType::ACACIA() => VanillaBlocks::ACACIA_SAPLING(),
 				LeavesType::BIRCH() => VanillaBlocks::BIRCH_SAPLING(),
@@ -148,16 +150,20 @@ class Leaves extends Transparent{
 				LeavesType::SPRUCE() => VanillaBlocks::SPRUCE_SAPLING(),
 				LeavesType::MANGROVE(), //TODO: mangrove propagule
 				LeavesType::AZALEA(), LeavesType::FLOWERING_AZALEA() => null, //TODO: azalea
+				LeavesType::CHERRY() => null, //TODO: cherry
 				default => throw new AssumptionFailedError("Unreachable")
 			})?->asItem();
 			if($sapling !== null){
 				$drops[] = $sapling;
 			}
 		}
-		if(($this->leavesType->equals(LeavesType::OAK()) || $this->leavesType->equals(LeavesType::DARK_OAK())) && mt_rand(1, 200) === 1){ //Apples
+		if(
+			($this->leavesType->equals(LeavesType::OAK()) || $this->leavesType->equals(LeavesType::DARK_OAK())) &&
+			FortuneDropHelper::bonusChanceDivisor($item, 200, 20)
+		){ //Apples
 			$drops[] = VanillaItems::APPLE();
 		}
-		if(mt_rand(1, 50) === 1){
+		if(FortuneDropHelper::bonusChanceDivisor($item, 50, 5)){
 			$drops[] = VanillaItems::STICK()->setCount(mt_rand(1, 2));
 		}
 

src/block/Lectern.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Lectern as TileLectern;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
@@ -39,7 +38,6 @@ use function count;
 
 class Lectern extends Transparent{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	protected int $viewedPage = 0;
 	protected ?WritableBookBase $book = null;

src/block/Lever.php

@@ -66,7 +66,7 @@ class Lever extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide(Facing::opposite($face)), $face)){
+		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}
 
@@ -90,8 +90,7 @@ class Lever extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		$facing = $this->facing->getFacing();
-		if(!$this->canBeSupportedBy($this->getSide(Facing::opposite($facing)), $facing)){
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing->getFacing()))){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
@@ -107,8 +106,8 @@ class Lever extends Flowable{
 		return true;
 	}
 
-	private function canBeSupportedBy(Block $block, int $face) : bool{
-		return $block->getSupportType($face)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block, int $face) : bool{
+		return $block->getAdjacentSupportType($face)->hasCenterSupport();
 	}
 
 	//TODO

src/block/Liquid.php

@@ -312,7 +312,7 @@ abstract class Liquid extends Transparent{
 			}
 
 			if($adjacentDecay <= self::MAX_DECAY){
-				$calculator = new MinimumCostFlowCalculator($world, $this->getFlowDecayPerBlock(), \Closure::fromCallable([$this, 'canFlowInto']));
+				$calculator = new MinimumCostFlowCalculator($world, $this->getFlowDecayPerBlock(), $this->canFlowInto(...));
 				foreach($calculator->getOptimalFlowDirections($this->position->getFloorX(), $this->position->getFloorY(), $this->position->getFloorZ()) as $facing){
 					$this->flowIntoBlock($world->getBlock($this->position->getSide($facing)), $adjacentDecay, false);
 				}

src/block/Loom.php

@@ -25,14 +25,12 @@ namespace pocketmine\block;
 
 use pocketmine\block\inventory\LoomInventory;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\item\Item;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 final class Loom extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){

src/block/Melon.php

@@ -23,15 +23,16 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
+use function min;
 
 class Melon extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::MELON()->setCount(mt_rand(3, 7))
+			VanillaItems::MELON()->setCount(min(9, FortuneDropHelper::discrete($item, 3, 7)))
 		];
 	}
 

src/block/MobHead.php

@@ -23,8 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\tile\Skull as TileSkull;
-use pocketmine\block\utils\SkullType;
+use pocketmine\block\tile\MobHead as TileMobHead;
+use pocketmine\block\utils\MobHeadType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
@@ -35,22 +35,22 @@ use pocketmine\world\BlockTransaction;
 use function assert;
 use function floor;
 
-class Skull extends Flowable{
+class MobHead extends Flowable{
 	public const MIN_ROTATION = 0;
 	public const MAX_ROTATION = 15;
 
-	protected SkullType $skullType;
+	protected MobHeadType $mobHeadType;
 
 	protected int $facing = Facing::NORTH;
 	protected int $rotation = self::MIN_ROTATION; //TODO: split this into floor skull and wall skull handling
 
 	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->skullType = SkullType::SKELETON(); //TODO: this should be a parameter
+		$this->mobHeadType = MobHeadType::SKELETON(); //TODO: this should be a parameter
 		parent::__construct($idInfo, $name, $typeInfo);
 	}
 
 	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
-		$w->skullType($this->skullType);
+		$w->mobHeadType($this->mobHeadType);
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
@@ -60,8 +60,8 @@ class Skull extends Flowable{
 	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 		$tile = $this->position->getWorld()->getTile($this->position);
-		if($tile instanceof TileSkull){
-			$this->skullType = $tile->getSkullType();
+		if($tile instanceof TileMobHead){
+			$this->mobHeadType = $tile->getMobHeadType();
 			$this->rotation = $tile->getRotation();
 		}
 
@@ -72,18 +72,18 @@ class Skull extends Flowable{
 		parent::writeStateToWorld();
 		//extra block properties storage hack
 		$tile = $this->position->getWorld()->getTile($this->position);
-		assert($tile instanceof TileSkull);
+		assert($tile instanceof TileMobHead);
 		$tile->setRotation($this->rotation);
-		$tile->setSkullType($this->skullType);
+		$tile->setMobHeadType($this->mobHeadType);
 	}
 
-	public function getSkullType() : SkullType{
-		return $this->skullType;
+	public function getMobHeadType() : MobHeadType{
+		return $this->mobHeadType;
 	}
 
 	/** @return $this */
-	public function setSkullType(SkullType $skullType) : self{
-		$this->skullType = $skullType;
+	public function setMobHeadType(MobHeadType $mobHeadType) : self{
+		$this->mobHeadType = $mobHeadType;
 		return $this;
 	}
 

src/block/NetherGoldOre.php

@@ -23,14 +23,14 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use function mt_rand;
 
 final class NetherGoldOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		return [VanillaItems::GOLD_NUGGET()->setCount(mt_rand(2, 6))];
+		return [VanillaItems::GOLD_NUGGET()->setCount(FortuneDropHelper::weighted($item, min: 2, maxBase: 6))];
 	}
 
 	public function isAffectedBySilkTouch() : bool{ return true; }

src/block/NetherQuartzOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,7 @@ class NetherQuartzOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::NETHER_QUARTZ()
+			VanillaItems::NETHER_QUARTZ()->setCount(FortuneDropHelper::weighted($item, min: 1, maxBase: 1))
 		];
 	}
 

src/block/NetherVines.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\Entity;
@@ -82,16 +83,13 @@ class NetherVines extends Flowable{
 		return true;
 	}
 
-	private function getSupportFace() : int{
-		return Facing::opposite($this->growthFace);
-	}
-
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType($this->getSupportFace())->hasCenterSupport() || $block->hasSameTypeId($this);
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::opposite($this->growthFace));
+		return $supportBlock->getSupportType($this->growthFace)->hasCenterSupport() || $supportBlock->hasSameTypeId($this);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide($this->getSupportFace()))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
@@ -108,7 +106,7 @@ class NetherVines extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide($this->getSupportFace()))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 		$this->age = mt_rand(0, self::MAX_AGE - 1);
@@ -179,7 +177,7 @@ class NetherVines extends Flowable{
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if(($item->getBlockToolType() & BlockToolType::SHEARS) !== 0 || mt_rand(1, 3) === 1){
+		if(($item->getBlockToolType() & BlockToolType::SHEARS) !== 0 || FortuneDropHelper::bonusChanceFixed($item, 1 / 3, 2 / 9)){
 			return [$this->asItem()];
 		}
 		return [];

src/block/NetherWartPlant.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\BlockGrowEvent;
 use pocketmine\item\Item;
@@ -85,7 +86,7 @@ class NetherWartPlant extends Flowable{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			$this->asItem()->setCount($this->age === self::MAX_AGE ? mt_rand(2, 4) : 1)
+			$this->asItem()->setCount($this->age === self::MAX_AGE ? FortuneDropHelper::discrete($item, 2, 4) : 1)
 		];
 	}
 }

src/block/Potato.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use function mt_rand;
@@ -31,7 +32,8 @@ class Potato extends Crops{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		$result = [
-			VanillaItems::POTATO()->setCount($this->age >= self::MAX_AGE ? mt_rand(1, 5) : 1)
+			//min/max would be 2-5 in Java
+			VanillaItems::POTATO()->setCount($this->age >= self::MAX_AGE ? FortuneDropHelper::binomial($item, 1) : 1)
 		];
 		if($this->age >= self::MAX_AGE && mt_rand(0, 49) === 0){
 			$result[] = VanillaItems::POISONOUS_POTATO();

src/block/PressurePlate.php

@@ -45,18 +45,18 @@ abstract class PressurePlate extends Transparent{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 		return false;
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return !$block->getSupportType(Facing::UP)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block) : bool{
+		return !$block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::NONE());
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}

src/block/RedstoneComparator.php

@@ -85,7 +85,7 @@ class RedstoneComparator extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			if($player !== null){
 				$this->facing = Facing::opposite($player->getHorizontalFacing());
 			}
@@ -102,13 +102,13 @@ class RedstoneComparator extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return !$block->getSupportType(Facing::UP)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block) : bool{
+		return !$block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::NONE());
 	}
 
 	//TODO: redstone functionality

src/block/RedstoneOre.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
@@ -81,7 +82,7 @@ class RedstoneOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::REDSTONE_DUST()->setCount(mt_rand(4, 5))
+			VanillaItems::REDSTONE_DUST()->setCount(FortuneDropHelper::discrete($item, 4, 5))
 		];
 	}
 

src/block/RedstoneRepeater.php

@@ -68,7 +68,7 @@ class RedstoneRepeater extends Flowable{
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			if($player !== null){
 				$this->facing = Facing::opposite($player->getHorizontalFacing());
 			}
@@ -88,13 +88,13 @@ class RedstoneRepeater extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return !$block->getSupportType(Facing::UP)->equals(SupportType::NONE());
+	private function canBeSupportedAt(Block $block) : bool{
+		return !$block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::NONE());
 	}
 
 	//TODO: redstone functionality

src/block/RedstoneWire.php

@@ -35,7 +35,7 @@ class RedstoneWire extends Flowable{
 	use AnalogRedstoneSignalEmitterTrait;
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 		return false;
@@ -49,13 +49,13 @@ class RedstoneWire extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->hasCenterSupport();
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}
 
 	public function asItem() : Item{

src/block/RuntimeBlockStateRegistry.php

@@ -123,7 +123,7 @@ class RuntimeBlockStateRegistry{
 			$block = clone $this->fullList[$stateId];
 		}else{
 			$typeId = $stateId >> Block::INTERNAL_STATE_DATA_BITS;
-			$stateData = $stateId & Block::INTERNAL_STATE_DATA_MASK;
+			$stateData = ($stateId ^ $typeId) & Block::INTERNAL_STATE_DATA_MASK;
 			$block = new UnknownBlock(new BID($typeId), new BlockTypeInfo(BreakInfo::instant()), $stateData);
 		}
 

src/block/SeaLantern.php

@@ -23,8 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
+use function min;
 
 class SeaLantern extends Transparent{
 
@@ -34,7 +36,7 @@ class SeaLantern extends Transparent{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			VanillaItems::PRISMARINE_CRYSTALS()->setCount(3)
+			VanillaItems::PRISMARINE_CRYSTALS()->setCount(min(5, FortuneDropHelper::discrete($item, 2, 3)))
 		];
 	}
 

src/block/ShulkerBox.php

@@ -25,6 +25,7 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\ShulkerBox as TileShulkerBox;
 use pocketmine\block\utils\AnyFacingTrait;
+use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
 use pocketmine\math\Vector3;
@@ -110,4 +111,8 @@ class ShulkerBox extends Opaque{
 
 		return true;
 	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
 }

src/block/SmallDripleaf.php

@@ -0,0 +1,170 @@
+<?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\HorizontalFacingTrait;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\event\block\StructureGrowEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\Position;
+use function mt_rand;
+
+class SmallDripleaf extends Transparent{
+	use HorizontalFacingTrait;
+
+	protected bool $top = false;
+
+	public function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->horizontalFacing($this->facing);
+		$w->bool($this->top);
+	}
+
+	public function isTop() : bool{
+		return $this->top;
+	}
+
+	/** @return $this */
+	public function setTop(bool $top) : self{
+		$this->top = $top;
+		return $this;
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		//TODO: Moss
+		//TODO: Small Dripleaf also can be placed on dirt, coarse dirt, farmland, grass blocks,
+		// podzol, rooted dirt, mycelium, and mud if these blocks are underwater (needs waterlogging)
+		return $block->getTypeId() === BlockTypeIds::CLAY;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->top && !$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
+			$this->position->getWorld()->useBreakOn($this->position);
+			return;
+		}
+		$face = $this->top ? Facing::DOWN : Facing::UP;
+		if(!$this->getSide($face)->hasSameTypeId($this)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$block = $blockReplace->getSide(Facing::UP);
+		if($block->getTypeId() !== BlockTypeIds::AIR || !$this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN))){
+			return false;
+		}
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+
+		$tx->addBlock($block->getPosition(), VanillaBlocks::SMALL_DRIPLEAF()
+			->setFacing($this->facing)
+			->setTop(true)
+		);
+		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 Fertilizer && $this->grow($player)){
+			$item->pop();
+			return true;
+		}
+		return false;
+	}
+
+	private function canGrowTo(Position $pos) : bool{
+		$world = $pos->getWorld();
+		if(!$world->isInWorld($pos->getFloorX(), $pos->getFloorY(), $pos->getFloorZ())){
+			return false;
+		}
+		$block = $world->getBlock($pos);
+		return $block->hasSameTypeId($this) || $block->getTypeId() === BlockTypeIds::AIR;
+	}
+
+	private function grow(?Player $player) : bool{
+		$bottomBlock = $this->top ? $this->getSide(Facing::DOWN) : $this;
+		if(!$this->hasSameTypeId($bottomBlock)){
+			return false;
+		}
+		$world = $this->position->getWorld();
+		$tx = new BlockTransaction($world);
+		$height = mt_rand(2, 5);
+		$grown = 0;
+		for($i = 0; $i < $height; $i++){
+			$pos = $bottomBlock->getSide(Facing::UP, $i)->getPosition();
+			if(!$this->canGrowTo($pos)){
+				break;
+			}
+			$block = ++$grown < $height && $this->canGrowTo($pos->getSide(Facing::UP)) ?
+				VanillaBlocks::BIG_DRIPLEAF_STEM() :
+				VanillaBlocks::BIG_DRIPLEAF_HEAD();
+			$tx->addBlock($pos, $block->setFacing($this->facing));
+		}
+		if($grown > 1){
+			$ev = new StructureGrowEvent($bottomBlock, $tx, $player);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				return $tx->apply();
+			}
+		}
+
+		return false;
+	}
+
+	public function getAffectedBlocks() : array{
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other->hasSameTypeId($this)){
+			return [$this, $other];
+		}
+		return parent::getAffectedBlocks();
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		if(!$this->top){
+			return [$this->asItem()];
+		}
+		return [];
+	}
+
+	public function getFlameEncouragement() : int{
+		return 15;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+}

src/block/SnowLayer.php

@@ -80,8 +80,8 @@ class SnowLayer extends Flowable implements Fallable{
 		return SupportType::NONE();
 	}
 
-	private function canBeSupportedBy(Block $b) : bool{
-		return $b->getSupportType(Facing::UP)->equals(SupportType::FULL());
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::FULL());
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
@@ -91,7 +91,7 @@ class SnowLayer extends Flowable implements Fallable{
 			}
 			$this->layers = $blockReplace->layers + 1;
 		}
-		if($this->canBeSupportedBy($blockReplace->getSide(Facing::DOWN))){
+		if($this->canBeSupportedAt($blockReplace)){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 

src/block/SporeBlossom.php

@@ -32,12 +32,12 @@ use pocketmine\world\BlockTransaction;
 
 final class SporeBlossom extends Flowable{
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::DOWN)->equals(SupportType::FULL());
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getAdjacentSupportType(Facing::UP)->equals(SupportType::FULL());
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->getSide(Facing::UP))){
+		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
 		}
 
@@ -45,12 +45,8 @@ final class SporeBlossom extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::UP))){
+		if(!$this->canBeSupportedAt($this)){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
-
-	public function getDropsForCompatibleTool(Item $item) : array{
-		return [];
-	}
 }

src/block/Stem.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\BlockGrowEvent;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
@@ -30,11 +31,35 @@ use function array_rand;
 use function mt_rand;
 
 abstract class Stem extends Crops{
+	protected int $facing = Facing::UP;
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		parent::describeBlockOnlyState($w);
+		$w->facingExcept($this->facing, Facing::DOWN);
+	}
+
+	public function getFacing() : int{ return $this->facing; }
+
+	/** @return $this */
+	public function setFacing(int $facing) : self{
+		if($facing === Facing::DOWN){
+			throw new \InvalidArgumentException("DOWN is not a valid facing for this block");
+		}
+		$this->facing = $facing;
+		return $this;
+	}
 
 	abstract protected function getPlant() : Block;
 
+	public function onNearbyBlockChange() : void{
+		if($this->facing !== Facing::UP && !$this->getSide($this->facing)->hasSameTypeId($this->getPlant())){
+			$this->position->getWorld()->setBlock($this->position, $this->setFacing(Facing::UP));
+		}
+		parent::onNearbyBlockChange();
+	}
+
 	public function onRandomTick() : void{
-		if(mt_rand(0, 2) === 1){
+		if($this->facing === Facing::UP && mt_rand(0, 2) === 1){
 			$world = $this->position->getWorld();
 			if($this->age < self::MAX_AGE){
 				$block = clone $this;
@@ -52,11 +77,13 @@ abstract class Stem extends Crops{
 					}
 				}
 
-				$side = $this->getSide(Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)]);
+				$facing = Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)];
+				$side = $this->getSide($facing);
 				if($side->getTypeId() === BlockTypeIds::AIR && $side->getSide(Facing::DOWN)->hasTypeTag(BlockTypeTags::DIRT)){
 					$ev = new BlockGrowEvent($side, $grow);
 					$ev->call();
 					if(!$ev->isCancelled()){
+						$world->setBlock($this->position, $this->setFacing($facing));
 						$world->setBlock($side->position, $ev->getNewState());
 					}
 				}

src/block/Stonecutter.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\inventory\StonecutterInventory;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
-use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
@@ -35,7 +34,6 @@ use pocketmine\player\Player;
 
 class Stonecutter extends Transparent{
 	use FacesOppositePlacingPlayerTrait;
-	use HorizontalFacingTrait;
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){

src/block/SweetBerryBush.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\FortuneDropHelper;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\Entity;
 use pocketmine\entity\Living;
@@ -108,13 +109,14 @@ class SweetBerryBush extends Flowable{
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if(($dropAmount = $this->getBerryDropAmount()) > 0){
-			return [
-				$this->asItem()->setCount($dropAmount)
-			];
-		}
-
-		return [];
+		$count = match($this->age){
+			self::STAGE_MATURE => FortuneDropHelper::discrete($item, 2, 3),
+			self::STAGE_BUSH_SOME_BERRIES => FortuneDropHelper::discrete($item, 1, 2),
+			default => 0
+		};
+		return [
+			$this->asItem()->setCount($count)
+		];
 	}
 
 	public function onNearbyBlockChange() : void{