Release 5.14.1

as seen in pmmp/BedrockBlockUpgradeSchema@ebd768e5b2, this enables use of newFlattenedName in more places (by allowing the flattened values to be transformed before building the new ID), as well as reducing the number of remappedStates in general by compacting stuff which was partially transformed like color silver -> light_gray.

.github/PULL_REQUEST_TEMPLATE.md

@@ -34,7 +34,10 @@ Requires translations:
 
 ## Tests
 <!--
-Details should be provided of tests done. Simply saying "tested" or equivalent is not acceptable.
-
-Attach scripts or actions to test this pull request, as well as the result
+PRs which have not been tested MUST be marked as draft.
 -->
+I tested this PR by doing the following (tick all that apply):
+- [ ] Writing PHPUnit tests (commit these in the `tests/phpunit` folder)
+- [ ] Playtesting using a Minecraft client (provide screenshots or a video)
+- [ ] Writing a test plugin (provide the code and sample output)
+- [ ] Other (provide details)

.github/dependabot.yml

@@ -3,7 +3,7 @@ updates:
 - package-ecosystem: composer
   directory: "/"
   schedule:
-    interval: daily
+    interval: weekly
     time: "10:00"
   open-pull-requests-limit: 10
   ignore:
@@ -21,4 +21,4 @@ updates:
 - package-ecosystem: github-actions
   directory: "/"
   schedule:
-    interval: daily
+    interval: weekly

.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@v5.0.0
+        uses: docker/build-push-action@v5.3.0
         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@v5.0.0
+        uses: docker/build-push-action@v5.3.0
         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@v5.0.0
+        uses: docker/build-push-action@v5.3.0
         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@v5.0.0
+        uses: docker/build-push-action@v5.3.0
         with:
           push: true
           context: ./pocketmine-mp

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

@@ -13,12 +13,12 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.26.0
+        uses: shivammathur/setup-php@2.30.2
         with:
-          php-version: 8.1
+          php-version: 8.2
 
       - name: Restore Composer package cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cache/composer/files

.github/workflows/draft-release.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php-version: [8.1]
+        php-version: [8.2]
 
     steps:
       - uses: actions/checkout@v4
@@ -20,12 +20,12 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.26.0
+        uses: shivammathur/setup-php@2.30.2
         with:
           php-version: ${{ matrix.php-version }}
 
       - name: Restore Composer package cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cache/composer/files
@@ -77,7 +77,7 @@ jobs:
             > build_info.json
 
       - name: Upload release artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: release_artifacts
           path: |
@@ -86,7 +86,7 @@ jobs:
             ${{ github.workspace }}/build_info.json
 
       - name: Create draft release
-        uses: ncipollo/release-action@v1.13.0
+        uses: ncipollo/release-action@v1.14.0
         with:
           artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json
           commit: ${{ github.sha }}

.github/workflows/main-php-matrix.yml

@@ -0,0 +1,165 @@
+name: CI (all supported PHP versions)
+
+on:
+  workflow_call:
+    inputs:
+      php:
+        description: 'PHP version in X.Y format'
+        required: true
+        type: string
+
+      #these are parameterized to ease updating
+      pm-version-major:
+        description: 'PocketMine-MP major version'
+        default: 5
+        type: number
+      image:
+        description: 'Runner image to use'
+        default: 'ubuntu-20.04'
+        type: string
+
+jobs:
+  phpstan:
+    name: PHPStan analysis
+    runs-on: ${{ inputs.image }}
+
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --prefer-dist --no-interaction
+
+      - name: Run PHPStan
+        run: ./vendor/bin/phpstan analyze --no-progress --memory-limit=2G
+
+  phpunit:
+    name: PHPUnit tests
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        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
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction
+
+      - name: Run integration tests
+        run: ./tests/travis.sh -t4
+
+  codegen:
+    name: Generated Code consistency checks
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction
+
+      - name: Regenerate registry annotations
+        run: php build/generate-registry-annotations.php src
+
+      - name: Regenerate KnownTranslation APIs
+        run: php build/generate-known-translation-apis.php
+
+      - name: Regenerate BedrockData available files constants
+        run: php build/generate-bedrockdata-path-consts.php
+
+      - name: Regenerate YmlServerProperties constants
+        run: php build/generate-pocketmine-yml-property-consts.php
+
+      - name: Verify code is unchanged
+        run: |
+          git diff
+          git diff --quiet

.github/workflows/main.yml

@@ -6,165 +6,17 @@ on:
   workflow_dispatch:
 
 jobs:
-  phpstan:
-    name: PHPStan analysis
-    runs-on: ${{ matrix.image }}
-
+  all-php-versions:
+    name: PHP ${{ matrix.php }}
     strategy:
       fail-fast: false
       matrix:
-        image: [ubuntu-20.04]
-        php: ["8.1", "8.2"]
+        php: ["8.1", "8.2", "8.3"]
 
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup PHP
-        uses: pmmp/setup-php-action@2.0.0
-        with:
-          php-version: ${{ matrix.php }}
-          install-path: "./bin"
-          pm-version-major: "5"
-
-      - name: Restore Composer package cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/composer/files
-            ~/.cache/composer/vcs
-          key: "composer-v2-cache-${{ matrix.php }}-${{ hashFiles('./composer.lock') }}"
-          restore-keys: |
-            composer-v2-cache-
-
-      - name: Install Composer dependencies
-        run: composer install --prefer-dist --no-interaction
-
-      - name: Run PHPStan
-        run: ./vendor/bin/phpstan analyze --no-progress --memory-limit=2G
-
-  phpunit:
-    name: PHPUnit tests
-    runs-on: ${{ matrix.image }}
-    strategy:
-      fail-fast: false
-      matrix:
-        image: [ubuntu-20.04]
-        php: ["8.1", "8.2"]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup PHP
-        uses: pmmp/setup-php-action@2.0.0
-        with:
-          php-version: ${{ matrix.php }}
-          install-path: "./bin"
-          pm-version-major: "5"
-
-      - name: Restore Composer package cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/composer/files
-            ~/.cache/composer/vcs
-          key: "composer-v2-cache-${{ matrix.php }}-${{ hashFiles('./composer.lock') }}"
-          restore-keys: |
-            composer-v2-cache-
-
-      - name: Install Composer dependencies
-        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
-    runs-on: ${{ matrix.image }}
-    strategy:
-      fail-fast: false
-      matrix:
-        image: [ubuntu-20.04]
-        php: ["8.1", "8.2"]
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-
-      - name: Setup PHP
-        uses: pmmp/setup-php-action@2.0.0
-        with:
-          php-version: ${{ matrix.php }}
-          install-path: "./bin"
-          pm-version-major: "5"
-
-      - name: Restore Composer package cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/composer/files
-            ~/.cache/composer/vcs
-          key: "composer-v2-cache-${{ matrix.php }}-${{ hashFiles('./composer.lock') }}"
-          restore-keys: |
-            composer-v2-cache-
-
-      - name: Install Composer dependencies
-        run: composer install --no-dev --prefer-dist --no-interaction
-
-      - name: Run integration tests
-        run: ./tests/travis.sh -t4
-
-  codegen:
-    name: Generated Code consistency checks
-    runs-on: ${{ matrix.image }}
-    strategy:
-      fail-fast: false
-      matrix:
-        image: [ubuntu-20.04]
-        php: ["8.1", "8.2"]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup PHP
-        uses: pmmp/setup-php-action@2.0.0
-        with:
-          php-version: ${{ matrix.php }}
-          install-path: "./bin"
-          pm-version-major: "5"
-
-      - name: Restore Composer package cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/composer/files
-            ~/.cache/composer/vcs
-          key: "composer-v2-cache-${{ matrix.php }}-${{ hashFiles('./composer.lock') }}"
-          restore-keys: |
-            composer-v2-cache-
-
-      - name: Install Composer dependencies
-        run: composer install --no-dev --prefer-dist --no-interaction
-
-      - name: Regenerate registry annotations
-        run: php build/generate-registry-annotations.php src
-
-      - name: Regenerate KnownTranslation APIs
-        run: php build/generate-known-translation-apis.php
-
-      - name: Regenerate RuntimeEnum(De)serializer
-        run: php build/generate-runtime-enum-serializers.php
-
-      - name: Regenerate BedrockData available files constants
-        run: php build/generate-bedrockdata-path-consts.php
-
-      - name: Regenerate YmlServerProperties constants
-        run: php build/generate-pocketmine-yml-property-consts.php
-
-      - name: Verify code is unchanged
-        run: |
-          git diff
-          git diff --quiet
+    uses: ./.github/workflows/main-php-matrix.yml
+    with:
+      php: ${{ matrix.php }}
+    secrets: inherit
 
   codestyle:
     name: Code Style checks
@@ -176,10 +28,10 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.26.0
+        uses: shivammathur/setup-php@2.30.2
         with:
-          php-version: 8.1
-          tools: php-cs-fixer:3.17
+          php-version: 8.2
+          tools: php-cs-fixer:3.49
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/support.yml

@@ -8,7 +8,7 @@ jobs:
   support:
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/support-requests@v3
+      - uses: dessant/support-requests@v4
         with:
           github-token: ${{ github.token }}
           support-label:  "Support request"

BUILDING.md

