5.21.2 (#6545)

this doesn't work for PRs from forks, since fork PRs don't have access to repo secrets.

we'll need some more advanced mechanism to avoid redundant reviews, but that's a job for another time.

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @pmmp/server-developers

.github/ISSUE_TEMPLATE/api-change-request.md

@@ -7,13 +7,13 @@ assignees: ''
 
 ---
 
-<!--- tell us what you want -->
-## Description
+<!--- Describe the problem you want to solve -->
+## Problem description
 
 
-<!--- explain why you want this and why it's a good idea -->
-## Justification
+<!--- Describe what changes you want to make to solve this problem -->
+## Proposed solution
 
 
 <!--- (optional) describe alternative methods you've explored to achieve your goal -->
-## Alternative methods
+## Alternative solutions that don't require API changes

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,40 +1,32 @@
-## Introduction
+<!-- Summarize your PR here. Keep it short and simple. -->
 <!-- Explain existing problems or why this pull request is necessary -->
 
-### Relevant issues
-<!-- List relevant issues here -->
+### Related issues & PRs
 <!--
-
 * Fixes #1
-* Fixes #2
-
+* Related to #2
 -->
 
 ## Changes
 ### API changes
 <!-- Any additions to the API that should be documented in release notes? -->
+<!-- If not, you can delete this section -->
 
 ### Behavioural changes
 <!-- Any change in how the server behaves, or its performance? -->
+<!-- If not, you can delete this section -->
 
 ## Backwards compatibility
 <!-- Any possible backwards incompatible changes? How are they solved, or how can they be solved? -->
+<!-- If not, you can delete this section -->
 
 ## Follow-up
 <!-- Suggest any actions to be done before/after merging this pull request -->
-<!--
-
-Requires translations:
-
-| Name | Value in eng.ini |
-| :--: | :---: |
-| `foo.bar` | `Foo bar` |
-
--->
+<!-- For example, future changes that this PR lays the groundwork for -->
 
 ## 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
+If this PR affects gameplay or user experience in some way, it must be manually tested.
+Include any screenshots or videos of manual testing here.
+Any test plugin code should also be pasted here if it can't be adapted to a PHPUnit test.
 -->

.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:
@@ -12,6 +12,22 @@ updates:
       update-types:
         - "version-update:semver-major"
         - "version-update:semver-minor"
+  groups:
+    production-patch-updates:
+      dependency-type: production
+      patterns:
+        - "*"
+      update-types:
+        - "patch"
+    development-patch-updates:
+      dependency-type: development
+      patterns:
+        - "*"
+      update-types:
+        - "patch"
+    phpstan:
+      patterns:
+        - "phpstan/*"
 
 - package-ecosystem: gitsubmodule
   directory: "/"
@@ -21,4 +37,4 @@ updates:
 - package-ecosystem: github-actions
   directory: "/"
   schedule:
-    interval: daily
+    interval: weekly

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

@@ -12,23 +12,23 @@ jobs:
 
     steps:
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Clone pmmp/PocketMine-Docker repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: pmmp/PocketMine-Docker
           fetch-depth: 1
@@ -53,7 +53,7 @@ jobs:
         run: echo NAME=$(echo "${GITHUB_REPOSITORY,,}") >> $GITHUB_OUTPUT
 
       - name: Build image for tag
-        uses: docker/build-push-action@v4.1.1
+        uses: docker/build-push-action@v6.9.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@v4.1.1
+        uses: docker/build-push-action@v6.9.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@v4.1.1
+        uses: docker/build-push-action@v6.9.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@v4.1.1
+        uses: docker/build-push-action@v6.9.0
         with:
           push: true
           context: ./pocketmine-mp

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

@@ -10,15 +10,15 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.25.5
+        uses: shivammathur/setup-php@2.31.1
         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-from-pr.yml

@@ -0,0 +1,65 @@
+name: Draft release from PR
+
+on:
+  #presume that pull_request_target is safe at this point, since the PR was approved and merged
+  #we need write access to prepare the release & create comments
+  pull_request_target:
+    types:
+      - closed
+    branches:
+      - stable
+      - minor-next
+      - major-next
+      - "legacy/*"
+    paths:
+      - "src/VersionInfo.php"
+
+jobs:
+  check:
+    name: Check release
+    uses: ./.github/workflows/draft-release-pr-check.yml
+
+  draft:
+    name: Create GitHub draft release
+    needs: [check]
+    if: needs.check.outputs.valid == 'true'
+
+    uses: ./.github/workflows/draft-release.yml
+
+  post-draft-url-comment:
+    name: Post draft release URL as comment
+    needs: [draft]
+
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Post draft release URL on PR
+        uses: thollander/actions-comment-pull-request@v3
+        with:
+          message: "[Draft release ${{ needs.draft.outputs.version }}](${{ needs.draft.outputs.draft-url }}) has been created for commit ${{ github.sha }}. Please review and publish it."
+
+  trigger-post-release-workflow:
+    name: Trigger post-release RestrictedActions workflow
+    # Not sure if needs is actually needed here
+    needs: [check]
+    if: needs.check.outputs.valid == 'true'
+
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Generate access token
+        id: generate-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ vars.RESTRICTED_ACTIONS_DISPATCH_ID }}
+          private-key: ${{ secrets.RESTRICTED_ACTIONS_DISPATCH_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: RestrictedActions
+
+      - name: Dispatch post-release restricted action
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          repository: ${{ github.repository_owner }}/RestrictedActions
+          event-type: pocketmine_mp_post_release
+          client-payload: '{"branch": "${{ github.ref }}"}'

.github/workflows/draft-release-from-tag.yml

@@ -0,0 +1,13 @@
+#Allows creating a release by pushing a tag
+#This might be useful for retroactive releases
+name: Draft release from git tag
+
+on:
+  push:
+    tags: "*"
+
+jobs:
+  draft:
+    name: Create GitHub draft release
+    if: "startsWith(github.event.head_commit.message, 'Release ')"
+    uses: ./.github/workflows/draft-release.yml

.github/workflows/draft-release-pr-check.yml

@@ -0,0 +1,111 @@
+name: Release PR checks
+
+on:
+  #do checks on every PR update
+  pull_request:
+    branches:
+      - stable
+      - minor-next
+      - major-next
+      - "legacy/*"
+    paths:
+      - "src/VersionInfo.php"
+
+  #allow this workflow to be invoked on PR merge, prior to creating the release
+  workflow_call:
+    outputs:
+      valid:
+        description: Whether this commit is valid for release
+        value: ${{ jobs.check-intent.outputs.valid && jobs.check-validity.result == 'success' }}
+
+permissions:
+  contents: read #for user access check
+
+jobs:
+  check-intent:
+    name: Check release trigger
+    runs-on: ubuntu-20.04
+
+    outputs:
+      valid: ${{ steps.validate.outputs.DEV_BUILD == 'false' }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check IS_DEVELOPMENT_BUILD flag
+        id: validate
+        run: |
+          echo DEV_BUILD=$(sed -n "s/^\s*public const IS_DEVELOPMENT_BUILD = \(true\|false\);$/\1/p" src/VersionInfo.php) >> $GITHUB_OUTPUT
+
+  check-validity:
+    name: Validate release info
+    needs: [check-intent]
+    #don't do these checks if this isn't a release - we don't want to generate unnecessary failed statuses
+    if: needs.check-intent.outputs.valid == 'true'
+
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@2.31.1
+        with:
+          php-version: 8.2
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction --ignore-platform-reqs
+
+      - name: Check author permissions
+        id: check-permission
+        uses: actions-cool/check-user-permission@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          require: write
+          username: ${{ github.event.pull_request.user.login }}
+          #technically this would be fine for dependabot but generally bots don't count as team members
+          check-bot: true
+
+      - name: Abort if user permissions are insufficient
+        #user doesn't have permission or is a bot
+        if: steps.check-permission.outputs.require-result != 'true' || steps.check-permission.outputs.check-result != 'false'
+        run: |
+          echo "::error::This user is not authorized to trigger releases"
+          exit 1
+
+      - name: Check changelog file is present
+        id: file-presence
+        run: |
+          CHANGELOG_FILE="changelogs/$(php build/dump-version-info.php changelog_file_name)"
+          if [ ! -f "${{ github.workspace }}/$CHANGELOG_FILE" ]; then
+            echo "::error::$CHANGELOG_FILE does not exist"
+            exit 1
+          fi
+          echo FILE="$CHANGELOG_FILE" >> $GITHUB_OUTPUT
+
+      - name: Check header is present in changelog file
+        run: |
+          FILE="${{ steps.file-presence.outputs.FILE }}"
+          VERSION="$(php build/dump-version-info.php base_version)"
+          if ! grep -Fqx "# $VERSION" "${{ github.workspace }}/$FILE"; then
+            echo "::error::Header for $VERSION not found in $FILE"
+            exit 1
+          fi
+
+      - name: Check version is valid for the selected channel
+        run: |
+          CHANNEL="$(php build/dump-version-info.php channel)"
+          if [ "$(php build/dump-version-info.php suffix_valid)" != "true" ]; then
+            echo "::error::Version $(php build/dump-version-info.php base_version) is not allowed on the $CHANNEL channel"
+            exit 1
+          fi

.github/workflows/draft-release.yml

@@ -1,31 +1,41 @@
 name: Draft release
 
 on:
-  push:
-    tags: "*"
+  workflow_call:
+    outputs:
+      draft-url:
+        description: 'The URL of the draft release'
+        value: ${{ jobs.draft.outputs.draft-url }}
+      version:
+        description: 'PocketMine-MP version'
+        value: ${{ jobs.draft.outputs.version }}
 
 jobs:
   draft:
     name: Create GitHub draft release
-    if: "startsWith(github.event.head_commit.message, 'Release ')"
+
     runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
-        php-version: [8.1]
+        php-version: [8.2]
+
+    outputs:
+      draft-url: ${{ steps.create-draft.outputs.html_url }}
+      version: ${{ steps.get-pm-version.outputs.PM_VERSION }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.25.5
+        uses: shivammathur/setup-php@2.31.1
         with:
           php-version: ${{ matrix.php-version }}
 
       - name: Restore Composer package cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cache/composer/files
@@ -53,17 +63,17 @@ jobs:
       - name: Get PocketMine-MP release version
         id: get-pm-version
         run: |
-          echo PM_VERSION=$(php -r 'require "vendor/autoload.php"; echo \pocketmine\VersionInfo::BASE_VERSION;') >> $GITHUB_OUTPUT
-          echo MCPE_VERSION=$(php -r 'require "vendor/autoload.php"; echo \pocketmine\network\mcpe\protocol\ProtocolInfo::MINECRAFT_VERSION_NETWORK;') >> $GITHUB_OUTPUT
-          echo PM_VERSION_SHORT=$(php -r 'require "vendor/autoload.php"; $v = explode(".", \pocketmine\VersionInfo::BASE_VERSION); array_pop($v); echo implode(".", $v);') >> $GITHUB_OUTPUT
-          echo PM_VERSION_MD=$(php -r 'require "vendor/autoload.php"; echo str_replace(".", "", \pocketmine\VersionInfo::BASE_VERSION);') >> $GITHUB_OUTPUT
-          echo CHANGELOG_SUFFIX=$(php -r 'require "vendor/autoload.php"; echo \pocketmine\VersionInfo::BUILD_CHANNEL === "stable" ? "" : "-" . \pocketmine\VersionInfo::BUILD_CHANNEL;') >> $GITHUB_OUTPUT
-          echo PRERELEASE=$(php -r 'require "vendor/autoload.php"; echo \pocketmine\VersionInfo::BUILD_CHANNEL === "stable" ? "false" : "true";') >> $GITHUB_OUTPUT
+          echo PM_VERSION=$(php build/dump-version-info.php base_version) >> $GITHUB_OUTPUT
+          echo PM_MAJOR=$(php build/dump-version-info.php major_version) >> $GITHUB_OUTPUT
+          echo MCPE_VERSION=$(php build/dump-version-info.php mcpe_version) >> $GITHUB_OUTPUT
+          echo CHANGELOG_FILE_NAME=$(php build/dump-version-info.php changelog_file_name) >> $GITHUB_OUTPUT
+          echo CHANGELOG_MD_HEADER=$(php build/dump-version-info.php changelog_md_header) >> $GITHUB_OUTPUT
+          echo PRERELEASE=$(php build/dump-version-info.php prerelease) >> $GITHUB_OUTPUT
 
       - name: Generate PHP binary download URL
         id: php-binary-url
         run: |
-          echo PHP_BINARY_URL="${{ github.server_url }}/${{ github.repository_owner }}/PHP-Binaries/releases/tag/php-${{ matrix.php-version }}-latest" >> $GITHUB_OUTPUT
+          echo PHP_BINARY_URL="${{ github.server_url }}/${{ github.repository_owner }}/PHP-Binaries/releases/tag/pm${{ steps.get-pm-version.outputs.PM_MAJOR }}-php-${{ matrix.php-version }}-latest" >> $GITHUB_OUTPUT
 
       - name: Generate build info
         run: |
@@ -76,28 +86,34 @@ jobs:
             ${{ steps.php-binary-url.outputs.PHP_BINARY_URL }} \
             > build_info.json
 
+      - name: Generate core permission doc for doc.pmmp.io
+        run: php tools/generate-permission-doc.php rst
+
       - name: Upload release artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: release_artifacts
           path: |
             ${{ github.workspace }}/PocketMine-MP.phar
             ${{ github.workspace }}/start.*
             ${{ github.workspace }}/build_info.json
+            ${{ github.workspace }}/core-permissions.rst
 
       - name: Create draft release
-        uses: ncipollo/release-action@v1.12.0
+        uses: ncipollo/release-action@v1.14.0
+        id: create-draft
         with:
-          artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json
+          artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json,${{ github.workspace }}/core-permissions.rst
           commit: ${{ github.sha }}
           draft: true
           prerelease: ${{ steps.get-pm-version.outputs.PRERELEASE }}
           name: PocketMine-MP ${{ steps.get-pm-version.outputs.PM_VERSION }}
           tag: ${{ steps.get-pm-version.outputs.PM_VERSION }}
           token: ${{ secrets.GITHUB_TOKEN }}
+          skipIfReleaseExists: true #for release PRs, tags will be created on release publish and trigger the tag release workflow - don't create a second draft
           body: |
             **For Minecraft: Bedrock Edition ${{ steps.get-pm-version.outputs.MCPE_VERSION }}**
 
-            Please see the [changelogs](${{ github.server_url }}/${{ github.repository }}/blob/${{ steps.get-pm-version.outputs.PM_VERSION }}/changelogs/${{ steps.get-pm-version.outputs.PM_VERSION_SHORT }}${{ steps.get-pm-version.outputs.CHANGELOG_SUFFIX }}.md#${{ steps.get-pm-version.outputs.PM_VERSION_MD }}) for details.
+            Please see the [changelogs](${{ github.server_url }}/${{ github.repository }}/blob/${{ steps.get-pm-version.outputs.PM_VERSION }}/changelogs/${{ steps.get-pm-version.outputs.CHANGELOG_FILE_NAME }}#${{ steps.get-pm-version.outputs.CHANGELOG_MD_HEADER }}) for details.
 
             :information_source: Download the recommended PHP binary [here](${{ steps.php-binary-url.outputs.PHP_BINARY_URL }}).

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

@@ -0,0 +1,156 @@
+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.2.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.2.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.2.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.2.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: Update generated code
+        run: composer update-codegen
+
+      - name: Verify code is unchanged
+        run: |
+          git diff
+          git diff --quiet

.github/workflows/main.yml

@@ -6,162 +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@v3
-
-      - 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@v3
-
-      - 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@v3
-        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@v3
-
-      - 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: 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
@@ -170,15 +25,27 @@ jobs:
       fail-fast: false
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.25.5
+        uses: shivammathur/setup-php@2.31.1
         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 }}
 
       - name: Run PHP-CS-Fixer
         run: php-cs-fixer fix --dry-run --diff --ansi
+
+  shellcheck:
+    name: ShellCheck
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run ShellCheck
+        uses: ludeeus/action-shellcheck@2.0.0

.github/workflows/pr-remove-waiting-label.yml

@@ -0,0 +1,33 @@
+name: Remove waiting label from PRs
+
+on:
+  pull_request_target:
+    types: synchronize
+
+jobs:
+  delabel:
+    name: Remove label
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Remove label
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ github.token }}
+          script: |
+            const [owner, repo] = context.payload.repository.full_name.split('/');
+            try {
+              await github.rest.issues.removeLabel({
+                owner: owner,
+                repo: repo,
+                issue_number: context.payload.number,
+                name: "Status: Waiting on Author",
+              });
+            } catch (error) {
+              if (error.status === 404) {
+                //probably label wasn't set on the issue
+                console.log('Failed to remove label (probably label isn\'t on the PR): ' + error.message);
+              } else {
+                throw error;
+              }
+            }

.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"

.github/workflows/team-pr-auto-approve.yml

@@ -0,0 +1,38 @@
+#Due to GitHub awkwardness, it's not easy to reduce the review requirement for collaborators.
+#Our policy is that 2 collaborators should be aware of every change.
+#For outside PRs, this means 2 collaborator reviews.
+#For PRs made by collaborators, this means 1 reviewer + the author.
+#We trust that collaborators don't need as much oversight.
+name: Auto approve collaborator PRs
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+      - ready_for_review
+      - synchronize
+
+jobs:
+  dispatch:
+    name: Request approval
+    runs-on: ubuntu-latest
+    if: '! github.event.pull_request.draft'
+
+    steps:
+      - name: Generate access token
+        id: generate-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ vars.RESTRICTED_ACTIONS_DISPATCH_ID }}
+          private-key: ${{ secrets.RESTRICTED_ACTIONS_DISPATCH_KEY }}
+          owner: ${{ github.repository_owner }}
+          repositories: RestrictedActions
+
+      - name: Dispatch restricted action
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          repository: ${{ github.repository_owner }}/RestrictedActions
+          event-type: auto_approve_collaborator_pr
+          client-payload: '{"repo": "${{ github.repository }}", "pull_request_id": "${{ github.event.pull_request.number }}", "reviewer_id": "0" }'

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

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