@@ -2,7 +2,7 @@
 ## Pre-requisites
 - A bash shell (git bash is sufficient for Windows)
 - [`git`](https://git-scm.com) available in your shell
-- PHP 8.1 or newer available in your shell
+- PHP 8.2 or newer available in your shell
 - [`composer`](https://getcomposer.org) available in your shell
 
 ## Custom PHP binaries

README.md

@@ -20,31 +20,61 @@
 	<a href="https://github.com/pmmp/PocketMine-MP/releases/latest"><img alt="GitHub release (latest by SemVer)" src="https://img.shields.io/github/downloads/pmmp/PocketMine-MP/latest/total?sort=semver"></a>
 </p>
 
-## Getting started
+## What is this?
+PocketMine-MP is a highly customisable server software for Minecraft: Bedrock Edition, built from scratch in PHP, with over 10 years of history.
+
+If you're looking to create a Minecraft: Bedrock server with **custom functionality**, look no further.
+
+- 🧩 **Powerful plugin API** - extend and customise gameplay as you see fit
+- 🗺️ **Rich ecosystem** and **large developer community** - find plugins easily and learn to develop your own
+- 🌐 **Multi-world support** - offer a more varied game experience to players without transferring them to other server nodes
+- 🏎️ **Performance** - get 100+ players onto one server (depending on hardware and plugins)
+- ⤴️ **Continuously updated** - new Minecraft versions are usually supported within days
+
+## :x: PocketMine-MP is NOT a vanilla Minecraft server software.
+**It is poorly suited to hosting vanilla survival servers.**
+It doesn't have many features from the vanilla game, such as vanilla world generation, redstone, mob AI, and various other things.
+
+If you just want to play **vanilla survival multiplayer**, consider using the [official Minecraft: Bedrock server software](https://minecraft.net/download/server/bedrock) instead of PocketMine-MP.
+
+If that's not an option for you, you may be able to add some of PocketMine-MP's missing features using plugins from [Poggit](https://poggit.pmmp.io/plugins), or write plugins to implement them yourself.
+
+## Getting Started
 - [Documentation](http://pmmp.readthedocs.org/)
 - [Installation instructions](https://pmmp.readthedocs.io/en/rtfd/installation.html)
 - [Docker image](https://github.com/pmmp/PocketMine-MP/pkgs/container/pocketmine-mp)
 - [Plugin repository](https://poggit.pmmp.io/plugins)
 
 ## Community & Support
-- [Forums](https://forums.pmmp.io/)
-- [Discord](https://discord.gg/bmSAZBG)
-- [StackOverflow](https://stackoverflow.com/tags/pocketmine)
+Join our [Discord](https://discord.gg/bmSAZBG) server to chat with other users and developers.
+
+You can also post questions on [StackOverflow](https://stackoverflow.com/tags/pocketmine) under the tag `pocketmine`.
+
+## Developing Plugins
+If you want to write your own plugins, the following resources may be useful.
+Don't forget you can always ask our community if you need help.
 
-## For developers
- * [Building and running from source](BUILDING.md)
  * [Developer documentation](https://devdoc.pmmp.io) - General documentation for PocketMine-MP plugin developers
  * [Latest release API documentation](https://apidoc.pmmp.io) - Doxygen API documentation generated for each release
  * [Latest bleeding-edge API documentation](https://apidoc-dev.pmmp.io) - Doxygen API documentation generated weekly from `major-next` branch
  * [DevTools](https://github.com/pmmp/DevTools/) - Development tools plugin for creating plugins
  * [ExamplePlugin](https://github.com/pmmp/ExamplePlugin/) - Example plugin demonstrating some basic API features
+
+## Contributing to PocketMine-MP
+PocketMine-MP accepts community contributions! The following resources will be useful if you want to contribute to PocketMine-MP.
+ * [Building and running PocketMine-MP from source](BUILDING.md)
  * [Contributing Guidelines](CONTRIBUTING.md)
 
 ## Donate
-- Bitcoin Cash (BCH): `qq3r46hn6ljnhnqnfwxt5pg3g447eq9jhvw5ddfear`
+PocketMine-MP is free, but it requires a lot of time and effort from unpaid volunteers to develop. Donations enable us to keep delivering support for new versions and adding features your players love.
+
+You can support development using the following methods:
+
+- [Patreon](https://www.patreon.com/pocketminemp)
 - Bitcoin (BTC): `171u8K9e4FtU6j3e5sqNoxKUgEw9qWQdRV`
 - Stellar Lumens (XLM): `GAAC5WZ33HCTE3BFJFZJXONMEIBNHFLBXM2HJVAZHXXPYA3HP5XPPS7T`
-- [Patreon](https://www.patreon.com/pocketminemp)
+
+Thanks for your support!
 
 ## Licensing information
 This project is licensed under LGPL-3.0. Please see the [LICENSE](/LICENSE) file for details.

build/generate-biome-ids.php

@@ -0,0 +1,133 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\build\generate_biome_ids;
+
+use pocketmine\data\bedrock\BedrockDataFiles;
+use pocketmine\utils\Filesystem;
+use pocketmine\utils\Utils;
+use function asort;
+use function dirname;
+use function fclose;
+use function fopen;
+use function fwrite;
+use function is_array;
+use function is_int;
+use function is_string;
+use function json_decode;
+use function str_replace;
+use function strtoupper;
+use const SORT_NUMERIC;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+const HEADER = <<<'HEADER'
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+
+HEADER;
+
+/** @return resource */
+function safe_fopen(string $file, string $flags){
+	$result = fopen($file, $flags);
+	if($result === false){
+		throw new \RuntimeException("Failed to open file");
+	}
+	return $result;
+}
+
+function make_const_name(string $name) : string{
+	return strtoupper(str_replace(['.', 'minecraft:'], ['_', ''], $name));
+}
+
+/**
+ * @param int[] $map
+ * @phpstan-param array<string, int> $map
+ */
+function generate(array $map, string $outputFile) : void{
+	$file = safe_fopen($outputFile, 'wb');
+	fwrite($file, HEADER);
+	fwrite($file, <<<'CLASSHEADER'
+namespace pocketmine\data\bedrock;
+
+final class BiomeIds{
+
+	private function __construct(){
+		//NOOP
+	}
+
+
+CLASSHEADER
+);
+	$list = $map;
+	asort($list, SORT_NUMERIC);
+	$lastId = -1;
+	foreach(Utils::stringifyKeys($list) as $name => $id){
+		if($name === ""){
+			continue;
+		}
+		if($id !== $lastId + 1){
+			fwrite($file, "\n");
+		}
+		$lastId = $id;
+		fwrite($file, "\tpublic const " . make_const_name($name) . ' = ' . $id . ';' . "\n");
+	}
+	fwrite($file, "}\n");
+	fclose($file);
+}
+
+$ids = json_decode(Filesystem::fileGetContents(BedrockDataFiles::BIOME_ID_MAP_JSON), true);
+if(!is_array($ids)){
+	throw new \RuntimeException("Invalid biome ID map, expected array for root JSON object");
+}
+$cleanedIds = [];
+foreach($ids as $name => $id){
+	if(!is_string($name) || !is_int($id)){
+		throw new \RuntimeException("Invalid biome ID map, expected string => int map");
+	}
+	$cleanedIds[$name] = $id;
+}
+generate($cleanedIds, dirname(__DIR__) . '/src/data/bedrock/BiomeIds.php');
+
+echo "Done. Don't forget to run CS fixup after generating code.\n";

build/generate-build-info-json.php

@@ -21,6 +21,9 @@
 
 declare(strict_types=1);
 
+use pocketmine\network\mcpe\protocol\ProtocolInfo;
+use pocketmine\VersionInfo;
+
 require dirname(__DIR__) . '/vendor/autoload.php';
 
 if(count($argv) !== 7){
@@ -30,12 +33,12 @@ if(count($argv) !== 7){
 
 echo json_encode([
 	"php_version" => sprintf("%d.%d", PHP_MAJOR_VERSION, PHP_MINOR_VERSION), //deprecated
-	"base_version" => \pocketmine\VersionInfo::BASE_VERSION,
+	"base_version" => VersionInfo::BASE_VERSION,
 	"build" => (int) $argv[4],
-	"is_dev" => \pocketmine\VersionInfo::IS_DEVELOPMENT_BUILD,
-	"channel" => \pocketmine\VersionInfo::BUILD_CHANNEL,
+	"is_dev" => VersionInfo::IS_DEVELOPMENT_BUILD,
+	"channel" => VersionInfo::BUILD_CHANNEL,
 	"git_commit" => $argv[1],
-	"mcpe_version" => \pocketmine\network\mcpe\protocol\ProtocolInfo::MINECRAFT_VERSION_NETWORK,
+	"mcpe_version" => ProtocolInfo::MINECRAFT_VERSION_NETWORK,
 	"date" => time(), //TODO: maybe we should embed this in VersionInfo?
 	"details_url" => "https://github.com/$argv[3]/releases/tag/$argv[2]",
 	"download_url" => "https://github.com/$argv[3]/releases/download/$argv[2]/PocketMine-MP.phar",

build/generate-runtime-enum-serializers.php

@@ -1,265 +0,0 @@
-<?php
-
-/*
- *
- *  ____            _        _   __  __ _                  __  __ ____
- * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
- * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
- * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
- * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * @author PocketMine Team
- * @link http://www.pocketmine.net/
- *
- *
- */
-
-declare(strict_types=1);
-
-namespace pocketmine\build\generate_runtime_enum_serializers;
-
-use pocketmine\block\utils\BellAttachmentType;
-use pocketmine\block\utils\CopperOxidation;
-use pocketmine\block\utils\CoralType;
-use pocketmine\block\utils\DirtType;
-use pocketmine\block\utils\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\SlabType;
-use pocketmine\item\MedicineType;
-use pocketmine\item\PotionType;
-use pocketmine\item\SuspiciousStewType;
-use function array_key_first;
-use function array_keys;
-use function array_map;
-use function ceil;
-use function count;
-use function dirname;
-use function file_put_contents;
-use function implode;
-use function ksort;
-use function lcfirst;
-use function log;
-use function ob_get_clean;
-use function ob_start;
-use const SORT_STRING;
-
-require dirname(__DIR__) . '/vendor/autoload.php';
-
-/**
- * @param string[] $memberNames
- * @phpstan-param list<string> $memberNames
- *
- * @return string[]
- * @phpstan-return list<string>
- */
-function buildWriterFunc(string $virtualTypeName, string $nativeTypeName, array $memberNames, string $functionName) : array{
-	$bits = getBitsRequired($memberNames);
-	$lines = [];
-
-	$lines[] = "public function $functionName(\\$nativeTypeName &\$value) : void{";
-	$lines[] = "\t\$this->writeInt($bits, match(\$value){";
-
-	foreach($memberNames as $key => $memberName){
-		$lines[] = "\t\t$memberName => $key,";
-	}
-	$lines[] = "\t\tdefault => throw new \pocketmine\utils\AssumptionFailedError(\"All $virtualTypeName cases should be covered\")";
-	$lines[] = "\t});";
-	$lines[] = "}";
-
-	return $lines;
-}
-
-/**
- * @param string[] $memberNames
- * @phpstan-param list<string> $memberNames
- *
- * @return string[]
- * @phpstan-return list<string>
- */
-function buildReaderFunc(string $virtualTypeName, string $nativeTypeName, array $memberNames, string $functionName) : array{
-	$bits = getBitsRequired($memberNames);
-	$lines = [];
-
-	$lines[] = "public function $functionName(\\$nativeTypeName &\$value) : void{";
-	$lines[] = "\t\$value = match(\$this->readInt($bits)){";
-
-	foreach($memberNames as $key => $memberName){
-		$lines[] = "\t\t$key => $memberName,";
-	}
-	$lines[] = "\t\tdefault => throw new InvalidSerializedRuntimeDataException(\"Invalid serialized value for $virtualTypeName\")";
-	$lines[] = "\t};";
-	$lines[] = "}";
-
-	return $lines;
-}
-
-function buildInterfaceFunc(string $nativeTypeName, string $functionName) : string{
-	return "public function $functionName(\\$nativeTypeName &\$value) : void;";
-}
-
-/**
- * @param string[] $memberNames
- * @phpstan-param list<string> $memberNames
- *
- * @return string[]
- * @phpstan-return list<string>
- */
-function buildSizeCalculationFunc(string $nativeTypeName, string $functionName, array $memberNames) : array{
-	$lines = [];
-	$lines[] = "public function $functionName(\\$nativeTypeName &\$value) : void{";
-	$lines[] = "\t\$this->addBits(" . getBitsRequired($memberNames) . ");";
-	$lines[] = "}";
-
-	return $lines;
-}
-
-/**
- * @param mixed[] $members
- */
-function getBitsRequired(array $members) : int{
-	return (int) ceil(log(count($members), 2));
-}
-
-/**
- * @param object[] $members
- * @phpstan-param array<string, object> $members
- *
- * @return string[]
- * @phpstan-return list<string>
- */
-function stringifyEnumMembers(array $members, string $enumClass) : array{
-	ksort($members, SORT_STRING);
-	return array_map(fn(string $enumCaseName) => "\\$enumClass::$enumCaseName()", array_keys($members));
-}
-
-$enumsUsed = [
-	BellAttachmentType::getAll(),
-	CopperOxidation::getAll(),
-	CoralType::getAll(),
-	DirtType::getAll(),
-	DripleafState::getAll(),
-	DyeColor::getAll(),
-	FroglightType::getAll(),
-	LeverFacing::getAll(),
-	MedicineType::getAll(),
-	MushroomBlockType::getAll(),
-	MobHeadType::getAll(),
-	SlabType::getAll(),
-	SuspiciousStewType::getAll(),
-	PotionType::getAll()
-];
-
-$readerFuncs = [
-	"" => [
-		"abstract protected function readInt(int \$bits) : int;"
-	]
-];
-$writerFuncs = [
-	"" => [
-		"abstract protected function writeInt(int \$bits, int \$value) : void;"
-	]
-];
-$interfaceFuncs = [];
-$sizeCalculationFuncs = [
-	"" => [
-		"abstract protected function addBits(int \$bits) : void;"
-	]
-];
-
-foreach($enumsUsed as $enumMembers){
-	if(count($enumMembers) === 0){
-		throw new \InvalidArgumentException("Enum members cannot be empty");
-	}
-	$reflect = new \ReflectionClass($enumMembers[array_key_first($enumMembers)]);
-	$virtualTypeName = $reflect->getShortName();
-	$nativeTypeName = $reflect->getName();
-	$functionName = lcfirst($virtualTypeName);
-
-	$stringifiedMembers = stringifyEnumMembers($enumMembers, $nativeTypeName);
-	$writerFuncs[$functionName] = buildWriterFunc(
-		$virtualTypeName,
-		$nativeTypeName,
-		$stringifiedMembers,
-		$functionName
-	);
-	$readerFuncs[$functionName] = buildReaderFunc(
-		$virtualTypeName,
-		$nativeTypeName,
-		$stringifiedMembers,
-		$functionName
-	);
-	$interfaceFuncs[$functionName] = [buildInterfaceFunc(
-		$nativeTypeName,
-		$functionName
-	)];
-	$sizeCalculationFuncs[$functionName] = buildSizeCalculationFunc(
-		$nativeTypeName,
-		$functionName,
-		$stringifiedMembers
-	);
-}
-
-/**
- * @param string[][] $functions
- * @phpstan-param array<string, list<string>> $functions
- */
-function printFunctions(array $functions, string $className, string $classType) : void{
-	ksort($functions, SORT_STRING);
-
-	ob_start();
-
-	echo <<<'HEADER'
-<?php
-
-/*
- *
- *  ____            _        _   __  __ _                  __  __ ____
- * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
- * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
- * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
- * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * @author PocketMine Team
- * @link http://www.pocketmine.net/
- *
- *
- */
-
-declare(strict_types=1);
-
-namespace pocketmine\data\runtime;
-
-/**
- * This class is auto-generated. Do not edit it manually.
- * @see build/generate-runtime-enum-serializers.php
- */
-
-HEADER;
-
-	echo "$classType $className{\n\n";
-	echo implode("\n\n", array_map(fn(array $functionLines) => "\t" . implode("\n\t", $functionLines), $functions));
-	echo "\n\n}\n";
-
-	file_put_contents(dirname(__DIR__) . '/src/data/runtime/' . $className . '.php', ob_get_clean());
-}
-
-printFunctions($writerFuncs, "RuntimeEnumSerializerTrait", "trait");
-printFunctions($readerFuncs, "RuntimeEnumDeserializerTrait", "trait");
-printFunctions($interfaceFuncs, "RuntimeEnumDescriber", "interface");
-printFunctions($sizeCalculationFuncs, "RuntimeEnumSizeCalculatorTrait", "trait");
-
-echo "Done. Don't forget to run CS fixup after generating code.\n";

build/server-phar-stub.php

@@ -0,0 +1,168 @@
+<?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\server_phar_stub;
+
+use function clearstatcache;
+use function copy;
+use function fclose;
+use function fflush;
+use function flock;
+use function fopen;
+use function fwrite;
+use function getmypid;
+use function hrtime;
+use function is_dir;
+use function is_file;
+use function mkdir;
+use function number_format;
+use function str_replace;
+use function stream_get_contents;
+use function sys_get_temp_dir;
+use function tempnam;
+use function unlink;
+use const DIRECTORY_SEPARATOR;
+use const LOCK_EX;
+use const LOCK_NB;
+use const LOCK_UN;
+
+/**
+ * Finds the appropriate tmp directory to store the decompressed phar cache, accounting for potential file name
+ * collisions.
+ */
+function preparePharCacheDirectory() : string{
+	clearstatcache();
+
+	$i = 0;
+	do{
+		$tmpPath = sys_get_temp_dir() . '/PocketMine-MP-phar-cache.' . $i;
+		$i++;
+	}while(is_file($tmpPath));
+	if(!@mkdir($tmpPath) && !is_dir($tmpPath)){
+		throw new \RuntimeException("Failed to create temporary directory $tmpPath. Please ensure the disk has enough space and that the current user has permission to write to this location.");
+	}
+
+	return $tmpPath;
+}
+
+/**
+ * Deletes caches left behind by previous server instances.
+ * This ensures that the tmp directory doesn't get flooded by servers crashing in restart loops.
+ */
+function cleanupPharCache(string $tmpPath) : void{
+	clearstatcache();
+
+	/** @var string[] $matches */
+	foreach(new \RegexIterator(
+		new \FilesystemIterator(
+			$tmpPath,
+			\FilesystemIterator::CURRENT_AS_PATHNAME | \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::UNIX_PATHS
+		),
+		'/(.+)\.lock$/',
+		\RegexIterator::GET_MATCH
+	) as $matches){
+		$lockFilePath = $matches[0];
+		$baseTmpPath = $matches[1];
+
+		$file = @fopen($lockFilePath, "rb");
+		if($file === false){
+			//another process probably deleted the lock file already
+			continue;
+		}
+
+		if(flock($file, LOCK_EX | LOCK_NB)){
+			//this tmpfile is no longer in use
+			flock($file, LOCK_UN);
+			fclose($file);
+
+			unlink($lockFilePath);
+			unlink($baseTmpPath . ".tar");
+			unlink($baseTmpPath);
+			echo "Deleted stale phar cache at $baseTmpPath\n";
+		}else{
+			$pid = stream_get_contents($file);
+			fclose($file);
+
+			echo "Phar cache at $baseTmpPath is still in use by PID $pid\n";
+		}
+	}
+}
+
+function convertPharToTar(string $tmpName, string $pharPath) : string{
+	$tmpPharPath = $tmpName . ".phar";
+	copy($pharPath, $tmpPharPath);
+
+	$phar = new \Phar($tmpPharPath);
+	//phar requires phar.readonly=0, and zip doesn't support disabling compression - tar is the only viable option
+	//we don't need phar anyway since we don't need to directly execute the file, only require files from inside it
+	$phar->convertToData(\Phar::TAR, \Phar::NONE);
+	unset($phar);
+	\Phar::unlinkArchive($tmpPharPath);
+
+	return $tmpName . ".tar";
+}
+
+/**
+ * Locks a phar tmp cache to prevent it from being deleted by other server instances.
+ * This code looks similar to Filesystem::createLockFile(), but we can't use that because it's inside the compressed
+ * phar.
+ */
+function lockPharCache(string $lockFilePath) : void{
+	//this static variable will keep the file(s) locked until the process ends
+	static $lockFiles = [];
+
+	$lockFile = fopen($lockFilePath, "wb");
+	if($lockFile === false){
+		throw new \RuntimeException("Failed to open temporary file");
+	}
+	flock($lockFile, LOCK_EX); //this tells other server instances not to delete this cache file
+	fwrite($lockFile, (string) getmypid()); //maybe useful for debugging
+	fflush($lockFile);
+	$lockFiles[$lockFilePath] = $lockFile;
+}
+
+/**
+ * Prepares a decompressed .tar of PocketMine-MP.phar in the system temp directory for loading code from.
+ *
+ * @return string path to the temporary decompressed phar (actually a .tar)
+ */
+function preparePharCache(string $tmpPath, string $pharPath) : string{
+	clearstatcache();
+
+	$tmpName = tempnam($tmpPath, "PMMP");
+	if($tmpName === false){
+		throw new \RuntimeException("Failed to create temporary file");
+	}
+
+	lockPharCache($tmpName . ".lock");
+	return convertPharToTar($tmpName, $pharPath);
+}
+
+$tmpDir = preparePharCacheDirectory();
+cleanupPharCache($tmpDir);
+echo "Preparing PocketMine-MP.phar decompressed cache...\n";
+$start = hrtime(true);
+$cacheName = preparePharCache($tmpDir, __FILE__);
+echo "Cache ready at $cacheName in " . number_format((hrtime(true) - $start) / 1e9, 2) . "s\n";
+
+require 'phar://' . str_replace(DIRECTORY_SEPARATOR, '/', $cacheName) . '/src/PocketMine.php';

build/server-phar.php

@@ -23,7 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\build\server_phar;
 
+use pocketmine\utils\Filesystem;
 use pocketmine\utils\Git;
+use Symfony\Component\Filesystem\Path;
 use function array_map;
 use function count;
 use function dirname;
@@ -32,6 +34,7 @@ use function getcwd;
 use function getopt;
 use function implode;
 use function ini_get;
+use function is_string;
 use function microtime;
 use function preg_quote;
 use function realpath;
@@ -147,8 +150,17 @@ function main() : void{
 	}else{
 		$build = 0;
 	}
+	if(isset($opts["out"])){
+		if(!is_string($opts["out"])){
+			echo "--out cannot be specified multiple times" . PHP_EOL;
+			exit(1);
+		}
+		$pharPath = $opts["out"];
+	}else{
+		$pharPath = getcwd() . DIRECTORY_SEPARATOR . "PocketMine-MP.phar";
+	}
 	foreach(buildPhar(
-		$opts["out"] ?? getcwd() . DIRECTORY_SEPARATOR . "PocketMine-MP.phar",
+		$pharPath,
 		dirname(__DIR__) . DIRECTORY_SEPARATOR,
 		[
 			'resources',
@@ -159,21 +171,7 @@ function main() : void{
 			'git' => $gitHash,
 			'build' => $build
 		],
-		<<<'STUB'
-<?php
-
-$tmpDir = sys_get_temp_dir();
-if(!is_readable($tmpDir) or !is_writable($tmpDir)){
-	echo "ERROR: tmpdir $tmpDir is not accessible." . PHP_EOL;
-	echo "Check that the directory exists, and that the current user has read/write permissions for it." . PHP_EOL;
-	echo "Alternatively, set 'sys_temp_dir' to a different directory in your php.ini file." . PHP_EOL;
-	exit(1);
-}
-
-require("phar://" . __FILE__ . "/src/PocketMine.php");
-__HALT_COMPILER();
-STUB
-,
+		Filesystem::fileGetContents(Path::join(__DIR__, 'server-phar-stub.php')) . "\n__HALT_COMPILER();",
 		\Phar::SHA1,
 		\Phar::GZ
 	) as $line){

changelogs/4.26.md

@@ -0,0 +1,16 @@
+# 4.26.0
+Released 6th December 2023.
+
+**For Minecraft: Bedrock Edition 1.20.50**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.50.
+
+**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.50.
+- Removed support for older versions.

changelogs/5.10.md

@@ -0,0 +1,46 @@
+# 5.10.0
+Released 14th December 2023.
+
+**For Minecraft: Bedrock Edition 1.20.50**
+
+This is a minor feature release, including new gameplay features and minor performance improvements.
+
+**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
+- PHP 8.2 is now used by default. PHP 8.1 is still supported, but will be removed in a future 5.x release.
+- Improved timings reports by removing `Breakdown` timings group. This group serves no purpose with tree timings and made for confusing reading.
+
+## Performance
+- Improved performance of `Block::encodeFullState()` in most conditions. This in turn improves performance of `World::setBlock()` and `World::setBlockAt()`.
+- Improved network compression performance by avoiding unnecessary object allocations.
+- Timings now report time spent in individual `Snooze` handlers, making it easier to debug performance issues.
+
+## Gameplay
+### Blocks
+- Implemented crop growth speed modifiers.
+  - The following things now positively affect crop growth speed:
+    - Being planted on or being adjacent to farmland (hydrated farmland offers a larger benefit than dry farmland)
+    - Potential light level of at least 9
+    - Being planted in rows with space between them (or a different type of crop)
+  - The following things now negatively affect crop growth speed:
+    - Improper arrangement (e.g. the same crop on all sides)
+    - Insufficient light level (below 9)
+  - Poorly arranged crops will grow slower in this version. Past versions behaved as if crops were always planted in ideal conditions.
+  - Crops planted in ideal conditions will grow at the same speed as before.
+
+### Items
+- Added the following new items:
+  - All types of Smithing Template
+- Pitcher Pod is now correctly registered. In previous versions, it was mapped to the Pitcher Crop block, causing incorrect name display in commands.
+
+## Internals
+- Cleaned up various getter usages where direct property access is possible.
+- Avoided unnecessary repeated getter calls in some loops.
+- `NetworkSession` may now track `string` instead of `CompressBatchPromise` when a batch was synchronously compressed. This significantly reduces object allocations and improves performance.
+- `NetworkSession` now sends less information to clients on login validation failure. This avoids leaking potentially sensitive error information to clients.
+  - Clients can correlate their disconnects with server-side logs using the `Error ID` shown on the disconnect screen.

changelogs/5.11.md

@@ -0,0 +1,45 @@
+# 5.11.0
+Released 7th February 2024.
+
+**For Minecraft: Bedrock Edition 1.20.60**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.60.
+
+**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
+- Added support for Minecraft: Bedrock Edition 1.20.60.
+- Removed support for earlier versions.
+
+## Fixes
+- Fixed `tools/generate-item-upgrade-schema.php` not correctly handling items whose IDs were changed multiple times.
+- Fixed `ServerKiller` not working correctly in some cases (incorrectly handled wake-up conditions).
+- `ItemBlock`s of `Air` blocks are now always considered as "null" items regardless of count, and don't occupy inventory slots.
+
+## Internals
+- Restructured GitHub Actions CI workflows to make them easier to maintain (no need to update PHP versions in multiple places anymore).
+- GitHub Actions CodeStyle workflow now uses php-cs-fixer 3.49.x.
+- Dependabot updates are now processed weekly instead of daily.
+
+# 5.11.1
+Released 23rd February 2024.
+
+## Fixes
+- Fixed subchunk count calculation in `ChunkSerializer` for non-overworld dimension (useful for dimension plugins).
+- Harden options used for processing JSON data, particularly on the network, to close security issues.
+
+## Documentation
+- Fixed PHPStan signature for `Utils::cloneObjectArray()`.
+
+## Internals
+- Updated GitHub Actions versions to get rid of deprecation warnings.
+
+# 5.11.2
+Released 26th February 2024.
+
+## Fixes
+- Added extra checks for `BookEditPacket` handling.

changelogs/5.12.md

@@ -0,0 +1,63 @@
+# 5.12.0
+Released 28th February 2024
+
+**For Minecraft: Bedrock Edition 1.20.60**
+
+This is a minor feature release, with a few new features and improvements.
+
+**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
+- Added a `--version` command-line option to display the server version and exit.
+
+## Tools
+- Added `tools/generate-biome-ids.php` to generate `pocketmine\data\bedrock\BiomeIds`.
+- Fixed ordering of property values generated by `tools/generate-block-palette-spec.php`.
+
+## API
+### `pocketmine\block`
+- The following new classes have been added:
+  - `utils\LightableTrait` - used by blocks with `getLit()` and `setLit()` methods
+- The following methods have been deprecated:
+  - `Block->isSolid()` - this method returns confusing results which don't match expectations and no one really knows what it actually means
+- `CocoaBlock` now extends `Flowable` to match vanilla Minecraft behaviour.
+
+### `pocketmine\plugin`
+- `PluginManager->registerEvent()` now throws an exception when given a generator function for the event handler.
+- `PluginManager->registerEvents()` now throws an exception if any of the detected event handlers are generator functions. Use `@notHandler` to have the function ignored if intended.
+
+### `pocketmine\promise`
+- The following methods have been added:
+  - `public static Promise::all(list<Promise> $promises) : Promise` - returns a promise that is resolved once all given promises are resolved, or is rejected if any of the promises are rejected.
+
+### `pocketmine\scheduler`
+- The following methods have been deprecated:
+  - `AsyncWorker->getFromThreadStore()` - use class static properties for thread-local storage
+  - `AsyncWorker->removeFromThreadStore()`
+  - `AsyncWorker->saveToThreadStore()`
+
+## Documentation
+- Improved documentation of various methods in `Block`.
+
+## Gameplay
+- The following new items have been added:
+  - Name Tag
+
+## Internals
+- Removed specialization of shutdown logic for `Thread` vs `Worker` (no specialization is required).
+- Authentication system no longer accepts logins signed with the old Mojang root public key.
+- ID to enum mappings in `pocketmine\data` now use a new `match` convention to allow static analysis to ensure that all enum cases are handled.
+- Updated version of `pocketmine/bedrock-protocol` allows avoiding decoding of some itemstack data from the client in most cases, improving performance.
+
+# 5.12.1
+Released 13th March 2024.
+
+## Fixes
+- Fixed `Player Network Receive - Decompression` timings not being stopped correctly when receiving an uncompressed packet.
+
+## Internals
+- Removed hardcoded batch packet size limit. This was already covered by other limits anyway.

changelogs/5.13.md

@@ -0,0 +1,16 @@
+# 5.13.0
+Released 13th March 2024.
+
+**For Minecraft: Bedrock Edition 1.20.70**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.70.
+
+**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
+- Added support for Minecraft: Bedrock Edition 1.20.70.
+- Removed support for earlier versions.

changelogs/5.14.md

@@ -0,0 +1,94 @@
+# 5.14.0
+Released 5th April 2024.
+
+**For Minecraft: Bedrock Edition 1.20.70**
+
+This is a minor feature release, including performance improvements, minor gameplay features, new API features, and various internal improvements.
+
+**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
+- Added support for a `--no-log-file` command-line option, which disables the creation of a `server.log` file.
+  - **Use this with caution.** If you don't have another mechanism for collecting logs (e.g. Docker), this may make debugging harder.
+- Added support for automatic `server.log` rotation. When the `server.log` exceeds 32 MB, it will be renamed and moved to the `log_archive` folder in the server's data directory.
+  - Files in the `log_archive` folder can be safely modified or deleted without stopping the server.
+  - We suggest a cron job or similar to manage old log files (e.g. deleting or compressing them).
+- Added a new cache mechanism for `PocketMine-MP.phar`. This has several advantages:
+  - Caches are now reused by all threads - this significantly reduces `/tmp` usage (previously every thread generated its own cache, wasting lots of space)
+  - Dead cache files are automatically cleaned up by new servers - this means that a server crash loop won't flood `/tmp` anymore
+- `/status` now reports a more accurate number of threads on Windows.
+- Large resource packs are now able to be properly downloaded from the server.
+- Larger player skin sizes are now accepted by the server.
+- Improved logging from world providers to reduce spam when chunks contain invalid data.
+- Added more error logging for Anvil, PMAnvil and MCRegion worlds.
+- PHP deprecation warnings no longer cause the server to crash. This should make it easier for server owners to update to newer PHP versions.
+
+## Performance
+- Improved world loading performance. This was achieved through a combination of changes:
+  - Improvements to `BlockStateUpgrader` to avoid unnecessary work
+  - Improvements to `BlockStateUpgradeSchema` to clean up stupid code
+  - Improvements to `BlockStateReader` unused state handling
+  - Optimizations to `RegistryTrait` (see below)
+- Improved performance of `RegistryTrait::__callStatic()` accessor by introducing a fast-path optimization. Ensure that you access registries with the correct function name case to benefit from this.
+  - This improves the performance of `VanillaBlocks::WHATEVER()`, `VanillaItems`, etc.
+
+## Tools
+- `tools/generate-blockstate-upgrade-schema.php` now supports generating schemas using `flattenedValueRemaps` (described in [BlockStateUpgradeSchema](https://github.com/pmmp/BedrockBlockUpgradeSchema/releases/tag/4.0.0)).
+
+## Gameplay
+- Added sounds for armour equipping and unequipping.
+- Added sound for picking berries from a sweet berry bush.
+
+## API
+### `pocketmine\block\utils`
+- The following enum cases have been added:
+  - `BannerPatternType::GLOBE`
+  - `BannerPatternType::PIGLIN`
+
+### `pocketmine\event\player`
+- The following classes have been added:
+  - `PlayerResourcePackOfferEvent` - called before the server tells a connecting client which resource packs are available to download - allows customizing the pack list and other options
+
+### `pocketmine\item`
+- The following API methods have been added:
+  - `public ArmorMaterial->getEquipSound() : ?\pocketmine\world\Sound` - returns the sound to play when this armour is equipped or unequipped
+- The following API methods have signature changes:
+  - `ArmorMaterial->__construct()` now accepts an optional `?Sound $equipSound` parameter
+
+### `pocketmine\utils`
+- The following API methods have signature changes:
+  - `MainLogger->__construct()` now accepts `null` for the `$logFile` parameter - this disables the creation of a logger thread and log file
+  - `MainLogger->__construct()` now accepts an optional `?string $logArchiveDir` parameter. If set, this enables log archiving in the specified directory when the current log file exceeds 32 MB.
+
+## Dependencies
+- Now uses [`pocketmine/bedrock-block-upgrade-schema` version 4.0.0](https://github.com/pmmp/BedrockBlockUpgradeSchema/releases/tag/4.0.0).
+- Now uses [`pmmp/ext-pmmpthread` version 6.1.0](https://github.com/pmmp/ext-pmmpthread/releases/tag/6.1.0).
+- Now uses [`pocketmine/errorhandler` version 0.7.0](https://github.com/pmmp/ErrorHandler/releases/tag/0.7.0).
+- Now uses [`pocketmine/raklib` version 1.1.0](https://github.com/pmmp/RakLib/releases/tag/1.1.0).
+- Now uses [`pocketmine/raklib-ipc` version 1.0.0](https://github.com/pmmp/RakLibIpc/releases/tag/1.0.0).
+
+## Internals
+- (Re)Added support for RakLib packet ACK receipts. This was used to throttle resource pack sending and prevent network overloading.
+  - Added `NetworkSession->sendDataPacketWithReceipt()` to make use of this feature.
+  - `PacketSender` now requires an additional `?int $receiptId` parameter.
+- `ResourcePackPacketHandler` now uses `sendDataPacketWithReceipt()` to send resource packs, and delays sending the next chunk until the current one is acknowledged.
+- `ResourcePackPacketHandler` now accepts resource pack info directly in the constructor, instead of `ResourcePackManager`. This eases the implementation of `PlayerResourcePackOfferEvent`.
+- Increased `ZlibCompressor::DEFAULT_MAX_DECOMPRESSION_SIZE` to 8 MB (previously 2 MB). While this weakens server security, it appears to be necessary to deal with extremely bloated Persona skins.
+- Increased max split packet parts accepted by `RakLib` to 512 (previously 128). Again, this is necessary to deal with extremely bloated Persona skins.
+- Added a new cache mechanism for `PocketMine-MP.phar`.
+  - `ext-phar`'s default mechanism is extremely wasteful (generating a separate cache file per thread), and doesn't clean up after itself.
+  - The new cache mechanism is shared between all threads, and automatically cleans up stale caches.
+  - The phar stub (`build/server-phar-stub.php`) now converts the phar contents into a `.tar`, and decompresses all the files into `$TMPDIR/PocketMine-MP-phar-cache.<random>/`.
+  - `phar://` URIs still work with this system, but `new Phar(__FILE__)` must be replaced by `new PharData(__FILE__)` within PocketMine-MP core code.
+  - Backtraces from a `phar`'d server will now point to a location in the extracted phar cache, rather than the phar itself.
+- `block_factory_consistency_check` test (actually for `RuntimeBlockStateRegistry`) now stores less data, and is no longer affected by changes to internal state ID construction.
+
+# 5.14.1
+Released 5th April 2024.
+
+## Fixes
+- Fixed incorrect `pmmpthread` version check in server bootstrap.

changelogs/5.8.md

@@ -0,0 +1,138 @@
+# 5.8.0
+Released 1st November 2023.
+
+**Borked release, forgot to merge branches.**
+
+# 5.8.1
+Released 1st November 2023.
+
+**For Minecraft: Bedrock Edition 1.20.40**
+
+This is a minor feature release, including new gameplay features, various performance improvements to internal `World` and `Block` systems, and changes to the API.
+
+**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
+- Neighbour block updates now have a separate timer for timings. Previously, these were counted under `Scheduled Block Updates`, which was misleading.
+
+## Performance
+- `LightUpdate` now avoids attempting to propagate back in the same direction the light came from. This produces a small performance improvement of around 6% in light propagation.
+- Improved worst-case (non-cached) performance of `World::getCollisionBlocks()` (and its successor `World::getBlockCollisionBlocks()`).
+  - While 5.5.0 introduced caching at the `World` level for AABBs, the cache was rarely useful due to entity and player movement being too unpredictable. This meant that most users saw a performance degradation with lots of moving entities, except in specific situations.
+  - Performance for fetching non-cached AABBs for a cell is now improved by 2x. Overall performance benefit to a server depends on the number of entities and players.
+- Added cache for hydrated farmland blocks to remember the last known location of nearby water.
+  - If nearby water sources are not changed, this cache allows hydrated farmland to completely avoid checking up to 161 nearby blocks for water after the first check.
+  - Tests with large wheat farms showed a 25% performance improvement in overall server performance compared to previous 5.x versions.
+- Migrated various internal enums to native PHP 8.1 enums. Bypassing magic `__callStatic()` accessors improved performance in many areas, although it's hard to quantify the exact benefit.
+- Made use of `Facing::OFFSET` constant in various places to avoid unnecessary `Vector3` and `Position` object allocations. Many pathways benefit from this, including neighbour block updates (due to faster `Block::getSide()` and less useless objects).
+- Avoided clearing block AABB caches except when strictly necessary. Previously, the cache was wiped every time blocks were read from the world, making them mostly useless.
+- Avoided random updates on blocks which have reached their final state, such as fully-grown crops. This produces a minimal performance improvement.
+- Removed useless checks in some `World` hot paths.
+
+## API
+### General
+- All enums have been migrated to native PHP 8.1 enums.
+  - For now, the old APIs and accessors are still usable (via `LegacyEnumShimTrait`), but these will be removed in the next major release.
+  - `EnumTrait` has been deprecated, and will be removed in the next major release.
+  - Migration for most plugin developers will simply involve deleting `()` from the end of enum case usages, which is a trivial change and also improves performance.
+  - Plugin usages of `EnumTrait` are encouraged to move to native enums, optionally using `LegacyEnumShimTrait` to provide backwards compatibility.
+    - See [this code](https://github.com/pmmp/PocketMine-MP/blob/9832fe899f13a8ea47cc9d73de7088f7775a12f5/src/block/utils/DyeColor.php#L85-L107) for an example of how to associate properties with enum cases (since native enums don't support this directly).
+  - Thanks to improvements in `RuntimeDataDescriber`, any native enum can now be used as a custom block's state property.
+
+### `pocketmine\block`
+- The following classes have been added:
+  - `utils\AgeableTrait` - used by blocks which have an age property, such as crops
+  - `utils\StaticSupportTrait` - used by blocks which have the same support requirements regardless of their state, such as crops
+
+### `pocketmine\data\runtime`
+- The following API methods have been added:
+  - `public RuntimeDataDescriber->boundedIntAuto(int $min, int $max, int &$value) : void` - similar to `boundedInt()`, but automatically calculates the needed number of bits based on the given min/max
+  - `public RuntimeDataDescriber->enum(T extends \UnitEnum &$case) : void` - describes any native PHP 8.1 enum case
+  - `public RuntimeDataDescriber->enumSet(array<int, T extends \UnitEnum> &$set, array<int, T extends \UnitEnum> $allCases) : void` - describes a set of enum cases (similar to bitflags)
+- The following API methods have been deprecated:
+  - `RuntimeDataDescriber->bellAttachmentType()` - use `enum()` instead
+  - `RuntimeDataDescriber->boundedInt()` - use `boundedIntAuto()` instead
+  - `RuntimeDataDescriber->brewingStandSlots()` - use `enumSet()` instead
+  - `RuntimeDataDescriber->copperOxidation()` - use `enum()` instead
+  - `RuntimeDataDescriber->coralType()` - use `enum()` instead
+  - `RuntimeDataDescriber->dirtType()` - use `enum()` instead
+  - `RuntimeDataDescriber->dripleafState()` - use `enum()` instead
+  - `RuntimeDataDescriber->dyeColor()` - use `enum()` instead
+  - `RuntimeDataDescriber->froglightType()` - use `enum()` instead
+  - `RuntimeDataDescriber->leverFacing()` - use `enum()` instead
+  - `RuntimeDataDescriber->medicineType()` - use `enum()` instead
+  - `RuntimeDataDescriber->mobHeadType()` - use `enum()` instead
+  - `RuntimeDataDescriber->mushroomBlockType()` - use `enum()` instead
+  - `RuntimeDataDescriber->potionType()` - use `enum()` instead
+  - `RuntimeDataDescriber->slabType()` - use `enum()` instead
+  - `RuntimeDataDescriber->suspiciousStewType()` - use `enum()` instead
+
+### `pocketmine\player`
+- `TitleID` is now included in `PlayerInfo` metadata for plugin consumption.
+
+### `pocketmine\world`
+- The following API methods have been added:
+  - `public World->getBlockCollisionBoxes(AxisAlignedBB $bb) : list<AxisAlignedBB>` - similar to `getCollisionBoxes` but exclusively for blocks, avoiding the need for conditionally useless parameters
+- The following API methods have been deprecated:
+  - `World->getCollisionBoxes()` - use `getBlockCollisionBoxes()` instead (alongside `getCollidingEntities()` if entity collision boxes are also required)
+
+### `pocketmine\utils`
+- The following classes have been deprecated:
+  - `EnumTrait` - use native PHP 8.1 enums instead
+- The following classes have been added:
+  - `LegacyEnumShimTrait` - can be `use`d by native PHP 8.1 enums to provide the same API as `EnumTrait`
+
+## Gameplay
+### Blocks
+- Implemented the following blocks:
+  - Amethyst
+  - Amethyst Cluster
+  - Chiseled Bookshelf
+  - Crimson Roots
+  - Pitcher Crop
+  - Pitcher Plant
+  - Torchflower
+  - Torchflower Crop
+  - Warped Roots
+
+### Items
+- Implemented the following items:
+  - Pitcher Pod
+  - Torchflower Seeds
+
+## Internals
+- `Farmland` block now has an extra property (`waterPositionIndex`) stored in its blockstate ID to track the position of nearby water. This property is not saved to disk, and is only used for caching.
+- The format of internal blockstate ID has been updated.
+  - The lower `11` bits are now reserved for state data (previously `8` bits). This increase facilitates the new cache for `Farmland` blocks.
+  - The state data bits are now XOR'd with the `xxh3` of the block's type ID, instead of being directly XOR'd with the type ID.
+    - This XOR improves the distribution of the lower bits of the blockstate ID, which is important for hashtable indexing to minimize collisions.
+    - Previously, the lower bits were XOR'd with the type ID directly, but the effectiveness of this reduced as more state data bits were added.
+    - `xxh3` produces consistently good results for this purpose regardless of the number of state data bits allocated.
+    - Hash collisions with blockstate IDs are reduced by 50% with this change, which is a happy side effect.
+  - This is backwards-incompatible, so anyone saving internal blockstate IDs on disk or in a DB will be burned by this change (though they shouldn't have been doing that anyway).
+- Removed code generation step for `RuntimeDataDescriber` enum serialization. All described enums now use PHP 8.1 native enums, which can be described without codegen using `RuntimeDataDescriber->enum()`.
+- Added `DeprecatedLegacyEnumAccessRule` custom PHPStan rule to flag legacy `EnumTrait` case accessors.
+- Cleaned up remaining hardcoded `Config` keys in `SetupWizard`. These usages now use auto-generated constants like the rest of the codebase.
+
+# 5.8.2
+Released 9th November 2023.
+
+## Performance
+- Improved performance of small packet zero-compression (unintended use of slow zlib compressor instead of fast libdeflate one).
+  - This affected the majority of outbound packets, as most packets are below the 256-byte threshold for compression.
+  - This faster method is over 20x faster than the old method, producing noticeable performance gains for large servers.
+
+## Fixes
+- Fixed melons and pumpkins not growing.
+- Fixed melon and pumpkin stems not attaching to the grown melon/pumpkin.
+- Fixed iron and gold ores not being affected by the Fortune enchantment.
+- Fixed ancient debris burning in lava.
+- Fixed sign (front) text loading from vanilla world saves (back text is not yet supported).
+
+## Internals
+- Removed bogus optimization from `tools/generate-blockstate-upgrade-schema.php` that could cause incorrect `remappedStates` generation when some of the states stayed under the old ID.
+- Fixed possible crash in `BlockStateUpgrader` name flattening rule handling with invalid blockstate NBT data.

changelogs/5.9.md

@@ -0,0 +1,30 @@
+# 5.9.0
+Released 6th December 2023.
+
+**For Minecraft: Bedrock Edition 1.20.50**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.50.
+
+**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
+- Added support for Minecraft: Bedrock Edition 1.20.50.
+- Removed support for older versions.
+
+## Fixes
+- Fixed `pitcher_plant` and `pitcher_pod` not being accepted by `StringToItemParser` (and therefore not being usable in commands).
+- Rotation of items in item frames in worlds from newer versions of Bedrock is now correctly loaded.
+- Fixed possible crash in block update sending if a chunk was unloaded during a previous chunk's block update syncing.
+- Fixed `AsyncTask::fetchLocal()` throwing an exception if `null` was stored in the local storage.
+
+## Documentation
+- `Server::prepareBatch()` is now correctly marked as `@internal`.
+- Updated documentation for `Server::prepareBatch()` to accurately reflect its behaviour.
+- Fixed incorrect path in doc comments of `EnumTrait` and `RegistryTrait`.
+
+## Internals
+- Added PHP 8.3 to the test matrix. This has not been thoroughly tested yet, so it should only be used for testing purposes.

composer.json

@@ -22,7 +22,7 @@
       "ext-openssl": "*",
       "ext-pcre": "*",
       "ext-phar": "*",
-      "ext-pmmpthread": "^6.0.7",
+      "ext-pmmpthread": "^6.1.0",
       "ext-reflection": "*",
       "ext-simplexml": "*",
       "ext-sockets": "*",
@@ -32,27 +32,27 @@
       "ext-zlib": ">=1.2.11",
       "composer-runtime-api": "^2.0",
       "adhocore/json-comment": "~1.2.0",
-      "pocketmine/netresearch-jsonmapper": "~v4.2.1000",
-      "pocketmine/bedrock-block-upgrade-schema": "~3.3.0+bedrock-1.20.40",
-      "pocketmine/bedrock-data": "~2.6.0+bedrock-1.20.40",
-      "pocketmine/bedrock-item-upgrade-schema": "~1.5.0+bedrock-1.20.30",
-      "pocketmine/bedrock-protocol": "~25.0.0+bedrock-1.20.40",
+      "pocketmine/netresearch-jsonmapper": "~v4.4.999",
+      "pocketmine/bedrock-block-upgrade-schema": "~4.0.0+bedrock-1.20.70",
+      "pocketmine/bedrock-data": "~2.9.0+bedrock-1.20.70",
+      "pocketmine/bedrock-item-upgrade-schema": "~1.8.0+bedrock-1.20.70",
+      "pocketmine/bedrock-protocol": "~29.0.0+bedrock-1.20.70",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/color": "^0.3.0",
-      "pocketmine/errorhandler": "^0.6.0",
+      "pocketmine/errorhandler": "^0.7.0",
       "pocketmine/locale-data": "~2.19.0",
       "pocketmine/log": "^0.4.0",
       "pocketmine/math": "~1.0.0",
       "pocketmine/nbt": "~1.0.0",
-      "pocketmine/raklib": "^0.15.0",
-      "pocketmine/raklib-ipc": "^0.2.0",
+      "pocketmine/raklib": "~1.1.0",
+      "pocketmine/raklib-ipc": "~1.0.0",
       "pocketmine/snooze": "^0.5.0",
       "ramsey/uuid": "~4.7.0",
-      "symfony/filesystem": "~6.3.0"
+      "symfony/filesystem": "~6.4.0"
    },
    "require-dev": {
-      "phpstan/phpstan": "1.10.40",
+      "phpstan/phpstan": "1.10.66",
       "phpstan/phpstan-phpunit": "^1.1.0",
       "phpstan/phpstan-strict-rules": "^1.2.0",
       "phpunit/phpunit": "~10.3.0 || ~10.2.0 || ~10.1.0"

phpstan.neon.dist

@@ -10,6 +10,7 @@ includes:
 	- vendor/phpstan/phpstan-strict-rules/rules.neon
 
 rules:
+	- pocketmine\phpstan\rules\DeprecatedLegacyEnumAccessRule
 	- pocketmine\phpstan\rules\DisallowEnumComparisonRule
 	- pocketmine\phpstan\rules\DisallowForeachByReferenceRule
 	- pocketmine\phpstan\rules\UnsafeForeachArrayOfStringRule

src/BootstrapOptions.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine;
+
+/**
+ * Constants for all the command-line options that PocketMine-MP supports.
+ * Other options not listed here can be used to override server.properties and pocketmine.yml values temporarily.
+ *
+ * @internal
+ */
+final class BootstrapOptions{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	/** Disables the setup wizard on first startup */
+	public const NO_WIZARD = "no-wizard";
+	/** Force-disables console text colour and formatting */
+	public const DISABLE_ANSI = "disable-ansi";
+	/** Force-enables console text colour and formatting */
+	public const ENABLE_ANSI = "enable-ansi";
+	/** Path to look in for plugins */
+	public const PLUGINS = "plugins";
+	/** Path to store and load server data */
+	public const DATA = "data";
+	/** Shows basic server version information and exits */
+	public const VERSION = "version";
+	/** Disables writing logs to server.log */
+	public const NO_LOG_FILE = "no-log-file";
+}

src/PocketMine.php

@@ -25,6 +25,7 @@ namespace pocketmine {
 
 	use Composer\InstalledVersions;
 	use pocketmine\errorhandler\ErrorToExceptionHandler;
+	use pocketmine\network\mcpe\protocol\ProtocolInfo;
 	use pocketmine\thread\ThreadManager;
 	use pocketmine\thread\ThreadSafeClassLoader;
 	use pocketmine\utils\Filesystem;
@@ -40,14 +41,17 @@ namespace pocketmine {
 	use function extension_loaded;
 	use function function_exists;
 	use function getcwd;
+	use function getopt;
 	use function is_dir;
 	use function mkdir;
 	use function phpversion;
 	use function preg_match;
 	use function preg_quote;
+	use function printf;
 	use function realpath;
 	use function version_compare;
 	use const DIRECTORY_SEPARATOR;
+	use const PHP_EOL;
 
 	require_once __DIR__ . '/VersionInfo.php';
 
@@ -120,8 +124,8 @@ namespace pocketmine {
 		}
 
 		if(($pmmpthread_version = phpversion("pmmpthread")) !== false){
-			if(version_compare($pmmpthread_version, "6.0.7") < 0 || version_compare($pmmpthread_version, "7.0.0") >= 0){
-				$messages[] = "pmmpthread ^6.0.7 is required, while you have $pmmpthread_version.";
+			if(version_compare($pmmpthread_version, "6.1.0") < 0 || version_compare($pmmpthread_version, "7.0.0") >= 0){
+				$messages[] = "pmmpthread ^6.1.0 is required, while you have $pmmpthread_version.";
 			}
 		}
 
@@ -144,6 +148,13 @@ namespace pocketmine {
 			$messages[] = "chunkutils2 ^$wantedVersionMin is required, while you have $chunkutils2_version.";
 		}
 
+		if(($libdeflate_version = phpversion("libdeflate")) !== false){
+			//make sure level 0 compression is available
+			if(version_compare($libdeflate_version, "0.2.0") < 0 || version_compare($libdeflate_version, "0.3.0") >= 0){
+				$messages[] = "php-libdeflate ^0.2.0 is required, while you have $libdeflate_version.";
+			}
+		}
+
 		if(extension_loaded("pocketmine")){
 			$messages[] = "The native PocketMine extension is no longer supported.";
 		}
@@ -159,7 +170,7 @@ namespace pocketmine {
 	 * @return void
 	 */
 	function emit_performance_warnings(\Logger $logger){
-		if(PHP_DEBUG !== 0){
+		if(ZEND_DEBUG_BUILD){
 			$logger->warning("This PHP binary was compiled in debug mode. This has a major impact on performance.");
 		}
 		if(extension_loaded("xdebug") && (!function_exists('xdebug_info') || count(xdebug_info('mode')) !== 0)){
@@ -266,9 +277,14 @@ JIT_WARNING
 
 		ErrorToExceptionHandler::set();
 
+		if(count(getopt("", [BootstrapOptions::VERSION])) > 0){
+			printf("%s %s (git hash %s) for Minecraft: Bedrock Edition %s\n", VersionInfo::NAME, VersionInfo::VERSION()->getFullVersion(true), VersionInfo::GIT_HASH(), ProtocolInfo::MINECRAFT_VERSION);
+			exit(0);
+		}
+
 		$cwd = Utils::assumeNotFalse(realpath(Utils::assumeNotFalse(getcwd())));
-		$dataPath = getopt_string("data") ?? $cwd;
-		$pluginPath = getopt_string("plugins") ?? $cwd . DIRECTORY_SEPARATOR . "plugins";
+		$dataPath = getopt_string(BootstrapOptions::DATA) ?? $cwd;
+		$pluginPath = getopt_string(BootstrapOptions::PLUGINS) ?? $cwd . DIRECTORY_SEPARATOR . "plugins";
 		Filesystem::addCleanedPath($pluginPath, Filesystem::CLEAN_PATH_PLUGINS_PREFIX);
 
 		if(!@mkdir($dataPath, 0777, true) && !is_dir($dataPath)){
@@ -301,23 +317,28 @@ JIT_WARNING
 		//Logger has a dependency on timezone
 		Timezone::init();
 
-		$opts = getopt("", ["no-wizard", "enable-ansi", "disable-ansi"]);
-		if(isset($opts["enable-ansi"])){
+		$opts = getopt("", [BootstrapOptions::NO_WIZARD, BootstrapOptions::ENABLE_ANSI, BootstrapOptions::DISABLE_ANSI, BootstrapOptions::NO_LOG_FILE]);
+		if(isset($opts[BootstrapOptions::ENABLE_ANSI])){
 			Terminal::init(true);
-		}elseif(isset($opts["disable-ansi"])){
+		}elseif(isset($opts[BootstrapOptions::DISABLE_ANSI])){
 			Terminal::init(false);
 		}else{
 			Terminal::init();
 		}
+		$logFile = isset($opts[BootstrapOptions::NO_LOG_FILE]) ? null : Path::join($dataPath, "server.log");
+
+		$logger = new MainLogger($logFile, Terminal::hasFormattingCodes(), "Server", new \DateTimeZone(Timezone::get()), false, Path::join($dataPath, "log_archive"));
+		if($logFile === null){
+			$logger->notice("Logging to file disabled. Ensure logs are collected by other means (e.g. Docker logs).");
+		}
 
-		$logger = new MainLogger(Path::join($dataPath, "server.log"), Terminal::hasFormattingCodes(), "Server", new \DateTimeZone(Timezone::get()));
 		\GlobalLogger::set($logger);
 
 		emit_performance_warnings($logger);
 
 		$exitCode = 0;
 		do{
-			if(!file_exists(Path::join($dataPath, "server.properties")) && !isset($opts["no-wizard"])){
+			if(!file_exists(Path::join($dataPath, "server.properties")) && !isset($opts[BootstrapOptions::NO_WIZARD])){
 				$installer = new SetupWizard($dataPath);
 				if(!$installer->run()){
 					$exitCode = -1;

src/Server.php

@@ -59,7 +59,7 @@ use pocketmine\network\mcpe\EntityEventBroadcaster;
 use pocketmine\network\mcpe\NetworkSession;
 use pocketmine\network\mcpe\PacketBroadcaster;
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
-use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
+use pocketmine\network\mcpe\protocol\types\CompressionAlgorithm;
 use pocketmine\network\mcpe\raklib\RakLibInterface;
 use pocketmine\network\mcpe\StandardEntityEventBroadcaster;
 use pocketmine\network\mcpe\StandardPacketBroadcaster;
@@ -125,6 +125,7 @@ use Symfony\Component\Filesystem\Path;
 use function array_fill;
 use function array_sum;
 use function base64_encode;
+use function chr;
 use function cli_set_process_title;
 use function copy;
 use function count;
@@ -390,7 +391,7 @@ class Server{
 	}
 
 	public function getGamemode() : GameMode{
-		return GameMode::fromString($this->configGroup->getConfigString(ServerProperties::GAME_MODE, GameMode::SURVIVAL()->name())) ?? GameMode::SURVIVAL();
+		return GameMode::fromString($this->configGroup->getConfigString(ServerProperties::GAME_MODE)) ?? GameMode::SURVIVAL;
 	}
 
 	public function getForceGamemode() : bool{
@@ -523,7 +524,7 @@ class Server{
 				return $this->playerDataProvider->loadData($name);
 			}catch(PlayerDataLoadException $e){
 				$this->logger->debug("Failed to load player data for $name: " . $e->getMessage());
-				$this->logger->error($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_data_playerCorrupted($name)));
+				$this->logger->error($this->language->translate(KnownTranslationFactory::pocketmine_data_playerCorrupted($name)));
 				return null;
 			}
 		});
@@ -542,7 +543,7 @@ class Server{
 				try{
 					$this->playerDataProvider->saveData($name, $ev->getSaveData());
 				}catch(PlayerDataSaveException $e){
-					$this->logger->critical($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_data_saveError($name, $e->getMessage())));
+					$this->logger->critical($this->language->translate(KnownTranslationFactory::pocketmine_data_saveError($name, $e->getMessage())));
 					$this->logger->logException($e);
 				}
 			});
@@ -737,7 +738,7 @@ class Server{
 	 * @return string[][]
 	 */
 	public function getCommandAliases() : array{
-		$section = $this->configGroup->getProperty(YmlServerProperties::ALIASES);
+		$section = $this->configGroup->getProperty(Yml::ALIASES);
 		$result = [];
 		if(is_array($section)){
 			foreach($section as $key => $value){
@@ -818,7 +819,7 @@ class Server{
 					ServerProperties::ENABLE_IPV6 => true,
 					ServerProperties::WHITELIST => false,
 					ServerProperties::MAX_PLAYERS => self::DEFAULT_MAX_PLAYERS,
-					ServerProperties::GAME_MODE => GameMode::SURVIVAL()->name(),
+					ServerProperties::GAME_MODE => GameMode::SURVIVAL->name, //TODO: this probably shouldn't use the enum name directly
 					ServerProperties::FORCE_GAME_MODE => false,
 					ServerProperties::HARDCORE => false,
 					ServerProperties::PVP => true,
@@ -854,14 +855,14 @@ class Server{
 				}
 			}
 
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::language_selected($this->getLanguage()->getName(), $this->getLanguage()->getLang())));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::language_selected($this->language->getName(), $this->language->getLang())));
 
 			if(VersionInfo::IS_DEVELOPMENT_BUILD){
 				if(!$this->configGroup->getPropertyBool(Yml::SETTINGS_ENABLE_DEV_BUILDS, false)){
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error1(VersionInfo::NAME)));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error2()));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error3()));
-					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4(YmlServerProperties::SETTINGS_ENABLE_DEV_BUILDS)));
+					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4(Yml::SETTINGS_ENABLE_DEV_BUILDS)));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error5("https://github.com/pmmp/PocketMine-MP/releases")));
 					$this->forceShutdownExit();
 
@@ -877,7 +878,7 @@ class Server{
 
 			$this->memoryManager = new MemoryManager($this);
 
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_start(TextFormat::AQUA . $this->getVersion() . TextFormat::RESET)));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_start(TextFormat::AQUA . $this->getVersion() . TextFormat::RESET)));
 
 			if(($poolSize = $this->configGroup->getPropertyString(Yml::SETTINGS_ASYNC_WORKERS, "auto")) === "auto"){
 				$poolSize = 2;
@@ -937,11 +938,11 @@ class Server{
 
 			$this->onlineMode = $this->configGroup->getConfigBool(ServerProperties::XBOX_AUTH, true);
 			if($this->onlineMode){
-				$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_auth_enabled()));
+				$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_auth_enabled()));
 			}else{
-				$this->logger->warning($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_auth_disabled()));
-				$this->logger->warning($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_authWarning()));
-				$this->logger->warning($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_authProperty_disabled()));
+				$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_auth_disabled()));
+				$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_authWarning()));
+				$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_authProperty_disabled()));
 			}
 
 			if($this->configGroup->getConfigBool(ServerProperties::HARDCORE, false) && $this->getDifficulty() < World::DIFFICULTY_HARD){
@@ -952,17 +953,17 @@ class Server{
 
 			$this->serverID = Utils::getMachineUniqueId($this->getIp() . $this->getPort());
 
-			$this->getLogger()->debug("Server unique id: " . $this->getServerUniqueId());
-			$this->getLogger()->debug("Machine unique id: " . Utils::getMachineUniqueId());
+			$this->logger->debug("Server unique id: " . $this->getServerUniqueId());
+			$this->logger->debug("Machine unique id: " . Utils::getMachineUniqueId());
 
 			$this->network = new Network($this->logger);
 			$this->network->setName($this->getMotd());
 
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_info(
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_info(
 				$this->getName(),
 				(VersionInfo::IS_DEVELOPMENT_BUILD ? TextFormat::YELLOW : "") . $this->getPocketMineVersion() . TextFormat::RESET
 			)));
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_license($this->getName())));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_license($this->getName())));
 
 			TimingsHandler::setEnabled($this->configGroup->getPropertyBool(Yml::SETTINGS_ENABLE_PROFILING, false));
 			$this->profilingTickRate = $this->configGroup->getPropertyInt(Yml::SETTINGS_PROFILE_REPORT_TRIGGER, self::TARGET_TICKS_PER_SECOND);
@@ -973,7 +974,7 @@ class Server{
 
 			$this->craftingManager = CraftingManagerFromDataHelper::make(Path::join(\pocketmine\BEDROCK_DATA_PATH, "recipes"));
 
-			$this->resourceManager = new ResourcePackManager(Path::join($this->getDataPath(), "resource_packs"), $this->logger);
+			$this->resourceManager = new ResourcePackManager(Path::join($this->dataPath, "resource_packs"), $this->logger);
 
 			$pluginGraylist = null;
 			$graylistFile = Path::join($this->dataPath, "plugin_list.yml");
@@ -987,7 +988,7 @@ class Server{
 				$this->forceShutdownExit();
 				return;
 			}
-			$this->pluginManager = new PluginManager($this, $this->configGroup->getPropertyBool(Yml::PLUGINS_LEGACY_DATA_DIR, true) ? null : Path::join($this->getDataPath(), "plugin_data"), $pluginGraylist);
+			$this->pluginManager = new PluginManager($this, $this->configGroup->getPropertyBool(Yml::PLUGINS_LEGACY_DATA_DIR, true) ? null : Path::join($this->dataPath, "plugin_data"), $pluginGraylist);
 			$this->pluginManager->registerInterface(new PharPluginLoader($this->autoloader));
 			$this->pluginManager->registerInterface(new ScriptPluginLoader());
 
@@ -1020,7 +1021,7 @@ class Server{
 				$this->forceShutdownExit();
 				return;
 			}
-			if(!$this->enablePlugins(PluginEnableOrder::STARTUP())){
+			if(!$this->enablePlugins(PluginEnableOrder::STARTUP)){
 				$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_plugin_someEnableErrors()));
 				$this->forceShutdownExit();
 				return;
@@ -1031,7 +1032,7 @@ class Server{
 				return;
 			}
 
-			if(!$this->enablePlugins(PluginEnableOrder::POSTWORLD())){
+			if(!$this->enablePlugins(PluginEnableOrder::POSTWORLD)){
 				$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_plugin_someEnableErrors()));
 				$this->forceShutdownExit();
 				return;
@@ -1049,9 +1050,9 @@ class Server{
 
 			$this->configGroup->save();
 
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_defaultGameMode($this->getGamemode()->getTranslatableName())));
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_donate(TextFormat::AQUA . "https://patreon.com/pocketminemp" . TextFormat::RESET)));
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_startFinished(strval(round(microtime(true) - $this->startTime, 3)))));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_defaultGameMode($this->getGamemode()->getTranslatableName())));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_donate(TextFormat::AQUA . "https://patreon.com/pocketminemp" . TextFormat::RESET)));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_startFinished(strval(round(microtime(true) - $this->startTime, 3)))));
 
 			$forwarder = new BroadcastLoggerForwarder($this, $this->logger, $this->language);
 			$this->subscribeToBroadcastChannel(self::BROADCAST_CHANNEL_ADMINISTRATIVE, $forwarder);
@@ -1139,13 +1140,13 @@ class Server{
 		if($this->worldManager->getDefaultWorld() === null){
 			$default = $this->configGroup->getConfigString(ServerProperties::DEFAULT_WORLD_NAME, "world");
 			if(trim($default) == ""){
-				$this->getLogger()->warning("level-name cannot be null, using default");
+				$this->logger->warning("level-name cannot be null, using default");
 				$default = "world";
 				$this->configGroup->setConfigString(ServerProperties::DEFAULT_WORLD_NAME, "world");
 			}
 			if(!$this->worldManager->loadWorld($default, true)){
 				if($this->worldManager->isWorldGenerated($default)){
-					$this->getLogger()->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
+					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
 
 					return false;
 				}
@@ -1154,7 +1155,7 @@ class Server{
 				$generatorClass = $getGenerator($generatorName, $generatorOptions, $default);
 
 				if($generatorClass === null){
-					$this->getLogger()->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
+					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_level_defaultError()));
 					return false;
 				}
 				$creationOptions = WorldCreationOptions::create()
@@ -1185,12 +1186,11 @@ class Server{
 		bool $useQuery,
 		PacketBroadcaster $packetBroadcaster,
 		EntityEventBroadcaster $entityEventBroadcaster,
-		PacketSerializerContext $packetSerializerContext,
 		TypeConverter $typeConverter
 	) : bool{
 		$prettyIp = $ipV6 ? "[$ip]" : $ip;
 		try{
-			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter));
+			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6, $packetBroadcaster, $entityEventBroadcaster, $typeConverter));
 		}catch(NetworkInterfaceStartException $e){
 			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_networkStartFailed(
 				$ip,
@@ -1200,7 +1200,7 @@ class Server{
 			return false;
 		}
 		if($rakLibRegistered){
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_networkStart($prettyIp, (string) $port)));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_networkStart($prettyIp, (string) $port)));
 		}
 		if($useQuery){
 			if(!$rakLibRegistered){
@@ -1208,7 +1208,7 @@ class Server{
 				//if it's not registered we need to make sure Query still works
 				$this->network->registerInterface(new DedicatedQueryNetworkInterface($ip, $port, $ipV6, new \PrefixedLogger($this->logger, "Dedicated Query Interface")));
 			}
-			$this->logger->info($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_query_running($prettyIp, (string) $port)));
+			$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_query_running($prettyIp, (string) $port)));
 		}
 		return true;
 	}
@@ -1217,15 +1217,14 @@ class Server{
 		$useQuery = $this->configGroup->getConfigBool(ServerProperties::ENABLE_QUERY, true);
 
 		$typeConverter = TypeConverter::getInstance();
-		$packetSerializerContext = new PacketSerializerContext($typeConverter->getItemTypeDictionary());
-		$packetBroadcaster = new StandardPacketBroadcaster($this, $packetSerializerContext);
+		$packetBroadcaster = new StandardPacketBroadcaster($this);
 		$entityEventBroadcaster = new StandardEntityEventBroadcaster($packetBroadcaster, $typeConverter);
 
 		if(
-			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter) ||
+			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $typeConverter) ||
 			(
 				$this->configGroup->getConfigBool(ServerProperties::ENABLE_IPV6, true) &&
-				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter)
+				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $typeConverter)
 			)
 		){
 			return false;
@@ -1356,29 +1355,43 @@ class Server{
 	}
 
 	/**
-	 * Broadcasts a list of packets in a batch to a list of players
+	 * @internal
+	 * Promises to compress the given batch buffer using the selected compressor, optionally on a separate thread.
+	 *
+	 * If the buffer is smaller than the batch-threshold (usually 256), the buffer will be compressed at level 0 if supported
+	 * by the compressor. This means that the payload will be wrapped with the appropriate header and footer, but not
+	 * actually compressed.
+	 *
+	 * If the buffer is larger than the async-compression-threshold (usually 10,000), the buffer may be compressed in
+	 * a separate thread (if available).
 	 *
 	 * @param bool|null $sync Compression on the main thread (true) or workers (false). Default is automatic (null).
 	 */
-	public function prepareBatch(string $buffer, Compressor $compressor, ?bool $sync = null, ?TimingsHandler $timings = null) : CompressBatchPromise{
+	public function prepareBatch(string $buffer, Compressor $compressor, ?bool $sync = null, ?TimingsHandler $timings = null) : CompressBatchPromise|string{
 		$timings ??= Timings::$playerNetworkSendCompress;
 		try{
 			$timings->startTiming();
 
-			if($sync === null){
-				$threshold = $compressor->getCompressionThreshold();
-				$sync = !$this->networkCompressionAsync || $threshold === null || strlen($buffer) < $threshold;
-			}
+			$threshold = $compressor->getCompressionThreshold();
+			if($threshold === null || strlen($buffer) < $compressor->getCompressionThreshold()){
+				$compressionType = CompressionAlgorithm::NONE;
+				$compressed = $buffer;
 
-			$promise = new CompressBatchPromise();
-			if(!$sync && strlen($buffer) >= $this->networkCompressionAsyncThreshold){
-				$task = new CompressBatchTask($buffer, $promise, $compressor);
-				$this->asyncPool->submitTask($task);
 			}else{
-				$promise->resolve($compressor->compress($buffer));
+				$sync ??= !$this->networkCompressionAsync;
+
+				if(!$sync && strlen($buffer) >= $this->networkCompressionAsyncThreshold){
+					$promise = new CompressBatchPromise();
+					$task = new CompressBatchTask($buffer, $promise, $compressor);
+					$this->asyncPool->submitTask($task);
+					return $promise;
+				}
+
+				$compressionType = $compressor->getNetworkId();
+				$compressed = $compressor->compress($buffer);
 			}
 
-			return $promise;
+			return chr($compressionType) . $compressed;
 		}finally{
 			$timings->stopTiming();
 		}
@@ -1387,14 +1400,14 @@ class Server{
 	public function enablePlugins(PluginEnableOrder $type) : bool{
 		$allSuccess = true;
 		foreach($this->pluginManager->getPlugins() as $plugin){
-			if(!$plugin->isEnabled() && $plugin->getDescription()->getOrder()->equals($type)){
+			if(!$plugin->isEnabled() && $plugin->getDescription()->getOrder() === $type){
 				if(!$this->pluginManager->enablePlugin($plugin)){
 					$allSuccess = false;
 				}
 			}
 		}
 
-		if($type->equals(PluginEnableOrder::POSTWORLD())){
+		if($type === PluginEnableOrder::POSTWORLD){
 			$this->commandMap->registerServerAliases();
 		}
 
@@ -1455,43 +1468,43 @@ class Server{
 			$this->shutdown();
 
 			if(isset($this->pluginManager)){
-				$this->getLogger()->debug("Disabling all plugins");
+				$this->logger->debug("Disabling all plugins");
 				$this->pluginManager->disablePlugins();
 			}
 
 			if(isset($this->network)){
-				$this->network->getSessionManager()->close($this->configGroup->getPropertyString(YmlServerProperties::SETTINGS_SHUTDOWN_MESSAGE, "Server closed"));
+				$this->network->getSessionManager()->close($this->configGroup->getPropertyString(Yml::SETTINGS_SHUTDOWN_MESSAGE, "Server closed"));
 			}
 
 			if(isset($this->worldManager)){
-				$this->getLogger()->debug("Unloading all worlds");
+				$this->logger->debug("Unloading all worlds");
 				foreach($this->worldManager->getWorlds() as $world){
 					$this->worldManager->unloadWorld($world, true);
 				}
 			}
 
-			$this->getLogger()->debug("Removing event handlers");
+			$this->logger->debug("Removing event handlers");
 			HandlerListManager::global()->unregisterAll();
 
 			if(isset($this->asyncPool)){
-				$this->getLogger()->debug("Shutting down async task worker pool");
+				$this->logger->debug("Shutting down async task worker pool");
 				$this->asyncPool->shutdown();
 			}
 
 			if(isset($this->configGroup)){
-				$this->getLogger()->debug("Saving properties");
+				$this->logger->debug("Saving properties");
 				$this->configGroup->save();
 			}
 
 			if($this->console !== null){
-				$this->getLogger()->debug("Closing console");
+				$this->logger->debug("Closing console");
 				$this->console->quit();
 			}
 
 			if(isset($this->network)){
-				$this->getLogger()->debug("Stopping network interfaces");
+				$this->logger->debug("Stopping network interfaces");
 				foreach($this->network->getInterfaces() as $interface){
-					$this->getLogger()->debug("Stopping network interface " . get_class($interface));
+					$this->logger->debug("Stopping network interface " . get_class($interface));
 					$this->network->unregisterInterface($interface);
 				}
 			}
@@ -1559,7 +1572,7 @@ class Server{
 	}
 
 	private function writeCrashDumpFile(CrashDump $dump) : string{
-		$crashFolder = Path::join($this->getDataPath(), "crashdumps");
+		$crashFolder = Path::join($this->dataPath, "crashdumps");
 		if(!is_dir($crashFolder)){
 			mkdir($crashFolder);
 		}
@@ -1590,17 +1603,17 @@ class Server{
 		ini_set("error_reporting", '0');
 		ini_set("memory_limit", '-1'); //Fix error dump not dumped on memory problems
 		try{
-			$this->logger->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_crash_create()));
+			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_crash_create()));
 			$dump = new CrashDump($this, $this->pluginManager ?? null);
 
 			$crashDumpPath = $this->writeCrashDumpFile($dump);
 
-			$this->logger->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_crash_submit($crashDumpPath)));
+			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_crash_submit($crashDumpPath)));
 
 			if($this->configGroup->getPropertyBool(Yml::AUTO_REPORT_ENABLED, true)){
 				$report = true;
 
-				$stamp = Path::join($this->getDataPath(), "crashdumps", ".last_crash");
+				$stamp = Path::join($this->dataPath, "crashdumps", ".last_crash");
 				$crashInterval = 120; //2 minutes
 				if(($lastReportTime = @filemtime($stamp)) !== false && $lastReportTime + $crashInterval >= time()){
 					$report = false;
@@ -1631,7 +1644,7 @@ class Server{
 						if(isset($data->crashId) && is_int($data->crashId) && isset($data->crashUrl) && is_string($data->crashUrl)){
 							$reportId = $data->crashId;
 							$reportUrl = $data->crashUrl;
-							$this->logger->emergency($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_crash_archive($reportUrl, (string) $reportId)));
+							$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_crash_archive($reportUrl, (string) $reportId)));
 						}elseif(isset($data->error) && is_string($data->error)){
 							$this->logger->emergency("Automatic crash report submission failed: $data->error");
 						}else{
@@ -1645,7 +1658,7 @@ class Server{
 		}catch(\Throwable $e){
 			$this->logger->logException($e);
 			try{
-				$this->logger->critical($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_crash_error($e->getMessage())));
+				$this->logger->critical($this->language->translate(KnownTranslationFactory::pocketmine_crash_error($e->getMessage())));
 			}catch(\Throwable $e){}
 		}
 
@@ -1763,7 +1776,7 @@ class Server{
 
 		echo "\x1b]0;" . $this->getName() . " " .
 			$this->getPocketMineVersion() .
-			" | Online $online/" . $this->getMaxPlayers() .
+			" | Online $online/" . $this->maxPlayers .
 			($connecting > 0 ? " (+$connecting connecting)" : "") .
 			" | Memory " . $usage .
 			" | U " . round($bandwidthStats->getSend()->getAverageBytes() / 1024, 2) .
@@ -1828,10 +1841,10 @@ class Server{
 		}
 
 		if(($this->tickCounter % self::TICKS_PER_TPS_OVERLOAD_WARNING) === 0 && $this->getTicksPerSecondAverage() < self::TPS_OVERLOAD_WARNING_THRESHOLD){
-			$this->logger->warning($this->getLanguage()->translate(KnownTranslationFactory::pocketmine_server_tickOverload()));
+			$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_tickOverload()));
 		}
 
-		$this->getMemoryManager()->check();
+		$this->memoryManager->check();
 
 		if($this->console !== null){
 			Timings::$serverCommand->startTiming();

src/TimeTrackingSleeperHandler.php

@@ -24,7 +24,9 @@ declare(strict_types=1);
 namespace pocketmine;
 
 use pocketmine\snooze\SleeperHandler;
+use pocketmine\snooze\SleeperHandlerEntry;
 use pocketmine\timings\TimingsHandler;
+use pocketmine\utils\Utils;
 use function hrtime;
 
 /**
@@ -35,12 +37,29 @@ final class TimeTrackingSleeperHandler extends SleeperHandler{
 
 	private int $notificationProcessingTimeNs = 0;
 
+	/**
+	 * @var TimingsHandler[]
+	 * @phpstan-var array<string, TimingsHandler>
+	 */
+	private static array $handlerTimings = [];
+
 	public function __construct(
 		private TimingsHandler $timings
 	){
 		parent::__construct();
 	}
 
+	public function addNotifier(\Closure $handler) : SleeperHandlerEntry{
+		$name = Utils::getNiceClosureName($handler);
+		$timings = self::$handlerTimings[$name] ??= new TimingsHandler("Snooze Handler: " . $name, $this->timings);
+
+		return parent::addNotifier(function() use ($timings, $handler) : void{
+			$timings->startTiming();
+			$handler();
+			$timings->stopTiming();
+		});
+	}
+
 	/**
 	 * Returns the time in nanoseconds spent processing notifications since the last reset.
 	 */

src/VersionInfo.php

@@ -31,7 +31,7 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "5.7.1";
+	public const BASE_VERSION = "5.14.1";
 	public const IS_DEVELOPMENT_BUILD = false;
 	public const BUILD_CHANNEL = "stable";
 
@@ -63,7 +63,8 @@ final class VersionInfo{
 			if(\Phar::running(true) === ""){
 				$gitHash = Git::getRepositoryStatePretty(\pocketmine\PATH);
 			}else{
-				$phar = new \Phar(\Phar::running(false));
+				$pharPath = \Phar::running(false);
+				$phar = \Phar::isValidPharFilename($pharPath) ? new \Phar($pharPath) : new \PharData($pharPath);
 				$meta = $phar->getMetadata();
 				if(isset($meta["git"])){
 					$gitHash = $meta["git"];
@@ -82,7 +83,8 @@ final class VersionInfo{
 		if(self::$buildNumber === null){
 			self::$buildNumber = 0;
 			if(\Phar::running(true) !== ""){
-				$phar = new \Phar(\Phar::running(false));
+				$pharPath = \Phar::running(false);
+				$phar = \Phar::isValidPharFilename($pharPath) ? new \Phar($pharPath) : new \PharData($pharPath);
 				$meta = $phar->getMetadata();
 				if(is_array($meta) && isset($meta["build"]) && is_int($meta["build"])){
 					self::$buildNumber = $meta["build"];

src/block/AmethystCluster.php

@@ -0,0 +1,133 @@
+<?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\AmethystTrait;
+use pocketmine\block\utils\AnyFacingTrait;
+use pocketmine\block\utils\FortuneDropHelper;
+use pocketmine\block\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\BlockTransaction;
+
+final class AmethystCluster extends Transparent{
+	use AmethystTrait;
+	use AnyFacingTrait;
+
+	public const STAGE_SMALL_BUD = 0;
+	public const STAGE_MEDIUM_BUD = 1;
+	public const STAGE_LARGE_BUD = 2;
+	public const STAGE_CLUSTER = 3;
+
+	private int $stage = self::STAGE_CLUSTER;
+
+	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
+		$w->boundedIntAuto(self::STAGE_SMALL_BUD, self::STAGE_CLUSTER, $this->stage);
+	}
+
+	public function getStage() : int{ return $this->stage; }
+
+	public function setStage(int $stage) : self{
+		if($stage < self::STAGE_SMALL_BUD || $stage > self::STAGE_CLUSTER){
+			throw new \InvalidArgumentException("Size must be in range " . self::STAGE_SMALL_BUD . " ... " . self::STAGE_CLUSTER);
+		}
+		$this->stage = $stage;
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return match($this->stage){
+			self::STAGE_SMALL_BUD => 1,
+			self::STAGE_MEDIUM_BUD => 2,
+			self::STAGE_LARGE_BUD => 4,
+			self::STAGE_CLUSTER => 5,
+			default => throw new AssumptionFailedError("Invalid stage $this->stage"),
+		};
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		$myAxis = Facing::axis($this->facing);
+
+		$box = AxisAlignedBB::one();
+		foreach([Axis::Y, Axis::Z, Axis::X] as $axis){
+			if($axis === $myAxis){
+				continue;
+			}
+			$box->squash($axis, $this->stage === self::STAGE_SMALL_BUD ? 4 / 16 : 3 / 16);
+		}
+		$box->trim($this->facing, 1 - ($this->stage === self::STAGE_CLUSTER ? 7 / 16 : ($this->stage + 3) / 16));
+
+		return [$box];
+	}
+
+	private function canBeSupportedAt(Block $block, int $facing) : bool{
+		return $block->getAdjacentSupportType($facing) === SupportType::FULL;
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
+			return false;
+		}
+
+		$this->facing = $face;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing))){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		if($this->stage === self::STAGE_CLUSTER){
+			return [VanillaItems::AMETHYST_SHARD()->setCount(FortuneDropHelper::weighted($item, min: 4, maxBase: 4))];
+		}
+
+		return [];
+	}
+
+	public function getDropsForIncompatibleTool(Item $item) : array{
+		if($this->stage === self::STAGE_CLUSTER){
+			return [VanillaItems::AMETHYST_SHARD()->setCount(FortuneDropHelper::weighted($item, min: 2, maxBase: 2))];
+		}
+
+		return [];
+	}
+}

src/block/Anvil.php

@@ -52,7 +52,7 @@ class Anvil extends Transparent implements Fallable{
 	private int $damage = self::UNDAMAGED;
 
 	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(2, self::UNDAMAGED, self::VERY_DAMAGED, $this->damage);
+		$w->boundedIntAuto(self::UNDAMAGED, self::VERY_DAMAGED, $this->damage);
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
@@ -78,7 +78,7 @@ class Anvil extends Transparent implements Fallable{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/Bamboo.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\StructureGrowEvent;
@@ -46,6 +47,7 @@ use function mt_rand;
 use const PHP_INT_MAX;
 
 class Bamboo extends Transparent{
+	use StaticSupportTrait;
 
 	public const NO_LEAVES = 0;
 	public const SMALL_LEAVES = 1;
@@ -56,7 +58,7 @@ class Bamboo extends Transparent{
 	protected int $leafSize = self::NO_LEAVES;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(2, self::NO_LEAVES, self::LARGE_LEAVES, $this->leafSize);
+		$w->boundedIntAuto(self::NO_LEAVES, self::LARGE_LEAVES, $this->leafSize);
 		$w->bool($this->thick);
 		$w->bool($this->ready);
 	}
@@ -95,7 +97,7 @@ class Bamboo extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	private static function getOffsetSeed(int $x, int $y, int $z) : int{
@@ -120,12 +122,14 @@ class Bamboo extends Transparent{
 		return new Vector3($retX, 0, $retZ);
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::DOWN);
 		return
-			$block->getTypeId() === BlockTypeIds::GRAVEL ||
-			$block->hasTypeTag(BlockTypeTags::DIRT) ||
-			$block->hasTypeTag(BlockTypeTags::MUD) ||
-			$block->hasTypeTag(BlockTypeTags::SAND);
+			$supportBlock->hasSameTypeId($this) ||
+			$supportBlock->getTypeId() === BlockTypeIds::GRAVEL ||
+			$supportBlock->hasTypeTag(BlockTypeTags::DIRT) ||
+			$supportBlock->hasTypeTag(BlockTypeTags::MUD) ||
+			$supportBlock->hasTypeTag(BlockTypeTags::SAND);
 	}
 
 	private function seekToTop() : Bamboo{
@@ -153,14 +157,6 @@ class Bamboo extends Transparent{
 		return false;
 	}
 
-	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		$below = $world->getBlock($this->position->down());
-		if(!$this->canBeSupportedBy($below) && !$below->hasSameTypeId($this)){
-			$world->useBreakOn($this->position);
-		}
-	}
-
 	private function grow(int $maxHeight, int $growAmount, ?Player $player) : bool{
 		$world = $this->position->getWorld();
 		if(!$world->getBlock($this->position->up())->canBeReplaced()){
@@ -177,7 +173,7 @@ class Bamboo extends Transparent{
 		$newHeight = $height + $growAmount;
 
 		$stemBlock = (clone $this)->setReady(false)->setLeafSize(self::NO_LEAVES);
-		if($newHeight >= 4 && !$stemBlock->isThick()){ //don't change it to false if height is less, because it might have been chopped
+		if($newHeight >= 4 && !$stemBlock->thick){ //don't change it to false if height is less, because it might have been chopped
 			$stemBlock = $stemBlock->setThick(true);
 		}
 		$smallLeavesBlock = (clone $stemBlock)->setLeafSize(self::SMALL_LEAVES);

src/block/BambooSapling.php

@@ -23,17 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\StructureGrowEvent;
 use pocketmine\item\Bamboo as ItemBamboo;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 
 final class BambooSapling extends Flowable{
+	use StaticSupportTrait;
+
 	private bool $ready = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
@@ -48,19 +52,13 @@ final class BambooSapling extends Flowable{
 		return $this;
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::DOWN);
 		return
-			$block->getTypeId() === BlockTypeIds::GRAVEL ||
-			$block->hasTypeTag(BlockTypeTags::DIRT) ||
-			$block->hasTypeTag(BlockTypeTags::MUD) ||
-			$block->hasTypeTag(BlockTypeTags::SAND);
-	}
-
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedBy($blockReplace->position->getWorld()->getBlock($blockReplace->position->down()))){
-			return false;
-		}
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+			$supportBlock->getTypeId() === BlockTypeIds::GRAVEL ||
+			$supportBlock->hasTypeTag(BlockTypeTags::DIRT) ||
+			$supportBlock->hasTypeTag(BlockTypeTags::MUD) ||
+			$supportBlock->hasTypeTag(BlockTypeTags::SAND);
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
@@ -73,13 +71,6 @@ final class BambooSapling extends Flowable{
 		return false;
 	}
 
-	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedBy($world->getBlock($this->position->down()))){
-			$world->useBreakOn($this->position);
-		}
-	}
-
 	private function grow(?Player $player) : bool{
 		$world = $this->position->getWorld();
 		if(!$world->getBlock($this->position->up())->canBeReplaced()){

src/block/Barrel.php

@@ -55,12 +55,12 @@ class Barrel extends Opaque{
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			if(abs($player->getPosition()->getX() - $this->position->getX()) < 2 && abs($player->getPosition()->getZ() - $this->position->getZ()) < 2){
-				$y = $player->getEyePos()->getY();
+			if(abs($player->getPosition()->x - $this->position->x) < 2 && abs($player->getPosition()->z - $this->position->z) < 2){
+				$y = $player->getEyePos()->y;
 
-				if($y - $this->position->getY() > 2){
+				if($y - $this->position->y > 2){
 					$this->facing = Facing::UP;
-				}elseif($this->position->getY() - $y > 0){
+				}elseif($this->position->y - $y > 0){
 					$this->facing = Facing::DOWN;
 				}else{
 					$this->facing = Facing::opposite($player->getHorizontalFacing());

src/block/BaseBanner.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\tile\Banner as TileBanner;
 use pocketmine\block\utils\BannerPatternLayer;
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Banner as ItemBanner;
 use pocketmine\item\Item;
@@ -35,7 +34,6 @@ use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
-use function array_filter;
 use function assert;
 use function count;
 
@@ -48,11 +46,6 @@ abstract class BaseBanner extends Transparent{
 	 */
 	protected array $patterns = [];
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::BLACK();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 		$tile = $this->position->getWorld()->getTile($this->position);
@@ -95,11 +88,12 @@ abstract class BaseBanner extends Transparent{
 	 * @return $this
 	 */
 	public function setPatterns(array $patterns) : self{
-		$checked = array_filter($patterns, fn($v) => $v instanceof BannerPatternLayer);
-		if(count($checked) !== count($patterns)){
-			throw new \TypeError("Deque must only contain " . BannerPatternLayer::class . " objects");
+		foreach($patterns as $pattern){
+			if(!$pattern instanceof BannerPatternLayer){
+				throw new \TypeError("Array must only contain " . BannerPatternLayer::class . " objects");
+			}
 		}
-		$this->patterns = $checked;
+		$this->patterns = $patterns;
 		return $this;
 	}
 
@@ -111,7 +105,7 @@ abstract class BaseBanner extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	private function canBeSupportedBy(Block $block) : bool{

src/block/BaseBigDripleaf.php

@@ -65,8 +65,8 @@ abstract class BaseBigDripleaf extends Transparent{
 			$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));
+			$this->facing = $block->facing;
+			$tx->addBlock($block->position, VanillaBlocks::BIG_DRIPLEAF_STEM()->setFacing($this->facing));
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
@@ -98,7 +98,7 @@ abstract class BaseBigDripleaf extends Transparent{
 		if($head === null){
 			return false;
 		}
-		$pos = $head->getPosition();
+		$pos = $head->position;
 		$up = $pos->up();
 		$world = $pos->getWorld();
 		if(
@@ -110,8 +110,8 @@ abstract class BaseBigDripleaf extends Transparent{
 
 		$tx = new BlockTransaction($world);
 
-		$tx->addBlock($pos, VanillaBlocks::BIG_DRIPLEAF_STEM()->setFacing($head->getFacing()));
-		$tx->addBlock($up, VanillaBlocks::BIG_DRIPLEAF_HEAD()->setFacing($head->getFacing()));
+		$tx->addBlock($pos, VanillaBlocks::BIG_DRIPLEAF_STEM()->setFacing($head->facing));
+		$tx->addBlock($up, VanillaBlocks::BIG_DRIPLEAF_HEAD()->setFacing($head->facing));
 
 		$ev = new StructureGrowEvent($head, $tx, $player);
 		$ev->call();
@@ -131,6 +131,6 @@ abstract class BaseBigDripleaf extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 }

src/block/BaseCake.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\entity\effect\EffectInstance;
 use pocketmine\entity\FoodSource;
@@ -31,27 +32,16 @@ use pocketmine\item\Item;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
 abstract class BaseCake extends Transparent implements FoodSource{
+	use StaticSupportTrait;
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->getTypeId() !== BlockTypeIds::AIR){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::AIR){ //Replace with common break method
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getSide(Facing::DOWN)->getTypeId() !== BlockTypeIds::AIR;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/BaseCoral.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\BlockEventHelper;
-use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\CoralTypeTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
@@ -33,11 +32,6 @@ use function mt_rand;
 abstract class BaseCoral extends Transparent{
 	use CoralTypeTrait;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->coralType = CoralType::TUBE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	public function onNearbyBlockChange() : void{
 		if(!$this->dead){
 			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(40, 200));
@@ -78,6 +72,6 @@ abstract class BaseCoral extends Transparent{
 	protected function recalculateCollisionBoxes() : array{ return []; }
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 }

src/block/BaseSign.php

@@ -103,7 +103,7 @@ abstract class BaseSign extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	abstract protected function getSupportingFace() : int;
@@ -172,13 +172,13 @@ abstract class BaseSign extends Transparent{
 		}
 
 		$dyeColor = $item instanceof Dye ? $item->getColor() : match($item->getTypeId()){
-			ItemTypeIds::BONE_MEAL => DyeColor::WHITE(),
-			ItemTypeIds::LAPIS_LAZULI => DyeColor::BLUE(),
-			ItemTypeIds::COCOA_BEANS => DyeColor::BROWN(),
+			ItemTypeIds::BONE_MEAL => DyeColor::WHITE,
+			ItemTypeIds::LAPIS_LAZULI => DyeColor::BLUE,
+			ItemTypeIds::COCOA_BEANS => DyeColor::BROWN,
 			default => null
 		};
 		if($dyeColor !== null){
-			$color = $dyeColor->equals(DyeColor::BLACK()) ? new Color(0, 0, 0) : $dyeColor->getRgbValue();
+			$color = $dyeColor === DyeColor::BLACK ? new Color(0, 0, 0) : $dyeColor->getRgbValue();
 			if(
 				$color->toARGB() !== $this->text->getBaseColor()->toARGB() &&
 				$this->doSignChange(new SignText($this->text->getLines(), $color, $this->text->isGlowing()), $player, $item)

src/block/Bed.php

@@ -48,11 +48,6 @@ class Bed extends Transparent{
 	protected bool $occupied = false;
 	protected bool $head = false;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::RED();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->horizontalFacing($this->facing);
 		$w->bool($this->occupied);
@@ -65,6 +60,8 @@ class Bed extends Transparent{
 		$tile = $this->position->getWorld()->getTile($this->position);
 		if($tile instanceof TileBed){
 			$this->color = $tile->getColor();
+		}else{
+			$this->color = DyeColor::RED; //legacy pre-1.1 beds don't have tiles
 		}
 
 		return $this;
@@ -87,7 +84,7 @@ class Bed extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function isHeadPart() : bool{
@@ -148,7 +145,7 @@ class Bed extends Transparent{
 
 			$b = ($this->isHeadPart() ? $this : $other);
 
-			if($b->isOccupied()){
+			if($b->occupied){
 				$player->sendMessage(KnownTranslationFactory::tile_bed_occupied()->prefix(TextFormat::GRAY));
 
 				return true;
@@ -209,7 +206,7 @@ class Bed extends Transparent{
 	}
 
 	private function canBeSupportedAt(Block $block) : bool{
-		return !$block->getAdjacentSupportType(Facing::DOWN)->equals(SupportType::NONE());
+		return $block->getAdjacentSupportType(Facing::DOWN) !== SupportType::NONE;
 	}
 
 	public function getMaxStackSize() : int{ return 1; }

src/block/Bell.php

@@ -35,32 +35,26 @@ 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;
 
 final class Bell extends Transparent{
 	use HorizontalFacingTrait;
 
-	private BellAttachmentType $attachmentType;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->attachmentType = BellAttachmentType::FLOOR();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
+	private BellAttachmentType $attachmentType = BellAttachmentType::FLOOR;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->bellAttachmentType($this->attachmentType);
+		$w->enum($this->attachmentType);
 		$w->horizontalFacing($this->facing);
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		if($this->attachmentType->equals(BellAttachmentType::FLOOR())){
+		if($this->attachmentType === BellAttachmentType::FLOOR){
 			return [
 				AxisAlignedBB::one()->squash(Facing::axis($this->facing), 1 / 4)->trim(Facing::UP, 3 / 16)
 			];
 		}
-		if($this->attachmentType->equals(BellAttachmentType::CEILING())){
+		if($this->attachmentType === BellAttachmentType::CEILING){
 			return [
 				AxisAlignedBB::one()->contract(1 / 4, 0, 1 / 4)->trim(Facing::DOWN, 1 / 4)
 			];
@@ -72,12 +66,12 @@ final class Bell extends Transparent{
 			->trim(Facing::DOWN, 1 / 4);
 
 		return [
-			$this->attachmentType->equals(BellAttachmentType::ONE_WALL()) ? $box->trim($this->facing, 3 / 16) : $box
+			$this->attachmentType === BellAttachmentType::ONE_WALL ? $box->trim($this->facing, 3 / 16) : $box
 		];
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function getAttachmentType() : BellAttachmentType{ return $this->attachmentType; }
@@ -89,7 +83,7 @@ final class Bell extends Transparent{
 	}
 
 	private function canBeSupportedAt(Block $block, int $face) : bool{
-		return !$block->getAdjacentSupportType($face)->equals(SupportType::NONE());
+		return $block->getAdjacentSupportType($face) !== SupportType::NONE;
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
@@ -100,15 +94,15 @@ final class Bell extends Transparent{
 			if($player !== null){
 				$this->setFacing(Facing::opposite($player->getHorizontalFacing()));
 			}
-			$this->setAttachmentType(BellAttachmentType::FLOOR());
+			$this->setAttachmentType(BellAttachmentType::FLOOR);
 		}elseif($face === Facing::DOWN){
-			$this->setAttachmentType(BellAttachmentType::CEILING());
+			$this->setAttachmentType(BellAttachmentType::CEILING);
 		}else{
 			$this->setFacing($face);
 			$this->setAttachmentType(
 				$this->canBeSupportedAt($blockReplace, $face) ?
-					BellAttachmentType::TWO_WALLS() :
-					BellAttachmentType::ONE_WALL()
+					BellAttachmentType::TWO_WALLS :
+					BellAttachmentType::ONE_WALL
 			);
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
@@ -116,11 +110,10 @@ final class Bell extends Transparent{
 
 	public function onNearbyBlockChange() : void{
 		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")
+			BellAttachmentType::CEILING => [Facing::UP],
+			BellAttachmentType::FLOOR => [Facing::DOWN],
+			BellAttachmentType::ONE_WALL => [Facing::opposite($this->facing)],
+			BellAttachmentType::TWO_WALLS => [$this->facing, Facing::opposite($this->facing)]
 		} as $supportBlockDirection){
 			if(!$this->canBeSupportedAt($this, $supportBlockDirection)){
 				$this->position->getWorld()->useBreakOn($this->position);
@@ -159,10 +152,9 @@ final class Bell extends Transparent{
 
 	private function isValidFaceToRing(int $faceHit) : bool{
 		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")
+			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),
 		};
 	}
 }

src/block/BigDripleafHead.php

@@ -30,22 +30,16 @@ 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 DripleafState $leafState = DripleafState::STABLE;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		parent::describeBlockOnlyState($w);
-		$w->dripleafState($this->leafState);
+		$w->enum($this->leafState);
 	}
 
 	protected function isHead() : bool{
@@ -76,20 +70,20 @@ class BigDripleafHead extends BaseBigDripleaf{
 
 	private function getLeafTopOffset() : float{
 		return match($this->leafState){
-			DripleafState::STABLE(), DripleafState::UNSTABLE() => 1 / 16,
-			DripleafState::PARTIAL_TILT() => 3 / 16,
+			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())){
+		if(!$entity instanceof Projectile && $this->leafState === 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());
+				$this->setTiltAndScheduleTick(DripleafState::UNSTABLE);
 				return false;
 			}
 		}
@@ -97,22 +91,21 @@ class BigDripleafHead extends BaseBigDripleaf{
 	}
 
 	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
-		if(!$this->leafState->equals(DripleafState::FULL_TILT())){
-			$this->setTiltAndScheduleTick(DripleafState::FULL_TILT());
+		if($this->leafState !== 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()));
+		if($this->leafState !== DripleafState::STABLE){
+			if($this->leafState === 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->setTiltAndScheduleTick(match($this->leafState){
+					DripleafState::UNSTABLE => DripleafState::PARTIAL_TILT,
+					DripleafState::PARTIAL_TILT => DripleafState::FULL_TILT,
 				});
 				$this->position->getWorld()->addSound($this->position, new DripleafTiltDownSound());
 			}
@@ -120,7 +113,7 @@ class BigDripleafHead extends BaseBigDripleaf{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		if(!$this->leafState->equals(DripleafState::FULL_TILT())){
+		if($this->leafState !== DripleafState::FULL_TILT){
 			return [
 				AxisAlignedBB::one()
 					->trim(Facing::DOWN, 11 / 16)

src/block/Block.php

@@ -42,7 +42,6 @@ use pocketmine\item\enchantment\ItemEnchantmentTags;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\item\Item;
 use pocketmine\item\ItemBlock;
-use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\RayTraceResult;
@@ -50,22 +49,26 @@ use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\player\Player;
 use pocketmine\utils\AssumptionFailedError;
+use pocketmine\utils\Binary;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\format\Chunk;
 use pocketmine\world\Position;
 use pocketmine\world\World;
 use function count;
 use function get_class;
+use function hash;
 use const PHP_INT_MAX;
 
 class Block{
-	public const INTERNAL_STATE_DATA_BITS = 8;
+	public const INTERNAL_STATE_DATA_BITS = 11;
 	public const INTERNAL_STATE_DATA_MASK = ~(~0 << self::INTERNAL_STATE_DATA_BITS);
 
 	/**
 	 * @internal
+	 * Hardcoded int is `Binary::readLong(hash('xxh3', Binary::writeLLong(BlockTypeIds::AIR), binary: true))`
+	 * TODO: it would be much easier if we could just make this 0 or some other easy value
 	 */
-	public const EMPTY_STATE_ID = (BlockTypeIds::AIR << self::INTERNAL_STATE_DATA_BITS) | (BlockTypeIds::AIR & self::INTERNAL_STATE_DATA_MASK);
+	public const EMPTY_STATE_ID = (BlockTypeIds::AIR << self::INTERNAL_STATE_DATA_BITS) | (-7482769108513497636 & self::INTERNAL_STATE_DATA_MASK);
 
 	protected BlockIdentifier $idInfo;
 	protected string $fallbackName;
@@ -80,6 +83,23 @@ class Block{
 
 	private Block $defaultState;
 
+	private int $stateIdXorMask;
+
+	/**
+	 * Computes the mask to be XOR'd with the state data.
+	 * This is to improve distribution of the state data bits, which occupy the least significant bits of the state ID.
+	 * Improved distribution improves PHP array performance when using the state ID as a key, as PHP arrays use some of
+	 * the lower bits of integer keys directly without hashing.
+	 *
+	 * The type ID is included in the XOR mask. This is not necessary to improve distribution, but it reduces the number
+	 * of operations required to compute the state ID (micro optimization).
+	 */
+	private static function computeStateIdXorMask(int $typeId) : int{
+		return
+			$typeId << self::INTERNAL_STATE_DATA_BITS |
+			(Binary::readLong(hash('xxh3', Binary::writeLLong($typeId), binary: true)) & self::INTERNAL_STATE_DATA_MASK);
+	}
+
 	/**
 	 * @param string $name English name of the block type (TODO: implement translations)
 	 */
@@ -97,6 +117,9 @@ class Block{
 		$this->describeBlockOnlyState($calculator);
 		$this->requiredBlockOnlyStateDataBits = $calculator->getBitsUsed();
 
+		$this->stateIdXorMask = self::computeStateIdXorMask($idInfo->getBlockTypeId());
+
+		//this must be done last, otherwise the defaultState could have uninitialized fields
 		$defaultState = clone $this;
 		$this->defaultState = $defaultState;
 		$defaultState->defaultState = $defaultState;
@@ -152,13 +175,7 @@ class Block{
 	 * {@link RuntimeBlockStateRegistry::fromStateId()}.
 	 */
 	public function getStateId() : int{
-		$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));
+		return $this->encodeFullState() ^ $this->stateIdXorMask;
 	}
 
 	/**
@@ -228,12 +245,6 @@ class Block{
 		}
 	}
 
-	private function decodeFullState(int $data) : void{
-		$reader = new RuntimeDataReader($this->requiredBlockItemStateDataBits + $this->requiredBlockOnlyStateDataBits, $data);
-		$this->decodeBlockItemState($reader->readInt($this->requiredBlockItemStateDataBits));
-		$this->decodeBlockOnlyState($reader->readInt($this->requiredBlockOnlyStateDataBits));
-	}
-
 	private function encodeBlockItemState() : int{
 		$writer = new RuntimeDataWriter($this->requiredBlockItemStateDataBits);
 
@@ -259,11 +270,22 @@ class Block{
 	}
 
 	private function encodeFullState() : int{
-		$writer = new RuntimeDataWriter($this->requiredBlockItemStateDataBits + $this->requiredBlockOnlyStateDataBits);
-		$writer->writeInt($this->requiredBlockItemStateDataBits, $this->encodeBlockItemState());
-		$writer->writeInt($this->requiredBlockOnlyStateDataBits, $this->encodeBlockOnlyState());
+		$blockItemBits = $this->requiredBlockItemStateDataBits;
+		$blockOnlyBits = $this->requiredBlockOnlyStateDataBits;
 
-		return $writer->getValue();
+		if($blockOnlyBits === 0 && $blockItemBits === 0){
+			return 0;
+		}
+
+		$result = 0;
+		if($blockItemBits > 0){
+			$result |= $this->encodeBlockItemState();
+		}
+		if($blockOnlyBits > 0){
+			$result |= $this->encodeBlockOnlyState() << $blockItemBits;
+		}
+
+		return $result;
 	}
 
 	/**
@@ -304,34 +326,44 @@ class Block{
 		if($bits > Block::INTERNAL_STATE_DATA_BITS){
 			throw new \LogicException("Block state data cannot use more than " . Block::INTERNAL_STATE_DATA_BITS . " bits");
 		}
-		for($stateData = 0; $stateData < (1 << $bits); ++$stateData){
-			$v = clone $this;
+		for($blockItemStateData = 0; $blockItemStateData < (1 << $this->requiredBlockItemStateDataBits); ++$blockItemStateData){
+			$withType = clone $this;
 			try{
-				$v->decodeFullState($stateData);
-				if($v->encodeFullState() !== $stateData){
-					throw new \LogicException(static::class . "::decodeStateData() accepts invalid state data (returned " . $v->encodeFullState() . " for input $stateData)");
+				$withType->decodeBlockItemState($blockItemStateData);
+				$encoded = $withType->encodeBlockItemState();
+				if($encoded !== $blockItemStateData){
+					throw new \LogicException(static::class . "::decodeBlockItemState() accepts invalid inputs (returned $encoded for input $blockItemStateData)");
 				}
 			}catch(InvalidSerializedRuntimeDataException){ //invalid property combination, leave it
 				continue;
 			}
 
-			yield $v;
+			for($blockOnlyStateData = 0; $blockOnlyStateData < (1 << $this->requiredBlockOnlyStateDataBits); ++$blockOnlyStateData){
+				$withState = clone $withType;
+				try{
+					$withState->decodeBlockOnlyState($blockOnlyStateData);
+					$encoded = $withState->encodeBlockOnlyState();
+					if($encoded !== $blockOnlyStateData){
+						throw new \LogicException(static::class . "::decodeBlockOnlyState() accepts invalid inputs (returned $encoded for input $blockOnlyStateData)");
+					}
+				}catch(InvalidSerializedRuntimeDataException){ //invalid property combination, leave it
+					continue;
+				}
+
+				yield $withState;
+			}
 		}
 	}
 
 	/**
 	 * Called when this block is created, set, or has a neighbouring block update, to re-detect dynamic properties which
-	 * are not saved on the world.
-	 *
-	 * Clears any cached precomputed objects, such as bounding boxes. Remove any outdated precomputed things such as
-	 * AABBs and force recalculation.
+	 * are not saved in the blockstate ID.
+	 * If any such properties are updated, don't forget to clear things like AABB caches if necessary.
 	 *
 	 * A replacement block may be returned. This is useful if the block type changed due to reading of world data (e.g.
 	 * data from a block entity).
 	 */
 	public function readStateFromWorld() : Block{
-		$this->collisionBoxes = null;
-
 		return $this;
 	}
 
@@ -370,7 +402,7 @@ class Block{
 	}
 
 	/**
-	 * AKA: Block->isPlaceable
+	 * Returns whether this block can be placed when obtained as an item.
 	 */
 	public function canBePlaced() : bool{
 		return true;
@@ -540,16 +572,28 @@ class Block{
 		return $this->getLightFilter() > 0;
 	}
 
+	/**
+	 * Returns whether this block allows any light to pass through it.
+	 */
 	public function isTransparent() : bool{
 		return false;
 	}
 
+	/**
+	 * @deprecated TL;DR: Don't use this function. Its results are confusing and inconsistent.
+	 *
+	 * No one is sure what the meaning of this property actually is. It's borrowed from Minecraft Java Edition, and is
+	 * used by various blocks for support checks.
+	 *
+	 * Things like signs and banners are considered "solid" despite having no collision box, and things like skulls and
+	 * flower pots are considered non-solid despite obviously being "solid" in the conventional, real-world sense.
+	 */
 	public function isSolid() : bool{
 		return true;
 	}
 
 	/**
-	 * AKA: Block->isFlowable
+	 * Returns whether this block can be destroyed by liquid flowing into its cell.
 	 */
 	public function canBeFlowedInto() : bool{
 		return false;
@@ -571,6 +615,7 @@ class Block{
 	 */
 	final public function position(World $world, int $x, int $y, int $z) : void{
 		$this->position = new Position($x, $y, $z, $world);
+		$this->collisionBoxes = null;
 	}
 
 	/**
@@ -721,8 +766,14 @@ class Block{
 	 * @return Block
 	 */
 	public function getSide(int $side, int $step = 1){
-		if($this->position->isValid()){
-			return $this->position->getWorld()->getBlock($this->position->getSide($side, $step));
+		$position = $this->position;
+		if($position->isValid()){
+			[$dx, $dy, $dz] = Facing::OFFSET[$side] ?? [0, 0, 0];
+			return $position->getWorld()->getBlockAt(
+				$position->x + ($dx * $step),
+				$position->y + ($dy * $step),
+				$position->z + ($dz * $step)
+			);
 		}
 
 		throw new \LogicException("Block does not have a valid world");
@@ -736,8 +787,14 @@ class Block{
 	 */
 	public function getHorizontalSides() : \Generator{
 		$world = $this->position->getWorld();
-		foreach($this->position->sidesAroundAxis(Axis::Y) as $vector3){
-			yield $world->getBlock($vector3);
+		foreach(Facing::HORIZONTAL as $facing){
+			[$dx, $dy, $dz] = Facing::OFFSET[$facing];
+			//TODO: yield Facing as the key?
+			yield $world->getBlockAt(
+				$this->position->x + $dx,
+				$this->position->y + $dy,
+				$this->position->z + $dz
+			);
 		}
 	}
 
@@ -749,8 +806,13 @@ class Block{
 	 */
 	public function getAllSides() : \Generator{
 		$world = $this->position->getWorld();
-		foreach($this->position->sides() as $vector3){
-			yield $world->getBlock($vector3);
+		foreach(Facing::OFFSET as [$dx, $dy, $dz]){
+			//TODO: yield Facing as the key?
+			yield $world->getBlockAt(
+				$this->position->x + $dx,
+				$this->position->y + $dy,
+				$this->position->z + $dz
+			);
 		}
 	}
 
@@ -877,7 +939,7 @@ class Block{
 	 * blocks placed on the given face can be supported by this block.
 	 */
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::FULL();
+		return SupportType::FULL;
 	}
 
 	protected function getAdjacentSupportType(int $facing) : SupportType{

src/block/BlockTypeIds.php

@@ -562,10 +562,10 @@ final class BlockTypeIds{
 	public const WEIGHTED_PRESSURE_PLATE_HEAVY = 10532;
 	public const WEIGHTED_PRESSURE_PLATE_LIGHT = 10533;
 	public const WHEAT = 10534;
-
+	public const BUDDING_AMETHYST = 10535;
 	public const WHITE_TULIP = 10536;
 	public const WOOL = 10537;
-
+	public const AMETHYST_CLUSTER = 10538;
 	public const GLAZED_TERRACOTTA = 10539;
 	public const AMETHYST = 10540;
 	public const ANCIENT_DEBRIS = 10541;
@@ -737,8 +737,16 @@ final class BlockTypeIds{
 	public const BIG_DRIPLEAF_HEAD = 10707;
 	public const BIG_DRIPLEAF_STEM = 10708;
 	public const PINK_PETALS = 10709;
+	public const CRIMSON_ROOTS = 10710;
+	public const WARPED_ROOTS = 10711;
+	public const CHISELED_BOOKSHELF = 10712;
+	public const TORCHFLOWER = 10713;
+	public const TORCHFLOWER_CROP = 10714;
+	public const PITCHER_PLANT = 10715;
+	public const PITCHER_CROP = 10716;
+	public const DOUBLE_PITCHER_CROP = 10717;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10710;
+	public const FIRST_UNUSED_BLOCK_ID = 10718;
 
 	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
 

src/block/BrewingStand.php

@@ -34,6 +34,7 @@ use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use function array_key_exists;
+use function spl_object_id;
 
 class BrewingStand extends Transparent{
 
@@ -44,7 +45,7 @@ class BrewingStand extends Transparent{
 	protected array $slots = [];
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->brewingStandSlots($this->slots);
+		$w->enumSet($this->slots, BrewingStandSlot::cases());
 	}
 
 	protected function recalculateCollisionBoxes() : array{
@@ -61,18 +62,18 @@ class BrewingStand extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function hasSlot(BrewingStandSlot $slot) : bool{
-		return array_key_exists($slot->id(), $this->slots);
+		return array_key_exists(spl_object_id($slot), $this->slots);
 	}
 
 	public function setSlot(BrewingStandSlot $slot, bool $occupied) : self{
 		if($occupied){
-			$this->slots[$slot->id()] = $slot;
+			$this->slots[spl_object_id($slot)] = $slot;
 		}else{
-			unset($this->slots[$slot->id()]);
+			unset($this->slots[spl_object_id($slot)]);
 		}
 		return $this;
 	}
@@ -89,7 +90,7 @@ class BrewingStand extends Transparent{
 	public function setSlots(array $slots) : self{
 		$this->slots = [];
 		foreach($slots as $slot){
-			$this->slots[$slot->id()] = $slot;
+			$this->slots[spl_object_id($slot)] = $slot;
 		}
 		return $this;
 	}
@@ -114,7 +115,7 @@ class BrewingStand extends Transparent{
 			}
 
 			$changed = false;
-			foreach(BrewingStandSlot::getAll() as $slot){
+			foreach(BrewingStandSlot::cases() as $slot){
 				$occupied = !$brewing->getInventory()->isSlotEmpty($slot->getSlotNumber());
 				if($occupied !== $this->hasSlot($slot)){
 					$this->setSlot($slot, $occupied);

src/block/BuddingAmethyst.php

@@ -0,0 +1,68 @@
+<?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\AmethystTrait;
+use pocketmine\block\utils\BlockEventHelper;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use function array_rand;
+use function mt_rand;
+
+final class BuddingAmethyst extends Opaque{
+	use AmethystTrait;
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if(mt_rand(1, 5) === 1){
+			$face = Facing::ALL[array_rand(Facing::ALL)];
+
+			$adjacent = $this->getSide($face);
+			//TODO: amethyst buds can spawn in water - we need waterlogging support for this
+
+			$newStage = null;
+
+			if($adjacent->getTypeId() === BlockTypeIds::AIR){
+				$newStage = AmethystCluster::STAGE_SMALL_BUD;
+			}elseif(
+				$adjacent->getTypeId() === BlockTypeIds::AMETHYST_CLUSTER &&
+				$adjacent instanceof AmethystCluster &&
+				$adjacent->getStage() < AmethystCluster::STAGE_CLUSTER &&
+				$adjacent->getFacing() === $face
+			){
+				$newStage = $adjacent->getStage() + 1;
+			}
+			if($newStage !== null){
+				BlockEventHelper::grow($adjacent, VanillaBlocks::AMETHYST_CLUSTER()->setStage($newStage)->setFacing($face), null);
+			}
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+}

src/block/Cactus.php

@@ -23,39 +23,22 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\block\utils\SupportType;
-use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\Entity;
 use pocketmine\event\entity\EntityDamageByBlockEvent;
 use pocketmine\event\entity\EntityDamageEvent;
-use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
 class Cactus extends Transparent{
+	use AgeableTrait;
+	use StaticSupportTrait;
+
 	public const MAX_AGE = 15;
 
-	protected int $age = 0;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(4, 0, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
 	public function hasEntityCollision() : bool{
 		return true;
 	}
@@ -69,7 +52,7 @@ class Cactus extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onEntityInside(Entity $entity) : bool{
@@ -78,23 +61,18 @@ class Cactus extends Transparent{
 		return true;
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
-		return $block->hasSameTypeId($this) || $block->hasTypeTag(BlockTypeTags::SAND);
-	}
-
-	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
-			$world->useBreakOn($this->position);
-		}else{
-			foreach(Facing::HORIZONTAL as $side){
-				$b = $this->getSide($side);
-				if($b->isSolid()){
-					$world->useBreakOn($this->position);
-					break;
-				}
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::DOWN);
+		if(!$supportBlock->hasSameTypeId($this) && !$supportBlock->hasTypeTag(BlockTypeTags::SAND)){
+			return false;
+		}
+		foreach(Facing::HORIZONTAL as $side){
+			if($block->getSide($side)->isSolid()){
+				return false;
 			}
 		}
+
+		return true;
 	}
 
 	public function ticksRandomly() : bool{
@@ -124,18 +102,4 @@ class Cactus 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))){
-			foreach(Facing::HORIZONTAL as $side){
-				if($this->getSide($side)->isSolid()){
-					return false;
-				}
-			}
-
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
-	}
 }

src/block/Cake.php

@@ -37,7 +37,7 @@ class Cake extends BaseCake{
 	protected int $bites = 0;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(3, 0, self::MAX_BITES, $this->bites);
+		$w->boundedIntAuto(0, self::MAX_BITES, $this->bites);
 	}
 
 	/**

src/block/CakeWithDyedCandle.php

@@ -30,7 +30,7 @@ class CakeWithDyedCandle extends CakeWithCandle{
 	use ColoredTrait;
 
 	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
+		$this->color = DyeColor::WHITE;
 		parent::__construct($idInfo, $name, $typeInfo);
 	}
 

src/block/Candle.php

@@ -48,7 +48,7 @@ class Candle extends Transparent{
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$this->encodeLitState($w);
-		$w->boundedInt(2, self::MIN_COUNT, self::MAX_COUNT, $this->count);
+		$w->boundedIntAuto(self::MIN_COUNT, self::MAX_COUNT, $this->count);
 	}
 
 	public function getCount() : int{ return $this->count; }
@@ -91,7 +91,7 @@ class Candle extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	protected function getCandleIfCompatibleType(Block $block) : ?Candle{

src/block/Carpet.php

@@ -24,21 +24,13 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
-use pocketmine\item\Item;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
 class Carpet extends Flowable{
 	use ColoredTrait;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
+	use StaticSupportTrait;
 
 	public function isSolid() : bool{
 		return true;
@@ -51,19 +43,8 @@ class Carpet extends Flowable{
 		return [AxisAlignedBB::one()->trim(Facing::UP, 15 / 16)];
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->getTypeId() !== BlockTypeIds::AIR){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::AIR){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getSide(Facing::DOWN)->getTypeId() !== BlockTypeIds::AIR;
 	}
 
 	public function getFlameEncouragement() : int{

src/block/Cauldron.php

@@ -61,7 +61,7 @@ final class Cauldron extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return $facing === Facing::UP ? SupportType::EDGE() : SupportType::NONE();
+		return $facing === Facing::UP ? SupportType::EDGE : SupportType::NONE;
 	}
 
 	/**
@@ -83,7 +83,7 @@ final class Cauldron extends Transparent{
 		}elseif($item->getTypeId() === ItemTypeIds::POWDER_SNOW_BUCKET){
 			//TODO: powder snow cauldron
 		}elseif($item instanceof Potion || $item instanceof SplashPotion){ //TODO: lingering potion
-			if($item->getType()->equals(PotionType::WATER())){
+			if($item->getType() === PotionType::WATER){
 				$this->fill(WaterCauldron::WATER_BOTTLE_FILL_AMOUNT, VanillaBlocks::WATER_CAULDRON(), $item, VanillaItems::GLASS_BOTTLE(), $returnedItems);
 			}else{
 				$this->fill(PotionCauldron::POTION_FILL_AMOUNT, VanillaBlocks::POTION_CAULDRON()->setPotionItem($item), $item, VanillaItems::GLASS_BOTTLE(), $returnedItems);

src/block/CaveVines.php

@@ -23,7 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\Entity;
@@ -38,14 +40,16 @@ use pocketmine\world\sound\GlowBerriesPickSound;
 use function mt_rand;
 
 class CaveVines extends Flowable{
+	use AgeableTrait;
+	use StaticSupportTrait;
+
 	public const MAX_AGE = 25;
 
-	protected int $age = 0;
 	protected bool $berries = false;
 	protected bool $head = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(5, 0, self::MAX_AGE, $this->age);
+		$w->boundedIntAuto(0, self::MAX_AGE, $this->age);
 		$w->bool($this->berries);
 		$w->bool($this->head);
 	}
@@ -66,19 +70,6 @@ class CaveVines extends Flowable{
 		return $this;
 	}
 
-	public function getAge() : int{
-		return $this->age;
-	}
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0-" . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
 	public function canClimb() : bool{
 		return true;
 	}
@@ -89,19 +80,10 @@ class CaveVines extends Flowable{
 
 	private function canBeSupportedAt(Block $block) : bool{
 		$supportBlock = $block->getSide(Facing::UP);
-		return $supportBlock->getSupportType(Facing::DOWN)->equals(SupportType::FULL()) || $supportBlock->hasSameTypeId($this);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+		return $supportBlock->getSupportType(Facing::DOWN) === SupportType::FULL || $supportBlock->hasSameTypeId($this);
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedAt($blockReplace)){
-			return false;
-		}
 		$this->age = mt_rand(0, self::MAX_AGE);
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
@@ -177,6 +159,6 @@ class CaveVines extends Flowable{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 }

src/block/Chain.php

@@ -33,7 +33,7 @@ final class Chain extends Transparent{
 	use PillarRotationTrait;
 
 	public function getSupportType(int $facing) : SupportType{
-		return $this->axis === Axis::Y && Facing::axis($facing) === Axis::Y ? SupportType::CENTER() : SupportType::NONE();
+		return $this->axis === Axis::Y && Facing::axis($facing) === Axis::Y ? SupportType::CENTER : SupportType::NONE;
 	}
 
 	protected function recalculateCollisionBoxes() : array{

src/block/Chest.php

@@ -45,7 +45,7 @@ class Chest extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onPostPlace() : void{

src/block/ChiseledBookshelf.php

@@ -0,0 +1,134 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\tile\ChiseledBookshelf as TileChiseledBookshelf;
+use pocketmine\block\utils\ChiseledBookshelfSlot;
+use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\item\Book;
+use pocketmine\item\EnchantedBook;
+use pocketmine\item\Item;
+use pocketmine\item\WritableBookBase;
+use pocketmine\math\Axis;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use function spl_object_id;
+
+class ChiseledBookshelf extends Opaque{
+	use HorizontalFacingTrait;
+	use FacesOppositePlacingPlayerTrait;
+
+	/**
+	 * @var ChiseledBookshelfSlot[]
+	 * @phpstan-var array<int, ChiseledBookshelfSlot>
+	 */
+	private array $slots = [];
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->horizontalFacing($this->facing);
+		$w->enumSet($this->slots, ChiseledBookshelfSlot::cases());
+	}
+
+	/**
+	 * Returns whether the given slot is displayed as occupied.
+	 * This doesn't guarantee that there is or isn't a book in the bookshelf's inventory.
+	 */
+	public function hasSlot(ChiseledBookshelfSlot $slot) : bool{
+		return isset($this->slots[spl_object_id($slot)]);
+	}
+
+	/**
+	 * Sets whether the given slot is displayed as occupied.
+	 *
+	 * This doesn't modify the bookshelf's inventory, so you can use this to make invisible
+	 * books or display books that aren't actually in the bookshelf.
+	 *
+	 * To modify the contents of the bookshelf inventory, access the tile inventory.
+	 *
+	 * @return $this
+	 */
+	public function setSlot(ChiseledBookshelfSlot $slot, bool $occupied) : self{
+		if($occupied){
+			$this->slots[spl_object_id($slot)] = $slot;
+		}else{
+			unset($this->slots[spl_object_id($slot)]);
+		}
+		return $this;
+	}
+
+	/**
+	 * Returns which slots of the bookshelf are displayed as occupied.
+	 * As above, these values do not necessarily reflect the contents of the bookshelf inventory,
+	 * although they usually will unless modified by plugins.
+	 *
+	 * @return ChiseledBookshelfSlot[]
+	 * @phpstan-return array<int, ChiseledBookshelfSlot>
+	 */
+	public function getSlots() : array{
+		return $this->slots;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($face !== $this->facing){
+			return false;
+		}
+
+		$x = Facing::axis($face) === Axis::X ? $clickVector->z : $clickVector->x;
+		$slot = ChiseledBookshelfSlot::fromBlockFaceCoordinates(
+			Facing::isPositive(Facing::rotateY($face, true)) ? 1 - $x : $x,
+			$clickVector->y
+		);
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if(!$tile instanceof TileChiseledBookshelf){
+			return false;
+		}
+
+		$inventory = $tile->getInventory();
+		if(!$inventory->isSlotEmpty($slot->value)){
+			$returnedItems[] = $inventory->getItem($slot->value);
+			$inventory->clear($slot->value);
+			$this->setSlot($slot, false);
+		}elseif($item instanceof WritableBookBase || $item instanceof Book || $item instanceof EnchantedBook){
+			//TODO: type tags like blocks would be better for this
+			$inventory->setItem($slot->value, $item->pop());
+			$this->setSlot($slot, true);
+		}else{
+			return true;
+		}
+
+		$this->position->getWorld()->setBlock($this->position, $this);
+		return true;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+}

src/block/ChorusFlower.php

@@ -23,52 +23,38 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\block\utils\AgeableTrait;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\entity\projectile\Projectile;
 use pocketmine\event\block\StructureGrowEvent;
-use pocketmine\item\Item;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\RayTraceResult;
 use pocketmine\math\Vector3;
-use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
-use pocketmine\world\Position;
 use pocketmine\world\sound\ChorusFlowerDieSound;
 use pocketmine\world\sound\ChorusFlowerGrowSound;
 use pocketmine\world\World;
 use function array_rand;
+use function min;
 use function mt_rand;
 
 final class ChorusFlower extends Flowable{
+	use AgeableTrait;
+	use StaticSupportTrait;
+
 	public const MIN_AGE = 0;
 	public const MAX_AGE = 5;
 
 	private const MAX_STEM_HEIGHT = 5;
 
-	private int $age = self::MIN_AGE;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(3, self::MIN_AGE, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < self::MIN_AGE || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in the range " . self::MIN_AGE . " ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
 	protected function recalculateCollisionBoxes() : array{
 		return [AxisAlignedBB::one()];
 	}
 
-	private function canBeSupportedAt(Position $position) : bool{
+	private function canBeSupportedAt(Block $block) : bool{
+		$position = $block->position;
 		$world = $position->getWorld();
 		$down = $world->getBlock($position->down());
 
@@ -93,25 +79,10 @@ final class ChorusFlower extends Flowable{
 		return $plantAdjacent;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedAt($blockReplace->getPosition())){
-			return false;
-		}
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this->position)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
-	}
-
 	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
 		$this->position->getWorld()->useBreakOn($this->position);
 	}
 
-	public function ticksRandomly() : bool{ return $this->age < self::MAX_AGE; }
-
 	/**
 	 * @phpstan-return array{int, bool}
 	 */
@@ -181,11 +152,13 @@ final class ChorusFlower extends Flowable{
 		if($tx === null){
 			$tx = new BlockTransaction($this->position->getWorld());
 		}
-		$tx->addBlock($this->position->getSide($facing), (clone $this)->setAge($this->getAge() + $ageChange));
+		$tx->addBlock($this->position->getSide($facing), (clone $this)->setAge(min(self::MAX_AGE, $this->age + $ageChange)));
 
 		return $tx;
 	}
 
+	public function ticksRandomly() : bool{ return $this->age < self::MAX_AGE; }
+
 	public function onRandomTick() : void{
 		$world = $this->position->getWorld();
 

src/block/ChorusPlant.php

@@ -23,18 +23,16 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
-use pocketmine\world\Position;
 use function mt_rand;
 
 final class ChorusPlant extends Flowable{
+	use StaticSupportTrait;
 
 	protected function recalculateCollisionBoxes() : array{
 		$bb = AxisAlignedBB::one();
@@ -52,7 +50,8 @@ final class ChorusPlant extends Flowable{
 		return $block->hasSameTypeId($this) || $block->getTypeId() === BlockTypeIds::END_STONE;
 	}
 
-	private function canStay(Position $position) : bool{
+	private function canBeSupportedAt(Block $block) : bool{
+		$position = $block->position;
 		$world = $position->getWorld();
 
 		$down = $world->getBlock($position->down());
@@ -72,24 +71,7 @@ final class ChorusPlant extends Flowable{
 			}
 		}
 
-		if($this->canBeSupportedBy($down)){
-			return true;
-		}
-
-		return false;
-	}
-
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canStay($blockReplace->getPosition())){
-			return false;
-		}
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canStay($this->position)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+		return $this->canBeSupportedBy($down);
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{

src/block/CocoaBlock.php

@@ -23,9 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\HorizontalFacingTrait;
-use pocketmine\block\utils\SupportType;
 use pocketmine\block\utils\WoodType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Fertilizer;
@@ -39,27 +39,15 @@ use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
-class CocoaBlock extends Transparent{
+class CocoaBlock extends Flowable{
 	use HorizontalFacingTrait;
+	use AgeableTrait;
 
 	public const MAX_AGE = 2;
 
-	protected int $age = 0;
-
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->horizontalFacing($this->facing);
-		$w->boundedInt(2, 0, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
+		$w->boundedIntAuto(0, self::MAX_AGE, $this->age);
 	}
 
 	/**
@@ -76,12 +64,8 @@ class CocoaBlock extends Transparent{
 		];
 	}
 
-	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
-	}
-
 	private function canAttachTo(Block $block) : bool{
-		return $block instanceof Wood && $block->getWoodType()->equals(WoodType::JUNGLE());
+		return $block instanceof Wood && $block->getWoodType() === WoodType::JUNGLE;
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
@@ -110,7 +94,7 @@ class CocoaBlock extends Transparent{
 	}
 
 	public function ticksRandomly() : bool{
-		return true;
+		return $this->age < self::MAX_AGE;
 	}
 
 	public function onRandomTick() : void{

src/block/Concrete.php

@@ -24,13 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 
 class Concrete extends Opaque{
 	use ColoredTrait;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
 }

src/block/ConcretePowder.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\Fallable;
 use pocketmine\block\utils\FallableTrait;
 use pocketmine\math\Facing;
@@ -36,11 +35,6 @@ class ConcretePowder extends Opaque implements Fallable{
 		onNearbyBlockChange as protected startFalling;
 	}
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	public function onNearbyBlockChange() : void{
 		if(($water = $this->getAdjacentWater()) !== null){
 			BlockEventHelper::form($this, VanillaBlocks::CONCRETE()->setColor($this->color), $water);

src/block/CopperStairs.php

@@ -23,14 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\CopperOxidation;
 use pocketmine\block\utils\CopperTrait;
 
 class CopperStairs extends Stair{
 	use CopperTrait;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->oxidation = CopperOxidation::NONE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
 }

src/block/Coral.php

@@ -23,29 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\Item;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-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->canBeSupportedAt($blockReplace)){
-			return false;
-		}
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-	}
-
-	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedAt($this)){
-			$world->useBreakOn($this->position);
-		}else{
-			parent::onNearbyBlockChange();
-		}
-	}
+	use StaticSupportTrait;
 
 	private function canBeSupportedAt(Block $block) : bool{
 		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();

src/block/CoralBlock.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\BlockEventHelper;
-use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\CoralTypeTrait;
 use pocketmine\item\Item;
 use function mt_rand;
@@ -32,11 +31,6 @@ use function mt_rand;
 final class CoralBlock extends Opaque{
 	use CoralTypeTrait;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->coralType = CoralType::TUBE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	public function onNearbyBlockChange() : void{
 		if(!$this->dead){
 			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(40, 200));

src/block/Crops.php

@@ -23,51 +23,35 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
-use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\block\utils\CropGrowthHelper;
+use pocketmine\block\utils\StaticSupportTrait;
 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 function mt_rand;
 
 abstract class Crops extends Flowable{
+	use AgeableTrait;
+	use StaticSupportTrait;
+
 	public const MAX_AGE = 7;
 
-	protected int $age = 0;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(3, 0, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if($blockReplace->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::FARMLAND){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
+	private function canBeSupportedAt(Block $block) : bool{
+		return $block->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::FARMLAND;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->age < self::MAX_AGE && $item instanceof Fertilizer){
 			$block = clone $this;
-			$block->age += mt_rand(2, 5);
-			if($block->age > self::MAX_AGE){
-				$block->age = self::MAX_AGE;
+			$tempAge = $block->age + mt_rand(2, 5);
+			if($tempAge > self::MAX_AGE){
+				$tempAge = self::MAX_AGE;
 			}
+			$block->age = $tempAge;
 			if(BlockEventHelper::grow($this, $block, $player)){
 				$item->pop();
 			}
@@ -78,18 +62,12 @@ abstract class Crops extends Flowable{
 		return false;
 	}
 
-	public function onNearbyBlockChange() : void{
-		if($this->getSide(Facing::DOWN)->getTypeId() !== BlockTypeIds::FARMLAND){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
-	}
-
 	public function ticksRandomly() : bool{
-		return true;
+		return $this->age < self::MAX_AGE;
 	}
 
 	public function onRandomTick() : void{
-		if($this->age < self::MAX_AGE && mt_rand(0, 2) === 1){
+		if($this->age < self::MAX_AGE && CropGrowthHelper::canGrow($this)){
 			$block = clone $this;
 			++$block->age;
 			BlockEventHelper::grow($this, $block, null);

src/block/DaylightSensor.php

@@ -42,7 +42,7 @@ class DaylightSensor extends Transparent{
 	protected bool $inverted = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(4, 0, 15, $this->signalStrength);
+		$w->boundedIntAuto(0, 15, $this->signalStrength);
 		$w->bool($this->inverted);
 	}
 
@@ -70,7 +70,7 @@ class DaylightSensor extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/DeadBush.php

@@ -23,29 +23,14 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
 class DeadBush 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))){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedBy($this->getSide(Facing::DOWN))){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
-	}
+	use StaticSupportTrait;
 
 	public function getDropsForIncompatibleTool(Item $item) : array{
 		return [
@@ -65,11 +50,12 @@ class DeadBush extends Flowable{
 		return 100;
 	}
 
-	private function canBeSupportedBy(Block $block) : bool{
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::DOWN);
 		return
-			$block->hasTypeTag(BlockTypeTags::SAND) ||
-			$block->hasTypeTag(BlockTypeTags::MUD) ||
-			match($block->getTypeId()){
+			$supportBlock->hasTypeTag(BlockTypeTags::SAND) ||
+			$supportBlock->hasTypeTag(BlockTypeTags::MUD) ||
+			match($supportBlock->getTypeId()){
 				//can't use DIRT tag here because it includes farmland
 				BlockTypeIds::PODZOL,
 				BlockTypeIds::MYCELIUM,

src/block/Dirt.php

@@ -38,15 +38,10 @@ use pocketmine\world\sound\ItemUseOnBlockSound;
 use pocketmine\world\sound\WaterSplashSound;
 
 class Dirt extends Opaque{
-	protected DirtType $dirtType;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->dirtType = DirtType::NORMAL();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
+	protected DirtType $dirtType = DirtType::NORMAL;
 
 	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
-		$w->dirtType($this->dirtType);
+		$w->enum($this->dirtType);
 	}
 
 	public function getDirtType() : DirtType{ return $this->dirtType; }
@@ -67,16 +62,16 @@ class Dirt extends Opaque{
 
 			$item->applyDamage(1);
 
-			$newBlock = $this->dirtType->equals(DirtType::NORMAL()) ? VanillaBlocks::FARMLAND() : VanillaBlocks::DIRT();
+			$newBlock = $this->dirtType === DirtType::NORMAL ? VanillaBlocks::FARMLAND() : VanillaBlocks::DIRT();
 			$center = $this->position->add(0.5, 0.5, 0.5);
 			$world->addSound($center, new ItemUseOnBlockSound($newBlock));
 			$world->setBlock($this->position, $newBlock);
-			if($this->dirtType->equals(DirtType::ROOTED())){
+			if($this->dirtType === DirtType::ROOTED){
 				$world->dropItem($center, VanillaBlocks::HANGING_ROOTS()->asItem());
 			}
 
 			return true;
-		}elseif($this->dirtType->equals(DirtType::ROOTED()) && $item instanceof Fertilizer){
+		}elseif($this->dirtType === DirtType::ROOTED && $item instanceof Fertilizer){
 			$down = $this->getSide(Facing::DOWN);
 			if($down->getTypeId() !== BlockTypeIds::AIR){
 				return true;
@@ -85,7 +80,7 @@ class Dirt extends Opaque{
 			$item->pop();
 			$world->setBlock($down->position, VanillaBlocks::HANGING_ROOTS());
 			//TODO: bonemeal particles, growth sounds
-		}elseif(($item instanceof Potion || $item instanceof SplashPotion) && $item->getType()->equals(PotionType::WATER())){
+		}elseif(($item instanceof Potion || $item instanceof SplashPotion) && $item->getType() === PotionType::WATER){
 			$item->pop();
 			$world->setBlock($this->position, VanillaBlocks::MUD());
 			$world->addSound($this->position, new WaterSplashSound(0.5));

src/block/Door.php

@@ -51,6 +51,8 @@ class Door extends Transparent{
 	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 
+		$this->collisionBoxes = null;
+
 		//copy door properties from other half
 		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
 		if($other instanceof Door && $other->hasSameTypeId($this)){
@@ -102,7 +104,7 @@ class Door extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/DoublePitcherCrop.php

@@ -0,0 +1,120 @@
+<?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\AgeableTrait;
+use pocketmine\block\utils\CropGrowthHelper;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\event\block\StructureGrowEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+final class DoublePitcherCrop extends DoublePlant{
+	use AgeableTrait {
+		describeBlockOnlyState as describeAge;
+	}
+
+	public const MAX_AGE = 1;
+
+	public function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		parent::describeBlockOnlyState($w);
+		$this->describeAge($w);
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		if($this->top){
+			return [];
+		}
+
+		//the pod exists only in the bottom half of the plant
+		return [
+			AxisAlignedBB::one()
+			->trim(Facing::UP, 11 / 16)
+			->squash(Axis::X, 3 / 16)
+			->squash(Axis::Z, 3 / 16)
+			->extend(Facing::DOWN, 1 / 16) //presumably this is to correct for farmland being 15/16 of a block tall
+		];
+	}
+
+	private function grow(?Player $player) : bool{
+		if($this->age >= self::MAX_AGE){
+			return false;
+		}
+
+		$bottom = $this->top ? $this->getSide(Facing::DOWN) : $this;
+		$top = $this->top ? $this : $this->getSide(Facing::UP);
+		if($top->getTypeId() !== BlockTypeIds::AIR && !$top->hasSameTypeId($this)){
+			return false;
+		}
+
+		$newState = (clone $this)->setAge($this->age + 1);
+
+		$tx = new BlockTransaction($this->position->getWorld());
+		$tx->addBlock($bottom->position, (clone $newState)->setTop(false));
+		$tx->addBlock($top->position, (clone $newState)->setTop(true));
+
+		$ev = new StructureGrowEvent($bottom, $tx, $player);
+		$ev->call();
+
+		return !$ev->isCancelled() && $tx->apply();
+
+	}
+
+	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;
+	}
+
+	public function ticksRandomly() : bool{
+		return $this->age < self::MAX_AGE && !$this->top;
+	}
+
+	public function onRandomTick() : void{
+		//only the bottom half of the plant can grow randomly
+		if(CropGrowthHelper::canGrow($this) && !$this->top){
+			$this->grow(null);
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			$this->age >= self::MAX_AGE ? VanillaBlocks::PITCHER_PLANT()->asItem() : VanillaItems::PITCHER_POD()
+		];
+	}
+
+	public function asItem() : Item{
+		return VanillaItems::PITCHER_POD();
+	}
+}

src/block/DragonEgg.php

@@ -50,7 +50,7 @@ class DragonEgg extends Transparent implements Fallable{
 	}
 
 	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
-		if($player !== null && !$player->getGamemode()->equals(GameMode::CREATIVE())){
+		if($player !== null && $player->getGamemode() !== GameMode::CREATIVE){
 			$this->teleport();
 			return true;
 		}
@@ -82,6 +82,6 @@ class DragonEgg extends Transparent implements Fallable{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 }

src/block/DyedCandle.php

@@ -24,19 +24,13 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 
 class DyedCandle extends Candle{
 	use ColoredTrait;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
-
 	protected function getCandleIfCompatibleType(Block $block) : ?Candle{
 		$result = parent::getCandleIfCompatibleType($block);
 		//different coloured candles can't be combined in the same block
-		return $result instanceof DyedCandle && $result->color->equals($this->color) ? $result : null;
+		return $result instanceof DyedCandle && $result->color === $this->color ? $result : null;
 	}
 }

src/block/DyedShulkerBox.php

@@ -24,13 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 
 final class DyedShulkerBox extends ShulkerBox{
 	use ColoredTrait;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::WHITE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
 }

src/block/EnchantingTable.php

@@ -41,7 +41,7 @@ class EnchantingTable extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/EnderChest.php

@@ -49,7 +49,7 @@ class EnderChest extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/Farmland.php

@@ -31,15 +31,40 @@ use pocketmine\event\entity\EntityTrampleFarmlandEvent;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
+use function intdiv;
 use function lcg_value;
 
 class Farmland extends Transparent{
 	public const MAX_WETNESS = 7;
 
+	private const WATER_SEARCH_HORIZONTAL_LENGTH = 9;
+
+	private const WATER_SEARCH_VERTICAL_LENGTH = 2;
+
+	private const WATER_POSITION_INDEX_UNKNOWN = -1;
+	/** Total possible options for water X/Z indexes */
+	private const WATER_POSITION_INDICES_TOTAL = (self::WATER_SEARCH_HORIZONTAL_LENGTH ** 2) * 2;
+
 	protected int $wetness = 0; //"moisture" blockstate property in PC
 
+	/**
+	 * Cached value indicating the relative coordinates of the most recently found water block.
+	 *
+	 * If this is set to a non-unknown value, the farmland block will check the relative coordinates indicated by
+	 * this value for water, before searching the entire 9x2x9 grid around the farmland. This significantly benefits
+	 * hydrating or fully hydrated farmland, avoiding the need for costly searches on every random tick.
+	 *
+	 * If the coordinates indicated don't contain water, the full 9x2x9 volume will be searched as before. A new index
+	 * will be recorded if water is found, otherwise it will be set to unknown and future searches will search the full
+	 * 9x2x9 volume again.
+	 *
+	 * This property is not exposed to the API or saved on disk. It is only used by PocketMine-MP at runtime as a cache.
+	 */
+	private int $waterPositionIndex = self::WATER_POSITION_INDEX_UNKNOWN;
+
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(3, 0, self::MAX_WETNESS, $this->wetness);
+		$w->boundedIntAuto(0, self::MAX_WETNESS, $this->wetness);
+		$w->boundedIntAuto(-1, self::WATER_POSITION_INDICES_TOTAL - 1, $this->waterPositionIndex);
 	}
 
 	public function getWetness() : int{ return $this->wetness; }
@@ -53,6 +78,22 @@ class Farmland extends Transparent{
 		return $this;
 	}
 
+	/**
+	 * @internal
+	 */
+	public function getWaterPositionIndex() : int{ return $this->waterPositionIndex; }
+
+	/**
+	 * @internal
+	 */
+	public function setWaterPositionIndex(int $waterPositionIndex) : self{
+		if($waterPositionIndex < -1 || $waterPositionIndex >= self::WATER_POSITION_INDICES_TOTAL){
+			throw new \InvalidArgumentException("Water XZ index must be in range -1 ... " . (self::WATER_POSITION_INDICES_TOTAL - 1));
+		}
+		$this->waterPositionIndex = $waterPositionIndex;
+		return $this;
+	}
+
 	/**
 	 * @return AxisAlignedBB[]
 	 */
@@ -72,6 +113,11 @@ class Farmland extends Transparent{
 
 	public function onRandomTick() : void{
 		$world = $this->position->getWorld();
+
+		//this property may be updated by canHydrate() - track this so we know if we need to set the block again
+		$oldWaterPositionIndex = $this->waterPositionIndex;
+		$changed = false;
+
 		if(!$this->canHydrate()){
 			if($this->wetness > 0){
 				$event = new FarmlandHydrationChangeEvent($this, $this->wetness, $this->wetness - 1);
@@ -79,9 +125,11 @@ class Farmland extends Transparent{
 				if(!$event->isCancelled()){
 					$this->wetness = $event->getNewHydration();
 					$world->setBlock($this->position, $this, false);
+					$changed = true;
 				}
 			}else{
 				$world->setBlock($this->position, VanillaBlocks::DIRT());
+				$changed = true;
 			}
 		}elseif($this->wetness < self::MAX_WETNESS){
 			$event = new FarmlandHydrationChangeEvent($this, $this->wetness, self::MAX_WETNESS);
@@ -89,8 +137,14 @@ class Farmland extends Transparent{
 			if(!$event->isCancelled()){
 				$this->wetness = $event->getNewHydration();
 				$world->setBlock($this->position, $this, false);
+				$changed = true;
 			}
 		}
+
+		if(!$changed && $oldWaterPositionIndex !== $this->waterPositionIndex){
+			//ensure the water square index is saved regardless of whether anything else happened
+			$world->setBlock($this->position, $this, false);
+		}
 	}
 
 	public function onEntityLand(Entity $entity) : ?float{
@@ -98,26 +152,46 @@ class Farmland extends Transparent{
 			$ev = new EntityTrampleFarmlandEvent($entity, $this);
 			$ev->call();
 			if(!$ev->isCancelled()){
-				$this->getPosition()->getWorld()->setBlock($this->getPosition(), VanillaBlocks::DIRT());
+				$this->position->getWorld()->setBlock($this->position, VanillaBlocks::DIRT());
 			}
 		}
 		return null;
 	}
 
 	protected function canHydrate() : bool{
-		//TODO: check rain
-		$start = $this->position->add(-4, 0, -4);
-		$end = $this->position->add(4, 1, 4);
-		for($y = $start->y; $y <= $end->y; ++$y){
-			for($z = $start->z; $z <= $end->z; ++$z){
-				for($x = $start->x; $x <= $end->x; ++$x){
-					if($this->position->getWorld()->getBlockAt($x, $y, $z) instanceof Water){
+		$world = $this->position->getWorld();
+
+		$startX = $this->position->getFloorX() - (int) (self::WATER_SEARCH_HORIZONTAL_LENGTH / 2);
+		$startY = $this->position->getFloorY();
+		$startZ = $this->position->getFloorZ() - (int) (self::WATER_SEARCH_HORIZONTAL_LENGTH / 2);
+
+		if($this->waterPositionIndex !== self::WATER_POSITION_INDEX_UNKNOWN){
+			$raw = $this->waterPositionIndex;
+			$x = $raw % self::WATER_SEARCH_HORIZONTAL_LENGTH;
+			$raw = intdiv($raw, self::WATER_SEARCH_HORIZONTAL_LENGTH);
+			$z = $raw % self::WATER_SEARCH_HORIZONTAL_LENGTH;
+			$raw = intdiv($raw, self::WATER_SEARCH_HORIZONTAL_LENGTH);
+			$y = $raw % self::WATER_SEARCH_VERTICAL_LENGTH;
+
+			if($world->getBlockAt($startX + $x, $startY + $y, $startZ + $z) instanceof Water){
+				return true;
+			}
+		}
+
+		//no water found at cached position - search the whole area
+		//y will increment after x/z have been exhausted, as usually water will be at the same Y as the farmland
+		for($y = 0; $y < self::WATER_SEARCH_VERTICAL_LENGTH; $y++){
+			for($x = 0; $x < self::WATER_SEARCH_HORIZONTAL_LENGTH; $x++){
+				for($z = 0; $z < self::WATER_SEARCH_HORIZONTAL_LENGTH; $z++){
+					if($world->getBlockAt($startX + $x, $startY + $y, $startZ + $z) instanceof Water){
+						$this->waterPositionIndex = $x + ($z * self::WATER_SEARCH_HORIZONTAL_LENGTH) + ($y * self::WATER_SEARCH_HORIZONTAL_LENGTH ** 2);
 						return true;
 					}
 				}
 			}
 		}
 
+		$this->waterPositionIndex = self::WATER_POSITION_INDEX_UNKNOWN;
 		return false;
 	}
 

src/block/Fence.php

@@ -40,9 +40,11 @@ class Fence extends Transparent{
 	public function readStateFromWorld() : Block{
 		parent::readStateFromWorld();
 
+		$this->collisionBoxes = null;
+
 		foreach(Facing::HORIZONTAL as $facing){
 			$block = $this->getSide($facing);
-			if($block instanceof static || $block instanceof FenceGate || $block->getSupportType(Facing::opposite($facing))->equals(SupportType::FULL())){
+			if($block instanceof static || $block instanceof FenceGate || $block->getSupportType(Facing::opposite($facing)) === SupportType::FULL){
 				$this->connections[$facing] = true;
 			}else{
 				unset($this->connections[$facing]);
@@ -98,6 +100,6 @@ class Fence extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return Facing::axis($facing) === Axis::Y ? SupportType::CENTER() : SupportType::NONE();
+		return Facing::axis($facing) === Axis::Y ? SupportType::CENTER : SupportType::NONE;
 	}
 }

src/block/FenceGate.php

@@ -72,7 +72,7 @@ class FenceGate extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	private function checkInWall() : bool{

src/block/FillableCauldron.php

@@ -38,7 +38,7 @@ abstract class FillableCauldron extends Transparent{
 	private int $fillLevel = self::MIN_FILL_LEVEL;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(3, self::MIN_FILL_LEVEL, self::MAX_FILL_LEVEL, $this->fillLevel);
+		$w->boundedIntAuto(self::MIN_FILL_LEVEL, self::MAX_FILL_LEVEL, $this->fillLevel);
 	}
 
 	public function getFillLevel() : int{ return $this->fillLevel; }
@@ -64,7 +64,7 @@ abstract class FillableCauldron extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return $facing === Facing::UP ? SupportType::EDGE() : SupportType::NONE();
+		return $facing === Facing::UP ? SupportType::EDGE : SupportType::NONE;
 	}
 
 	protected function withFillLevel(int $fillLevel) : Block{

src/block/Fire.php

@@ -23,9 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\SupportType;
-use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\BlockBurnEvent;
 use pocketmine\math\Facing;
 use pocketmine\world\format\Chunk;
@@ -36,31 +36,16 @@ use function min;
 use function mt_rand;
 
 class Fire extends BaseFire{
+	use AgeableTrait;
+
 	public const MAX_AGE = 15;
 
-	protected int $age = 0;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(4, 0, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
 	protected function getFireDamage() : int{
 		return 1;
 	}
 
 	private function canBeSupportedBy(Block $block) : bool{
-		return $block->getSupportType(Facing::UP)->equals(SupportType::FULL());
+		return $block->getSupportType(Facing::UP) === SupportType::FULL;
 	}
 
 	public function onNearbyBlockChange() : void{
@@ -155,7 +140,7 @@ class Fire extends BaseFire{
 				$block->onIncinerate();
 
 				$world = $this->position->getWorld();
-				if($world->getBlock($block->getPosition())->isSameState($block)){
+				if($world->getBlock($block->position)->isSameState($block)){
 					$spreadedFire = false;
 					if(mt_rand(0, $this->age + 9) < 5){ //TODO: check rain
 						$fire = clone $this;

src/block/FloorCoralFan.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
@@ -35,6 +36,8 @@ use function atan2;
 use function rad2deg;
 
 final class FloorCoralFan extends BaseCoral{
+	use StaticSupportTrait;
+
 	private int $axis = Axis::X;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
@@ -53,12 +56,9 @@ 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->canBeSupportedAt($blockReplace)){
-			return false;
-		}
 		if($player !== null){
 			$playerBlockPos = $player->getPosition()->floor();
-			$directionVector = $blockReplace->getPosition()->subtractVector($playerBlockPos)->normalize();
+			$directionVector = $blockReplace->position->subtractVector($playerBlockPos)->normalize();
 			$angle = rad2deg(atan2($directionVector->getZ(), $directionVector->getX()));
 
 			if($angle <= 45 || 315 <= $angle || (135 <= $angle && $angle <= 225)){
@@ -73,15 +73,6 @@ final class FloorCoralFan extends BaseCoral{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onNearbyBlockChange() : void{
-		$world = $this->position->getWorld();
-		if(!$this->canBeSupportedAt($this)){
-			$world->useBreakOn($this->position);
-		}else{
-			parent::onNearbyBlockChange();
-		}
-	}
-
 	private function canBeSupportedAt(Block $block) : bool{
 		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}

src/block/Flowable.php

@@ -48,6 +48,6 @@ abstract class Flowable extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 }

src/block/Flower.php

@@ -23,28 +23,15 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\Item;
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
 class Flower extends Flowable{
+	use StaticSupportTrait;
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$down = $this->getSide(Facing::DOWN);
-		if($down->hasTypeTag(BlockTypeTags::DIRT) || $down->hasTypeTag(BlockTypeTags::MUD)){
-			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-		}
-
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-		$down = $this->getSide(Facing::DOWN);
-		if(!$down->hasTypeTag(BlockTypeTags::DIRT) && !$down->hasTypeTag(BlockTypeTags::MUD)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+	private function canBeSupportedAt(Block $block) : bool{
+		$supportBlock = $block->getSide(Facing::DOWN);
+		return $supportBlock->hasTypeTag(BlockTypeTags::DIRT) || $supportBlock->hasTypeTag(BlockTypeTags::MUD);
 	}
 
 	public function getFlameEncouragement() : int{

src/block/FlowerPot.php

@@ -24,15 +24,16 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\tile\FlowerPot as TileFlowerPot;
+use pocketmine\block\utils\StaticSupportTrait;
 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 function assert;
 
 class FlowerPot extends Flowable{
+	use StaticSupportTrait;
 
 	protected ?Block $plant = null;
 
@@ -89,20 +90,6 @@ class FlowerPot extends Flowable{
 		return [AxisAlignedBB::one()->contract(3 / 16, 0, 3 / 16)->trim(Facing::UP, 5 / 8)];
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedAt($blockReplace)){
-			return false;
-		}
-
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
-	}
-
 	private function canBeSupportedAt(Block $block) : bool{
 		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}

src/block/Froglight.php

@@ -28,15 +28,10 @@ use pocketmine\data\runtime\RuntimeDataDescriber;
 
 final class Froglight extends SimplePillar{
 
-	private FroglightType $froglightType;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->froglightType = FroglightType::OCHRE();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
+	private FroglightType $froglightType = FroglightType::OCHRE;
 
 	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
-		$w->froglightType($this->froglightType);
+		$w->enum($this->froglightType);
 	}
 
 	public function getFroglightType() : FroglightType{ return $this->froglightType; }

src/block/FrostedIce.php

@@ -23,30 +23,15 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
-use pocketmine\data\runtime\RuntimeDataDescriber;
 use function mt_rand;
 
 class FrostedIce extends Ice{
+	use AgeableTrait;
+
 	public const MAX_AGE = 3;
 
-	protected int $age = 0;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->boundedInt(2, 0, self::MAX_AGE, $this->age);
-	}
-
-	public function getAge() : int{ return $this->age; }
-
-	/** @return $this */
-	public function setAge(int $age) : self{
-		if($age < 0 || $age > self::MAX_AGE){
-			throw new \InvalidArgumentException("Age must be in range 0 ... " . self::MAX_AGE);
-		}
-		$this->age = $age;
-		return $this;
-	}
-
 	public function onNearbyBlockChange() : void{
 		$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(20, 40));
 	}

src/block/Furnace.php

@@ -25,6 +25,7 @@ namespace pocketmine\block;
 
 use pocketmine\block\tile\Furnace as TileFurnace;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
+use pocketmine\block\utils\LightableTrait;
 use pocketmine\crafting\FurnaceType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
@@ -34,11 +35,10 @@ use function mt_rand;
 
 class Furnace extends Opaque{
 	use FacesOppositePlacingPlayerTrait;
+	use LightableTrait;
 
 	protected FurnaceType $furnaceType;
 
-	protected bool $lit = false;
-
 	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo, FurnaceType $furnaceType){
 		$this->furnaceType = $furnaceType;
 		parent::__construct($idInfo, $name, $typeInfo);
@@ -57,18 +57,6 @@ class Furnace extends Opaque{
 		return $this->lit ? 13 : 0;
 	}
 
-	public function isLit() : bool{
-		return $this->lit;
-	}
-
-	/**
-	 * @return $this
-	 */
-	public function setLit(bool $lit = true) : self{
-		$this->lit = $lit;
-		return $this;
-	}
-
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$furnace = $this->position->getWorld()->getTile($this->position);

src/block/GlazedTerracotta.php

@@ -24,15 +24,9 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\ColoredTrait;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 
 class GlazedTerracotta extends Opaque{
 	use ColoredTrait;
 	use FacesOppositePlacingPlayerTrait;
-
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
-		$this->color = DyeColor::BLACK();
-		parent::__construct($idInfo, $name, $typeInfo);
-	}
 }

src/block/GlowLichen.php

@@ -95,7 +95,7 @@ class GlowLichen extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function canBeReplaced() : bool{
@@ -121,7 +121,7 @@ class GlowLichen extends Transparent{
 		$changed = false;
 
 		foreach($this->faces as $face){
-			if(!$this->getAdjacentSupportType($face)->equals(SupportType::FULL())){
+			if($this->getAdjacentSupportType($face) !== SupportType::FULL){
 				unset($this->faces[$face]);
 				$changed = true;
 			}
@@ -156,7 +156,7 @@ class GlowLichen extends Transparent{
 		$supportBlock = $world->getBlock($replacePos->getSide($spreadFace));
 		$supportFace = Facing::opposite($spreadFace);
 
-		if(!$supportBlock->getSupportType($supportFace)->equals(SupportType::FULL())){
+		if($supportBlock->getSupportType($supportFace) !== SupportType::FULL){
 			return false;
 		}
 
@@ -268,7 +268,7 @@ class GlowLichen extends Transparent{
 	private function getAvailableFaces() : array{
 		$faces = [];
 		foreach(Facing::ALL as $face){
-			if(!$this->hasFace($face) && $this->getAdjacentSupportType($face)->equals(SupportType::FULL())){
+			if(!$this->hasFace($face) && $this->getAdjacentSupportType($face) === SupportType::FULL){
 				$faces[$face] = $face;
 			}
 		}

src/block/GoldOre.php

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

src/block/Grass.php

@@ -69,7 +69,7 @@ class Grass extends Opaque{
 				$b = $world->getBlockAt($x, $y, $z);
 				if(
 					!($b instanceof Dirt) ||
-					!$b->getDirtType()->equals(DirtType::NORMAL()) ||
+					$b->getDirtType() !== DirtType::NORMAL ||
 					$world->getFullLightAt($x, $y + 1, $z) < 4 ||
 					$world->getBlockAt($x, $y + 1, $z)->getLightFilter() >= 2
 				){

src/block/HangingRoots.php

@@ -23,32 +23,18 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
-use pocketmine\math\Vector3;
-use pocketmine\player\Player;
-use pocketmine\world\BlockTransaction;
 
 final class HangingRoots extends Flowable{
+	use StaticSupportTrait;
 
 	private function canBeSupportedAt(Block $block) : bool{
 		return $block->getAdjacentSupportType(Facing::UP)->hasCenterSupport(); //weird I know, but they can be placed on the bottom of fences
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(!$this->canBeSupportedAt($blockReplace)){
-			return false;
-		}
-		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
-	}
-
 	public function getDropsForIncompatibleTool(Item $item) : array{
 		if($item->hasEnchantment(VanillaEnchantments::SILK_TOUCH())){
 			return $this->getDropsForCompatibleTool($item);

src/block/Hopper.php

@@ -68,9 +68,9 @@ class Hopper extends Transparent{
 
 	public function getSupportType(int $facing) : SupportType{
 		return match($facing){
-			Facing::UP => SupportType::FULL(),
-			Facing::DOWN => $this->facing === Facing::DOWN ? SupportType::CENTER() : SupportType::NONE(),
-			default => SupportType::NONE()
+			Facing::UP => SupportType::FULL,
+			Facing::DOWN => $this->facing === Facing::DOWN ? SupportType::CENTER : SupportType::NONE,
+			default => SupportType::NONE
 		};
 	}
 

src/block/IronOre.php

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

src/block/ItemFrame.php

@@ -164,7 +164,7 @@ class ItemFrame extends Flowable{
 	}
 
 	private function canBeSupportedAt(Block $block, int $face) : bool{
-		return !$block->getAdjacentSupportType($face)->equals(SupportType::NONE());
+		return $block->getAdjacentSupportType($face) !== SupportType::NONE;
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/Jukebox.php

@@ -61,7 +61,7 @@ class Jukebox extends Opaque{
 
 	public function ejectRecord() : void{
 		if($this->record !== null){
-			$this->getPosition()->getWorld()->dropItem($this->getPosition()->add(0.5, 1, 0.5), $this->record);
+			$this->position->getWorld()->dropItem($this->position->add(0.5, 1, 0.5), $this->record);
 			$this->record = null;
 			$this->stopSound();
 		}
@@ -76,12 +76,12 @@ class Jukebox extends Opaque{
 
 	public function startSound() : void{
 		if($this->record !== null){
-			$this->getPosition()->getWorld()->addSound($this->getPosition(), new RecordSound($this->record->getRecordType()));
+			$this->position->getWorld()->addSound($this->position, new RecordSound($this->record->getRecordType()));
 		}
 	}
 
 	public function stopSound() : void{
-		$this->getPosition()->getWorld()->addSound($this->getPosition(), new RecordStopSound());
+		$this->position->getWorld()->addSound($this->position, new RecordStopSound());
 	}
 
 	public function onBreak(Item $item, ?Player $player = null, array &$returnedItems = []) : bool{

src/block/Ladder.php

@@ -66,7 +66,7 @@ class Ladder extends Transparent{
 	}
 
 	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE();
+		return SupportType::NONE;
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
@@ -85,6 +85,6 @@ class Ladder extends Transparent{
 	}
 
 	private function canBeSupportedAt(Block $block, int $face) : bool{
-		return $block->getAdjacentSupportType($face)->equals(SupportType::FULL());
+		return $block->getAdjacentSupportType($face) === SupportType::FULL;
 	}
 }