.gitignore

@@ -53,3 +53,6 @@ Documentation/*
 # php-cs-fixer
 /.php_cs.cache
 /.php-cs-fixer.cache
+
+# install-local-protocol.sh
+/composer-local-protocol.*

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

CONTRIBUTING.md

@@ -88,45 +88,58 @@ Depending on the changes, maintainers might ask you to make changes to the PR to
 ### Requirements
 The following are required as a minimum for pull requests. PRs that don't meet these requirements will be declined unless updated to meet them.
 
-#### Licensing
-PocketMine-MP is licensed under [LGPLv3 license](LICENSE).
-By proposing a pull request, you agree to your code being distributed within PocketMine-MP under the same license.
-If you take code from other projects, that code MUST be licensed under an LGPL-compatible license.
-
-#### PRs should be about exactly ONE thing
-If you want to make multiple changes, those changes should each be contributed as separate pull requests. **DO NOT** mix unrelated changes.
-
-#### PRs must not include unnecessary/unrelated changes
-Do not include changes which aren't strictly necessary. This makes it harder to review a PR, because the code diff becomes larger and harder to review.
-This means:
-- don't reformat or rearrange existing code
-- don't change things that aren't related to the PR's objective
-- don't rewrite existing code just to make it "look nicer"
-- don't change PhpDocs to native types in code you didn't write
-
-#### Tests must be provided
-Where possible, PHPUnit tests should be written for new or changed code.
-If that's not possible (e.g. for in-game functionality), the code must be tested manually and details of the tests done must be provided.
-**Simply saying "Tested" is not acceptable** and will lead to your PR being declined.
-
-#### Comments and documentation must be written in American English
-English is the shared languages of all current maintainers.
-
-#### Code must be in the PocketMine-MP style
-It's your responsibility to ensure your code matches the formatting and styling of the rest of the code.
-If you use PhpStorm, a `Project` code style is provided, which you can use to automatically format new code.
-You can also use [`php-cs-fixer`](https://github.com/FriendsOfPHP/PHP-CS-Fixer) to format your code.
+- **All code must be licensed under the [LGPLv3 license](LICENSE)** as per PocketMine-MP's own license, or a compatible license.
+  - By proposing a pull request, you agree to your code being distributed within PocketMine-MP under the same license.
+  - If you take code from other projects, that code MUST be licensed under an LGPL-compatible license.
+- **PRs should be about ONE thing**
+  - If you want to make multiple changes, those changes should each be contributed as separate pull requests. **DO NOT** mix unrelated changes.
+  - **Do not include unnecessary changes.** This makes the code diff larger and more noisy, making it harder to review.
+    - Don't change things that aren't related to the PR's objective
+    - Don't reformat or rearrange existing code without a good reason related to the PR's objective
+    - Don't rewrite existing code just to make it "look nicer"
+    - Don't change PhpDocs to native types in code you didn't write, unless that's the objective of the PR
+- **Test code changes, and tell us what tests have been done.**
+  - Where possible, PHPUnit tests should be written for new or changed code. If that's not possible (e.g. for in-game functionality), the code must be tested manually and details of the tests done must be provided.
+  - **Simply saying "Tested" is not acceptable** and could lead to your PR being declined.
+- **Code, comments and documentation must be written in American English.** English is the shared languages of all current maintainers.
+- **Code must be in the PocketMine-MP style.**
+  - It's your responsibility to ensure your code matches the formatting and styling of the rest of the code.
+  - If you use PhpStorm, a `Project` code style is provided, which you can use to automatically format new code.
+  - You can also use [`php-cs-fixer`](https://github.com/FriendsOfPHP/PHP-CS-Fixer) to format your code.
+- **Use `final` and `private` wherever possible**.
+  - Changing from `private` to `protected` or `final` to non-`final` doesn't break backwards compatibility, but the opposite does.
+  - `private` and `final` also enable certain performance optimizations which are otherwise not possible.
+  - `private` members can be freely changed, added and removed in the future, so it's ideal for internal functions. Abusing `protected` makes internal improvements inconvenient.
+  - "Let's leave it protected/public in case someone needs it for ... idk what" is **not a valid reason to expose things**. If there isn't a clear reason for something to be accessible from the outside, don't expose it.
+  - **This is a lesson learned through years of experience.** You may not like it, but it's for the best.
+- **Immutable things are almost always preferred.**
+  - Do not add unnecessary setters or public writable properties to classes. As above, "Let's leave it in case someone needs it" is **not a valid reason to expose things**.
+  - Mutable classes and properties are unpredictable, since code has no way to know if the object it's working with might be randomly modified by another part of the code. This makes it harder to maintain code and debug issues.
+  - Most classes exist only to hold some data. These are called "data transfer objects" (DTOs). These types of classes should pretty much always be immutable.
+  - Make use of `final`, `private` and `readonly` modifiers.
 
 ### Recommendations
-
+- **Be patient.** Reviewing pull requests takes a lot of time and energy, and maintainers are often unavailable or busy. Your PR might not receive attention for a while.
+  - Remember, PRs with small diffs are much easier to review. Small PRs are generally reviewed and merged much faster than large ones.
+- **Start small.** Try fixing minor bugs or doing something isolated (e.g. adding a new block or item) before attempting larger changes.
+  - This helps you get familiar with the codebase, the contribution process, and the expectations of maintainers.
+  - Check out the [issues page]() for something that you could tackle without too much effort.
+- **Do not copy-paste other people's code**. Many PRs involve discussion about the changes, and changes are often requested by reviewers. If you don't understand the code you're copy-pasting, your PR is likely to fail.
 - **Do not edit code directly on github.com.** We recommend learning how to use [`git`](https://git-scm.com). `git` allows you to "clone" a repository onto your computer, so that you can make changes using an IDE.
 - **Use an IDE, not a text editor.** We recommend PhpStorm or VSCode.
+- **Do not make large pull requests without an RFC.**
+  - Large changes should be discussed beforehand using the [RFC / Change Proposal](#rfcs--change-proposals) process.
+  - Large changes are much harder to review, and are more likely to be declined if maintainers don't have a good idea what you're trying to do in advance.
 - **Create a new branch on your fork for each pull request.** This allows you to use the same fork to make multiple pull requests at the same time.
+- **Make your PR diff as small as possible.** Smaller PRs are **much more likely** to be accepted, as they are easier to review.
+  - Avoid moving code around in files if possible.
+  - Don't make random CS changes. This makes the diff noisier and harder to review.
 - **Use descriptive commit titles.** You can see an example [here](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
-- **Do not include multiple unrelated changes in one commit.** An atomic style for commits is preferred - this means that changes included in a commit should be part of a single distinct change set. See [this link](https://www.freshconsulting.com/atomic-commits/) for more information on atomic commits. See the [documentation on `git add`](https://git-scm.com/docs/git-add) for information on how to isolate local changes for committing.
-- **Your pull request will be checked and discussed in due time.** Since the team is scattered all around the world, your PR may not receive any attention for some time.
-- **Do not make large pull requests without an RFC.** Large changes should be discussed beforehand using the [RFC / Change Proposal](#rfcs--change-proposals) process. Large changes are much harder to review and are more likely to be declined if maintainers don't have a good idea what you're trying to do in advance.
-- **Do not copy-paste code**. There are potential license issues implicit with copy-pasting, and copy-paste usually indicates a lack of understanding of the actual code. Copy-pasted code is obvious a mile off and **any PR like this is likely to be closed**. If you want to use somebody else's code from a Git repository, **use [GIT's cherry-pick feature](https://git-scm.com/docs/git-cherry-pick)** to cherry-pick the commit.
+- **Split unrelated changes into multiple commits.**
+  - An atomic style for commits is preferred - this means that changes included in a commit should be part of a single distinct change set.
+  - If you need to use "and" or "multiple changes" in your commit message, the commit probably needs to be split up. There are exceptions, but this is a good rule of thumb.
+  - See [this link](https://www.freshconsulting.com/atomic-commits/) for more information on atomic commits.
+  - See the [documentation on `git add -i` or `git add -p`](https://git-scm.com/docs/git-add) for information on how to split up local changes for committing.
 
 
 **Thanks for contributing to PocketMine-MP!**

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/dump-version-info.php

@@ -0,0 +1,87 @@
+<?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);
+
+use pocketmine\network\mcpe\protocol\ProtocolInfo;
+use pocketmine\VersionInfo;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+/*
+ * Dumps version info in a machine-readable format for use in GitHub Actions workflows
+ */
+
+/**
+ * @var string[]|\Closure[] $options
+ * @phpstan-var array<string, string|\Closure() : string> $options
+ */
+$options = [
+	"base_version" => VersionInfo::BASE_VERSION,
+	"major_version" => fn() => explode(".", VersionInfo::BASE_VERSION)[0],
+	"mcpe_version" => ProtocolInfo::MINECRAFT_VERSION_NETWORK,
+	"is_dev" => VersionInfo::IS_DEVELOPMENT_BUILD,
+	"changelog_file_name" => function() : string{
+		$version = VersionInfo::VERSION();
+		$result = $version->getMajor() . "." . $version->getMinor();
+		$suffix = $version->getSuffix();
+		if($suffix !== ""){
+			if(preg_match('/^([A-Za-z]+)(\d+)$/', $suffix, $matches) !== 1){
+				fwrite(STDERR, "error: invalid current version suffix \"$suffix\"; aborting" . PHP_EOL);
+				exit(1);
+			}
+			$baseSuffix = $matches[1];
+			$result .= "-" . strtolower($baseSuffix);
+		}
+		return $result . ".md";
+	},
+	"changelog_md_header" => fn() : string => str_replace(".", "", VersionInfo::BASE_VERSION),
+	"prerelease" => fn() : bool => VersionInfo::VERSION()->getSuffix() !== "",
+	"channel" => VersionInfo::BUILD_CHANNEL,
+	"suffix_valid" => function() : bool{
+		//TODO: maybe this should be put into its own script?
+		$suffix = VersionInfo::VERSION()->getSuffix();
+		if(VersionInfo::BUILD_CHANNEL === "stable"){
+			//stable builds may not have suffixes
+			return $suffix === "";
+		}
+		if(VersionInfo::BUILD_CHANNEL === "alpha" || VersionInfo::BUILD_CHANNEL === "beta"){
+			$upperChannel = strtoupper(VersionInfo::BUILD_CHANNEL);
+			$upperSuffix = strtoupper($suffix);
+			return str_starts_with($upperSuffix, $upperChannel) && is_numeric(substr($upperSuffix, strlen($upperChannel)));
+		}
+		return true;
+	}
+];
+if(count($argv) !== 2 || !isset($options[$argv[1]])){
+	fwrite(STDERR, "Please provide an option (one of: " . implode(", ", array_keys($options)) . PHP_EOL);
+	exit(1);
+}
+
+$result = $options[$argv[1]];
+if($result instanceof Closure){
+	$result = $result();
+}
+if(is_bool($result)){
+	echo $result ? "true" : "false";
+}else{
+	echo $result;
+}

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(Utils::promoteKeys($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-block-serializer-consts.php

@@ -102,6 +102,25 @@ function generateClassHeader(string $className) : string{
 	return <<<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 $namespace;

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-item-type-names.php

@@ -61,6 +61,25 @@ function generateItemIds(ItemTypeDictionary $dictionary, BlockItemIdMap $blockIt
 	fwrite($file, <<<'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\bedrock\item;

build/generate-pocketmine-yml-property-consts.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);
+
+use pocketmine\utils\Filesystem;
+use pocketmine\utils\Utils;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+$defaultConfig = yaml_parse(Filesystem::fileGetContents(dirname(__DIR__) . '/resources/pocketmine.yml'));
+
+if(!is_array($defaultConfig)){
+	fwrite(STDERR, "Invalid default pocketmine.yml\n");
+	exit(1);
+}
+
+$constants = [];
+
+/**
+ * @param mixed[]  $properties
+ * @param string[] $constants
+ * @phpstan-param array<string, string> $constants
+ * @phpstan-param-out array<string, string> $constants
+ */
+function collectProperties(string $prefix, array $properties, array &$constants) : void{
+	foreach(Utils::promoteKeys($properties) as $propertyName => $property){
+		$fullPropertyName = ($prefix !== "" ? $prefix . "." : "") . $propertyName;
+
+		$constName = str_replace([".", "-"], "_", strtoupper($fullPropertyName));
+		$constants[$constName] = $fullPropertyName;
+
+		if(is_array($property)){
+			collectProperties($fullPropertyName, $property, $constants);
+		}
+	}
+}
+
+collectProperties("", $defaultConfig, $constants);
+ksort($constants, SORT_STRING);
+
+$file = fopen(dirname(__DIR__) . '/src/YmlServerProperties.php', 'wb');
+if($file === false){
+	fwrite(STDERR, "Failed to open output file\n");
+	exit(1);
+}
+fwrite($file, "<?php\n");
+fwrite($file, <<<'HEADER'
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * 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/
+ *
+ *
+ */
+
+
+HEADER
+);
+fwrite($file, "declare(strict_types=1);\n\n");
+fwrite($file, "namespace pocketmine;\n\n");
+
+fwrite($file, <<<'DOC'
+/**
+ * @internal
+ * Constants for all properties available in pocketmine.yml.
+ * This is generated by build/generate-pocketmine-yml-property-consts.php.
+ * Do not edit this file manually.
+ */
+
+DOC
+);
+fwrite($file, "final class YmlServerProperties{\n");
+fwrite($file, <<<'CONSTRUCTOR'
+
+	private function __construct(){
+		//NOOP
+	}
+
+
+CONSTRUCTOR
+);
+foreach(Utils::stringifyKeys($constants) as $constName => $propertyName){
+	fwrite($file, "\tpublic const $constName = '$propertyName';\n");
+}
+fwrite($file, "}\n");
+
+fclose($file);
+
+echo "Done. Don't forget to run CS fixup after generating code.\n";

build/generate-registry-annotations.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\build\update_registry_annotations;
 
+use pocketmine\utils\Utils;
 use function basename;
 use function class_exists;
 use function count;
@@ -48,6 +49,7 @@ if(count($argv) !== 2){
 
 /**
  * @param object[] $members
+ * @phpstan-param array<string, object> $members
  */
 function generateMethodAnnotations(string $namespaceName, array $members) : string{
 	$selfName = basename(__FILE__);
@@ -60,7 +62,7 @@ function generateMethodAnnotations(string $namespaceName, array $members) : stri
 
 	static $lineTmpl = " * @method static %2\$s %s()";
 	$memberLines = [];
-	foreach($members as $name => $member){
+	foreach(Utils::stringifyKeys($members) as $name => $member){
 		$reflect = new \ReflectionClass($member);
 		while($reflect !== false && $reflect->isAnonymous()){
 			$reflect = $reflect->getParentClass();

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/make-release.php

@@ -86,7 +86,8 @@ function systemWrapper(string $command, string $errorMessage) : void{
 
 function main() : void{
 	$filteredOpts = [];
-	foreach(Utils::stringifyKeys(getopt("", ["current:", "next:", "channel:", "help"])) as $optName => $optValue){
+	$postCommitOnly = false;
+	foreach(Utils::stringifyKeys(getopt("", ["current:", "next:", "channel:", "help", "post"])) as $optName => $optValue){
 		if($optName === "help"){
 			fwrite(STDOUT, "Options:\n");
 
@@ -96,6 +97,10 @@ function main() : void{
 			}
 			exit(0);
 		}
+		if($optName === "post"){
+			$postCommitOnly = true;
+			continue;
+		}
 		if(!is_string($optValue)){
 			fwrite(STDERR, "--$optName expects exactly 1 value\n");
 			exit(1);
@@ -141,20 +146,25 @@ function main() : void{
 		$channel ??= "stable";
 	}
 
-	echo "About to tag version $currentVer. Next version will be $nextVer.\n";
-	echo "$currentVer will be published on release channel \"$channel\".\n";
-	echo "please add appropriate notes to the changelog and press enter...";
-	fgets(STDIN);
-	systemWrapper('git add "' . dirname(__DIR__) . '/changelogs"', "failed to stage changelog changes");
-	system('git diff --cached --quiet "' . dirname(__DIR__) . '/changelogs"', $result);
-	if($result === 0){
-		echo "error: no changelog changes detected; aborting\n";
-		exit(1);
-	}
 	$versionInfoPath = dirname(__DIR__) . '/src/VersionInfo.php';
-	replaceVersion($versionInfoPath, $currentVer->getBaseVersion(), false, $channel);
-	systemWrapper('git commit -m "Release ' . $currentVer->getBaseVersion() . '" --include "' . $versionInfoPath . '"', "failed to create release commit");
-	systemWrapper('git tag ' . $currentVer->getBaseVersion(), "failed to create release tag");
+
+	if($postCommitOnly){
+		echo "Skipping release commit & tag. Bumping to next version $nextVer directly.\n";
+	}else{
+		echo "About to tag version $currentVer. Next version will be $nextVer.\n";
+		echo "$currentVer will be published on release channel \"$channel\".\n";
+		echo "please add appropriate notes to the changelog and press enter...";
+		fgets(STDIN);
+		systemWrapper('git add "' . dirname(__DIR__) . '/changelogs"', "failed to stage changelog changes");
+		system('git diff --cached --quiet "' . dirname(__DIR__) . '/changelogs"', $result);
+		if($result === 0){
+			echo "error: no changelog changes detected; aborting\n";
+			exit(1);
+		}
+		replaceVersion($versionInfoPath, $currentVer->getBaseVersion(), false, $channel);
+		systemWrapper('git commit -m "Release ' . $currentVer->getBaseVersion() . '" --include "' . $versionInfoPath . '"', "failed to create release commit");
+		systemWrapper('git tag ' . $currentVer->getBaseVersion(), "failed to create release tag");
+	}
 
 	replaceVersion($versionInfoPath, $nextVer->getBaseVersion(), true, $channel);
 	systemWrapper('git add "' . $versionInfoPath . '"', "failed to stage changes for post-release commit");

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.23.md

@@ -60,3 +60,9 @@ Released 9th August 2023.
 - Fixed `PluginBase->saveResource()` leaking file resources when the data file already exists in the plugin's data folder. This bug existed since 2014 and was only discovered recently.
 - Fixed coral blocks becoming dead after calling `getDropsForCompatibleTool()` on them.
 - Fixed `BlockDeathEvent->getOldState()` returning a block which is already dead.
+
+# 4.23.6
+Released 21st August 2023.
+
+## Fixes
+- Added a workaround for armor and other inventories not working correctly after inventory sync. This is caused by a client bug.

changelogs/4.24.md

@@ -0,0 +1,17 @@
+# 4.24.0
+Released 20th September 2023.
+
+**For Minecraft: Bedrock Edition 1.20.30**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.30.
+
+**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.30.
+- Removed support for older versions.
+- Updated 4.x obsoletion message.

changelogs/4.25.md

@@ -0,0 +1,16 @@
+# 4.25.0
+Released 26th October 2023.
+
+**For Minecraft: Bedrock Edition 1.20.40**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.40.
+
+**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.40.
+- Removed support for older versions.

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.15.md

@@ -0,0 +1,16 @@
+# 5.15.0
+Released 25th April 2024.
+
+**For Minecraft: Bedrock Edition 1.20.80**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.80.
+
+**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.80.
+- Removed support for earlier versions.

changelogs/5.16.md

@@ -0,0 +1,26 @@
+# 5.16.0
+Released 13th June 2024.
+
+**For Minecraft: Bedrock Edition 1.21.0**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.0.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.21.0.
+- Removed support for earlier versions.
+- Generated permission docs are now included with every release.
+- Crash throttle message (which appears when the server crashed after being up for less than 120 seconds) now shows the server uptime as well as the wait time. This should make it clearer how the wait time is decided.
+
+## Tools
+- Added `install-local-protocol.sh` script. This allows installing local copies of protocol dependencies without needing to create releases. Useful for integration testing when doing protocol updates.
+
+## Fixes
+- Attacking an entity with a higher damage weapon while it's on attack cooldown from a lower damage weapon (switching) no longer causes additional knockback to the victim.
+- Wooden stairs can now be used as fuel in furnaces.
+- Fixed incorrect description of the permission `pocketmine.command.save.perform`.

changelogs/5.17.md

@@ -0,0 +1,38 @@
+# 5.17.0
+Released 10th July 2024.
+
+**For Minecraft: Bedrock Edition 1.21.2**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.2.
+
+**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.21.2.
+- Removed support for earlier versions.
+
+## API
+### `pocketmine\player`
+- The following methods have been added:
+  - `public function closeAllForms() : void` - closes the current viewing form and forms in queue.
+
+## Fixes
+- Bowl can now be used as fuel.
+- Bells always drops themselves even when using an incompatible tool.
+
+# 5.17.1
+Released 13th August 2024.
+
+## Documentation
+- Added a note about `BlockStateData::CURRENT_VERSION`.
+
+## Fixes
+- Fixed anvil placement rotation to match vanilla.
+- Fixed outdated `BedrockWorldData` version, this was preventing use newer worlds.
+
+## Internals
+- Dependabot: PHPStan and patch updates are now grouped into a single PR.

changelogs/5.18.md

@@ -0,0 +1,30 @@
+# 5.18.0
+Released 16th August 2024.
+
+**For Minecraft: Bedrock Edition 1.21.20**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.20.
+
+**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.21.20.
+- Removed support for earlier versions.
+
+## Fixes
+- Use `VISIBLE_MOB_EFFECTS` actor metadata property to send effect bubbles, this fixes effect bubbles not showing
+
+# 5.18.1
+Released 3rd September 2024.
+
+## Fixes
+- Fixed shift-crafting.
+- Blue Ice block no longer emits light & it's now dropped when mined with a tool with silk touch enchantment.
+
+## Internals
+- Pull Requests from team members now get an approval automatically. This means that if a team member makes a PR, only one other approval should be needed.
+- Added [ShellCheck](https://github.com/koalaman/shellcheck) to the CI tests.

changelogs/5.19.md

@@ -0,0 +1,16 @@
+# 5.19.0
+Released 21st September 2024.
+
+**For Minecraft: Bedrock Edition 1.21.30**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.30.
+
+**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.21.30.
+- Removed support for earlier versions.

changelogs/5.20.md

@@ -0,0 +1,25 @@
+# 5.20.0
+Released 26th October 2024.
+
+**For Minecraft: Bedrock Edition 1.21.40**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.40.
+
+**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.21.40.
+- Removed support for earlier versions.
+
+## Fixes
+- Fixed a bug in `tools/generate-blockstate-upgrade-schema.php` that caused it to fail on 1.21.40 with the new mushroom block changes.
+
+# 5.20.1
+Released 31st October 2024.
+
+## Fixes
+- Workaround old mob heads in world saves not being upgraded correctly and causing crashes.

changelogs/5.21.md

@@ -0,0 +1,128 @@
+# 5.21.0
+Released 3rd November 2024.
+
+This is a minor feature release, including gameplay features and minor internals 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.
+
+## Gameplay
+- Added the following new blocks:
+  - Campfire
+  - Chiseled Copper
+  - Chiseled Tuff
+  - Chiseled Tuff Bricks
+  - Copper Bulb
+  - Copper Door
+  - Copper Grate
+  - Copper Trapdoor
+  - Polished Tuff, Slabs, Stairs and Walls
+  - Soul Campfire
+  - Tuff Bricks, Slabs, Stairs and Walls
+  - Tuff Slab, Stairs and Walls
+- Added the following new types of painting:
+  - backyard
+  - baroque
+  - bouquet
+  - cavebird
+  - changing
+  - cotan
+  - endboss
+  - fern
+  - finding
+  - humble
+  - lowmist
+  - meditative
+  - orb
+  - owlemons
+  - passage
+  - pond
+  - prairie_ride
+  - sunflowers
+  - tides
+  - unpacked
+- Armor slots are now properly restricted (on the server side) to only contain the appropriate type of armor or headwear.
+- Implemented Aqua Affinity enchantment. Since the server doesn't currently enforce any movement restrictions in water, this enchantment works based on client-side behaviour only.
+
+## API
+### `pocketmine\block`
+- The following new API methods have been added:
+  - `public ChiseledBookshelf->getLastInteractedSlot() : ?ChiseledBookshelfSlot`
+  - `public ChiseledBookshelf->setLastInteractedSlot(?ChiseledBookshelfSlot $lastInteractedSlot) : $this`
+- The following new classes have been added: 
+  - `utils\CopperMaterial` - interface implemented by all copper-like blocks with oxidation and waxed properties
+  - `CopperBulb`
+  - `CopperDoor`
+  - `CopperGrate`
+  - `CopperTrapdoor`
+  - `SoulCampfire`
+  - `Campfire`
+- The following enums have new cases:
+  - `utils\BannerPatternType` has new cases `FLOW` and `GUSTER`
+
+### `pocketmine\crafting`
+- The following enums have new cases:
+  - `FurnaceType` has new cases `CAMPFIRE` and `SOUL_CAMPFIRE`
+
+### `pocketmine\event`
+- The following new classes have been added:
+  - `block\CampfireCookEvent` - called when a campfire finishes cooking an item
+
+### `pocketmine\inventory`
+- Added support for slot validators, which permit restricting the types of items a player can put into an inventory slot.
+  - The following new classes have been added:
+    - `transaction\action\SlotValidator` - interface
+    - `transaction\action\CallbackSlotValidator` - class allowing a closure to be used for slot content validation
+    - `SlotValidatedInventory` - implemented by inventories which support the use of slot validators
+
+### `pocketmine\item`
+- The following new API methods have been added:
+  - `public Item->getCooldownTag() : ?string` - returns the cooldown group this item belongs to, used for ensuring that, for example, different types of goat horns all respect a general horn cooldown
+- The following new classes have been added:
+  - `ItemCooldownTags` - list of cooldown group tags used by PocketMine-MP
+
+### `pocketmine\world\sound`
+- The following new classes have been added
+  - `CampfireSound` - sound made by campfires while lit
+
+## Tools
+- `tools/blockstate-upgrade-schema-utils.php` (formerly `generate-blockstate-upgrade-schema.php`) has several improvements:
+  - Support for generating `flattenedProperties` rules as per [BedrockBlockUpgradeSchema 5.0.0](https://github.com/pmmp/BedrockBlockUpgradeSchema/releases/tag/5.0.0)
+  - Improved criteria for flattened property selection to minimize the amount of rules required
+  - Several subcommands are now available:
+    - `generate` - generates a schema from provided data
+    - `update` - regenerates an existing schema in a newer format
+    - `update-all` - regenerates a folder of existing schemas in a newer format (useful for updating `BedrockBlockUpgradeSchema` en masse)
+    - `test` - verifies that a schema produces the results expected by provided data
+
+## Internals
+- Fixed incorrect visibility of `createEntity` in spawn eggs.
+- Added support for newer `BedrockBlockUpgradeSchema` in `BlockStateUpgrader`.
+
+# 5.21.1
+Released 12th November 2024.
+
+## Fixes
+- Fixed server crash when applying a cooldown to an item with 1 count.
+- Fixed garbage collector cycle count increase on player disconnect.
+- Fixed weakness effect being applied to all attack types, causing damage splash potions to become weaker.
+- Fixed Enchanted Golden Apple regeneration effect amplifier to match vanilla.
+
+# 5.21.2
+Released 29th November 2024.
+
+## Fixes
+- Fixed blocks destroyable by water being able to be placed inside water.
+- Fixed deprecation warnings about nullable typehints on PHP 8.4.
+- Fixed `Utils::getNiceClosureName()` not working correctly on PHP 8.4.
+- Fixed incorrect break animations when breaking the block behind an instantly-breakable block like a torch.
+- Fixed candle extinguish logic.
+- Fixed various documentation issues around array key types.
+- Introduced a new PHPStan rule along with `Utils::promoteKeys()` to improve PHPStan error reporting around unspecified array key types. Previously, some errors were missed due to PHPStan's BenevolentUnionType.
+
+## DevOps
+- `pmmp/server-developers` team is now automatically requested for review on any new PR.
+- `Status: Waiting on Author` label is now automatically removed from PRs when they are updated.

changelogs/5.4.md

@@ -107,3 +107,27 @@ Released 9th August 2023.
 ## Fixes
 - Fixed cake accepting candle placement when slices have already been eaten.
 - Fixed fire charges not lighting candles.
+
+# 5.4.3
+Released 21st August 2023.
+
+## Included releases
+- [4.23.6](https://github.com/pmmp/PocketMine-MP/blob/4.23.6/changelogs/4.23.md#4236) - Armor inventory client bug workaround
+
+## Fixes
+- Fixed crashdumps not generating correctly on fatal errors.
+- Fixed `PotionCauldron::setPotionItem()` not validating the item type.
+- Fixed chorus fruit not considering teleport destinations below y=0.
+- Fixed cake dropping itself when mined.
+
+# 5.4.4
+Released 6th September 2023.
+
+## General
+- Crashdumps caused by non-phar plugins are now submitted to the Crash Archive, the same as other plugins. Previously, non-phar plugin crashes would not be submitted, causing maintainers to potentially miss important issues.
+
+## Fixes
+- Fixed player Y coordinates sometimes being slightly below the top of the block they were standing on (floating point error due to subtracting eye height).
+- Fixed template slot of smithing tables not accepting any items.
+- `tools/generate-bedrock-data-from-packets.php` is now significantly less spammy when warning about duplicated recipes.
+- Fixed empty stack traces in `lastError` data of crashdumps.

changelogs/5.5-beta.md

@@ -1,7 +1,7 @@
 # 5.5.0-BETA1
 Released 23rd August 2023.
 
-**For Minecraft: Bedrock Edition 1.20.0**
+**For Minecraft: Bedrock Edition 1.20.10**
 
 This is a minor feature release, including performance improvements, new API methods, and new gameplay features.
 

changelogs/5.5.md

@@ -0,0 +1,162 @@
+# 5.5.0
+Released 6th September 2023.
+
+**For Minecraft: Bedrock Edition 1.20.10**
+
+This is a minor feature release, including performance improvements, new API methods, and new gameplay features.
+
+**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.
+
+## Dependencies
+- Updated `pocketmine/math` dependency to [`1.0.0`](https://github.com/pmmp/Math/releases/tag/1.0.0).
+- Updated `pocketmine/nbt` dependency to [`1.0.0`](https://github.com/pmmp/NBT/releases/tag/1.0.0).
+
+## Performance
+- Some events are now no longer fired if no handlers are registered.
+  - This improves performance by avoiding unnecessary object allocations and function calls.
+  - Events such as `DataPacketReceiveEvent`, `DataPacketSendEvent` and `PlayerMoveEvent` are optimized away almost completely by this change, offering some much-needed performance gains.
+- Significantly improved performance of small moving entities, such as dropped items.
+  - This was achieved by a combination of changes, which together improved observed performance with 2000 item entities moving in water by 30-40%.
+  - The benefit of this will be most noticeable in SkyBlock servers, where large cactus farms can generate thousands of dropped items.
+- `World->getCollisionBoxes()` now uses an improved search method, which reduces the work done by the function by almost 90% for small entities.
+  - This improves performance of collision detection for small entities, such as dropped items.
+
+## Gameplay
+### General
+- Implemented enchanting using an enchanting table (yes, finally!)
+  - Thanks to [@S3v3Nice](https://github.com/S3v3Nice) for investing lots of time and effort into developing this.
+  - Since this feature is quite complex, it's possible there may be bugs. Please be vigilant and report any issues you find.
+
+### Blocks
+- The following new blocks have been implemented:
+  - Pink Petals
+- Pressure plates are now functional, in the sense that they react when entities stand on them and perform the correct logic.
+  - Note that since redstone is not yet implemented, pressure plates do not activate any redstone devices, similar to buttons and levers.
+- Signs can now be edited by right-clicking them.
+- Signs can now be waxed using a honeycomb, which prevents them from being edited.
+
+### Items
+- The following new items have been implemented:
+  - Enchanted Book
+
+## API
+### `pocketmine\block`
+- The following new API methods have been added:
+  - `public Block->getEnchantmentTags() : list<string>` returns a list of strings indicating which types of enchantment can be applied to the block when in item form
+  - `public BlockTypeInfo->getEnchantmentTags() : list<string>`
+  - `protected PressurePlate->getActivationBox() : AxisAlignedBB` - returns the AABB entities must intersect with in order to activate the pressure plate (not the same as the visual shape)
+  - `protected PressurePlate->hasOutputSignal() : bool` - returns whether the pressure plate has an output signal - this should be implemented by subclasses
+  - `protected PressurePlate->calculatePlateState() : array{Block, ?bool}` - returns the state the pressure plate will change to if the given list of entities are standing on it, and a bool indicating whether the plate activated or deactivated this tick
+  - `protected PressurePlate->filterIrrelevantEntities(list<Entity> $entities) : list<Entity>` - returns the given list filtered of entities that don't affect the plate's state (e.g. dropped items don't affect stone pressure plates)
+  - `public BaseSign->isWaxed() : bool`
+  - `public BaseSign->setWaxed(bool $waxed) : $this`
+  - `public inventory\EnchantInventory->getInput() : Item`
+  - `public inventory\EnchantInventory->getLapis() : Item`
+  - `public inventory\EnchantInventory->getOutput(int $optionId) : ?Item` - returns the item that would be produced if the input item was enchanted with the selected option, or `null` if the option is invalid
+  - `public inventory\EnchantInventory->getOption(int $optionId) : EnchantOption` - returns the enchanting option at the given index
+- The following API methods have signature changes:
+  - `BlockTypeInfo->__construct()` now accepts an optional `list<string> $enchantmentTags` parameter
+  - `PressurePlate->__construct()` now accepts an optional `int $deactivationDelayTicks` parameter
+  - `WeightedPressurePlate->__construct()` now accepts optional `int $deactivationDelayTicks` and `float $signalStrengthFactor` parameters
+  - `SimplePressurePlate->__construct()` now accepts an optional `int $deactivationDelayTicks` parameter
+- The following new classes have been added:
+  - `PinkPetals`
+  - `utils\BlockEventHelper` - provides helper methods for calling block-related events
+- The following classes have been deprecated:
+  - `WeightedPressurePlateLight`
+  - `WeightedPressurePlateHeavy`
+
+### `pocketmine\entity`
+- The following new API methods have been added:
+  - `public Human->getEnchantmentSeed() : int` - returns the current seed used to randomize options shown on the enchanting table for this human
+  - `public Human->setEnchantmentSeed(int $seed) : void`
+  - `public Human->regenerateEnchantmentSeed() : void` - returns a new randomly generated seed which can be set with `setEnchantmentSeed()`
+
+### `pocketmine\event`
+- The following new classes have been added:
+  - `block\FarmlandHydrationChangeEvent` - called when farmland is hydrated or dehydrated
+  - `block\PressurePlateUpdateEvent` - called when a pressure plate is activated or changes its power output
+  - `player\PlayerEnchantingOptionsRequestEvent` - called when a player puts an item to be enchanted into an enchanting table, to allow plugins to modify the enchanting options shown
+  - `player\PlayerItemEnchantEvent` - called when a player enchants an item in an enchanting table
+  - `world\WorldDifficultyChangeEvent` - called when a world's difficulty is changed
+- The following new API methods have been added:
+  - `public static Event::hasHandlers() : bool` - returns whether the event class has any registered handlers - used like `SomeEvent::hasHandlers()`
+  - `public HandlerListManager->getHandlersFor(class-string<? extends Event> $event) : list<RegisteredListener>` - returns a list of all registered listeners for the given event class, using cache if available
+
+### `pocketmine\inventory\transaction`
+- The following new classes have been added:
+  - `EnchantingTransaction` - used when a player enchants an item in an enchanting table
+
+### `pocketmine\item`
+- The following new API methods have been added:
+  - `public Armor->getMaterial() : ArmorMaterial` - returns an object containing properties shared by all items of the same armor material
+  - `public ArmorTypeInfo->getMaterial() : ArmorMaterial`
+  - `public Item->getEnchantability() : int` - returns the enchantability value of the item - higher values increase the chance of more powerful enchantments being offered by an enchanting table
+  - `public Item->getEnchantmentTags() : list<string>` - returns a list of strings indicating which types of enchantment can be applied to the item
+  - `public ToolTier->getEnchantability() : int`
+- The following API methods have signature changes:
+  - `Item->__construct()` now accepts an optional `list<string> $enchantmentTags` parameter
+  - `ArmorTypeInfo->__construct()` now accepts an optional `?ArmorMaterial $material` parameter
+- The following new classes have been added:
+  - `ArmorMaterial` - container for shared armor properties
+  - `VanillaArmorMaterials` - all vanilla armor materials
+  - `EnchantedBook` - represents an enchanted book item
+
+### `pocketmine\item\enchantment`
+- The following new classes have been added:
+  - `AvailableEnchantmentRegistry` - enchantments to be displayed on the enchanting table are selected from here - custom enchantments may be added
+  - `EnchantingHelper` - static class containing various helper methods for enchanting tables
+  - `EnchantingOption` - represents an option on the enchanting table menu
+  - `IncompatibleEnchantmentGroups` - list of constants naming groups of enchantments that are incompatible with each other - custom enchantments may be added using these group names to make them incompatible with existing enchantments in the same group
+  - `IncompatibleEnchantmentRegistry` - manages which enchantments are considered incompatible with each other - custom enchantments may be added using existing group names to make them incompatible with existing enchantments in the same group, or to entirely new groups
+  - `ItemEnchantmentTagRegistry` - manages item enchantment compatibility tags and which tags include which other tags
+  - `ItemEnchantmentTags` - list of constants naming item types for enchantment compatibility checks
+- The following classes have been deprecated
+  - `ItemFlags`
+- The following API methods have been added:
+  - `public Enchantment->isCompatibleWith(Enchantment $other) : bool`
+  - `public Enchantment->getMinEnchantingPower()` - returns the minimum enchanting power (derived from enchantability and number of bookshelves) needed to allow this enchantment to show on the enchanting table with a given level
+  - `public Enchantment->getMaxEnchantingPower()` - upper limit of enchanting power for this enchantment to be offered on the enchanting table with a given level
+- The following API methods have signature changes:
+  - `Enchantment->__construct()` now accepts optional `(\Closure(int $level) : int)|null $minEnchantingPower` and `int $enchantingPowerRange` parameters
+  - `Enchantment->__construct()` parameters `$primaryItemFlags` and `$secondaryItemFlags` are now deprecated and no longer used
+  - `ProtectionEnchantment->__construct()` has extra parameters to reflect `Enchantment->__construct()` changes
+- The following API methods have been deprecated:
+  - `Enchantment->getPrimaryItemFlags()` - use API methods provided by `AvailableEnchantmentRegistry` instead
+  - `Enchantment->getSecondaryItemFlags()` - use API methods provided by `AvailableEnchantmentRegistry` instead
+  - `Enchantment->hasPrimaryItemType()`
+  - `Enchantment->hasSecondaryItemType()`
+
+### `pocketmine\plugin`
+- The following new API methods have been added:
+  - `public PluginBase->getResourcePath(string $filename) : string` - returns a URI to an embedded resource file that can be used with `file_get_contents()` and similar functions
+  - `public PluginBase->getResourceFolder() : string` - returns a URI to the plugin's folder of embedded resources
+- The following API methods have been deprecated:
+  - `PluginBase->getResource()` - prefer using `getResourcePath()` with `file_get_contents()` or other PHP built-in functions instead
+
+### `pocketmine\resourcepacks`
+- The following new API methods have been added:
+  - `public ResourcePackManager->setResourcePacksRequired(bool $value) : void` - sets whether players must accept resource packs in order to join
+
+### `pocketmine\world\generator`
+- The following new API methods have been added:
+  - `public GeneratorManager->addAlias(string $name, string $alias) : void` - allows registering a generator alias without copying the generator registration parameters
+
+### `pocketmine\world\sound`
+- The following new classes have been added:
+- `PressurePlateActivateSound`
+- `PressurePlateDeactivateSound`
+
+### `pocketmine\utils`
+- The following new API methods have been added:
+  - `public StringToTParser->registerAlias(string $existing, string $alias) : void` - allows registering a string alias without copying registration parameters
+
+## Internals
+- Various `TypeIdMap` classes in the `pocketmine\data\bedrock` package now use the new `IntSaveIdMapTrait` to reduce code duplication.
+- Added a new `ServerProperties` class containing constants for all known `server.properties` keys.
+- Added a new `YmlServerProperties` class containing generated constants for all known `pocketmine.yml` keys. These keys can be used with `Config->getNested()`.
+

changelogs/5.6.md

@@ -0,0 +1,34 @@
+# 5.6.0
+Released 20th September 2023.
+
+**For Minecraft: Bedrock Edition 1.20.30**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.30.
+
+**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.30.
+- Removed support for older versions.
+
+## Fixes
+- Fixed support conditions for hanging roots, cave vines and dead bushes.
+- Fixed connection conditions for fences, glass panes, iron bars, and walls.
+
+# 5.6.1
+Released 20th October 2023.
+
+## Performance
+- Improved performance of cactus growth by disabling neighbour updates when only the age property was updated. While this isn't a perfect solution, it provides significant performance gains for servers with large cactus farms.
+
+## Fixes
+- Fixed `tools/generate-bedrock-data-from-packets.php` incorrectly interpreting network meta as blockstates in some cases (broken crafting recipes).
+- Fixed crafting recipes involving beds, skulls and some other items not working correctly (incorrectly interpreted data).
+- Fixed crashes when flower pot or cauldron blockentities exist in places where they shouldn't (leftovers from upgraded PM3 worlds).
+- Fixed `Entity->broadcastSound()` not firing `WorldSoundEvent` (bypassing internal sound system).
+- Fixed wooden signs, buttons and doors not being able to be used as furnace fuel.
+- Fixed bone meal and tools only working when used on the top side of dirt and grass. Bone meal now works from any side, and tools work on any side except the bottom.

changelogs/5.7.md

@@ -0,0 +1,27 @@
+# 5.7.0
+Released 26th October 2023.
+
+**For Minecraft: Bedrock Edition 1.20.40**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.40.
+
+**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.40.
+- Removed support for older versions.
+
+## Fixes
+- Fixed `cartography_table`, `smithing_table`, `stripped_cherry_log` and `stripped_cherry_wood` not working in `StringToItemParser`.
+- Fixed `Promise<null>::onCompletion()` always calling the reject handler if the promise was already completed.
+
+# 5.7.1
+Released 1st November 2023.
+
+## Fixes
+- Fixed non-reentrant-safe code in `PermissionManager` and various other subscriber subsystems.
+  - These issues caused server crashes when deleting a subscriber indirectly triggered the deletion of other subscribers (e.g. due to the GC activating in `unset()`).

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,30 +32,30 @@
       "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.1.0+bedrock-1.20.10",
-      "pocketmine/bedrock-data": "~2.4.0+bedrock-1.20.10",
-      "pocketmine/bedrock-item-upgrade-schema": "~1.4.0+bedrock-1.20.10",
-      "pocketmine/bedrock-protocol": "~23.0.2+bedrock-1.20.10",
+      "pocketmine/netresearch-jsonmapper": "~v4.4.999",
+      "pocketmine/bedrock-block-upgrade-schema": "~5.0.0+bedrock-1.21.40",
+      "pocketmine/bedrock-data": "~2.14.0+bedrock-1.21.40",
+      "pocketmine/bedrock-item-upgrade-schema": "~1.13.0+bedrock-1.21.40",
+      "pocketmine/bedrock-protocol": "~35.0.0+bedrock-1.21.40",
       "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.16",
+      "phpstan/phpstan": "1.11.11",
       "phpstan/phpstan-phpunit": "^1.1.0",
       "phpstan/phpstan-strict-rules": "^1.2.0",
-      "phpunit/phpunit": "^10.1"
+      "phpunit/phpunit": "^10.5.24"
    },
    "autoload": {
       "psr-4": {
@@ -83,11 +83,14 @@
          "@composer install --no-dev --classmap-authoritative --ignore-platform-reqs",
          "@php -dphar.readonly=0 build/server-phar.php"
       ],
-      "update-registry-annotations": [
+      "update-codegen": [
+         "@php build/generate-bedrockdata-path-consts.php",
+         "@php build/generate-biome-ids.php",
+         "@php build/generate-block-serializer-consts.php vendor/pocketmine/bedrock-data/canonical_block_states.nbt",
+         "@php build/generate-item-type-names.php vendor/pocketmine/bedrock-data/required_item_list.json",
+         "@php build/generate-known-translation-apis.php",
+         "@php build/generate-pocketmine-yml-property-consts.php",
          "@php build/generate-registry-annotations.php src"
-      ],
-      "update-translation-apis": [
-         "@php build/generate-known-translation-apis.php"
       ]
    }
 }

install-local-protocol.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+echo "--- Installing BedrockProtocol, BedrockData, BedrockBlockUpgradeSchema, BedrockItemUpgradeSchema dependencies from local repositories."
+echo "--- This allows you to perform integration tests using PocketMine-MP, without immediately publishing new versions of these libraries."
+
+cp composer.json composer-local-protocol.json
+cp composer.lock composer-local-protocol.lock
+
+export COMPOSER=composer-local-protocol.json
+composer config repositories.bedrock-protocol path ../deps/BedrockProtocol
+composer config repositories.bedrock-data path ../deps/BedrockData
+composer config repositories.bedrock-block-upgrade-schema path ../deps/BedrockBlockUpgradeSchema
+composer config repositories.bedrock-item-upgrade-schema path ../deps/BedrockItemUpgradeSchema
+
+composer require pocketmine/bedrock-protocol:*@dev pocketmine/bedrock-data:*@dev pocketmine/bedrock-block-upgrade-schema:*@dev pocketmine/bedrock-item-upgrade-schema:*@dev
+
+composer install
+
+echo "--- Local dependencies have been successfully installed."
+echo "--- This script does not modify composer.json. To go back to the original dependency versions, simply run 'composer install'."
+

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
@@ -39,6 +40,7 @@ parameters:
 			- build/php
 	dynamicConstantNames:
 		- pocketmine\VersionInfo::IS_DEVELOPMENT_BUILD
+		- pocketmine\VersionInfo::BUILD_CHANNEL
 		- pocketmine\DEBUG
 		- pocketmine\IS_DEVELOPMENT_BUILD
 	stubFiles:
@@ -46,8 +48,6 @@ parameters:
 		- tests/phpstan/stubs/leveldb.stub
 		- tests/phpstan/stubs/pmmpthread.stub
 	reportUnmatchedIgnoredErrors: false #no other way to silence platform-specific non-warnings
-	staticReflectionClassNamePatterns:
-		- "#^COM$#"
 	typeAliases:
 		#variadics don't work for this - mixed probably shouldn't work either, but for now it does
 		#what we actually need is something that accepts an infinite number of parameters, but in the absence of that,

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

@@ -30,6 +30,7 @@ use pocketmine\scheduler\GarbageCollectionTask;
 use pocketmine\timings\Timings;
 use pocketmine\utils\Process;
 use pocketmine\utils\Utils;
+use pocketmine\YmlServerProperties as Yml;
 use Symfony\Component\Filesystem\Path;
 use function arsort;
 use function count;
@@ -109,7 +110,7 @@ class MemoryManager{
 	}
 
 	private function init(ServerConfigGroup $config) : void{
-		$this->memoryLimit = $config->getPropertyInt("memory.main-limit", 0) * 1024 * 1024;
+		$this->memoryLimit = $config->getPropertyInt(Yml::MEMORY_MAIN_LIMIT, 0) * 1024 * 1024;
 
 		$defaultMemory = 1024;
 
@@ -127,7 +128,7 @@ class MemoryManager{
 			}
 		}
 
-		$hardLimit = $config->getPropertyInt("memory.main-hard-limit", $defaultMemory);
+		$hardLimit = $config->getPropertyInt(Yml::MEMORY_MAIN_HARD_LIMIT, $defaultMemory);
 
 		if($hardLimit <= 0){
 			ini_set("memory_limit", '-1');
@@ -135,22 +136,22 @@ class MemoryManager{
 			ini_set("memory_limit", $hardLimit . "M");
 		}
 
-		$this->globalMemoryLimit = $config->getPropertyInt("memory.global-limit", 0) * 1024 * 1024;
-		$this->checkRate = $config->getPropertyInt("memory.check-rate", self::DEFAULT_CHECK_RATE);
-		$this->continuousTrigger = $config->getPropertyBool("memory.continuous-trigger", true);
-		$this->continuousTriggerRate = $config->getPropertyInt("memory.continuous-trigger-rate", self::DEFAULT_CONTINUOUS_TRIGGER_RATE);
+		$this->globalMemoryLimit = $config->getPropertyInt(Yml::MEMORY_GLOBAL_LIMIT, 0) * 1024 * 1024;
+		$this->checkRate = $config->getPropertyInt(Yml::MEMORY_CHECK_RATE, self::DEFAULT_CHECK_RATE);
+		$this->continuousTrigger = $config->getPropertyBool(Yml::MEMORY_CONTINUOUS_TRIGGER, true);
+		$this->continuousTriggerRate = $config->getPropertyInt(Yml::MEMORY_CONTINUOUS_TRIGGER_RATE, self::DEFAULT_CONTINUOUS_TRIGGER_RATE);
 
-		$this->garbageCollectionPeriod = $config->getPropertyInt("memory.garbage-collection.period", self::DEFAULT_TICKS_PER_GC);
-		$this->garbageCollectionTrigger = $config->getPropertyBool("memory.garbage-collection.low-memory-trigger", true);
-		$this->garbageCollectionAsync = $config->getPropertyBool("memory.garbage-collection.collect-async-worker", true);
+		$this->garbageCollectionPeriod = $config->getPropertyInt(Yml::MEMORY_GARBAGE_COLLECTION_PERIOD, self::DEFAULT_TICKS_PER_GC);
+		$this->garbageCollectionTrigger = $config->getPropertyBool(Yml::MEMORY_GARBAGE_COLLECTION_LOW_MEMORY_TRIGGER, true);
+		$this->garbageCollectionAsync = $config->getPropertyBool(Yml::MEMORY_GARBAGE_COLLECTION_COLLECT_ASYNC_WORKER, true);
 
-		$this->lowMemChunkRadiusOverride = $config->getPropertyInt("memory.max-chunks.chunk-radius", 4);
-		$this->lowMemChunkGC = $config->getPropertyBool("memory.max-chunks.trigger-chunk-collect", true);
+		$this->lowMemChunkRadiusOverride = $config->getPropertyInt(Yml::MEMORY_MAX_CHUNKS_CHUNK_RADIUS, 4);
+		$this->lowMemChunkGC = $config->getPropertyBool(Yml::MEMORY_MAX_CHUNKS_TRIGGER_CHUNK_COLLECT, true);
 
-		$this->lowMemDisableChunkCache = $config->getPropertyBool("memory.world-caches.disable-chunk-cache", true);
-		$this->lowMemClearWorldCache = $config->getPropertyBool("memory.world-caches.low-memory-trigger", true);
+		$this->lowMemDisableChunkCache = $config->getPropertyBool(Yml::MEMORY_WORLD_CACHES_DISABLE_CHUNK_CACHE, true);
+		$this->lowMemClearWorldCache = $config->getPropertyBool(Yml::MEMORY_WORLD_CACHES_LOW_MEMORY_TRIGGER, true);
 
-		$this->dumpWorkers = $config->getPropertyBool("memory.memory-dump.dump-async-worker", true);
+		$this->dumpWorkers = $config->getPropertyBool(Yml::MEMORY_MEMORY_DUMP_DUMP_ASYNC_WORKER, true);
 		gc_enable();
 	}
 
@@ -331,7 +332,7 @@ class MemoryManager{
 					continue;
 				}
 				$methodStatics = [];
-				foreach($method->getStaticVariables() as $name => $variable){
+				foreach(Utils::promoteKeys($method->getStaticVariables()) as $name => $variable){
 					$methodStatics[$name] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 				}
 				if(count($methodStatics) > 0){
@@ -359,7 +360,7 @@ class MemoryManager{
 			'_SESSION' => true
 		];
 
-		foreach(Utils::stringifyKeys($GLOBALS) as $varName => $value){
+		foreach(Utils::promoteKeys($GLOBALS) as $varName => $value){
 			if(isset($ignoredGlobals[$varName])){
 				continue;
 			}
@@ -375,7 +376,7 @@ class MemoryManager{
 			$reflect = new \ReflectionFunction($function);
 
 			$vars = [];
-			foreach($reflect->getStaticVariables() as $varName => $variable){
+			foreach(Utils::promoteKeys($reflect->getStaticVariables()) as $varName => $variable){
 				$vars[$varName] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 			}
 			if(count($vars) > 0){
@@ -415,7 +416,7 @@ class MemoryManager{
 						$info["this"] = self::continueDump($closureThis, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 					}
 
-					foreach($reflect->getStaticVariables() as $name => $variable){
+					foreach(Utils::promoteKeys($reflect->getStaticVariables()) as $name => $variable){
 						$info["referencedVars"][$name] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 					}
 				}else{
@@ -498,7 +499,7 @@ class MemoryManager{
 			}
 			$data = [];
 			$numeric = 0;
-			foreach($from as $key => $value){
+			foreach(Utils::promoteKeys($from) as $key => $value){
 				$data[$numeric] = [
 					"k" => self::continueDump($key, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize),
 					"v" => self::continueDump($value, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize),

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;
@@ -80,7 +80,6 @@ use pocketmine\player\PlayerDataProvider;
 use pocketmine\player\PlayerDataSaveException;
 use pocketmine\player\PlayerInfo;
 use pocketmine\plugin\PharPluginLoader;
-use pocketmine\plugin\Plugin;
 use pocketmine\plugin\PluginEnableOrder;
 use pocketmine\plugin\PluginGraylist;
 use pocketmine\plugin\PluginManager;
@@ -120,11 +119,13 @@ use pocketmine\world\Position;
 use pocketmine\world\World;
 use pocketmine\world\WorldCreationOptions;
 use pocketmine\world\WorldManager;
+use pocketmine\YmlServerProperties as Yml;
 use Ramsey\Uuid\UuidInterface;
 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;
@@ -357,15 +358,15 @@ class Server{
 	}
 
 	public function getPort() : int{
-		return $this->configGroup->getConfigInt("server-port", self::DEFAULT_PORT_IPV4);
+		return $this->configGroup->getConfigInt(ServerProperties::SERVER_PORT_IPV4, self::DEFAULT_PORT_IPV4);
 	}
 
 	public function getPortV6() : int{
-		return $this->configGroup->getConfigInt("server-portv6", self::DEFAULT_PORT_IPV6);
+		return $this->configGroup->getConfigInt(ServerProperties::SERVER_PORT_IPV6, self::DEFAULT_PORT_IPV6);
 	}
 
 	public function getViewDistance() : int{
-		return max(2, $this->configGroup->getConfigInt("view-distance", self::DEFAULT_MAX_VIEW_DISTANCE));
+		return max(2, $this->configGroup->getConfigInt(ServerProperties::VIEW_DISTANCE, self::DEFAULT_MAX_VIEW_DISTANCE));
 	}
 
 	/**
@@ -376,12 +377,12 @@ class Server{
 	}
 
 	public function getIp() : string{
-		$str = $this->configGroup->getConfigString("server-ip");
+		$str = $this->configGroup->getConfigString(ServerProperties::SERVER_IPV4);
 		return $str !== "" ? $str : "0.0.0.0";
 	}
 
 	public function getIpV6() : string{
-		$str = $this->configGroup->getConfigString("server-ipv6");
+		$str = $this->configGroup->getConfigString(ServerProperties::SERVER_IPV6);
 		return $str !== "" ? $str : "::";
 	}
 
@@ -390,30 +391,30 @@ class Server{
 	}
 
 	public function getGamemode() : GameMode{
-		return GameMode::fromString($this->configGroup->getConfigString("gamemode", GameMode::SURVIVAL()->name())) ?? GameMode::SURVIVAL();
+		return GameMode::fromString($this->configGroup->getConfigString(ServerProperties::GAME_MODE)) ?? GameMode::SURVIVAL;
 	}
 
 	public function getForceGamemode() : bool{
-		return $this->configGroup->getConfigBool("force-gamemode", false);
+		return $this->configGroup->getConfigBool(ServerProperties::FORCE_GAME_MODE, false);
 	}
 
 	/**
 	 * Returns Server global difficulty. Note that this may be overridden in individual worlds.
 	 */
 	public function getDifficulty() : int{
-		return $this->configGroup->getConfigInt("difficulty", World::DIFFICULTY_NORMAL);
+		return $this->configGroup->getConfigInt(ServerProperties::DIFFICULTY, World::DIFFICULTY_NORMAL);
 	}
 
 	public function hasWhitelist() : bool{
-		return $this->configGroup->getConfigBool("white-list", false);
+		return $this->configGroup->getConfigBool(ServerProperties::WHITELIST, false);
 	}
 
 	public function isHardcore() : bool{
-		return $this->configGroup->getConfigBool("hardcore", false);
+		return $this->configGroup->getConfigBool(ServerProperties::HARDCORE, false);
 	}
 
 	public function getMotd() : string{
-		return $this->configGroup->getConfigString("motd", self::DEFAULT_SERVER_NAME);
+		return $this->configGroup->getConfigString(ServerProperties::MOTD, self::DEFAULT_SERVER_NAME);
 	}
 
 	public function getLoader() : ThreadSafeClassLoader{
@@ -496,7 +497,7 @@ class Server{
 	}
 
 	public function shouldSavePlayerData() : bool{
-		return $this->configGroup->getPropertyBool("player.save-player-data", true);
+		return $this->configGroup->getPropertyBool(Yml::PLAYER_SAVE_PLAYER_DATA, true);
 	}
 
 	public function getOfflinePlayer(string $name) : Player|OfflinePlayer|null{
@@ -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);
 				}
 			});
@@ -570,6 +571,7 @@ class Server{
 		$playerPromiseResolver = new PromiseResolver();
 
 		$createPlayer = function(Location $location) use ($playerPromiseResolver, $class, $session, $playerInfo, $authenticated, $offlinePlayerData) : void{
+			/** @see Player::__construct() */
 			$player = new $class($this, $session, $playerInfo, $authenticated, $location, $offlinePlayerData);
 			if(!$player->hasPlayedBefore()){
 				$player->onGround = true; //TODO: this hack is needed for new players in-air ticks - they don't get detected as on-ground until they move
@@ -734,12 +736,15 @@ class Server{
 
 	/**
 	 * @return string[][]
+	 * @phpstan-return array<string, list<string>>
 	 */
 	public function getCommandAliases() : array{
-		$section = $this->configGroup->getProperty("aliases");
+		$section = $this->configGroup->getProperty(Yml::ALIASES);
 		$result = [];
 		if(is_array($section)){
-			foreach($section as $key => $value){
+			foreach(Utils::promoteKeys($section) as $key => $value){
+				//TODO: more validation needed here
+				//key might not be a string, value might not be list<string>
 				$commands = [];
 				if(is_array($value)){
 					$commands = $value;
@@ -747,7 +752,7 @@ class Server{
 					$commands[] = (string) $value;
 				}
 
-				$result[$key] = $commands;
+				$result[(string) $key] = $commands;
 			}
 		}
 
@@ -811,36 +816,36 @@ class Server{
 			$this->configGroup = new ServerConfigGroup(
 				new Config($pocketmineYmlPath, Config::YAML, []),
 				new Config(Path::join($this->dataPath, "server.properties"), Config::PROPERTIES, [
-					"motd" => self::DEFAULT_SERVER_NAME,
-					"server-port" => self::DEFAULT_PORT_IPV4,
-					"server-portv6" => self::DEFAULT_PORT_IPV6,
-					"enable-ipv6" => true,
-					"white-list" => false,
-					"max-players" => self::DEFAULT_MAX_PLAYERS,
-					"gamemode" => GameMode::SURVIVAL()->name(),
-					"force-gamemode" => false,
-					"hardcore" => false,
-					"pvp" => true,
-					"difficulty" => World::DIFFICULTY_NORMAL,
-					"generator-settings" => "",
-					"level-name" => "world",
-					"level-seed" => "",
-					"level-type" => "DEFAULT",
-					"enable-query" => true,
-					"auto-save" => true,
-					"view-distance" => self::DEFAULT_MAX_VIEW_DISTANCE,
-					"xbox-auth" => true,
-					"language" => "eng"
+					ServerProperties::MOTD => self::DEFAULT_SERVER_NAME,
+					ServerProperties::SERVER_PORT_IPV4 => self::DEFAULT_PORT_IPV4,
+					ServerProperties::SERVER_PORT_IPV6 => self::DEFAULT_PORT_IPV6,
+					ServerProperties::ENABLE_IPV6 => true,
+					ServerProperties::WHITELIST => false,
+					ServerProperties::MAX_PLAYERS => self::DEFAULT_MAX_PLAYERS,
+					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,
+					ServerProperties::DIFFICULTY => World::DIFFICULTY_NORMAL,
+					ServerProperties::DEFAULT_WORLD_GENERATOR_SETTINGS => "",
+					ServerProperties::DEFAULT_WORLD_NAME => "world",
+					ServerProperties::DEFAULT_WORLD_SEED => "",
+					ServerProperties::DEFAULT_WORLD_GENERATOR => "DEFAULT",
+					ServerProperties::ENABLE_QUERY => true,
+					ServerProperties::AUTO_SAVE => true,
+					ServerProperties::VIEW_DISTANCE => self::DEFAULT_MAX_VIEW_DISTANCE,
+					ServerProperties::XBOX_AUTH => true,
+					ServerProperties::LANGUAGE => "eng"
 				])
 			);
 
-			$debugLogLevel = $this->configGroup->getPropertyInt("debug.level", 1);
+			$debugLogLevel = $this->configGroup->getPropertyInt(Yml::DEBUG_LEVEL, 1);
 			if($this->logger instanceof MainLogger){
 				$this->logger->setLogDebug($debugLogLevel > 1);
 			}
 
-			$this->forceLanguage = $this->configGroup->getPropertyBool("settings.force-language", false);
-			$selectedLang = $this->configGroup->getConfigString("language", $this->configGroup->getPropertyString("settings.language", Language::FALLBACK_LANGUAGE));
+			$this->forceLanguage = $this->configGroup->getPropertyBool(Yml::SETTINGS_FORCE_LANGUAGE, false);
+			$selectedLang = $this->configGroup->getConfigString(ServerProperties::LANGUAGE, $this->configGroup->getPropertyString("settings.language", Language::FALLBACK_LANGUAGE));
 			try{
 				$this->language = new Language($selectedLang);
 			}catch(LanguageNotFoundException $e){
@@ -853,14 +858,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("settings.enable-dev-builds", false)){
+				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("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();
 
@@ -876,9 +881,9 @@ 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("settings.async-workers", "auto")) === "auto"){
+			if(($poolSize = $this->configGroup->getPropertyString(Yml::SETTINGS_ASYNC_WORKERS, "auto")) === "auto"){
 				$poolSize = 2;
 				$processors = Utils::getCoreCount() - 2;
 
@@ -889,32 +894,32 @@ class Server{
 				$poolSize = max(1, (int) $poolSize);
 			}
 
-			$this->asyncPool = new AsyncPool($poolSize, max(-1, $this->configGroup->getPropertyInt("memory.async-worker-hard-limit", 256)), $this->autoloader, $this->logger, $this->tickSleeper);
+			$this->asyncPool = new AsyncPool($poolSize, max(-1, $this->configGroup->getPropertyInt(Yml::MEMORY_ASYNC_WORKER_HARD_LIMIT, 256)), $this->autoloader, $this->logger, $this->tickSleeper);
 
 			$netCompressionThreshold = -1;
-			if($this->configGroup->getPropertyInt("network.batch-threshold", 256) >= 0){
-				$netCompressionThreshold = $this->configGroup->getPropertyInt("network.batch-threshold", 256);
+			if($this->configGroup->getPropertyInt(Yml::NETWORK_BATCH_THRESHOLD, 256) >= 0){
+				$netCompressionThreshold = $this->configGroup->getPropertyInt(Yml::NETWORK_BATCH_THRESHOLD, 256);
 			}
 			if($netCompressionThreshold < 0){
 				$netCompressionThreshold = null;
 			}
 
-			$netCompressionLevel = $this->configGroup->getPropertyInt("network.compression-level", 6);
+			$netCompressionLevel = $this->configGroup->getPropertyInt(Yml::NETWORK_COMPRESSION_LEVEL, 6);
 			if($netCompressionLevel < 1 || $netCompressionLevel > 9){
 				$this->logger->warning("Invalid network compression level $netCompressionLevel set, setting to default 6");
 				$netCompressionLevel = 6;
 			}
 			ZlibCompressor::setInstance(new ZlibCompressor($netCompressionLevel, $netCompressionThreshold, ZlibCompressor::DEFAULT_MAX_DECOMPRESSION_SIZE));
 
-			$this->networkCompressionAsync = $this->configGroup->getPropertyBool("network.async-compression", true);
+			$this->networkCompressionAsync = $this->configGroup->getPropertyBool(Yml::NETWORK_ASYNC_COMPRESSION, true);
 			$this->networkCompressionAsyncThreshold = max(
-				$this->configGroup->getPropertyInt("network.async-compression-threshold", self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD),
+				$this->configGroup->getPropertyInt(Yml::NETWORK_ASYNC_COMPRESSION_THRESHOLD, self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD),
 				$netCompressionThreshold ?? self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD
 			);
 
-			EncryptionContext::$ENABLED = $this->configGroup->getPropertyBool("network.enable-encryption", true);
+			EncryptionContext::$ENABLED = $this->configGroup->getPropertyBool(Yml::NETWORK_ENABLE_ENCRYPTION, true);
 
-			$this->doTitleTick = $this->configGroup->getPropertyBool("console.title-tick", true) && Terminal::hasFormattingCodes();
+			$this->doTitleTick = $this->configGroup->getPropertyBool(Yml::CONSOLE_TITLE_TICK, true) && Terminal::hasFormattingCodes();
 
 			$this->operators = new Config(Path::join($this->dataPath, "ops.txt"), Config::ENUM);
 			$this->whitelist = new Config(Path::join($this->dataPath, "white-list.txt"), Config::ENUM);
@@ -932,39 +937,39 @@ class Server{
 			$this->banByIP = new BanList($bannedIpsTxt);
 			$this->banByIP->load();
 
-			$this->maxPlayers = $this->configGroup->getConfigInt("max-players", self::DEFAULT_MAX_PLAYERS);
+			$this->maxPlayers = $this->configGroup->getConfigInt(ServerProperties::MAX_PLAYERS, self::DEFAULT_MAX_PLAYERS);
 
-			$this->onlineMode = $this->configGroup->getConfigBool("xbox-auth", true);
+			$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("hardcore", false) && $this->getDifficulty() < World::DIFFICULTY_HARD){
-				$this->configGroup->setConfigInt("difficulty", World::DIFFICULTY_HARD);
+			if($this->configGroup->getConfigBool(ServerProperties::HARDCORE, false) && $this->getDifficulty() < World::DIFFICULTY_HARD){
+				$this->configGroup->setConfigInt(ServerProperties::DIFFICULTY, World::DIFFICULTY_HARD);
 			}
 
 			@cli_set_process_title($this->getName() . " " . $this->getPocketMineVersion());
 
 			$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("settings.enable-profiling", false));
-			$this->profilingTickRate = $this->configGroup->getPropertyInt("settings.profile-report-trigger", self::TARGET_TICKS_PER_SECOND);
+			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);
 
 			DefaultPermissions::registerCorePermissions();
 
@@ -972,7 +977,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");
@@ -986,13 +991,13 @@ class Server{
 				$this->forceShutdownExit();
 				return;
 			}
-			$this->pluginManager = new PluginManager($this, $this->configGroup->getPropertyBool("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());
 
 			$providerManager = new WorldProviderManager();
 			if(
-				($format = $providerManager->getProviderByName($formatName = $this->configGroup->getPropertyString("level-settings.default-format", ""))) !== null &&
+				($format = $providerManager->getProviderByName($formatName = $this->configGroup->getPropertyString(Yml::LEVEL_SETTINGS_DEFAULT_FORMAT, ""))) !== null &&
 				$format instanceof WritableWorldProviderManagerEntry
 			){
 				$providerManager->setDefault($format);
@@ -1001,10 +1006,10 @@ class Server{
 			}
 
 			$this->worldManager = new WorldManager($this, Path::join($this->dataPath, "worlds"), $providerManager);
-			$this->worldManager->setAutoSave($this->configGroup->getConfigBool("auto-save", $this->worldManager->getAutoSave()));
-			$this->worldManager->setAutoSaveInterval($this->configGroup->getPropertyInt("ticks-per.autosave", $this->worldManager->getAutoSaveInterval()));
+			$this->worldManager->setAutoSave($this->configGroup->getConfigBool(ServerProperties::AUTO_SAVE, $this->worldManager->getAutoSave()));
+			$this->worldManager->setAutoSaveInterval($this->configGroup->getPropertyInt(Yml::TICKS_PER_AUTOSAVE, $this->worldManager->getAutoSaveInterval()));
 
-			$this->updater = new UpdateChecker($this, $this->configGroup->getPropertyString("auto-updater.host", "update.pmmp.io"));
+			$this->updater = new UpdateChecker($this, $this->configGroup->getPropertyString(Yml::AUTO_UPDATER_HOST, "update.pmmp.io"));
 
 			$this->queryInfo = new QueryInfo($this);
 
@@ -1019,7 +1024,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;
@@ -1030,7 +1035,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;
@@ -1041,23 +1046,23 @@ class Server{
 				return;
 			}
 
-			if($this->configGroup->getPropertyBool("anonymous-statistics.enabled", true)){
+			if($this->configGroup->getPropertyBool(Yml::ANONYMOUS_STATISTICS_ENABLED, true)){
 				$this->sendUsageTicker = self::TICKS_PER_STATS_REPORT;
 				$this->sendUsage(SendUsageTask::TYPE_OPEN);
 			}
 
 			$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);
 			$this->subscribeToBroadcastChannel(self::BROADCAST_CHANNEL_USERS, $forwarder);
 
 			//TODO: move console parts to a separate component
-			if($this->configGroup->getPropertyBool("console.enable-input", true)){
+			if($this->configGroup->getPropertyBool(Yml::CONSOLE_ENABLE_INPUT, true)){
 				$this->console = new ConsoleReaderChildProcessDaemon($this->logger);
 			}
 
@@ -1092,7 +1097,11 @@ class Server{
 
 		$anyWorldFailedToLoad = false;
 
-		foreach((array) $this->configGroup->getProperty("worlds", []) as $name => $options){
+		foreach(Utils::promoteKeys((array) $this->configGroup->getProperty(Yml::WORLDS, [])) as $name => $options){
+			if(!is_string($name)){
+				//TODO: this probably should be an error
+				continue;
+			}
 			if($options === null){
 				$options = [];
 			}elseif(!is_array($options)){
@@ -1136,30 +1145,30 @@ class Server{
 		}
 
 		if($this->worldManager->getDefaultWorld() === null){
-			$default = $this->configGroup->getConfigString("level-name", "world");
+			$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("level-name", "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;
 				}
-				$generatorName = $this->configGroup->getConfigString("level-type");
-				$generatorOptions = $this->configGroup->getConfigString("generator-settings");
+				$generatorName = $this->configGroup->getConfigString(ServerProperties::DEFAULT_WORLD_GENERATOR);
+				$generatorOptions = $this->configGroup->getConfigString(ServerProperties::DEFAULT_WORLD_GENERATOR_SETTINGS);
 				$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()
 					->setGeneratorClass($generatorClass)
 					->setGeneratorOptions($generatorOptions);
-				$convertedSeed = Generator::convertSeed($this->configGroup->getConfigString("level-seed"));
+				$convertedSeed = Generator::convertSeed($this->configGroup->getConfigString(ServerProperties::DEFAULT_WORLD_SEED));
 				if($convertedSeed !== null){
 					$creationOptions->setSeed($convertedSeed);
 				}
@@ -1184,12 +1193,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,
@@ -1199,7 +1207,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){
@@ -1207,24 +1215,23 @@ 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;
 	}
 
 	private function startupPrepareNetworkInterfaces() : bool{
-		$useQuery = $this->configGroup->getConfigBool("enable-query", true);
+		$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("enable-ipv6", true) &&
-				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter)
+				$this->configGroup->getConfigBool(ServerProperties::ENABLE_IPV6, true) &&
+				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $typeConverter)
 			)
 		){
 			return false;
@@ -1238,7 +1245,7 @@ class Server{
 			$this->network->blockAddress($entry->getName(), -1);
 		}
 
-		if($this->configGroup->getPropertyBool("network.upnp-forwarding", false)){
+		if($this->configGroup->getPropertyBool(Yml::NETWORK_UPNP_FORWARDING, false)){
 			$this->network->registerInterface(new UPnPNetworkInterface($this->logger, Internet::getInternalIP(), $this->getPort()));
 		}
 
@@ -1258,9 +1265,10 @@ class Server{
 	 */
 	public function unsubscribeFromBroadcastChannel(string $channelId, CommandSender $subscriber) : void{
 		if(isset($this->broadcastSubscribers[$channelId][spl_object_id($subscriber)])){
-			unset($this->broadcastSubscribers[$channelId][spl_object_id($subscriber)]);
-			if(count($this->broadcastSubscribers[$channelId]) === 0){
+			if(count($this->broadcastSubscribers[$channelId]) === 1){
 				unset($this->broadcastSubscribers[$channelId]);
+			}else{
+				unset($this->broadcastSubscribers[$channelId][spl_object_id($subscriber)]);
 			}
 		}
 	}
@@ -1354,29 +1362,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();
 		}
@@ -1385,14 +1407,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();
 		}
 
@@ -1453,43 +1475,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("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);
 				}
 			}
@@ -1557,7 +1579,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);
 		}
@@ -1588,17 +1610,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("auto-report.enabled", true)){
+			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;
@@ -1606,15 +1628,6 @@ class Server{
 				}
 				@touch($stamp); //update file timestamp
 
-				$plugin = $dump->getData()->plugin;
-				if($plugin !== ""){
-					$p = $this->pluginManager->getPlugin($plugin);
-					if($p instanceof Plugin && !($p->getPluginLoader() instanceof PharPluginLoader)){
-						$this->logger->debug("Not sending crashdump due to caused by non-phar plugin");
-						$report = false;
-					}
-				}
-
 				if($dump->getData()->error["type"] === \ParseError::class){
 					$report = false;
 				}
@@ -1625,7 +1638,7 @@ class Server{
 				}
 
 				if($report){
-					$url = ($this->configGroup->getPropertyBool("auto-report.use-https", true) ? "https" : "http") . "://" . $this->configGroup->getPropertyString("auto-report.host", "crash.pmmp.io") . "/submit/api";
+					$url = ($this->configGroup->getPropertyBool(Yml::AUTO_REPORT_USE_HTTPS, true) ? "https" : "http") . "://" . $this->configGroup->getPropertyString(Yml::AUTO_REPORT_HOST, "crash.pmmp.io") . "/submit/api";
 					$postUrlError = "Unknown error";
 					$reply = Internet::postURL($url, [
 						"report" => "yes",
@@ -1638,7 +1651,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{
@@ -1652,7 +1665,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){}
 		}
 
@@ -1660,9 +1673,11 @@ class Server{
 		$this->isRunning = false;
 
 		//Force minimum uptime to be >= 120 seconds, to reduce the impact of spammy crash loops
-		$spacing = ((int) $this->startTime) - time() + 120;
+		$uptime = time() - ((int) $this->startTime);
+		$minUptime = 120;
+		$spacing = $minUptime - $uptime;
 		if($spacing > 0){
-			echo "--- Waiting $spacing seconds to throttle automatic restart (you can kill the process safely now) ---" . PHP_EOL;
+			echo "--- Uptime {$uptime}s - waiting {$spacing}s to throttle automatic restart (you can kill the process safely now) ---" . PHP_EOL;
 			sleep($spacing);
 		}
 		@Process::kill(Process::pid());
@@ -1736,7 +1751,7 @@ class Server{
 	}
 
 	public function sendUsage(int $type = SendUsageTask::TYPE_STATUS) : void{
-		if($this->configGroup->getPropertyBool("anonymous-statistics.enabled", true)){
+		if($this->configGroup->getPropertyBool(Yml::ANONYMOUS_STATISTICS_ENABLED, true)){
 			$this->asyncPool->submitTask(new SendUsageTask($this, $type, $this->uniquePlayers));
 		}
 		$this->uniquePlayers = [];
@@ -1770,7 +1785,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) .
@@ -1835,10 +1850,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/ServerProperties.php

@@ -0,0 +1,58 @@
+<?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;
+
+/**
+ * @internal
+ * Constants for all properties available in server.properties.
+ */
+final class ServerProperties{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	public const AUTO_SAVE = "auto-save";
+	public const DEFAULT_WORLD_GENERATOR = "level-type";
+	public const DEFAULT_WORLD_GENERATOR_SETTINGS = "generator-settings";
+	public const DEFAULT_WORLD_NAME = "level-name";
+	public const DEFAULT_WORLD_SEED = "level-seed";
+	public const DIFFICULTY = "difficulty";
+	public const ENABLE_IPV6 = "enable-ipv6";
+	public const ENABLE_QUERY = "enable-query";
+	public const FORCE_GAME_MODE = "force-gamemode";
+	public const GAME_MODE = "gamemode";
+	public const HARDCORE = "hardcore";
+	public const LANGUAGE = "language";
+	public const MAX_PLAYERS = "max-players";
+	public const MOTD = "motd";
+	public const PVP = "pvp";
+	public const SERVER_IPV4 = "server-ip";
+	public const SERVER_IPV6 = "server-ipv6";
+	public const SERVER_PORT_IPV4 = "server-port";
+	public const SERVER_PORT_IPV6 = "server-portv6";
+	public const VIEW_DISTANCE = "view-distance";
+	public const WHITELIST = "white-list";
+	public const XBOX_AUTH = "xbox-auth";
+}

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,9 +31,9 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "5.5.0-BETA1";
+	public const BASE_VERSION = "5.21.2";
 	public const IS_DEVELOPMENT_BUILD = false;
-	public const BUILD_CHANNEL = "beta";
+	public const BUILD_CHANNEL = "stable";
 
 	/**
 	 * PocketMine-MP-specific version ID for world data. Used to determine what fixes need to be applied to old world
@@ -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/YmlServerProperties.php

@@ -0,0 +1,118 @@
+<?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;
+
+/**
+ * @internal
+ * Constants for all properties available in pocketmine.yml.
+ * This is generated by build/generate-pocketmine-yml-property-consts.php.
+ * Do not edit this file manually.
+ */
+final class YmlServerProperties{
+
+	private function __construct(){
+		//NOOP
+	}
+
+	public const ALIASES = 'aliases';
+	public const ANONYMOUS_STATISTICS = 'anonymous-statistics';
+	public const ANONYMOUS_STATISTICS_ENABLED = 'anonymous-statistics.enabled';
+	public const ANONYMOUS_STATISTICS_HOST = 'anonymous-statistics.host';
+	public const AUTO_REPORT = 'auto-report';
+	public const AUTO_REPORT_ENABLED = 'auto-report.enabled';
+	public const AUTO_REPORT_HOST = 'auto-report.host';
+	public const AUTO_REPORT_SEND_CODE = 'auto-report.send-code';
+	public const AUTO_REPORT_SEND_PHPINFO = 'auto-report.send-phpinfo';
+	public const AUTO_REPORT_SEND_SETTINGS = 'auto-report.send-settings';
+	public const AUTO_REPORT_USE_HTTPS = 'auto-report.use-https';
+	public const AUTO_UPDATER = 'auto-updater';
+	public const AUTO_UPDATER_ENABLED = 'auto-updater.enabled';
+	public const AUTO_UPDATER_HOST = 'auto-updater.host';
+	public const AUTO_UPDATER_ON_UPDATE = 'auto-updater.on-update';
+	public const AUTO_UPDATER_ON_UPDATE_WARN_CONSOLE = 'auto-updater.on-update.warn-console';
+	public const AUTO_UPDATER_PREFERRED_CHANNEL = 'auto-updater.preferred-channel';
+	public const AUTO_UPDATER_SUGGEST_CHANNELS = 'auto-updater.suggest-channels';
+	public const CHUNK_GENERATION = 'chunk-generation';
+	public const CHUNK_GENERATION_POPULATION_QUEUE_SIZE = 'chunk-generation.population-queue-size';
+	public const CHUNK_SENDING = 'chunk-sending';
+	public const CHUNK_SENDING_PER_TICK = 'chunk-sending.per-tick';
+	public const CHUNK_SENDING_SPAWN_RADIUS = 'chunk-sending.spawn-radius';
+	public const CHUNK_TICKING = 'chunk-ticking';
+	public const CHUNK_TICKING_BLOCKS_PER_SUBCHUNK_PER_TICK = 'chunk-ticking.blocks-per-subchunk-per-tick';
+	public const CHUNK_TICKING_DISABLE_BLOCK_TICKING = 'chunk-ticking.disable-block-ticking';
+	public const CHUNK_TICKING_TICK_RADIUS = 'chunk-ticking.tick-radius';
+	public const CONSOLE = 'console';
+	public const CONSOLE_ENABLE_INPUT = 'console.enable-input';
+	public const CONSOLE_TITLE_TICK = 'console.title-tick';
+	public const DEBUG = 'debug';
+	public const DEBUG_LEVEL = 'debug.level';
+	public const LEVEL_SETTINGS = 'level-settings';
+	public const LEVEL_SETTINGS_DEFAULT_FORMAT = 'level-settings.default-format';
+	public const MEMORY = 'memory';
+	public const MEMORY_ASYNC_WORKER_HARD_LIMIT = 'memory.async-worker-hard-limit';
+	public const MEMORY_CHECK_RATE = 'memory.check-rate';
+	public const MEMORY_CONTINUOUS_TRIGGER = 'memory.continuous-trigger';
+	public const MEMORY_CONTINUOUS_TRIGGER_RATE = 'memory.continuous-trigger-rate';
+	public const MEMORY_GARBAGE_COLLECTION = 'memory.garbage-collection';
+	public const MEMORY_GARBAGE_COLLECTION_COLLECT_ASYNC_WORKER = 'memory.garbage-collection.collect-async-worker';
+	public const MEMORY_GARBAGE_COLLECTION_LOW_MEMORY_TRIGGER = 'memory.garbage-collection.low-memory-trigger';
+	public const MEMORY_GARBAGE_COLLECTION_PERIOD = 'memory.garbage-collection.period';
+	public const MEMORY_GLOBAL_LIMIT = 'memory.global-limit';
+	public const MEMORY_MAIN_HARD_LIMIT = 'memory.main-hard-limit';
+	public const MEMORY_MAIN_LIMIT = 'memory.main-limit';
+	public const MEMORY_MAX_CHUNKS = 'memory.max-chunks';
+	public const MEMORY_MAX_CHUNKS_CHUNK_RADIUS = 'memory.max-chunks.chunk-radius';
+	public const MEMORY_MAX_CHUNKS_TRIGGER_CHUNK_COLLECT = 'memory.max-chunks.trigger-chunk-collect';
+	public const MEMORY_MEMORY_DUMP = 'memory.memory-dump';
+	public const MEMORY_MEMORY_DUMP_DUMP_ASYNC_WORKER = 'memory.memory-dump.dump-async-worker';
+	public const MEMORY_WORLD_CACHES = 'memory.world-caches';
+	public const MEMORY_WORLD_CACHES_DISABLE_CHUNK_CACHE = 'memory.world-caches.disable-chunk-cache';
+	public const MEMORY_WORLD_CACHES_LOW_MEMORY_TRIGGER = 'memory.world-caches.low-memory-trigger';
+	public const NETWORK = 'network';
+	public const NETWORK_ASYNC_COMPRESSION = 'network.async-compression';
+	public const NETWORK_ASYNC_COMPRESSION_THRESHOLD = 'network.async-compression-threshold';
+	public const NETWORK_BATCH_THRESHOLD = 'network.batch-threshold';
+	public const NETWORK_COMPRESSION_LEVEL = 'network.compression-level';
+	public const NETWORK_ENABLE_ENCRYPTION = 'network.enable-encryption';
+	public const NETWORK_MAX_MTU_SIZE = 'network.max-mtu-size';
+	public const NETWORK_UPNP_FORWARDING = 'network.upnp-forwarding';
+	public const PLAYER = 'player';
+	public const PLAYER_SAVE_PLAYER_DATA = 'player.save-player-data';
+	public const PLAYER_VERIFY_XUID = 'player.verify-xuid';
+	public const PLUGINS = 'plugins';
+	public const PLUGINS_LEGACY_DATA_DIR = 'plugins.legacy-data-dir';
+	public const SETTINGS = 'settings';
+	public const SETTINGS_ASYNC_WORKERS = 'settings.async-workers';
+	public const SETTINGS_ENABLE_DEV_BUILDS = 'settings.enable-dev-builds';
+	public const SETTINGS_ENABLE_PROFILING = 'settings.enable-profiling';
+	public const SETTINGS_FORCE_LANGUAGE = 'settings.force-language';
+	public const SETTINGS_PROFILE_REPORT_TRIGGER = 'settings.profile-report-trigger';
+	public const SETTINGS_QUERY_PLUGINS = 'settings.query-plugins';
+	public const SETTINGS_SHUTDOWN_MESSAGE = 'settings.shutdown-message';
+	public const TICKS_PER = 'ticks-per';
+	public const TICKS_PER_AUTOSAVE = 'ticks-per.autosave';
+	public const TIMINGS = 'timings';
+	public const TIMINGS_HOST = 'timings.host';
+	public const WORLDS = 'worlds';
+}

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{
@@ -91,7 +91,7 @@ class Anvil extends Transparent implements Fallable{
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			$this->facing = Facing::rotateY($player->getHorizontalFacing(), true);
+			$this->facing = Facing::rotateY($player->getHorizontalFacing(), false);
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}

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)
@@ -271,4 +271,8 @@ abstract class BaseSign extends Transparent{
 	public function asItem() : Item{
 		return ($this->asItemCallback)();
 	}
+
+	public function getFuelTime() : int{
+		return $this->woodType->isFlammable() ? 200 : 0;
+	}
 }

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);
@@ -157,12 +150,15 @@ final class Bell extends Transparent{
 		}
 	}
 
+	public function getDropsForIncompatibleTool(Item $item) : array{
+		return [$this->asItem()];
+	}
+
 	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,46 @@ 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).
+	 *
+	 * @phpstan-impure
 	 */
 	public function readStateFromWorld() : Block{
-		$this->collisionBoxes = null;
-
 		return $this;
 	}
 
@@ -370,7 +404,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 +574,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 +617,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 +768,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 +789,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 +808,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 +941,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,36 @@ 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 CAMPFIRE = 10718;
+	public const SOUL_CAMPFIRE = 10719;
+	public const TUFF_SLAB = 10720;
+	public const TUFF_STAIRS = 10721;
+	public const TUFF_WALL = 10722;
+	public const CHISELED_TUFF = 10723;
+	public const TUFF_BRICKS = 10724;
+	public const TUFF_BRICK_SLAB = 10725;
+	public const TUFF_BRICK_STAIRS = 10726;
+	public const TUFF_BRICK_WALL = 10727;
+	public const CHISELED_TUFF_BRICKS = 10728;
+	public const POLISHED_TUFF = 10729;
+	public const POLISHED_TUFF_SLAB = 10730;
+	public const POLISHED_TUFF_STAIRS = 10731;
+	public const POLISHED_TUFF_WALL = 10732;
+	public const COPPER_BULB = 10733;
+	public const COPPER_DOOR = 10734;
+	public const COPPER_TRAPDOOR = 10735;
+	public const CHISELED_COPPER = 10736;
+	public const COPPER_GRATE = 10737;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10710;
+	public const FIRST_UNUSED_BLOCK_ID = 10738;
 
 	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
 

src/block/BlueIce.php

@@ -27,10 +27,6 @@ use pocketmine\item\Item;
 
 class BlueIce extends Opaque{
 
-	public function getLightLevel() : int{
-		return 1;
-	}
-
 	public function getFrictionFactor() : float{
 		return 0.99;
 	}
@@ -38,4 +34,8 @@ class BlueIce extends Opaque{
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [];
 	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
 }

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{
@@ -117,25 +95,11 @@ class Cactus extends Transparent{
 					}
 				}
 				$this->age = 0;
-				$world->setBlock($this->position, $this);
+				$world->setBlock($this->position, $this, update: false);
 			}else{
 				++$this->age;
-				$world->setBlock($this->position, $this);
+				$world->setBlock($this->position, $this, update: false);
 			}
 		}
 	}
-
-	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/CakeWithCandle.php

@@ -52,6 +52,9 @@ class CakeWithCandle extends BaseCake{
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($this->lit && $face !== Facing::UP){
+			return true;
+		}
 		if($this->onInteractCandle($item, $face, $clickVector, $player, $returnedItems)){
 			return true;
 		}

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

@@ -0,0 +1,277 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\inventory\CampfireInventory;
+use pocketmine\block\tile\Campfire as TileCampfire;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\LightableTrait;
+use pocketmine\block\utils\SupportType;
+use pocketmine\crafting\FurnaceRecipe;
+use pocketmine\crafting\FurnaceType;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\entity\Entity;
+use pocketmine\entity\Living;
+use pocketmine\entity\projectile\Projectile;
+use pocketmine\entity\projectile\SplashPotion;
+use pocketmine\event\block\CampfireCookEvent;
+use pocketmine\event\entity\EntityDamageByBlockEvent;
+use pocketmine\event\entity\EntityDamageEvent;
+use pocketmine\item\Durable;
+use pocketmine\item\enchantment\VanillaEnchantments;
+use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
+use pocketmine\item\PotionType;
+use pocketmine\item\Shovel;
+use pocketmine\item\VanillaItems;
+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\sound\BlazeShootSound;
+use pocketmine\world\sound\FireExtinguishSound;
+use pocketmine\world\sound\FlintSteelSound;
+use pocketmine\world\sound\ItemFrameAddItemSound;
+use function count;
+use function min;
+use function mt_rand;
+
+class Campfire extends Transparent{
+	use HorizontalFacingTrait{
+		HorizontalFacingTrait::describeBlockOnlyState as encodeFacingState;
+	}
+	use LightableTrait{
+		LightableTrait::describeBlockOnlyState as encodeLitState;
+	}
+
+	private const UPDATE_INTERVAL_TICKS = 10;
+
+	protected CampfireInventory $inventory;
+
+	/**
+	 * @var int[] slot => ticks
+	 * @phpstan-var array<int, int>
+	 */
+	protected array $cookingTimes = [];
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$this->encodeFacingState($w);
+		$this->encodeLitState($w);
+	}
+
+	public function readStateFromWorld() : Block{
+		parent::readStateFromWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileCampfire){
+			$this->inventory = $tile->getInventory();
+			$this->cookingTimes = $tile->getCookingTimes();
+		}else{
+			$this->inventory = new CampfireInventory($this->position);
+		}
+
+		return $this;
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileCampfire){
+			$tile->setCookingTimes($this->cookingTimes);
+		}
+	}
+
+	public function hasEntityCollision() : bool{
+		return true;
+	}
+
+	public function getLightLevel() : int{
+		return $this->lit ? 15 : 0;
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			VanillaItems::CHARCOAL()->setCount(2)
+		];
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE;
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()->trim(Facing::UP, 9 / 16)];
+	}
+
+	public function getInventory() : CampfireInventory{
+		return $this->inventory;
+	}
+
+	protected function getFurnaceType() : FurnaceType{
+		return FurnaceType::CAMPFIRE;
+	}
+
+	protected function getEntityCollisionDamage() : int{
+		return 1;
+	}
+
+	/**
+	 * Sets the number of ticks during the item in the given slot has been cooked.
+	 */
+	public function setCookingTime(int $slot, int $time) : void{
+		if($slot < 0 || $slot > 3){
+			throw new \InvalidArgumentException("Slot must be in range 0-3");
+		}
+		if($time < 0 || $time > $this->getFurnaceType()->getCookDurationTicks()){
+			throw new \InvalidArgumentException("CookingTime must be in range 0-" . $this->getFurnaceType()->getCookDurationTicks());
+		}
+		$this->cookingTimes[$slot] = $time;
+	}
+
+	/**
+	 * Returns the number of ticks during the item in the given slot has been cooked.
+	 */
+	public function getCookingTime(int $slot) : int{
+		return $this->cookingTimes[$slot] ?? 0;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->getSide(Facing::DOWN) instanceof Campfire){
+			return false;
+		}
+		if($player !== null){
+			$this->facing = $player->getHorizontalFacing();
+		}
+		$this->lit = true;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if(!$this->lit){
+			if($item->getTypeId() === ItemTypeIds::FIRE_CHARGE){
+				$item->pop();
+				$this->ignite();
+				$this->position->getWorld()->addSound($this->position, new BlazeShootSound());
+				return true;
+			}elseif($item->getTypeId() === ItemTypeIds::FLINT_AND_STEEL || $item->hasEnchantment(VanillaEnchantments::FIRE_ASPECT())){
+				if($item instanceof Durable){
+					$item->applyDamage(1);
+				}
+				$this->ignite();
+				return true;
+			}
+		}elseif($item instanceof Shovel){
+			$item->applyDamage(1);
+			$this->extinguish();
+			return true;
+		}
+
+		if($this->position->getWorld()->getServer()->getCraftingManager()->getFurnaceRecipeManager($this->getFurnaceType())->match($item) !== null){
+			$ingredient = clone $item;
+			$ingredient->setCount(1);
+			if(count($this->inventory->addItem($ingredient)) === 0){
+				$item->pop();
+				$this->position->getWorld()->addSound($this->position, new ItemFrameAddItemSound());
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->lit && $this->getSide(Facing::UP)->getTypeId() === BlockTypeIds::WATER){
+			$this->extinguish();
+			//TODO: Waterlogging
+		}
+	}
+
+	public function onEntityInside(Entity $entity) : bool{
+		if(!$this->lit){
+			if($entity->isOnFire()){
+				$this->ignite();
+				return false;
+			}
+		}elseif($entity instanceof Living){
+			$entity->attack(new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_FIRE, $this->getEntityCollisionDamage()));
+		}
+		return true;
+	}
+
+	public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
+		if($this->lit && $projectile instanceof SplashPotion && $projectile->getPotionType() === PotionType::WATER){
+			$this->extinguish();
+		}
+	}
+
+	public function onScheduledUpdate() : void{
+		if($this->lit){
+			$items = $this->inventory->getContents();
+			$furnaceType = $this->getFurnaceType();
+			$maxCookDuration = $furnaceType->getCookDurationTicks();
+			foreach($items as $slot => $item){
+				$this->setCookingTime($slot, min($maxCookDuration, $this->getCookingTime($slot) + self::UPDATE_INTERVAL_TICKS));
+				if($this->getCookingTime($slot) >= $maxCookDuration){
+					$result =
+						($recipe = $this->position->getWorld()->getServer()->getCraftingManager()->getFurnaceRecipeManager($furnaceType)->match($item)) instanceof FurnaceRecipe ?
+							$recipe->getResult() :
+							VanillaItems::AIR();
+
+					$ev = new CampfireCookEvent($this, $slot, $item, $result);
+					$ev->call();
+
+					if ($ev->isCancelled()){
+						continue;
+					}
+
+					$this->inventory->setItem($slot, VanillaItems::AIR());
+					$this->setCookingTime($slot, 0);
+					$this->position->getWorld()->dropItem($this->position->add(0.5, 1, 0.5), $ev->getResult());
+				}
+			}
+			if(count($items) > 0){
+				$this->position->getWorld()->setBlock($this->position, $this);
+			}
+			if(mt_rand(1, 6) === 1){
+				$this->position->getWorld()->addSound($this->position, $furnaceType->getCookSound());
+			}
+			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, self::UPDATE_INTERVAL_TICKS);
+		}
+	}
+
+	private function extinguish() : void{
+		$this->position->getWorld()->addSound($this->position, new FireExtinguishSound());
+		$this->position->getWorld()->setBlock($this->position, $this->setLit(false));
+	}
+
+	private function ignite() : void{
+		$this->position->getWorld()->addSound($this->position, new FlintSteelSound());
+		$this->position->getWorld()->setBlock($this->position, $this->setLit(true));
+		$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, self::UPDATE_INTERVAL_TICKS);
+	}
+}

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;
 	}
@@ -88,19 +79,11 @@ class CaveVines extends Flowable{
 	}
 
 	private function canBeSupportedAt(Block $block) : bool{
-		return $block->getAdjacentSupportType(Facing::UP)->equals(SupportType::FULL()) || $block->hasSameTypeId($this);
-	}
-
-	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this)){
-			$this->position->getWorld()->useBreakOn($this->position);
-		}
+		$supportBlock = $block->getSide(Facing::UP);
+		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);
 	}
@@ -176,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,174 @@
+<?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 = [];
+
+	private ?ChiseledBookshelfSlot $lastInteractedSlot = null;
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->horizontalFacing($this->facing);
+		$w->enumSet($this->slots, ChiseledBookshelfSlot::cases());
+	}
+
+	public function readStateFromWorld() : Block{
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileChiseledBookshelf){
+			$this->lastInteractedSlot = $tile->getLastInteractedSlot();
+		}else{
+			$this->lastInteractedSlot = null;
+		}
+		return $this;
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileChiseledBookshelf){
+			$tile->setLastInteractedSlot($this->lastInteractedSlot);
+		}
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * Returns the last slot interacted by a player or null if no slot has been interacted with yet.
+	 */
+	public function getLastInteractedSlot() : ?ChiseledBookshelfSlot{
+		return $this->lastInteractedSlot;
+	}
+
+	/**
+	 * Sets the last slot interacted by a player.
+	 *
+	 * @return $this
+	 */
+	public function setLastInteractedSlot(?ChiseledBookshelfSlot $lastInteractedSlot) : self{
+		$this->lastInteractedSlot = $lastInteractedSlot;
+		return $this;
+	}
+
+	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);
+			$this->lastInteractedSlot = $slot;
+		}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);
+			$this->lastInteractedSlot = $slot;
+		}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{