Release 4.0.7

form responses should only contain string|int|float|bool|null. Arrays or objects appearing in here are likely malicious.

.gitattributes

@@ -4,6 +4,7 @@
 *.sh text eol=lf
 *.txt text eol=lf
 *.properties text eol=lf
+*.neon text eol=lf
 *.bat text eol=crlf
 *.cmd text eol=crlf
 *.ps1 text eol=crlf

.github/ISSUE_TEMPLATE/bug_report.md

@@ -20,8 +20,9 @@ assignees: ''
 <!-- try the `version` command | LATEST IS NOT A VALID VERSION -->
 * PocketMine-MP:
 * PHP:
+* Using JIT: yes/no (delete as appropriate) <!-- look for the giant yellow warning in the log that says you're using JIT -->
 * Server OS:
-* Game version: PE/Win10 (delete as appropriate)
+* Game version: Android/iOS/Win10/Xbox/PS4/Switch (delete as appropriate)
 
 ### Plugins
 <!--- use the `plugins` command and paste the output below -->

.github/workflows/draft-release.yml

@@ -0,0 +1,83 @@
+name: Draft release
+
+on:
+  push:
+    tags: "*"
+
+jobs:
+  draft:
+    name: Create GitHub draft release
+    if: "startsWith(github.event.head_commit.message, 'Release ')"
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@2.12.0
+        with:
+          php-version: 8.0
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v2
+        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: Calculate build number
+        id: build-number
+        run: |
+          BUILD_NUMBER=$((2000+$GITHUB_RUN_NUMBER)) #to stay above jenkins
+          echo "Build number: $BUILD_NUMBER"
+          echo ::set-output name=BUILD_NUMBER::$BUILD_NUMBER
+
+      - name: Minify BedrockData JSON files
+        run: php vendor/pocketmine/bedrock-data/.minify_json.php
+
+      - name: Build PocketMine-MP.phar
+        run: php -dphar.readonly=0 build/server-phar.php --git ${{ github.sha }} --build ${{ steps.build-number.outputs.BUILD_NUMBER }}
+
+      - name: Get PocketMine-MP release version
+        id: get-pm-version
+        run: |
+          echo ::set-output name=PM_VERSION::$(php -r 'require "vendor/autoload.php"; echo \pocketmine\VersionInfo::BASE_VERSION;')
+          echo ::set-output name=MCPE_VERSION::$(php -r 'require "vendor/autoload.php"; echo \pocketmine\network\mcpe\protocol\ProtocolInfo::MINECRAFT_VERSION_NETWORK;')
+          echo ::set-output name=PM_VERSION_SHORT::$(php -r 'require "vendor/autoload.php"; $v = explode(".", \pocketmine\VersionInfo::BASE_VERSION); array_pop($v); echo implode(".", $v);')
+          echo ::set-output name=PM_VERSION_MD::$(php -r 'require "vendor/autoload.php"; echo str_replace(".", "", \pocketmine\VersionInfo::BASE_VERSION);')
+
+      - name: Generate build info
+        run: php build/generate-build-info-json.php ${{ github.sha }} ${{ steps.get-pm-version.outputs.PM_VERSION }} ${{ github.repository }} ${{ steps.build-number.outputs.BUILD_NUMBER }} > build_info.json
+
+      - name: Upload release artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: release_artifacts
+          path: |
+            ${{ github.workspace }}/PocketMine-MP.phar
+            ${{ github.workspace }}/start.*
+            ${{ github.workspace }}/build_info.json
+
+      - name: Create draft release
+        uses: ncipollo/release-action@v1.8.6
+        with:
+          artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json
+          commit: ${{ github.sha }}
+          draft: true
+          name: PocketMine-MP ${{ steps.get-pm-version.outputs.PM_VERSION }}
+          tag: ${{ steps.get-pm-version.outputs.PM_VERSION }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          body: |
+            **For Minecraft: Bedrock Edition ${{ steps.get-pm-version.outputs.MCPE_VERSION }}**
+
+            Please see the [changelogs](/changelogs/${{ steps.get-pm-version.outputs.PM_VERSION_SHORT }}.md#${{ steps.get-pm-version.outputs.PM_VERSION_MD }}) for details.

.github/workflows/main.yml

@@ -13,20 +13,14 @@ jobs:
     strategy:
       matrix:
         image: [ubuntu-20.04]
-        php: [7.3.28, 7.4.19]
+        php: [8.0.14]
 
     steps:
-      - uses: actions/checkout@v2 #needed for build.sh
-      - name: Check for PHP build cache
-        id: php-build-cache
-        uses: actions/cache@v2
+      - name: Build and prepare PHP cache
+        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
         with:
-          path: "./bin"
-          key: "php-build-generic-${{ matrix.php }}-${{ matrix.image }}-${{ hashFiles('./tests/gh-actions/build.sh') }}"
-
-      - name: Compile PHP
-        if: steps.php-build-cache.outputs.cache-hit != 'true'
-        run: ./tests/gh-actions/build.sh "${{ matrix.php }}"
+          php-version: ${{ matrix.php }}
+          install-path: "./bin"
 
   phpstan:
     name: PHPStan analysis
@@ -37,28 +31,16 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [7.3.28, 7.4.19]
+        php: [8.0.14]
 
     steps:
       - uses: actions/checkout@v2
 
-      - name: Restore PHP build cache
-        id: php-build-cache
-        uses: actions/cache@v2
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
         with:
-          path: "./bin"
-          key: "php-build-generic-${{ matrix.php }}-${{ matrix.image }}-${{ hashFiles('./tests/gh-actions/build.sh') }}"
-
-      - name: Kill build on PHP build cache miss (should never happen)
-        if: steps.php-build-cache.outputs.cache-hit != 'true'
-        run: exit 1
-
-      - name: Install cached PHP's dependencies
-        if: steps.php-build-cache.outputs.cache-hit == 'true'
-        run: ./tests/gh-actions/install-dependencies.sh
-
-      - name: Prefix PHP to PATH
-        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+          php-version: ${{ matrix.php }}
+          install-path: "./bin"
 
       - name: Install Composer
         run: curl -sS https://getcomposer.org/installer | php
@@ -87,28 +69,16 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [7.3.28, 7.4.19]
+        php: [8.0.14]
 
     steps:
       - uses: actions/checkout@v2
 
-      - name: Restore PHP build cache
-        id: php-build-cache
-        uses: actions/cache@v2
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
         with:
-          path: "./bin"
-          key: "php-build-generic-${{ matrix.php }}-${{ matrix.image }}-${{ hashFiles('./tests/gh-actions/build.sh') }}"
-
-      - name: Kill build on PHP build cache miss (should never happen)
-        if: steps.php-build-cache.outputs.cache-hit != 'true'
-        run: exit 1
-
-      - name: Install cached PHP's dependencies
-        if: steps.php-build-cache.outputs.cache-hit == 'true'
-        run: ./tests/gh-actions/install-dependencies.sh
-
-      - name: Prefix PHP to PATH
-        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+          php-version: ${{ matrix.php }}
+          install-path: "./bin"
 
       - name: Install Composer
         run: curl -sS https://getcomposer.org/installer | php
@@ -137,30 +107,18 @@ jobs:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [7.3.28, 7.4.19]
+        php: [8.0.14]
 
     steps:
       - uses: actions/checkout@v2
         with:
           submodules: true
 
-      - name: Restore PHP build cache
-        id: php-build-cache
-        uses: actions/cache@v2
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
         with:
-          path: "./bin"
-          key: "php-build-generic-${{ matrix.php }}-${{ matrix.image }}-${{ hashFiles('./tests/gh-actions/build.sh') }}"
-
-      - name: Kill build on PHP build cache miss (should never happen)
-        if: steps.php-build-cache.outputs.cache-hit != 'true'
-        run: exit 1
-
-      - name: Install cached PHP's dependencies
-        if: steps.php-build-cache.outputs.cache-hit == 'true'
-        run: ./tests/gh-actions/install-dependencies.sh
-
-      - name: Prefix PHP to PATH
-        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+          php-version: ${{ matrix.php }}
+          install-path: "./bin"
 
       - name: Install Composer
         run: curl -sS https://getcomposer.org/installer | php
@@ -181,38 +139,24 @@ jobs:
       - name: Run integration tests
         run: ./tests/travis.sh -t4
 
-  preprocessor:
-    name: Preprocessor tests
+  codegen:
+    name: Generated Code consistency checks
     needs: build-php
     runs-on: ${{ matrix.image }}
     strategy:
       fail-fast: false
       matrix:
         image: [ubuntu-20.04]
-        php: [7.3.28, 7.4.19]
+        php: [8.0.14]
 
     steps:
       - uses: actions/checkout@v2
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@e232f72a4330a07aae8418e8aa56b64efcdda636
         with:
-          submodules: true
-
-      - name: Restore PHP build cache
-        id: php-build-cache
-        uses: actions/cache@v2
-        with:
-          path: "./bin"
-          key: "php-build-generic-${{ matrix.php }}-${{ matrix.image }}-${{ hashFiles('./tests/gh-actions/build.sh') }}"
-
-      - name: Kill build on PHP build cache miss (should never happen)
-        if: steps.php-build-cache.outputs.cache-hit != 'true'
-        run: exit 1
-
-      - name: Install cached PHP's dependencies
-        if: steps.php-build-cache.outputs.cache-hit == 'true'
-        run: ./tests/gh-actions/install-dependencies.sh
-
-      - name: Prefix PHP to PATH
-        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+          php-version: ${{ matrix.php }}
+          install-path: "./bin"
 
       - name: Install Composer
         run: curl -sS https://getcomposer.org/installer | php
@@ -230,37 +174,16 @@ jobs:
       - name: Install Composer dependencies
         run: php composer.phar install --no-dev --prefer-dist --no-interaction
 
-      - name: Run preprocessor
+      - 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: Verify code is unchanged
         run: |
-          PM_PREPROCESSOR_PATH="$GITHUB_WORKSPACE/build/preprocessor"
-          php "$PM_PREPROCESSOR_PATH/PreProcessor.php" --path=src --multisize || (echo "Preprocessor exited with code $?" && exit 1)
-
-          #dump the diff of preprocessor replacements to a patch in case it has bugs
-          git diff > preprocessor_diff.patch
-
-          VENDOR_PM="$GITHUB_WORKSPACE/vendor"
-          VENDOR_PM_BACKUP="$GITHUB_WORKSPACE/vendor-before-preprocess"
-          cp -r "$VENDOR_PM" "$VENDOR_PM_BACKUP"
-          for f in $(ls $VENDOR_PM/pocketmine); do
-            echo "Processing directory \"$f\"..."
-            php "$PM_PREPROCESSOR_PATH/PreProcessor.php" --path="$VENDOR_PM/pocketmine/$f" --multisize || (echo "Preprocessor exited with code $?" && exit 1)
-            echo "Checking for changes in \"$f\"..."
-            DIFF=$(git diff --no-index "$VENDOR_PM_BACKUP/pocketmine/$f" "$VENDOR_PM/pocketmine/$f" || true)
-            if [ "$DIFF" != "" ]; then
-              PATCH="$GITHUB_WORKSPACE/preprocessor_diff_$f.patch"
-              echo "$DIFF" > "$PATCH"
-              echo "Generated patch file \"$PATCH\""
-            else
-              echo "No diff generated for \"$f\" (preprocessor made no changes)"
-            fi
-          done
-
-      - name: Upload preprocessor diffs
-        uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: preprocessor_diffs_${{ matrix.php }}_${{ matrix.image }}
-          path: ${{ github.workspace }}/preprocessor_diff*.patch
+          git diff
+          git diff --quiet
 
   codestyle:
     name: Code Style checks
@@ -272,10 +195,10 @@ jobs:
       - uses: actions/checkout@v2
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.9.0
+        uses: shivammathur/setup-php@2.15.0
         with:
-          php-version: 7.4
-          tools: php-cs-fixer
+          php-version: 8.0
+          tools: php-cs-fixer:3.2
 
       - name: Run PHP-CS-Fixer
-        run: php-cs-fixer fix --dry-run --diff
+        run: php-cs-fixer fix --dry-run --diff --ansi

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

@@ -22,8 +22,6 @@
 declare(strict_types=1);
 
 const VERSIONS = [
-	"7.3",
-	"7.4",
 	"8.0"
 ];
 

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

@@ -0,0 +1,45 @@
+name: Update update.pmmp.io API info
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install jq
+        run: sudo apt update && sudo apt install jq -y
+
+      - uses: actions/checkout@v2
+        with:
+          repository: pmmp/update.pmmp.io
+          ssh-key: ${{ secrets.UPDATE_PMMP_IO_DEPLOY_KEY }}
+
+      - name: Get actual tag name
+        id: tag-name
+        run: echo ::set-output name=TAG_NAME::$(echo "${{ github.ref }}" | sed 's{^refs/tags/{{')
+
+      - name: Download new release information
+        run: curl -f -L ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ steps.tag-name.outputs.TAG_NAME }}/build_info.json -o new_build_info.json
+
+      - name: Detect channel
+        id: channel
+        run: echo ::set-output name=CHANNEL::$(jq -r '.channel' new_build_info.json)
+
+      - name: Copy release information
+        run: |
+          cp new_build_info.json channels/${{ steps.channel.outputs.CHANNEL }}.json
+          rm new_build_info.json
+
+      - name: Commit changes
+        run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git add .
+          git diff-index --quiet HEAD || git commit -m "New ${{ steps.channel.outputs.CHANNEL }} release: ${{ github.repository }} ${{ steps.tag-name.outputs.TAG_NAME }}"
+
+      - name: Push changes
+        run: git push

.gitignore

@@ -1,5 +1,7 @@
 players/*
 worlds/*
+world_conversion_backups/*
+backups/*
 plugin_data/*
 plugins/*
 bin*/*
@@ -10,6 +12,7 @@ crashdumps/*
 *.phar
 server.properties
 /pocketmine.yml
+/plugin_list.yml
 memory_dumps/*
 resource_packs/
 server.lock

.gitmodules

@@ -1,15 +1,6 @@
-[submodule "src/pocketmine/lang/locale"]
-	path = src/pocketmine/lang/locale
-	url = https://github.com/pmmp/Language.git
-[submodule "tests/preprocessor"]
-	path = build/preprocessor
-	url = https://github.com/pmmp/preprocessor.git
 [submodule "tests/plugins/DevTools"]
 	path = tests/plugins/DevTools
 	url = https://github.com/pmmp/DevTools.git
 [submodule "build/php"]
 	path = build/php
 	url = https://github.com/pmmp/php-build-scripts.git
-[submodule "src/pocketmine/resources/vanilla"]
-	path = src/pocketmine/resources/vanilla
-	url = https://github.com/pmmp/BedrockData.git

.php-cs-fixer.php

@@ -4,9 +4,8 @@ $finder = PhpCsFixer\Finder::create()
 	->in(__DIR__ . '/src')
 	->in(__DIR__ . '/build')
 	->in(__DIR__ . '/tests')
+	->in(__DIR__ . '/tools')
 	->notPath('plugins/DevTools')
-	->notPath('preprocessor')
-	->notContains('#ifndef COMPILE') //preprocessor will break if these are changed
 	->notName('PocketMine.php');
 
 return (new PhpCsFixer\Config)
@@ -19,6 +18,9 @@ return (new PhpCsFixer\Config)
 		'array_syntax' => [
 			'syntax' => 'short'
 		],
+		'binary_operator_spaces' => [
+			'default' => 'single_space'
+		],
 		'blank_line_after_namespace' => true,
 		'blank_line_after_opening_tag' => true,
 		'blank_line_before_statement' => [
@@ -34,6 +36,7 @@ return (new PhpCsFixer\Config)
 		],
 		'declare_strict_types' => true,
 		'elseif' => true,
+		'fully_qualified_strict_types' => true,
 		'global_namespace_import' => [
 			'import_constants' => true,
 			'import_functions' => true,
@@ -41,7 +44,8 @@ return (new PhpCsFixer\Config)
 		],
 		'indentation_type' => true,
 		'native_function_invocation' => [
-		    'scope' => 'namespaced'
+			'scope' => 'namespaced',
+			'include' => ['@all'],
 		],
 		'no_closing_tag' => true,
 		'no_empty_phpdoc' => true,
@@ -61,10 +65,20 @@ return (new PhpCsFixer\Config)
 			],
 			'sort_algorithm' => 'alpha'
 		],
+		'phpdoc_line_span' => [
+			'property' => 'single',
+			'method' => null,
+			'const' => null
+		],
 		'phpdoc_trim' => true,
 		'phpdoc_trim_consecutive_blank_line_separation' => true,
+		'return_type_declaration' => [
+			'space_before' => 'one'
+		],
+		'single_blank_line_at_eof' => true,
 		'single_import_per_statement' => true,
 		'strict_param' => true,
+		'unary_operator_spaces' => true,
 	])
 	->setFinder($finder)
 	->setIndent("\t")

BUILDING.md

@@ -2,32 +2,27 @@
 ## Pre-requisites
 - A bash shell (git bash is sufficient for Windows)
 - [`git`](https://git-scm.com) available in your shell
-- PHP 7.3 or newer available in your shell
+- PHP 8.0 or newer available in your shell
 - [`composer`](https://getcomposer.org) available in your shell
 
 ## Custom PHP binaries
 Because PocketMine-MP requires several non-standard PHP extensions and configuration, PMMP provides scripts to build custom binaries for running PocketMine-MP, as well as prebuilt binaries.
 
-- [Prebuilt binaries](https://jenkins.pmmp.io/job/PHP-7.4-Aggregate)
+- [Prebuilt binaries](https://jenkins.pmmp.io/job/PHP-8.0-Aggregate)
 - [Compile scripts](https://github.com/pmmp/php-build-scripts) are provided as a submodule in the path `build/php`
 
 If you use a custom binary, you'll need to replace `composer` usages in this guide with `path/to/your/php path/to/your/composer.phar`.
 
 ## Setting up environment
-1. `git clone --recursive https://github.com/pmmp/PocketMine-MP.git`
+1. `git clone https://github.com/pmmp/PocketMine-MP.git`
 2. `composer install`
 
 ## Checking out a different branch to build
 1. `git checkout <branch to checkout>`
-2. `git submodule update --init`
-3. Re-run `composer install` to synchronize dependencies.
+2. Re-run `composer install` to synchronize dependencies.
 
 ## Optimizing for release builds
 1. Add the flags `--no-dev --classmap-authoritative` to your `composer install` command. This will reduce build size and improve autoloading speed.
-2. Preprocess the source code by running `build/preprocessor/PreProcessor.php`. Usage instructions are provided in `build/preprocessor/README.md`.
-
-### Note
-Preprocessor requires that the `cpp` (c preprocessor) is available in your PATH.
 
 ## Building `PocketMine-MP.phar`
 Run `composer make-server` using your preferred PHP binary. It'll drop a `PocketMine-MP.phar` into the current working directory.
@@ -38,7 +33,7 @@ There is a bug in PHP that might cause an error which looks like this:
 ```
 Fatal error: Uncaught BadMethodCallException: unable to create temporary file in PocketMine-MP/build/server-phar.php:119
 ```
-You can work around it by setting `ulimit -n` to some bigger number, e.g. `8192`, or by updating your PHP version to at least 7.4.16 or 8.0.3.
+You can work around it by setting `ulimit -n` to some bigger number, e.g. `8192`, or by updating your PHP version to at least 8.0.3.
 
 ## Running PocketMine-MP from source code
-Run `src/pocketmine/PocketMine.php` using your preferred PHP binary.
+Run `src/PocketMine.php` using your preferred PHP binary.

CONTRIBUTING.md

@@ -2,125 +2,102 @@
 
 # PocketMine-MP Contribution Guidelines
 
+PocketMine-MP is an open source project, and contributions from the community are welcomed, as long as they comply with our quality standards and licensing.
 
-## Creating an Issue
-- If you are reporting a bug:
-  - **make sure that you are using the latest supported version** before opening an issue.
-  - **test it on a clean test server, WITHOUT PLUGINS**, to see if the issue still occurs. If not then it may be a plugin issue. Please also indicate the result of such tests.
-- **[Search the issue tracker](https://github.com/pmmp/PocketMine-MP/issues?utf8=%E2%9C%93&q=is%3Aissue)** to check if anyone has already reported it, to avoid needlessly creating duplicate issues. Make sure you also check closed issues, as an issue you think is valid may already have been resolved.
-- **Do not report plugin issues here.** If your issue is related to a plugin, contact the plugin's original author instead.
-- **Support requests are not bugs.** Issues such as "How do I do this" are not bugs and will be closed. If you need help, please see [here](README.md#discussion) and do not misuse our issue tracker.
-- **No generic titles** such as "Question", "Help", "Crash Report" etc. A good issue report provides a quick summary in the title. If you just got a crash report but you don't understand it, please look for a line starting with `Message`. It summarizes the bug.
-- **Provide information in the issue body, not in the title.** No tags like `[BUG]` are allowed in the title, including `[SOLVED]` for solved issues.
-- **No generic issue reports.** For bugs, it is the issue author's responsibility to provide us an issue that is **trackable, debuggable, reproducible, reported professionally and is an actual bug**.
-<br>Valid issue reports must include instructions how to reproduce the issue or a crashdump/backtrace (unless the cause of the issue is obvious).
-<br>**If you do not provide us with a summary or instructions on how to reproduce the issue, it will be treated as spam and will therefore be closed.**
-<br>In simple words, if the issue cannot be properly confirmed to be valid or lacks required information, the issue will be closed until further information is provided.
-- To express appreciation, objection, confusion or other supported reactions on pull requests, issues or comments on them, use GitHub [reactions](https://github.com/blog/2119-add-reactions-to-pull-requests-issues-and-comments) rather than posting an individual comment with an emoji only. This helps keeping the issue/pull request conversation clean and readable.
-- If your issue is related to the PocketMine-MP website, forums, etc., please [talk to a human directly](README.md#discussion).
+Code contributions must be submitted using [GitHub Pull Requests](https://github.com/pmmp/PocketMine-MP/pulls), where they will be reviewed by maintainers.
 
+Small contributions (e.g. minor bug fixes) can be submitted as pull requests directly.
 
+Larger contributions like feature additions should be preceded by a [Change Proposal](#rfcs--change-proposals) to allow maintainers and other people to discuss and decide if it's a good idea or not.
 
-## Contributing
-To contribute to the repository, [fork it on GitHub](https://github.com/pmmp/PocketMine-MP/fork), create a branch on your fork, and make your changes on your fork. You can then make a [pull request](https://github.com/pmmp/PocketMine-MP/pull/new) to the project to compare your branch to ours and propose your changes to our repository. We use the Pull Request system to allow members of the team to review changes before they are merged.
+## Useful documentation from github.com
+- [About pull requests](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests)
+- [About forks](https://docs.github.com/en/github/collaborating-with-pull-requests/working-with-forks/about-forks)
+- [Creating a pull request from a fork](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork)
 
-### Licensing
-By proposing a pull request to the project, you agree to your code being distributed within PocketMine-MP under the [LGPL license](LICENSE).
+## Other things you'll need
+- [git](https://git-scm.com/)
 
-### Contribution standards
-- **We enforce a very high standard for contributions**. This is because PocketMine-MP and its related projects are used very widely in production. While this might seem like we are being mean at times, **our priority is what is best for PocketMine-MP itself**.
-We try to ensure that our project's codebase is as clean as possible and ensure that only top-quality material makes it through to PocketMine-MP itself.
-- **If a contribution does not meet our standards, changes may be requested or the pull request may be closed.**
+## Making a pull request
+The basic procedure to create a pull request is:
+1. [Fork the repository on GitHub](https://github.com/pmmp/PocketMine-MP/fork). This gives you your own copy of the repository to make changes to.
+2. Create a branch on your fork for your changes.
+3. Make the changes you want to make on this branch.
+4. You can then make a [pull request](https://github.com/pmmp/PocketMine-MP/pull/new) to the project.
 
-### Pull requests
-- **Create a new branch for each pull request.** Do not create a pull request with commits that exist in another pull request.
+## Pull request reviews
+Pull requests will be reviewed by maintainers when they are available.
+Note that there might be a long wait time before a reviewer looks at your PR.
+
+Depending on the changes, maintainers might ask you to make changes to the PR to fix problems or to improve the code.
+**Do not delete your fork** while your pull request remains open, otherwise you won't be able to make any requested changes and the PR will end up being declined.
+
+### 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.
+
+### Recommendations
+
+- **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.
+- **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.
 - **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.
-- **It is inadvisable to create large pull requests with lots of changes** unless this has been discussed with the team beforehand. Large pull requests are difficult to review, and such pull requests may end up being closed. The only exception is when all features in the pull request are related to each other, and share the same core changes.
-- **You may be asked to rebase your pull request** if the branch becomes outdated and/or if possibly conflicting changes are made to the target branch. To see how to do this, read [this page](https://github.com/edx/edx-platform/wiki/How-to-Rebase-a-Pull-Request).
-- **Details should be provided of tests done.** Simply saying "Tested" or equivalent is not acceptable.
-
-### Code contributions
-- **Avoid committing changes directly on GitHub. This includes use of the web editor, and also uploading files.** The web editor lacks most useful GIT features and **should only be used for very minor changes**. It is immediately clear if the web editor has been used, and if so the PR is more likely to be rejected. If you want to make serious contributions, **please learn how to use [GIT version control](https://git-scm.com/)**.
-- **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. **Cherry-picking is the politer way to copy somebody's changes** and retains all the original accreditation, so there is no need for copy-pasted commits with descriptions like `Some code, thanks @exampleperson`.
-- **Make sure you can explain your changes**. If you can't provide a good explanation of changes, your PR may be rejected.
-- **Code should use the same style as in PocketMine-MP.** See [below](#code-syntax) for an example.
-- **The code must be clear** and written in English, comments included.
+- **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.
 
 
 **Thanks for contributing to PocketMine-MP!**
 
+## RFCs / Change Proposals
+Change Proposals are issues or discussions which describe a new feature proposal or behavioural change.
+They are used to get feedback from maintainers and the community about an idea for a change, to decide whether or not it's a good idea.
 
+### Submitting an RFC
+RFCs should be submitted using Issues or Discussions.
+RFCs _can_ be submitted as pull requests if you've already written the code, but this is not recommended, since it's not guaranteed that an RFC will pass, in which case your effort would be wasted.
 
-### Code Syntax
+RFCs should include the following:
+- A summary of what you want to change
+- Why you want to change it (e.g. what problems it solves)
+- Alternative methods you've considered to solve the problem. This should include any possible ways that what you want can be done without the change.
 
-It is mainly [PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md) with a few exceptions.
+### Voting on RFCs
+Community members can vote on RFCs. This gives maintainers an idea of how popular the idea is.
+Votes can be cast using :+1: and :-1: reactions.
 
-- Opening braces MUST go on the same line, and MUST NOT have spaces before.
-- `else if` MUST be written as `elseif`. _(It is in PSR-2, but using a SHOULD)_
-- Control structure keywords or opening braces MUST NOT have one space before or after them.
-- Code MUST use tabs for indenting.
-- Long arrays MAY be split across multiple lines, where each subsequent line is indented once.
-- Files MUST use only the `<?php` tag.
-- Files MUST NOT have an ending `?>` tag.
-- Code MUST use namespaces.
-- Strings SHOULD use the double quote `"` except when the single quote is required.
-- All code SHOULD have parameter and type declarations where possible.
-- Strict types SHOULD be enabled on new files where it is sensible to do so.
-- All constant declarations SHOULD be preceded by a visibility modifier.
+**Please don't downvote without providing a reason why!**
 
-```php
-<?php
+### Implementing RFCs
+Anyone can write the code to implement an RFC, and submit a pull request for it. It doesn't have to be the RFC author.
 
-declare(strict_types=1);
-
-namespace pocketmine\example;
-
-class ExampleClass{
-
-	public const EXAMPLE_CLASS_CONSTANT = 1;
-
-	public $examplePublicVariable = "defaultValue";
-	private $examplePrivateVariable;
-
-	/**
-	 * Creates an instance of ExampleClass
-	 *
-	 * @param string      $firstArgument  the first argument
-	 * @param string|null $secondArgument default null
-	 */
-	public function __construct(string $firstArgument, ?string &$secondArgument = null){
-		if($firstArgument === "exampleValue"){ //Remember to use === instead of == when possible
-			//do things
-		}elseif($firstArgument === "otherValue"){
-			$secondArgument = function(){
-				$this->examplePrivateVariable = [
-					0 => "value1",
-					1 => "value2",
-					2 => "value3",
-					3 => "value4",
-					4 => "value5",
-					5 => "value6",
-				];
-			};
-		}
-	}
-
-	public function doStuff(string $stuff) : string{
-		return $stuff;
-	}
-}
-```
-
-<!-- TODO: RFC and voting on the forums instead -->
-### RFC and Voting
-* These are big Pull Requests or contributions that change important behavior.
-* RFCs will be tagged with the *Type: Request For Comments* label
-* A vote will be held once the RFC is ready. All users can vote commenting on the Pull Request
-* Comments MUST use "Yes" or "No" on the FIRST sentence to signify the vote, except when they don't want it to be counted.
-* If your comment is a voting comment, specify the reason of your vote or it won't be counted.
-* After voting has been closed, no further votes will be counted.
-* An RFC will be rejected if less than 50% + 1 (simple majority) has voted Yes.
-* If the RFC is approved, Team Members have the final word on its implementation or rejection.
-* RFCs with complex voting options will specify the vote percentage or other details.
+Implementations should be submitted as pull requests. The pull request description must include a link to the RFC.

README.md

@@ -4,10 +4,13 @@
 </p>
 
 <p align="center">
-	<img src="https://github.com/pmmp/PocketMine-MP/workflows/CI/badge.svg" alt="CI" />
-	<a href="https://github.com/pmmp/PocketMine-MP/releases"><img src="https://img.shields.io/github/v/tag/pmmp/PocketMine-MP?label=release&logo=github" alt="GitHub tag (latest semver)" /></a>
+	<a href="https://github.com/pmmp/PocketMine-MP/actions/workflows/main.yml"><img src="https://github.com/pmmp/PocketMine-MP/workflows/CI/badge.svg" alt="CI" /></a>
+	<a href="https://github.com/pmmp/PocketMine-MP/releases/latest"><img alt="GitHub release (latest SemVer)" src="https://img.shields.io/github/v/release/pmmp/PocketMine-MP?label=release&sort=semver"></a>
 	<a href="https://hub.docker.com/r/pmmp/pocketmine-mp"><img src="https://img.shields.io/docker/v/pmmp/pocketmine-mp?logo=docker&label=image" alt="Docker image version (latest semver)" /></a>
 	<a href="https://discord.gg/bmSAZBG"><img src="https://img.shields.io/discord/373199722573201408?label=discord&color=7289DA&logo=discord" alt="Discord" /></a>
+	<br>
+	<a href="https://github.com/pmmp/PocketMine-MP/releases"><img alt="GitHub all releases" src="https://img.shields.io/github/downloads/pmmp/PocketMine-MP/total?label=downloads%40total"></a>
+	<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

SECURITY.md

@@ -1,13 +1,5 @@
 # Security Policy
 
-## Supported Versions
-The following release lines are currently receiving active security updates and bug fixes:
-
-| Version  | Supported          |
-| -------- | ------------------ |
-| 3.15.x   | :white_check_mark: |
-| < 3.15.0 | :x:                |
-
 ## Reporting a Vulnerability
 
 **DO NOT report vulnerabilities on the GitHub issue tracker.**

build/generate-build-info-json.php

@@ -0,0 +1,43 @@
+<?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);
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+if(count($argv) !== 5){
+	fwrite(STDERR, "required args: <git hash> <tag name> <github repo (owner/name)> <build number>");
+	exit(1);
+}
+
+echo json_encode([
+	"php_version" => sprintf("%d.%d", PHP_MAJOR_VERSION, PHP_MINOR_VERSION),
+	"base_version" => \pocketmine\VersionInfo::BASE_VERSION,
+	"build" => (int) $argv[4],
+	"is_dev" => \pocketmine\VersionInfo::IS_DEVELOPMENT_BUILD,
+	"channel" => \pocketmine\VersionInfo::BUILD_CHANNEL,
+	"git_commit" => $argv[1],
+	"mcpe_version" => \pocketmine\network\mcpe\protocol\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",
+	"source_url" => "https://github.com/$argv[3]/tree/$argv[2]",
+], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . "\n";

build/generate-known-translation-apis.php

@@ -0,0 +1,193 @@
+<?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_known_translation_apis;
+
+use pocketmine\lang\Translatable;
+use pocketmine\utils\Utils;
+use Webmozart\PathUtil\Path;
+use function array_map;
+use function count;
+use function dirname;
+use function file_put_contents;
+use function fwrite;
+use function implode;
+use function is_numeric;
+use function ksort;
+use function ob_get_clean;
+use function ob_start;
+use function parse_ini_file;
+use function preg_match_all;
+use function str_replace;
+use function strtoupper;
+use const INI_SCANNER_RAW;
+use const SORT_NUMERIC;
+use const SORT_STRING;
+use const STDERR;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+function constantify(string $permissionName) : string{
+	return strtoupper(str_replace([".", "-"], "_", $permissionName));
+}
+
+function functionify(string $permissionName) : string{
+	return str_replace([".", "-"], "_", $permissionName);
+}
+
+const SHARED_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);
+
+namespace pocketmine\lang;
+
+
+HEADER;
+
+/**
+ * @param string[] $languageDefinitions
+ * @phpstan-param array<string, string> $languageDefinitions
+ */
+function generate_known_translation_keys(array $languageDefinitions) : void{
+	ob_start();
+
+	echo SHARED_HEADER;
+	echo <<<'HEADER'
+/**
+ * This class contains constants for all the translations known to PocketMine-MP as per the used version of pmmp/Language.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationKeys{
+
+HEADER;
+
+	ksort($languageDefinitions, SORT_STRING);
+	foreach(Utils::stringifyKeys($languageDefinitions) as $k => $_){
+		echo "\tpublic const ";
+		echo constantify($k);
+		echo " = \"" . $k . "\";\n";
+	}
+
+	echo "}\n";
+
+	file_put_contents(dirname(__DIR__) . '/src/lang/KnownTranslationKeys.php', ob_get_clean());
+
+	echo "Done generating KnownTranslationKeys.\n";
+}
+
+/**
+ * @param string[] $languageDefinitions
+ * @phpstan-param array<string, string> $languageDefinitions
+ */
+function generate_known_translation_factory(array $languageDefinitions) : void{
+	ob_start();
+
+	echo SHARED_HEADER;
+	echo <<<'HEADER'
+/**
+ * This class contains factory methods for all the translations known to PocketMine-MP as per the used version of
+ * pmmp/Language.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationFactory{
+
+HEADER;
+	ksort($languageDefinitions, SORT_STRING);
+
+	$parameterRegex = '/{%(.+?)}/';
+
+	$translationContainerClass = (new \ReflectionClass(Translatable::class))->getShortName();
+	foreach(Utils::stringifyKeys($languageDefinitions) as $key => $value){
+		$parameters = [];
+		$allParametersPositional = true;
+		if(preg_match_all($parameterRegex, $value, $matches) > 0){
+			foreach($matches[1] as $parameterName){
+				if(is_numeric($parameterName)){
+					$parameters[$parameterName] = "param$parameterName";
+				}else{
+					$parameters[$parameterName] = $parameterName;
+					$allParametersPositional = false;
+				}
+			}
+		}
+		if($allParametersPositional){
+			ksort($parameters, SORT_NUMERIC);
+		}
+		echo "\tpublic static function " .
+			functionify($key) .
+			"(" . implode(", ", array_map(fn(string $paramName) => "$translationContainerClass|string \$$paramName", $parameters)) . ") : $translationContainerClass{\n";
+		echo "\t\treturn new $translationContainerClass(KnownTranslationKeys::" . constantify($key) . ", [";
+		foreach($parameters as $parameterKey => $parameterName){
+			echo "\n\t\t\t";
+			if(!is_numeric($parameterKey)){
+				echo "\"$parameterKey\"";
+			}else{
+				echo $parameterKey;
+			}
+			echo " => \$$parameterName,";
+		}
+		if(count($parameters) !== 0){
+			echo "\n\t\t";
+		}
+		echo "]);\n\t}\n\n";
+	}
+
+	echo "}\n";
+
+	file_put_contents(dirname(__DIR__) . '/src/lang/KnownTranslationFactory.php', ob_get_clean());
+
+	echo "Done generating KnownTranslationFactory.\n";
+}
+
+$lang = parse_ini_file(Path::join(\pocketmine\LOCALE_DATA_PATH, "eng.ini"), false, INI_SCANNER_RAW);
+if($lang === false){
+	fwrite(STDERR, "Missing language files!\n");
+	exit(1);
+}
+
+generate_known_translation_keys($lang);
+generate_known_translation_factory($lang);

build/generate-registry-annotations.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\build\update_registry_annotations;
+
+use function basename;
+use function class_exists;
+use function count;
+use function dirname;
+use function file_get_contents;
+use function file_put_contents;
+use function implode;
+use function ksort;
+use function mb_strtoupper;
+use function preg_match;
+use function sprintf;
+use function str_replace;
+use function substr;
+use const SORT_STRING;
+
+if(count($argv) !== 2){
+	die("Provide a path to process");
+}
+
+/**
+ * @param object[] $members
+ */
+function generateMethodAnnotations(string $namespaceName, array $members) : string{
+	$selfName = basename(__FILE__);
+	$lines = ["/**"];
+	$lines[] = " * This doc-block is generated automatically, do not modify it manually.";
+	$lines[] = " * This must be regenerated whenever registry members are added, removed or changed.";
+	$lines[] = " * @see build/$selfName";
+	$lines[] = " * @generate-registry-docblock";
+	$lines[] = " *";
+
+	static $lineTmpl = " * @method static %2\$s %s()";
+	$memberLines = [];
+	foreach($members as $name => $member){
+		$reflect = new \ReflectionClass($member);
+		while($reflect !== false and $reflect->isAnonymous()){
+			$reflect = $reflect->getParentClass();
+		}
+		if($reflect === false){
+			$typehint = "object";
+		}elseif($reflect->getNamespaceName() === $namespaceName){
+			$typehint = $reflect->getShortName();
+		}else{
+			$typehint = '\\' . $reflect->getName();
+		}
+		$accessor = mb_strtoupper($name);
+		$memberLines[$accessor] = sprintf($lineTmpl, $accessor, $typehint);
+	}
+	ksort($memberLines, SORT_STRING);
+
+	foreach($memberLines as $line){
+		$lines[] = $line;
+	}
+	$lines[] = " */";
+	return implode("\n", $lines);
+}
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($argv[1], \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_PATHNAME)) as $file){
+	if(substr($file, -4) !== ".php"){
+		continue;
+	}
+	$contents = file_get_contents($file);
+	if($contents === false){
+		throw new \RuntimeException("Failed to get contents of $file");
+	}
+
+	if(preg_match("/(*ANYCRLF)^namespace (.+);$/m", $contents, $matches) !== 1 || preg_match('/(*ANYCRLF)^((final|abstract)\s+)?class /m', $contents) !== 1){
+		continue;
+	}
+	$shortClassName = basename($file, ".php");
+	$className = $matches[1] . "\\" . $shortClassName;
+	if(!class_exists($className)){
+		continue;
+	}
+	$reflect = new \ReflectionClass($className);
+	$docComment = $reflect->getDocComment();
+	if($docComment === false || preg_match("/(*ANYCRLF)^\s*\*\s*@generate-registry-docblock$/m", $docComment) !== 1){
+		continue;
+	}
+	echo "Found registry in $file\n";
+
+	$replacement = generateMethodAnnotations($matches[1], $className::getAll());
+
+	$newContents = str_replace($docComment, $replacement, $contents);
+	if($newContents !== $contents){
+		echo "Writing changed file $file\n";
+		file_put_contents($file, $newContents);
+	}else{
+		echo "No changes made to file $file\n";
+	}
+}

build/make-release.php

@@ -23,66 +23,123 @@ declare(strict_types=1);
 
 namespace pocketmine\build\make_release;
 
+use pocketmine\utils\Utils;
 use pocketmine\utils\VersionString;
+use pocketmine\VersionInfo;
+use function array_keys;
+use function array_map;
 use function dirname;
 use function fgets;
 use function file_get_contents;
 use function file_put_contents;
+use function fwrite;
+use function getopt;
+use function is_string;
+use function max;
 use function preg_replace;
 use function sleep;
 use function sprintf;
+use function str_pad;
+use function strlen;
 use function system;
-use const pocketmine\BASE_VERSION;
+use const STDERR;
 use const STDIN;
+use const STDOUT;
+use const STR_PAD_LEFT;
 
 require_once dirname(__DIR__) . '/vendor/autoload.php';
 
-function replaceVersion(string $versionInfoPath, string $newVersion, bool $isDev) : void{
+function replaceVersion(string $versionInfoPath, string $newVersion, bool $isDev, string $channel) : void{
 	$versionInfo = file_get_contents($versionInfoPath);
 	$versionInfo = preg_replace(
-		$pattern = '/^const BASE_VERSION = "(\d+)\.(\d+)\.(\d+)(?:-(.*))?";$/m',
-		'const BASE_VERSION = "' . $newVersion . '";',
+		$pattern = '/^([\t ]*public )?const BASE_VERSION = "(\d+)\.(\d+)\.(\d+)(?:-(.*))?";$/m',
+		'$1const BASE_VERSION = "' . $newVersion . '";',
 		$versionInfo
 	);
 	$versionInfo = preg_replace(
-		'/^const IS_DEVELOPMENT_BUILD = (?:true|false);$/m',
-		'const IS_DEVELOPMENT_BUILD = ' . ($isDev ? 'true' : 'false') . ';',
+		'/^([\t ]*public )?const IS_DEVELOPMENT_BUILD = (?:true|false);$/m',
+		'$1const IS_DEVELOPMENT_BUILD = ' . ($isDev ? 'true' : 'false') . ';',
+		$versionInfo
+	);
+	$versionInfo = preg_replace(
+		'/^([\t ]*public )?const BUILD_CHANNEL = ".*";$/m',
+		'$1const BUILD_CHANNEL = "' . $channel . '";',
 		$versionInfo
 	);
 	file_put_contents($versionInfoPath, $versionInfo);
 }
 
-/**
- * @param string[] $argv
- * @phpstan-param list<string> $argv
- */
-function main(array $argv) : void{
-	if(isset($argv[1])){
-		$currentVer = new VersionString($argv[1]);
-	}else{
-		$currentVer = new VersionString(BASE_VERSION);
+const ACCEPTED_OPTS = [
+	"current" => "Version to insert and tag",
+	"next" => "Version to put in the file after tagging",
+	"channel" => "Release channel to post this build into"
+];
+
+function systemWrapper(string $command, string $errorMessage) : void{
+	system($command, $result);
+	if($result !== 0){
+		echo "error: $errorMessage; aborting\n";
+		exit(1);
 	}
+}
+
+function main() : void{
+	$filteredOpts = [];
+	foreach(Utils::stringifyKeys(getopt("", ["current:", "next:", "channel:", "help"])) as $optName => $optValue){
+		if($optName === "help"){
+			fwrite(STDOUT, "Options:\n");
+
+			$maxLength = max(array_map(fn(string $str) => strlen($str), array_keys(ACCEPTED_OPTS)));
+			foreach(ACCEPTED_OPTS as $acceptedName => $description){
+				fwrite(STDOUT, str_pad("--$acceptedName", $maxLength + 4, " ", STR_PAD_LEFT) . ": $description\n");
+			}
+			exit(0);
+		}
+		if(!is_string($optValue)){
+			fwrite(STDERR, "--$optName expects exactly 1 value\n");
+			exit(1);
+		}
+		$filteredOpts[$optName] = $optValue;
+	}
+
+	if(isset($filteredOpts["current"])){
+		$currentVer = new VersionString($filteredOpts["current"]);
+	}else{
+		$currentVer = new VersionString(VersionInfo::BASE_VERSION);
+	}
+	if(isset($filteredOpts["next"])){
+		$nextVer = new VersionString($filteredOpts["next"]);
+	}else{
 		$nextVer = new VersionString(sprintf(
 			"%u.%u.%u",
 			$currentVer->getMajor(),
 			$currentVer->getMinor(),
 			$currentVer->getPatch() + 1
 		));
+	}
+	$channel = $filteredOpts["channel"] ?? VersionInfo::BUILD_CHANNEL;
 
-	$versionInfoPath = dirname(__DIR__) . '/src/pocketmine/VersionInfo.php';
-	replaceVersion($versionInfoPath, $currentVer->getBaseVersion(), false);
-
+	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);
-	system('git add "' . dirname(__DIR__) . '/changelogs"');
-	system('git commit -m "Release ' . $currentVer->getBaseVersion() . '" --include "' . $versionInfoPath . '"');
-	system('git tag ' . $currentVer->getBaseVersion());
-	replaceVersion($versionInfoPath, $nextVer->getBaseVersion(), true);
-	system('git add "' . $versionInfoPath . '"');
-	system('git commit -m "' . $nextVer->getBaseVersion() . ' is next" --include "' . $versionInfoPath . '"');
+	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");
+
+	replaceVersion($versionInfoPath, $nextVer->getBaseVersion(), true, $channel);
+	systemWrapper('git add "' . $versionInfoPath . '"', "failed to stage changes for post-release commit");
+	systemWrapper('git commit -m "' . $nextVer->getBaseVersion() . ' is next" --include "' . $versionInfoPath . '"', "failed to create post-release commit");
 	echo "pushing changes in 5 seconds\n";
 	sleep(5);
-	system('git push origin HEAD ' . $currentVer->getBaseVersion());
+	systemWrapper('git push origin HEAD ' . $currentVer->getBaseVersion(), "failed to push changes to remote");
 }
 
-main($argv);
+main();

build/server-phar.php

@@ -134,22 +134,29 @@ function main() : void{
 		exit(1);
 	}
 
-	$opts = getopt("", ["out:", "git:"]);
+	$opts = getopt("", ["out:", "git:", "build:"]);
 	if(isset($opts["git"])){
 		$gitHash = $opts["git"];
 	}else{
 		$gitHash = Git::getRepositoryStatePretty(dirname(__DIR__));
 		echo "Git hash detected as $gitHash" . PHP_EOL;
 	}
+	if(isset($opts["build"])){
+		$build = (int) $opts["build"];
+	}else{
+		$build = 0;
+	}
 	foreach(buildPhar(
 		$opts["out"] ?? getcwd() . DIRECTORY_SEPARATOR . "PocketMine-MP.phar",
 		dirname(__DIR__) . DIRECTORY_SEPARATOR,
 		[
+			'resources',
 			'src',
 			'vendor'
 		],
 		[
-			'git' => $gitHash
+			'git' => $gitHash,
+			'build' => $build
 		],
 		<<<'STUB'
 <?php
@@ -162,7 +169,7 @@ if(!is_readable($tmpDir) or !is_writable($tmpDir)){
 	exit(1);
 }
 
-require("phar://" . __FILE__ . "/src/pocketmine/PocketMine.php");
+require("phar://" . __FILE__ . "/src/PocketMine.php");
 __HALT_COMPILER();
 STUB
 ,

changelogs/3.19.md

@@ -24,3 +24,8 @@ Plugin developers should **only** update their required API to this version if y
 
 # 3.19.2
 - Signs can now only be edited by the player who placed them. They will become finalized if the chunk containing them is unloaded and reloaded, or if the creating player quits the server.
+
+# 3.19.3
+- Fixed `Worker->quit()` returning without stopping the thread.
+- Added some protocol constants in `SetDisplayObjectivePacket`.
+- Fixed possible client crash caused by `CraftingDataPacket`.

changelogs/3.20.md

@@ -0,0 +1,11 @@
+**For Minecraft: Bedrock Edition 1.17.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.20.0
+- Added support for Minecraft: Bedrock Edition 1.17.0
+- Removed compatibility with earlier versions.

changelogs/3.21.md

@@ -0,0 +1,15 @@
+**For Minecraft: Bedrock Edition 1.17.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.21.0
+- PHP 7.4 is now required as a minimum.
+- A workaround for player movement added in 1.14.30 has been removed.
+
+# 3.21.1
+- Fixed so-called 'pot lag' - a bug that could occur when using items while rapidly switching hotbar slots.
+- Plugins in crashdumps are now ordered alphabetically for easier reading. 

changelogs/3.22.md

@@ -0,0 +1,36 @@
+**For Minecraft: Bedrock Edition 1.17.10**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.22.0
+- Added support for Minecraft: Bedrock Edition 1.17.10.
+- Removed compatibility with earlier versions.
+
+# 3.22.1
+- Added a giant yellow startup warning if using OPcache JIT on PHP 8.0. JIT is currently considered highly unstable and not recommended for production use.
+- When using a bad PHP binary, the bootstrap will now report the used `php.ini` path. This can be useful for debugging issues with extension loading when the wrong `php.ini` file is loaded for some reason.
+- Fixed `start.cmd` causing the wrong `php.ini` to be loaded on Windows when a global PHP installation is used.
+- A debug message is now logged containing expected vs. actual XUID of players when an XUID mismatch is detected.
+- Improved the documentation for `Player->getUniqueId()`.
+- Fixed a mistake in the documentation of `PlayerAuthInputFlags`.
+- Fixed incorrect encoding of `NpcDialoguePacket`.
+
+# 3.22.2
+- PHP 8.0 is now the primary supported version. PHP 7.4 is still supported for now, but it will be dropped in the coming weeks. It's recommended to start testing your servers on 8.0 now so you're ready.
+- Fixed items in the crafting grid getting deleted on server-side disconnect or session timeout.
+- A warning is now logged on startup if a debug build of PHP is used to run the server (because it has a significant performance impact).
+- GitHub Actions is now used to build new releases, instead of Jenkins. You can see build logs [here](https://github.com/pmmp/PocketMine-MP/actions/workflows/draft-release.yml).
+
+# 3.22.3
+- Fixed a bug in the release build of 3.22.2 which caused the crash archive to reject all crashdumps.
+- Fixed possible server crash during player spawning.
+
+# 3.22.4
+- Fixed a bug which broke the build of 3.22.3.
+
+# 3.22.5
+- Added a workaround for polyfilled solid-colour Persona skin replacements turning into a corrupted mess (caused by https://bugs.mojang.com/browse/MCPE-130275).

changelogs/3.23.md

@@ -0,0 +1,14 @@
+**For Minecraft: Bedrock Edition 1.17.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.23.0
+- Added support for Minecraft: Bedrock Edition 1.17.30.
+- Removed compatibility with earlier versions.
+
+# 3.23.1
+- Fixed broken build of 3.23.0.

changelogs/3.24.md

@@ -0,0 +1,12 @@
+**For Minecraft: Bedrock Edition 1.17.30**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.24.0
+- PHP 8.0 is now required as a minimum.
+- Fixed stats reporting checking the wrong `pocketmine.yml` property.
+- Fixed `Projectile->move()` not respecting the given `dx`/`dy`/`dz` and using its own motion instead.

changelogs/3.25.md

@@ -0,0 +1,38 @@
+**For Minecraft: Bedrock Edition 1.17.40**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.25.0
+- Added support for Minecraft: Bedrock Edition 1.17.40.
+- Removed compatibility with earlier versions.
+
+# 3.25.1
+- Fixed autosave bug that caused unmodified chunks to be saved at least once (during the first autosave after they were loaded).
+- `Entity->spawnTo()` now has an additional sanity check for matching worlds (might expose a few new errors in plugins).
+- Fixed a missing field in `CraftRecipeAuto` item stack request type.
+
+# 3.25.2
+- Now analysed using level 9 on PHPStan 1.0.0.
+- `ext-pthreads` v4.0.0 or newer is now required.
+- Fixed crash in `Player->showPlayer()` when the target is not in the same world.
+- `Human->setLifetimeTotalXp()` now limits the maximum value to 2^31.
+- Fixed players, who died in hardcore mode and were unbanned, getting re-banned on next server join.
+
+# 3.25.3
+- Fixed crash when players try to pickup XP while already having max XP.
+- Added a sanity check to `Human->setCurrentTotalXp()` to try and catch an elusive bug that's been appearing in the wild - please get in touch if you know how to reproduce it!
+
+# 3.25.4
+- Fixed a long-standing issue with `Player->removeWindow()` breaking inventory UIs on the client.
+
+# 3.25.5
+- Protocol: Fixed incorrect encoding in `StructureSettings`
+- Fixed reading tags from non-docblock comments in script plugins.
+- Build number is now defined in phar metadata instead of being patched into the source code directly.
+
+# 3.25.6
+- Fixed borked build number in release build of 3.25.5.

changelogs/3.26.md

@@ -0,0 +1,32 @@
+**For Minecraft: Bedrock Edition 1.18.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.26.0
+- Added support for Minecraft: Bedrock Edition 1.18.0.
+- Removed compatibility with earlier versions.
+
+# 3.26.1
+- Fixed a bug in chunk sending that caused double chests to not be paired, signs to be blank, and various other issues.
+
+# 3.26.2
+- Improved error messages shown by `start.cmd`, `start.sh` and `start.ps1` when the PHP binary was not found.
+- The value of PHPRC is now shown when erroring out due to unsatisfied PHP requirements.
+- Removed restriction on the range of valid channels for `auto-updater.channel` in `pocketmine.yml`.
+
+# 3.26.3
+- `PlayerExperienceChangeEvent->setNewProgress()` now performs range checks. This fixes the root of a very old and confusing crash bug which took several years to identify the cause of.
+  - Note that the defective plugin(s) which caused this problem will still cause a server crash, but the plugin responsible will now get blamed correctly.
+
+# 3.26.4
+- Fixed skins appearing black when using RTX resource packs.
+- Fixed chunks containing furnaces in old worlds (pre-2017) being discarded as corrupted.
+  - This was caused by a strict corruption check detecting bad data created by a bug in PocketMine-MP that was fixed in 2017.
+
+# 3.26.5
+- Fixed several denial-of-service attack vectors related to writable book text length and encoding.
+- Fixed several denial-of-service attack vectors related to skin data field lengths.

composer.json

@@ -1,22 +1,28 @@
 {
    "name": "pocketmine/pocketmine-mp",
-   "description": "A server software for Minecraft: Pocket Edition written in PHP",
+   "description": "A server software for Minecraft: Bedrock Edition written in PHP",
    "type": "project",
    "homepage": "https://pmmp.io",
    "license": "LGPL-3.0",
    "require": {
-      "php": "^7.3 || ^8.0",
+      "php": "^8.0",
       "php-64bit": "*",
+      "ext-chunkutils2": "^0.3.1",
+      "ext-crypto": "^0.3.1",
       "ext-ctype": "*",
       "ext-curl": "*",
       "ext-date": "*",
+      "ext-gmp": "*",
       "ext-hash": "*",
+      "ext-igbinary": "^3.0.1",
       "ext-json": "*",
+      "ext-leveldb": "^0.2.1 || ^0.3.0",
       "ext-mbstring": "*",
+      "ext-morton": "^0.1.0",
       "ext-openssl": "*",
       "ext-pcre": "*",
       "ext-phar": "*",
-      "ext-pthreads": "~3.2.0",
+      "ext-pthreads": "^4.0",
       "ext-reflection": "*",
       "ext-simplexml": "*",
       "ext-sockets": "*",
@@ -26,49 +32,63 @@
       "ext-zlib": ">=1.2.11",
       "composer-runtime-api": "^2.0",
       "adhocore/json-comment": "^1.1",
-      "pocketmine/binaryutils": "^0.1.9",
+      "fgrosse/phpasn1": "^2.3",
+      "netresearch/jsonmapper": "^4.0",
+      "pocketmine/bedrock-data": "~1.5.0+bedrock-1.18.0",
+      "pocketmine/bedrock-protocol": "~7.1.0+bedrock-1.18.0",
+      "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
-      "pocketmine/classloader": "^0.1.0",
-      "pocketmine/log": "^0.2.0",
-      "pocketmine/log-pthreads": "^0.1.0",
-      "pocketmine/math": "^0.2.0",
-      "pocketmine/nbt": "^0.2.18",
-      "pocketmine/raklib": "^0.12.7",
-      "pocketmine/snooze": "^0.1.0",
-      "pocketmine/spl": "^0.4.0"
+      "pocketmine/classloader": "^0.2.0",
+      "pocketmine/color": "^0.2.0",
+      "pocketmine/errorhandler": "^0.3.0",
+      "pocketmine/locale-data": "~2.3.0",
+      "pocketmine/log": "^0.4.0",
+      "pocketmine/log-pthreads": "^0.4.0",
+      "pocketmine/math": "^0.4.0",
+      "pocketmine/nbt": "^0.3.2",
+      "pocketmine/raklib": "^0.14.2",
+      "pocketmine/raklib-ipc": "^0.1.0",
+      "pocketmine/snooze": "^0.3.0",
+      "ramsey/uuid": "^4.1",
+      "webmozart/path-util": "^2.3"
    },
    "require-dev": {
-      "phpstan/phpstan": "0.12.88",
-      "phpstan/phpstan-phpunit": "^0.12.6",
-      "phpstan/phpstan-strict-rules": "^0.12.2",
+      "phpstan/phpstan": "1.3.3",
+      "phpstan/phpstan-phpunit": "^1.0.0",
+      "phpstan/phpstan-strict-rules": "^1.0.0",
       "phpunit/phpunit": "^9.2"
    },
    "autoload": {
       "psr-4": {
-         "": ["src"]
+         "pocketmine\\": "src/"
       },
       "files": [
-         "src/pocketmine/CoreConstants.php",
-         "src/pocketmine/GlobalConstants.php",
-         "src/pocketmine/VersionInfo.php"
+         "src/CoreConstants.php"
       ]
    },
    "autoload-dev": {
       "psr-4": {
-         "pocketmine\\": "tests/phpunit/"
+         "pocketmine\\": "tests/phpunit/",
+         "pocketmine\\phpstan\\rules\\": "tests/phpstan/rules"
       }
    },
    "config": {
       "platform": {
-         "php": "7.3.0"
+         "php": "8.0.0"
       },
       "sort-packages": true
    },
    "scripts": {
-      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/DevTools/ConsoleScript.php --make tests/plugins/DevTools --out plugins/DevTools.phar",
+      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/ConsoleScript.php --make tests/plugins/DevTools --out plugins/DevTools.phar",
       "make-server": [
-         "@composer install --no-dev --classmap-authoritative",
+         "@composer install --no-dev --classmap-authoritative --ignore-platform-reqs",
          "@php -dphar.readonly=0 build/server-phar.php"
+      ],
+      "update-registry-annotations": [
+         "@php build/generate-registry-annotations.php src"
+      ],
+      "update-translation-apis": [
+         "@php build/generate-known-translation-apis.php"
       ]
    }
 }

phpstan.neon.dist

@@ -1,43 +1,51 @@
 includes:
 	- tests/phpstan/configs/actual-problems.neon
-	- tests/phpstan/configs/check-explicit-mixed-baseline.neon
 	- tests/phpstan/configs/gc-hacks.neon
-	- tests/phpstan/configs/l7-baseline.neon
-	- tests/phpstan/configs/l8-baseline.neon
+	- tests/phpstan/configs/impossible-generics.neon
 	- tests/phpstan/configs/php-bugs.neon
 	- tests/phpstan/configs/phpstan-bugs.neon
-	- tests/phpstan/configs/phpunit-wiring-tests.neon
-	- tests/phpstan/configs/pthreads-bugs.neon
 	- tests/phpstan/configs/runtime-type-checks.neon
+	- tests/phpstan/configs/spl-fixed-array-sucks.neon
 	- vendor/phpstan/phpstan-phpunit/extension.neon
 	- vendor/phpstan/phpstan-phpunit/rules.neon
 	- vendor/phpstan/phpstan-strict-rules/rules.neon
 
+rules:
+	- pocketmine\phpstan\rules\DisallowEnumComparisonRule
+	- pocketmine\phpstan\rules\UnsafeForeachArrayOfStringRule
+#	- pocketmine\phpstan\rules\ThreadedSupportedTypesRule
+
 parameters:
-	level: 8
-	checkExplicitMixed: true
+	level: 9
 	checkMissingCallableSignature: true
+	treatPhpDocTypesAsCertain: false
 	bootstrapFiles:
 		- tests/phpstan/bootstrap.php
 	scanDirectories:
+		- build
 		- tests/plugins/TesterPlugin
+		- tools
 	scanFiles:
-		- src/pocketmine/PocketMine.php
-		- build/make-release.php
-		- build/server-phar.php
+		- src/PocketMine.php
 	paths:
+		- build
 		- src
-		- build/make-release.php
-		- build/server-phar.php
+		- tests/phpstan/rules
 		- tests/phpunit
 		- tests/plugins/TesterPlugin
+		- tools
+	excludePaths:
+		analyseAndScan:
+			- build/php
 	dynamicConstantNames:
-		- pocketmine\IS_DEVELOPMENT_BUILD
+		- pocketmine\VersionInfo::IS_DEVELOPMENT_BUILD
 		- pocketmine\DEBUG
+		- pocketmine\IS_DEVELOPMENT_BUILD
 	stubFiles:
-		- tests/phpstan/stubs/pthreads.stub
-		- tests/phpstan/stubs/chunkutils.stub
+		- tests/phpstan/stubs/JsonMapper.stub
 		- tests/phpstan/stubs/leveldb.stub
+		- tests/phpstan/stubs/phpasn1.stub
+		- tests/phpstan/stubs/pthreads.stub
 	reportUnmatchedIgnoredErrors: false #no other way to silence platform-specific non-warnings
 	staticReflectionClassNamePatterns:
 		- "#^COM$#"
@@ -45,5 +53,5 @@ parameters:
 		#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,
 		#we'll just fill it with 10 - it's very unlikely to encounter a callable with 10 parameters anyway.
-	    anyCallable: 'callable(mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed) : mixed'
-	    anyClosure: '\Closure(mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed, mixed) : mixed'
+		anyCallable: 'callable(never, never, never, never, never, never, never, never, never, never) : mixed'
+		anyClosure: '\Closure(never, never, never, never, never, never, never, never, never, never) : mixed'

resources/plugin_list.yml

@@ -0,0 +1,8 @@
+#This configuration file allows you to control which plugins are loaded on your server.
+
+#List behaviour
+# - blacklist: Only plugins which ARE NOT listed will load.
+# - whitelist: Only plugins which ARE listed will load.
+mode: blacklist
+#List names of plugins here.
+plugins: []

resources/pocketmine.yml

@@ -92,6 +92,9 @@ network:
   #Maximum size in bytes of packets sent over the network (default 1492 bytes). Packets larger than this will be
   #fragmented or split into smaller parts. Clients can request MTU sizes up to but not more than this number.
   max-mtu-size: 1492
+  #Enable encryption of Minecraft network traffic. This has an impact on performance, but prevents hackers from stealing sessions and pretending to be other players.
+  #DO NOT DISABLE THIS unless you understand the risks involved.
+  enable-encryption: true
 
 debug:
   #If > 1, it will show debug messages in the console
@@ -103,13 +106,10 @@ player:
   #If true, checks that joining players' Xbox user ID (XUID) match what was previously recorded.
   #This also prevents non-XBL players using XBL players' usernames to steal their data on servers with xbox-auth=off.
   verify-xuid: true
-  anti-cheat:
-    #If false, will try to prevent speed and noclip cheats. May cause movement issues.
-    allow-movement-cheats: true
 
 level-settings:
-  #The default format that levels will use when created
-  default-format: pmanvil
+  #The default format that worlds will use when created
+  default-format: leveldb
 
 chunk-sending:
   #To change server normal render distance, change view-distance in server.properties.
@@ -123,8 +123,9 @@ chunk-ticking:
   per-tick: 40
   #Radius of chunks around a player to tick
   tick-radius: 3
-  light-updates: false
-  clear-tick-list: true
+  #Number of blocks inside ticking areas' subchunks that get ticked every tick. Higher values will accelerate events
+  #like tree and plant growth, but at a higher performance cost.
+  blocks-per-subchunk-per-tick: 3
   #IDs of blocks not to perform random ticking on.
   disable-block-ticking:
     #- 2 # grass
@@ -154,7 +155,6 @@ auto-updater:
   enabled: true
   on-update:
     warn-console: true
-    warn-ops: true
   #Can be development, alpha, beta or stable.
   preferred-channel: stable
   #If using a development version, it will suggest changing the channel
@@ -176,11 +176,12 @@ aliases:
   #savestop: [save-all, stop]
 
 worlds:
-  #These settings will override the generator set in server.properties and allows loading multiple levels
+  #These settings will override the generator set in server.properties and allows loading multiple worlds
   #Example:
   #world:
   # seed: 404
-  # generator: FLAT:2;7,59x1,3x3,2;1;decoration(treecount=80 grasscount=45)
+  # generator: FLAT
+  # preset: 2;bedrock,59xstone,3xdirt,grass;1
 
 plugins:
   #Setting this to true will cause the legacy structure to be used where plugin data is placed inside the --plugins dir.

src/CoreConstants.php

@@ -33,5 +33,8 @@ if(defined('pocketmine\_CORE_CONSTANTS_INCLUDED')){
 }
 define('pocketmine\_CORE_CONSTANTS_INCLUDED', true);
 
-define('pocketmine\PATH', dirname(__DIR__, 2) . '/');
-define('pocketmine\RESOURCE_PATH', __DIR__ . '/resources/');
+define('pocketmine\PATH', dirname(__DIR__) . '/');
+define('pocketmine\RESOURCE_PATH', dirname(__DIR__) . '/resources/');
+define('pocketmine\BEDROCK_DATA_PATH', dirname(__DIR__) . '/vendor/pocketmine/bedrock-data/');
+define('pocketmine\LOCALE_DATA_PATH', dirname(__DIR__) . '/vendor/pocketmine/locale-data/');
+define('pocketmine\COMPOSER_AUTOLOADER_PATH', dirname(__DIR__) . '/vendor/autoload.php');

src/MemoryManager.php

@@ -24,12 +24,14 @@ declare(strict_types=1);
 namespace pocketmine;
 
 use pocketmine\event\server\LowMemoryEvent;
+use pocketmine\network\mcpe\cache\ChunkCache;
 use pocketmine\scheduler\DumpWorkerMemoryTask;
 use pocketmine\scheduler\GarbageCollectionTask;
 use pocketmine\timings\Timings;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Process;
 use pocketmine\utils\Utils;
+use Webmozart\PathUtil\Path;
 use function arsort;
 use function count;
 use function fclose;
@@ -43,9 +45,10 @@ use function gc_enable;
 use function gc_mem_caches;
 use function get_class;
 use function get_declared_classes;
-use function implode;
+use function get_defined_functions;
 use function ini_get;
 use function ini_set;
+use function intdiv;
 use function is_array;
 use function is_object;
 use function is_resource;
@@ -67,70 +70,54 @@ use const SORT_NUMERIC;
 
 class MemoryManager{
 
-	/** @var Server */
-	private $server;
+	private Server $server;
 
-	/** @var int */
-	private $memoryLimit;
-	/** @var int */
-	private $globalMemoryLimit;
-	/** @var int */
-	private $checkRate;
-	/** @var int */
-	private $checkTicker = 0;
-	/** @var bool */
-	private $lowMemory = false;
+	private int $memoryLimit;
+	private int $globalMemoryLimit;
+	private int $checkRate;
+	private int $checkTicker = 0;
+	private bool $lowMemory = false;
 
-	/** @var bool */
-	private $continuousTrigger = true;
-	/** @var int */
-	private $continuousTriggerRate;
-	/** @var int */
-	private $continuousTriggerCount = 0;
-	/** @var int */
-	private $continuousTriggerTicker = 0;
+	private bool $continuousTrigger = true;
+	private int $continuousTriggerRate;
+	private int $continuousTriggerCount = 0;
+	private int $continuousTriggerTicker = 0;
 
-	/** @var int */
-	private $garbageCollectionPeriod;
-	/** @var int */
-	private $garbageCollectionTicker = 0;
-	/** @var bool */
-	private $garbageCollectionTrigger;
-	/** @var bool */
-	private $garbageCollectionAsync;
+	private int $garbageCollectionPeriod;
+	private int $garbageCollectionTicker = 0;
+	private bool $garbageCollectionTrigger;
+	private bool $garbageCollectionAsync;
 
-	/** @var int */
-	private $lowMemChunkRadiusOverride;
-	/** @var bool */
-	private $lowMemChunkGC;
+	private int $lowMemChunkRadiusOverride;
+	private bool $lowMemChunkGC;
 
-	/** @var bool */
-	private $lowMemDisableChunkCache;
-	/** @var bool */
-	private $lowMemClearWorldCache;
+	private bool $lowMemDisableChunkCache;
+	private bool $lowMemClearWorldCache;
 
-	/** @var bool */
-	private $dumpWorkers = true;
+	private bool $dumpWorkers = true;
+
+	private \Logger $logger;
 
 	public function __construct(Server $server){
 		$this->server = $server;
+		$this->logger = new \PrefixedLogger($server->getLogger(), "Memory Manager");
 
-		$this->init();
+		$this->init($server->getConfigGroup());
 	}
 
-	private function init() : void{
-		$this->memoryLimit = ((int) $this->server->getProperty("memory.main-limit", 0)) * 1024 * 1024;
+	private function init(ServerConfigGroup $config) : void{
+		$this->memoryLimit = $config->getPropertyInt("memory.main-limit", 0) * 1024 * 1024;
 
 		$defaultMemory = 1024;
 
-		if(preg_match("/([0-9]+)([KMGkmg])/", $this->server->getConfigString("memory-limit", ""), $matches) > 0){
+		if(preg_match("/([0-9]+)([KMGkmg])/", $config->getConfigString("memory-limit", ""), $matches) > 0){
 			$m = (int) $matches[1];
 			if($m <= 0){
 				$defaultMemory = 0;
 			}else{
 				switch(mb_strtoupper($matches[2])){
 					case "K":
-						$defaultMemory = $m / 1024;
+						$defaultMemory = intdiv($m, 1024);
 						break;
 					case "M":
 						$defaultMemory = $m;
@@ -145,7 +132,7 @@ class MemoryManager{
 			}
 		}
 
-		$hardLimit = ((int) $this->server->getProperty("memory.main-hard-limit", $defaultMemory));
+		$hardLimit = $config->getPropertyInt("memory.main-hard-limit", $defaultMemory);
 
 		if($hardLimit <= 0){
 			ini_set("memory_limit", '-1');
@@ -153,22 +140,22 @@ class MemoryManager{
 			ini_set("memory_limit", $hardLimit . "M");
 		}
 
-		$this->globalMemoryLimit = ((int) $this->server->getProperty("memory.global-limit", 0)) * 1024 * 1024;
-		$this->checkRate = (int) $this->server->getProperty("memory.check-rate", 20);
-		$this->continuousTrigger = (bool) $this->server->getProperty("memory.continuous-trigger", true);
-		$this->continuousTriggerRate = (int) $this->server->getProperty("memory.continuous-trigger-rate", 30);
+		$this->globalMemoryLimit = $config->getPropertyInt("memory.global-limit", 0) * 1024 * 1024;
+		$this->checkRate = $config->getPropertyInt("memory.check-rate", 20);
+		$this->continuousTrigger = $config->getPropertyBool("memory.continuous-trigger", true);
+		$this->continuousTriggerRate = $config->getPropertyInt("memory.continuous-trigger-rate", 30);
 
-		$this->garbageCollectionPeriod = (int) $this->server->getProperty("memory.garbage-collection.period", 36000);
-		$this->garbageCollectionTrigger = (bool) $this->server->getProperty("memory.garbage-collection.low-memory-trigger", true);
-		$this->garbageCollectionAsync = (bool) $this->server->getProperty("memory.garbage-collection.collect-async-worker", true);
+		$this->garbageCollectionPeriod = $config->getPropertyInt("memory.garbage-collection.period", 36000);
+		$this->garbageCollectionTrigger = $config->getPropertyBool("memory.garbage-collection.low-memory-trigger", true);
+		$this->garbageCollectionAsync = $config->getPropertyBool("memory.garbage-collection.collect-async-worker", true);
 
-		$this->lowMemChunkRadiusOverride = (int) $this->server->getProperty("memory.max-chunks.chunk-radius", 4);
-		$this->lowMemChunkGC = (bool) $this->server->getProperty("memory.max-chunks.trigger-chunk-collect", true);
+		$this->lowMemChunkRadiusOverride = $config->getPropertyInt("memory.max-chunks.chunk-radius", 4);
+		$this->lowMemChunkGC = $config->getPropertyBool("memory.max-chunks.trigger-chunk-collect", true);
 
-		$this->lowMemDisableChunkCache = (bool) $this->server->getProperty("memory.world-caches.disable-chunk-cache", true);
-		$this->lowMemClearWorldCache = (bool) $this->server->getProperty("memory.world-caches.low-memory-trigger", true);
+		$this->lowMemDisableChunkCache = $config->getPropertyBool("memory.world-caches.disable-chunk-cache", true);
+		$this->lowMemClearWorldCache = $config->getPropertyBool("memory.world-caches.low-memory-trigger", true);
 
-		$this->dumpWorkers = (bool) $this->server->getProperty("memory.memory-dump.dump-async-worker", true);
+		$this->dumpWorkers = $config->getPropertyBool("memory.memory-dump.dump-async-worker", true);
 		gc_enable();
 	}
 
@@ -176,6 +163,10 @@ class MemoryManager{
 		return $this->lowMemory;
 	}
 
+	public function getGlobalMemoryLimit() : int{
+		return $this->globalMemoryLimit;
+	}
+
 	public function canUseChunkCache() : bool{
 		return !$this->lowMemory or !$this->lowMemDisableChunkCache;
 	}
@@ -189,21 +180,20 @@ class MemoryManager{
 
 	/**
 	 * Triggers garbage collection and cache cleanup to try and free memory.
-	 *
-	 * @return void
 	 */
-	public function trigger(int $memory, int $limit, bool $global = false, int $triggerCount = 0){
-		$this->server->getLogger()->debug(sprintf("[Memory Manager] %sLow memory triggered, limit %gMB, using %gMB",
+	public function trigger(int $memory, int $limit, bool $global = false, int $triggerCount = 0) : void{
+		$this->logger->debug(sprintf("%sLow memory triggered, limit %gMB, using %gMB",
 			$global ? "Global " : "", round(($limit / 1024) / 1024, 2), round(($memory / 1024) / 1024, 2)));
 		if($this->lowMemClearWorldCache){
-			foreach($this->server->getLevels() as $level){
-				$level->clearCache(true);
+			foreach($this->server->getWorldManager()->getWorlds() as $world){
+				$world->clearCache(true);
 			}
+			ChunkCache::pruneCaches();
 		}
 
 		if($this->lowMemChunkGC){
-			foreach($this->server->getLevels() as $level){
-				$level->doChunkGarbageCollection();
+			foreach($this->server->getWorldManager()->getWorlds() as $world){
+				$world->doChunkGarbageCollection();
 			}
 		}
 
@@ -215,16 +205,14 @@ class MemoryManager{
 			$cycles = $this->triggerGarbageCollector();
 		}
 
-		$this->server->getLogger()->debug(sprintf("[Memory Manager] Freed %gMB, $cycles cycles", round(($ev->getMemoryFreed() / 1024) / 1024, 2)));
+		$this->logger->debug(sprintf("Freed %gMB, $cycles cycles", round(($ev->getMemoryFreed() / 1024) / 1024, 2)));
 	}
 
 	/**
 	 * Called every tick to update the memory manager state.
-	 *
-	 * @return void
 	 */
-	public function check(){
-		Timings::$memoryManagerTimer->startTiming();
+	public function check() : void{
+		Timings::$memoryManager->startTiming();
 
 		if(($this->memoryLimit > 0 or $this->globalMemoryLimit > 0) and ++$this->checkTicker >= $this->checkRate){
 			$this->checkTicker = 0;
@@ -257,16 +245,16 @@ class MemoryManager{
 			$this->triggerGarbageCollector();
 		}
 
-		Timings::$memoryManagerTimer->stopTiming();
+		Timings::$memoryManager->stopTiming();
 	}
 
 	public function triggerGarbageCollector() : int{
-		Timings::$garbageCollectorTimer->startTiming();
+		Timings::$garbageCollector->startTiming();
 
 		if($this->garbageCollectionAsync){
 			$pool = $this->server->getAsyncPool();
 			if(($w = $pool->shutdownUnusedWorkers()) > 0){
-				$this->server->getLogger()->debug("Shut down $w idle async pool workers");
+				$this->logger->debug("Shut down $w idle async pool workers");
 			}
 			foreach($pool->getRunningWorkers() as $i){
 				$pool->submitTaskToWorker(new GarbageCollectionTask(), $i);
@@ -276,19 +264,18 @@ class MemoryManager{
 		$cycles = gc_collect_cycles();
 		gc_mem_caches();
 
-		Timings::$garbageCollectorTimer->stopTiming();
+		Timings::$garbageCollector->stopTiming();
 
 		return $cycles;
 	}
 
 	/**
 	 * Dumps the server memory into the specified output folder.
-	 *
-	 * @return void
 	 */
-	public function dumpServerMemory(string $outputFolder, int $maxNesting, int $maxStringSize){
-		$this->server->getLogger()->notice("[Dump] After the memory dump is done, the server might crash");
-		self::dumpMemory($this->server, $outputFolder, $maxNesting, $maxStringSize, $this->server->getLogger());
+	public function dumpServerMemory(string $outputFolder, int $maxNesting, int $maxStringSize) : void{
+		$logger = new \PrefixedLogger($this->server->getLogger(), "Memory Dump");
+		$logger->notice("After the memory dump is done, the server might crash");
+		self::dumpMemory($this->server, $outputFolder, $maxNesting, $maxStringSize, $logger);
 
 		if($this->dumpWorkers){
 			$pool = $this->server->getAsyncPool();
@@ -302,11 +289,8 @@ class MemoryManager{
 	 * Static memory dumper accessible from any thread.
 	 *
 	 * @param mixed   $startingObject
-	 *
-	 * @return void
-	 * @throws \ReflectionException
 	 */
-	public static function dumpMemory($startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger){
+	public static function dumpMemory($startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger) : void{
 		$hardLimit = ini_get('memory_limit');
 		if($hardLimit === false) throw new AssumptionFailedError("memory_limit INI directive should always exist");
 		ini_set('memory_limit', '-1');
@@ -316,9 +300,7 @@ class MemoryManager{
 			mkdir($outputFolder, 0777, true);
 		}
 
-		$obData = fopen($outputFolder . "/objects.js", "wb+");
-
-		$data = [];
+		$obData = fopen(Path::join($outputFolder, "objects.js"), "wb+");
 
 		$objects = [];
 
@@ -329,6 +311,9 @@ class MemoryManager{
 		$staticProperties = [];
 		$staticCount = 0;
 
+		$functionStaticVars = [];
+		$functionStaticVarsCount = 0;
+
 		foreach(get_declared_classes() as $className){
 			$reflection = new \ReflectionClass($className);
 			$staticProperties[$className] = [];
@@ -340,6 +325,9 @@ class MemoryManager{
 				if(!$property->isPublic()){
 					$property->setAccessible(true);
 				}
+				if(!$property->isInitialized()){
+					continue;
+				}
 
 				$staticCount++;
 				$staticProperties[$className][$property->getName()] = self::continueDump($property->getValue(), $objects, $refCounts, 0, $maxNesting, $maxStringSize);
@@ -348,12 +336,25 @@ class MemoryManager{
 			if(count($staticProperties[$className]) === 0){
 				unset($staticProperties[$className]);
 			}
+
+			foreach($reflection->getMethods() as $method){
+				if($method->getDeclaringClass()->getName() !== $reflection->getName()){
+					continue;
+				}
+				$methodStatics = [];
+				foreach($method->getStaticVariables() as $name => $variable){
+					$methodStatics[$name] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
+				}
+				if(count($methodStatics) > 0){
+					$functionStaticVars[$className . "::" . $method->getName()] = $methodStatics;
+					$functionStaticVarsCount += count($functionStaticVars);
+				}
+			}
 		}
 
-		file_put_contents($outputFolder . "/staticProperties.js", json_encode($staticProperties, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
-		$logger->info("[Dump] Wrote $staticCount static properties");
+		file_put_contents(Path::join($outputFolder, "staticProperties.js"), json_encode($staticProperties, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		$logger->info("Wrote $staticCount static properties");
 
-		if(isset($GLOBALS)){ //This might be null if we're on a different thread
 		$globalVariables = [];
 		$globalCount = 0;
 
@@ -369,7 +370,7 @@ class MemoryManager{
 			'_SESSION' => true
 		];
 
-			foreach($GLOBALS as $varName => $value){
+		foreach(Utils::stringifyKeys($GLOBALS) as $varName => $value){
 			if(isset($ignoredGlobals[$varName])){
 				continue;
 			}
@@ -378,9 +379,23 @@ class MemoryManager{
 			$globalVariables[$varName] = self::continueDump($value, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 		}
 
-			file_put_contents($outputFolder . "/globalVariables.js", json_encode($globalVariables, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
-			$logger->info("[Dump] Wrote $globalCount global variables");
+		file_put_contents(Path::join($outputFolder, "globalVariables.js"), json_encode($globalVariables, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		$logger->info("Wrote $globalCount global variables");
+
+		foreach(get_defined_functions()["user"] as $function){
+			$reflect = new \ReflectionFunction($function);
+
+			$vars = [];
+			foreach($reflect->getStaticVariables() as $varName => $variable){
+				$vars[$varName] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 			}
+			if(count($vars) > 0){
+				$functionStaticVars[$function] = $vars;
+				$functionStaticVarsCount += count($vars);
+			}
+		}
+		file_put_contents(Path::join($outputFolder, 'functionStaticVars.js'), json_encode($functionStaticVars, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		$logger->info("Wrote $functionStaticVarsCount function static variables");
 
 		$data = self::continueDump($startingObject, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 
@@ -400,21 +415,24 @@ class MemoryManager{
 				}
 
 				$objects[$hash] = true;
-
-				$reflection = new \ReflectionObject($object);
-
 				$info = [
 					"information" => "$hash@$className",
-					"properties" => []
 				];
-
-				if(($parent = $reflection->getParentClass()) !== false){
-					$info["parent"] = $parent->getName();
+				if($object instanceof \Closure){
+					$info["definition"] = Utils::getNiceClosureName($object);
+					$info["referencedVars"] = [];
+					$reflect = new \ReflectionFunction($object);
+					if(($closureThis = $reflect->getClosureThis()) !== null){
+						$info["this"] = self::continueDump($closureThis, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 					}
 
-				if(count($reflection->getInterfaceNames()) > 0){
-					$info["implements"] = implode(", ", $reflection->getInterfaceNames());
+					foreach($reflect->getStaticVariables() as $name => $variable){
+						$info["referencedVars"][$name] = self::continueDump($variable, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 					}
+				}else{
+					$reflection = new \ReflectionObject($object);
+
+					$info["properties"] = [];
 
 					for($original = $reflection; $reflection !== false; $reflection = $reflection->getParentClass()){
 						foreach($reflection->getProperties() as $property){
@@ -433,27 +451,31 @@ class MemoryManager{
 							if(!$property->isPublic()){
 								$property->setAccessible(true);
 							}
+							if(!$property->isInitialized($object)){
+								continue;
+							}
 
 							$info["properties"][$name] = self::continueDump($property->getValue($object), $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 						}
 					}
+				}
 
-				fwrite($obData, "$hash@$className: " . json_encode($info, JSON_UNESCAPED_SLASHES) . "\n");
+				fwrite($obData, json_encode($info, JSON_UNESCAPED_SLASHES) . "\n");
 			}
 
 		}while($continue);
 
-		$logger->info("[Dump] Wrote " . count($objects) . " objects");
+		$logger->info("Wrote " . count($objects) . " objects");
 
 		fclose($obData);
 
-		file_put_contents($outputFolder . "/serverEntry.js", json_encode($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
-		file_put_contents($outputFolder . "/referenceCounts.js", json_encode($refCounts, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		file_put_contents(Path::join($outputFolder, "serverEntry.js"), json_encode($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		file_put_contents(Path::join($outputFolder, "referenceCounts.js"), json_encode($refCounts, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
 
 		arsort($instanceCounts, SORT_NUMERIC);
-		file_put_contents($outputFolder . "/instanceCounts.js", json_encode($instanceCounts, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
+		file_put_contents(Path::join($outputFolder, "instanceCounts.js"), json_encode($instanceCounts, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
 
-		$logger->info("[Dump] Finished!");
+		$logger->info("Finished!");
 
 		ini_set('memory_limit', $hardLimit);
 		gc_enable();
@@ -481,7 +503,7 @@ class MemoryManager{
 
 			++$refCounts[$hash];
 
-			$data = "(object) $hash@" . get_class($from);
+			$data = "(object) $hash";
 		}elseif(is_array($from)){
 			if($recursion >= 5){
 				return "(error) ARRAY RECURSION LIMIT REACHED";

src/PocketMine.php

@@ -24,19 +24,27 @@ declare(strict_types=1);
 namespace pocketmine {
 
 	use Composer\InstalledVersions;
-	use pocketmine\utils\Git;
+	use pocketmine\errorhandler\ErrorToExceptionHandler;
+	use pocketmine\thread\ThreadManager;
+	use pocketmine\utils\Filesystem;
 	use pocketmine\utils\MainLogger;
 	use pocketmine\utils\Process;
 	use pocketmine\utils\ServerKiller;
 	use pocketmine\utils\Terminal;
 	use pocketmine\utils\Timezone;
-	use pocketmine\utils\Utils;
-	use pocketmine\utils\VersionString;
 	use pocketmine\wizard\SetupWizard;
+	use Webmozart\PathUtil\Path;
+	use function defined;
+	use function extension_loaded;
+	use function phpversion;
+	use function preg_match;
+	use function preg_quote;
+	use function strpos;
+	use function version_compare;
 
 	require_once __DIR__ . '/VersionInfo.php';
 
-	const MIN_PHP_VERSION = "7.3.0";
+	const MIN_PHP_VERSION = "8.0.0";
 
 	/**
 	 * @param string $message
@@ -74,12 +82,18 @@ namespace pocketmine {
 		}
 
 		$extensions = [
+			"chunkutils2" => "PocketMine ChunkUtils v2",
 			"curl" => "cURL",
+			"crypto" => "php-crypto",
 			"ctype" => "ctype",
 			"date" => "Date",
+			"gmp" => "GMP",
 			"hash" => "Hash",
+			"igbinary" => "igbinary",
 			"json" => "JSON",
+			"leveldb" => "LevelDB",
 			"mbstring" => "Multibyte String",
+			"morton" => "morton",
 			"openssl" => "OpenSSL",
 			"pcre" => "PCRE",
 			"phar" => "Phar",
@@ -103,8 +117,8 @@ namespace pocketmine {
 			if(substr_count($pthreads_version, ".") < 2){
 				$pthreads_version = "0.$pthreads_version";
 			}
-			if(version_compare($pthreads_version, "3.2.0") < 0){
-				$messages[] = "pthreads >= 3.2.0 is required, while you have $pthreads_version.";
+			if(version_compare($pthreads_version, "4.0.0") < 0 || version_compare($pthreads_version, "5.0.0") > 0){
+				$messages[] = "pthreads ^4.0.0 is required, while you have $pthreads_version.";
 			}
 		}
 
@@ -113,32 +127,66 @@ namespace pocketmine {
 			if(version_compare($leveldb_version, "0.2.1") < 0){
 				$messages[] = "php-leveldb >= 0.2.1 is required, while you have $leveldb_version.";
 			}
+			if(!defined('LEVELDB_ZLIB_RAW_COMPRESSION')){
+				$messages[] = "Given version of php-leveldb doesn't support ZLIB_RAW compression (use https://github.com/pmmp/php-leveldb)";
+			}
+		}
+
+		$chunkutils2_version = phpversion("chunkutils2");
+		$wantedVersionLock = "0.3";
+		$wantedVersionMin = "$wantedVersionLock.0";
+		if($chunkutils2_version !== false && (
+			version_compare($chunkutils2_version, $wantedVersionMin) < 0 ||
+			preg_match("/^" . preg_quote($wantedVersionLock, "/") . "\.\d+(?:-dev)?$/", $chunkutils2_version) === 0 //lock in at ^0.2, optionally at a patch release
+		)){
+			$messages[] = "chunkutils2 ^$wantedVersionMin is required, while you have $chunkutils2_version.";
 		}
 
 		if(extension_loaded("pocketmine")){
 			$messages[] = "The native PocketMine extension is no longer supported.";
 		}
 
+		if(!defined('AF_INET6')){
+			$messages[] = "IPv6 support is required, but your PHP binary was built without IPv6 support.";
+		}
+
 		return $messages;
 	}
 
 	/**
-	 * @param \Logger $logger
 	 * @return void
 	 */
 	function emit_performance_warnings(\Logger $logger){
+		if(PHP_DEBUG !== 0){
+			$logger->warning("This PHP binary was compiled in debug mode. This has a major impact on performance.");
+		}
 		if(extension_loaded("xdebug")){
 			$logger->warning("Xdebug extension is enabled. This has a major impact on performance.");
 		}
-		if(!extension_loaded("pocketmine_chunkutils")){
-			$logger->warning("ChunkUtils extension is missing. Anvil-format worlds will experience degraded performance.");
-		}
 		if(((int) ini_get('zend.assertions')) !== -1){
 			$logger->warning("Debugging assertions are enabled. This may degrade performance. To disable them, set `zend.assertions = -1` in php.ini.");
 		}
 		if(\Phar::running(true) === ""){
 			$logger->warning("Non-packaged installation detected. This will degrade autoloading speed and make startup times longer.");
 		}
+		if(function_exists('opcache_get_status') && ($opcacheStatus = opcache_get_status(false)) !== false){
+			$jitEnabled = $opcacheStatus["jit"]["on"] ?? false;
+			if($jitEnabled !== false){
+				$logger->warning(<<<'JIT_WARNING'
+
+
+	--------------------------------------- ! WARNING ! ---------------------------------------
+	You're using PHP 8.0 with JIT enabled. This provides significant performance improvements.
+	HOWEVER, it is EXPERIMENTAL, and has already been seen to cause weird and unexpected bugs.
+	Proceed with caution.
+	If you want to report any bugs, make sure to mention that you are using PHP 8.0 with JIT.
+	To turn off JIT, change `opcache.jit` to `0` in your php.ini file.
+	-------------------------------------------------------------------------------------------
+
+JIT_WARNING
+);
+			}
+		}
 	}
 
 	/**
@@ -159,10 +207,14 @@ namespace pocketmine {
 		if(count($messages = check_platform_dependencies()) > 0){
 			echo PHP_EOL;
 			$binary = version_compare(PHP_VERSION, "5.4") >= 0 ? PHP_BINARY : "unknown";
-			critical_error("Selected PHP binary ($binary) does not satisfy some requirements.");
+			critical_error("Selected PHP binary does not satisfy some requirements.");
 			foreach($messages as $m){
 				echo " - $m" . PHP_EOL;
 			}
+			critical_error("PHP binary used: " . $binary);
+			critical_error("Loaded php.ini: " . (($file = php_ini_loaded_file()) !== false ? $file : "none"));
+			$phprc = getenv("PHPRC");
+			critical_error("Value of PHPRC environment variable: " . ($phprc === false ? "" : $phprc));
 			critical_error("Please recompile PHP with the needed configuration, or refer to the installation instructions at http://pmmp.rtfd.io/en/rtfd/installation.html.");
 			echo PHP_EOL;
 			exit(1);
@@ -172,43 +224,18 @@ namespace pocketmine {
 		error_reporting(-1);
 		set_ini_entries();
 
-		$opts = getopt("", ["bootstrap:"]);
-		if(isset($opts["bootstrap"])){
-			$bootstrap = ($real = realpath($opts["bootstrap"])) !== false ? $real : $opts["bootstrap"];
-		}else{
-			$bootstrap = dirname(__FILE__, 3) . '/vendor/autoload.php';
-		}
-
-		if($bootstrap === false or !is_file($bootstrap)){
+		$bootstrap = dirname(__FILE__, 2) . '/vendor/autoload.php';
+		if(!is_file($bootstrap)){
 			critical_error("Composer autoloader not found at " . $bootstrap);
 			critical_error("Please install/update Composer dependencies or use provided builds.");
 			exit(1);
 		}
-		define('pocketmine\COMPOSER_AUTOLOADER_PATH', $bootstrap);
-		require_once(\pocketmine\COMPOSER_AUTOLOADER_PATH);
-
-		set_error_handler([Utils::class, 'errorExceptionHandler']);
-
-		$version = new VersionString(\pocketmine\BASE_VERSION, \pocketmine\IS_DEVELOPMENT_BUILD, \pocketmine\BUILD_NUMBER);
-		define('pocketmine\VERSION', $version->getFullVersion(true));
-
-		$gitHash = str_repeat("00", 20);
-
-		if(\Phar::running(true) === ""){
-			$gitHash = Git::getRepositoryStatePretty(\pocketmine\PATH);
-		}else{
-			$phar = new \Phar(\Phar::running(false));
-			$meta = $phar->getMetadata();
-			if(isset($meta["git"])){
-				$gitHash = $meta["git"];
-			}
-		}
-
-		define('pocketmine\GIT_COMMIT', $gitHash);
+		require_once($bootstrap);
 
 		$composerGitHash = InstalledVersions::getReference('pocketmine/pocketmine-mp');
 		if($composerGitHash !== null){
-			$currentGitHash = explode("-", \pocketmine\GIT_COMMIT)[0];
+			//we can't verify dependency versions if we were installed without using git
+			$currentGitHash = explode("-", VersionInfo::GIT_HASH())[0];
 			if($currentGitHash !== $composerGitHash){
 				critical_error("Composer dependencies and/or autoloader are out of sync.");
 				critical_error("- Current revision is $currentGitHash");
@@ -218,38 +245,31 @@ namespace pocketmine {
 				exit(1);
 			}
 		}
+		if(extension_loaded('parallel')){
+			\parallel\bootstrap(\pocketmine\COMPOSER_AUTOLOADER_PATH);
+		}
+
+		ErrorToExceptionHandler::set();
 
 		$opts = getopt("", ["data:", "plugins:", "no-wizard", "enable-ansi", "disable-ansi"]);
 
-		define('pocketmine\DATA', isset($opts["data"]) ? $opts["data"] . DIRECTORY_SEPARATOR : realpath(getcwd()) . DIRECTORY_SEPARATOR);
-		define('pocketmine\PLUGIN_PATH', isset($opts["plugins"]) ? $opts["plugins"] . DIRECTORY_SEPARATOR : realpath(getcwd()) . DIRECTORY_SEPARATOR . "plugins" . DIRECTORY_SEPARATOR);
+		$dataPath = isset($opts["data"]) ? $opts["data"] . DIRECTORY_SEPARATOR : realpath(getcwd()) . DIRECTORY_SEPARATOR;
+		$pluginPath = isset($opts["plugins"]) ? $opts["plugins"] . DIRECTORY_SEPARATOR : realpath(getcwd()) . DIRECTORY_SEPARATOR . "plugins" . DIRECTORY_SEPARATOR;
+		Filesystem::addCleanedPath($pluginPath, Filesystem::CLEAN_PATH_PLUGINS_PREFIX);
 
-		if(!file_exists(\pocketmine\DATA)){
-			mkdir(\pocketmine\DATA, 0777, true);
+		if(!file_exists($dataPath)){
+			mkdir($dataPath, 0777, true);
 		}
 
-		$lockFile = fopen(\pocketmine\DATA . 'server.lock', "a+b");
-		if($lockFile === false){
-			critical_error("Unable to open server.lock file. Please check that the current user has read/write permissions to it.");
-			exit(1);
-		}
-		define('pocketmine\LOCK_FILE', $lockFile);
-		if(!flock(\pocketmine\LOCK_FILE, LOCK_EX | LOCK_NB)){
-			//wait for a shared lock to avoid race conditions if two servers started at the same time - this makes sure the
-			//other server wrote its PID and released exclusive lock before we get our lock
-			flock(\pocketmine\LOCK_FILE, LOCK_SH);
-			$pid = stream_get_contents(\pocketmine\LOCK_FILE);
-			critical_error("Another " . \pocketmine\NAME . " instance (PID $pid) is already using this folder (" . realpath(\pocketmine\DATA) . ").");
+		$lockFilePath = Path::join($dataPath, 'server.lock');
+		if(($pid = Filesystem::createLockFile($lockFilePath)) !== null){
+			critical_error("Another " . VersionInfo::NAME . " instance (PID $pid) is already using this folder (" . realpath($dataPath) . ").");
 			critical_error("Please stop the other server first before running a new one.");
 			exit(1);
 		}
-		ftruncate(\pocketmine\LOCK_FILE, 0);
-		fwrite(\pocketmine\LOCK_FILE, (string) getmypid());
-		fflush(\pocketmine\LOCK_FILE);
-		flock(\pocketmine\LOCK_FILE, LOCK_SH); //prevent acquiring an exclusive lock from another process, but allow reading
 
 		//Logger has a dependency on timezone
-		$tzError = Timezone::init();
+		Timezone::init();
 
 		if(isset($opts["enable-ansi"])){
 			Terminal::init(true);
@@ -259,36 +279,28 @@ namespace pocketmine {
 			Terminal::init();
 		}
 
-		$logger = new MainLogger(\pocketmine\DATA . "server.log");
-		$logger->registerStatic();
-
-		foreach($tzError as $e){
-			$logger->warning($e);
-		}
-		unset($tzError);
+		$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(\pocketmine\DATA . "server.properties") and !isset($opts["no-wizard"])){
-				$installer = new SetupWizard();
+			if(!file_exists(Path::join($dataPath, "server.properties")) and !isset($opts["no-wizard"])){
+				$installer = new SetupWizard($dataPath);
 				if(!$installer->run()){
 					$exitCode = -1;
 					break;
 				}
 			}
 
-			//TODO: move this to a Server field
-			define('pocketmine\START_TIME', microtime(true));
-
 			/*
 			 * We now use the Composer autoloader, but this autoloader is still for loading plugins.
 			 */
 			$autoloader = new \BaseClassLoader();
 			$autoloader->register(false);
 
-			new Server($autoloader, $logger, \pocketmine\DATA, \pocketmine\PLUGIN_PATH);
+			new Server($autoloader, $logger, $dataPath, $pluginPath);
 
 			$logger->info("Stopping other threads");
 
@@ -298,22 +310,15 @@ namespace pocketmine {
 
 			if(ThreadManager::getInstance()->stopAll() > 0){
 				$logger->debug("Some threads could not be stopped, performing a force-kill");
-				Process::kill(Process::pid());
+				Process::kill(Process::pid(), true);
 			}
 		}while(false);
 
-		$logger->shutdown();
-		$logger->join();
+		$logger->shutdownLogWriterThread();
 
 		echo Terminal::$FORMAT_RESET . PHP_EOL;
 
-		if(!flock(\pocketmine\LOCK_FILE, LOCK_UN)){
-			critical_error("Failed to release the server.lock file.");
-		}
-
-		if(!fclose(\pocketmine\LOCK_FILE)){
-			critical_error("Could not close server.lock resource.");
-		}
+		Filesystem::releaseLockFile($lockFilePath);
 
 		exit($exitCode);
 	}

src/ServerConfigGroup.php

@@ -0,0 +1,146 @@
+<?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;
+
+use pocketmine\utils\Config;
+use function array_key_exists;
+use function getopt;
+use function is_bool;
+use function is_int;
+use function is_string;
+use function strtolower;
+
+final class ServerConfigGroup{
+
+	/** @var Config */
+	private $pocketmineYml;
+	/** @var Config */
+	private $serverProperties;
+
+	/**
+	 * @var mixed[]
+	 * @phpstan-var array<string, mixed>
+	 */
+	private $propertyCache = [];
+
+	public function __construct(Config $pocketmineYml, Config $serverProperties){
+		$this->pocketmineYml = $pocketmineYml;
+		$this->serverProperties = $serverProperties;
+	}
+
+	/**
+	 * @param mixed  $defaultValue
+	 *
+	 * @return mixed
+	 */
+	public function getProperty(string $variable, $defaultValue = null){
+		if(!array_key_exists($variable, $this->propertyCache)){
+			$v = getopt("", ["$variable::"]);
+			if(isset($v[$variable])){
+				$this->propertyCache[$variable] = $v[$variable];
+			}else{
+				$this->propertyCache[$variable] = $this->pocketmineYml->getNested($variable);
+			}
+		}
+
+		return $this->propertyCache[$variable] ?? $defaultValue;
+	}
+
+	public function getPropertyBool(string $variable, bool $defaultValue) : bool{
+		return (bool) $this->getProperty($variable, $defaultValue);
+	}
+
+	public function getPropertyInt(string $variable, int $defaultValue) : int{
+		return (int) $this->getProperty($variable, $defaultValue);
+	}
+
+	public function getPropertyString(string $variable, string $defaultValue) : string{
+		return (string) $this->getProperty($variable, $defaultValue);
+	}
+
+	public function getConfigString(string $variable, string $defaultValue = "") : string{
+		$v = getopt("", ["$variable::"]);
+		if(isset($v[$variable])){
+			return (string) $v[$variable];
+		}
+
+		return $this->serverProperties->exists($variable) ? (string) $this->serverProperties->get($variable) : $defaultValue;
+	}
+
+	public function setConfigString(string $variable, string $value) : void{
+		$this->serverProperties->set($variable, $value);
+	}
+
+	public function getConfigInt(string $variable, int $defaultValue = 0) : int{
+		$v = getopt("", ["$variable::"]);
+		if(isset($v[$variable])){
+			return (int) $v[$variable];
+		}
+
+		return $this->serverProperties->exists($variable) ? (int) $this->serverProperties->get($variable) : $defaultValue;
+	}
+
+	public function setConfigInt(string $variable, int $value) : void{
+		$this->serverProperties->set($variable, $value);
+	}
+
+	public function getConfigBool(string $variable, bool $defaultValue = false) : bool{
+		$v = getopt("", ["$variable::"]);
+		if(isset($v[$variable])){
+			$value = $v[$variable];
+		}else{
+			$value = $this->serverProperties->exists($variable) ? $this->serverProperties->get($variable) : $defaultValue;
+		}
+		if(is_bool($value)){
+			return $value;
+		}
+		if(is_int($value)){
+			return $value !== 0;
+		}
+		if(is_string($value)){
+			switch(strtolower($value)){
+				case "on":
+				case "true":
+				case "1":
+				case "yes":
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	public function setConfigBool(string $variable, bool $value) : void{
+		$this->serverProperties->set($variable, $value ? "1" : "0");
+	}
+
+	public function save() : void{
+		if($this->serverProperties->hasChanged()){
+			$this->serverProperties->save();
+		}
+		if($this->pocketmineYml->hasChanged()){
+			$this->pocketmineYml->save();
+		}
+	}
+}

src/VersionInfo.php

@@ -0,0 +1,91 @@
+<?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;
+
+use pocketmine\utils\Git;
+use pocketmine\utils\VersionString;
+use function is_array;
+use function is_int;
+use function str_repeat;
+
+final class VersionInfo{
+	public const NAME = "PocketMine-MP";
+	public const BASE_VERSION = "4.0.7";
+	public const IS_DEVELOPMENT_BUILD = false;
+	public const BUILD_CHANNEL = "stable";
+
+	private function __construct(){
+		//NOOP
+	}
+
+	/** @var string|null */
+	private static $gitHash = null;
+
+	public static function GIT_HASH() : string{
+		if(self::$gitHash === null){
+			$gitHash = str_repeat("00", 20);
+
+			if(\Phar::running(true) === ""){
+				$gitHash = Git::getRepositoryStatePretty(\pocketmine\PATH);
+			}else{
+				$phar = new \Phar(\Phar::running(false));
+				$meta = $phar->getMetadata();
+				if(isset($meta["git"])){
+					$gitHash = $meta["git"];
+				}
+			}
+
+			self::$gitHash = $gitHash;
+		}
+
+		return self::$gitHash;
+	}
+
+	private static ?int $buildNumber = null;
+
+	public static function BUILD_NUMBER() : int{
+		if(self::$buildNumber === null){
+			self::$buildNumber = 0;
+			if(\Phar::running(true) !== ""){
+				$phar = new \Phar(\Phar::running(false));
+				$meta = $phar->getMetadata();
+				if(is_array($meta) && isset($meta["build"]) && is_int($meta["build"])){
+					self::$buildNumber = $meta["build"];
+				}
+			}
+		}
+
+		return self::$buildNumber;
+	}
+
+	/** @var VersionString|null */
+	private static $fullVersion = null;
+
+	public static function VERSION() : VersionString{
+		if(self::$fullVersion === null){
+			self::$fullVersion = new VersionString(self::BASE_VERSION, self::IS_DEVELOPMENT_BUILD, self::BUILD_NUMBER());
+		}
+		return self::$fullVersion;
+	}
+}

src/block/ActivatorRail.php

@@ -23,13 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class ActivatorRail extends RedstoneRail{
+use pocketmine\block\utils\RailPoweredByRedstoneTrait;
 
-	protected $id = self::ACTIVATOR_RAIL;
-
-	public function getName() : string{
-		return "Activator Rail";
-	}
+class ActivatorRail extends StraightOnlyRail{
+	use RailPoweredByRedstoneTrait;
 
 	//TODO
 }

src/block/Air.php

@@ -23,29 +23,33 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
 
-class Bedrock extends Solid{
+/**
+ * Air block
+ */
+class Air extends Transparent{
 
-	protected $id = self::BEDROCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function canBeFlowedInto() : bool{
+		return true;
 	}
 
-	public function getName() : string{
-		return "Bedrock";
+	public function canBeReplaced() : bool{
+		return true;
 	}
 
-	public function getHardness() : float{
-		return -1;
-	}
-
-	public function getBlastResistance() : float{
-		return 18000000;
-	}
-
-	public function isBreakable(Item $item) : bool{
+	public function canBePlaced() : bool{
 		return false;
 	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
 }

src/block/Anvil.php

@@ -0,0 +1,97 @@
+<?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\AnvilInventory;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
+use pocketmine\block\utils\HorizontalFacingTrait;
+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 Anvil extends Transparent implements Fallable{
+	use FallableTrait;
+	use HorizontalFacingTrait;
+
+	private int $damage = 0;
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) | ($this->damage << 2);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x3);
+		$this->damage = BlockDataSerializer::readBoundedInt("damage", $stateMeta >> 2, 0, 2);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return $this->damage << 2;
+	}
+
+	public function getDamage() : int{ return $this->damage; }
+
+	/** @return $this */
+	public function setDamage(int $damage) : self{
+		if($damage < 0 || $damage > 2){
+			throw new \InvalidArgumentException("Damage must be in range 0-2");
+		}
+		$this->damage = $damage;
+		return $this;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()->squash(Facing::axis(Facing::rotateY($this->facing, false)), 1 / 8)];
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$player->setCurrentWindow(new AnvilInventory($this->position));
+		}
+
+		return true;
+	}
+
+	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);
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function tickFalling() : ?Block{
+		return null;
+	}
+}

src/block/Bamboo.php

@@ -0,0 +1,240 @@
+<?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\BlockDataSerializer;
+use pocketmine\event\block\StructureGrowEvent;
+use pocketmine\item\Bamboo as ItemBamboo;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function count;
+use function gmp_add;
+use function gmp_and;
+use function gmp_intval;
+use function gmp_mul;
+use function gmp_xor;
+use function min;
+use function mt_rand;
+use const PHP_INT_MAX;
+
+class Bamboo extends Transparent{
+
+	public const NO_LEAVES = 0;
+	public const SMALL_LEAVES = 1;
+	public const LARGE_LEAVES = 2;
+
+	protected bool $thick = false; //age in PC, but this is 0/1
+	protected bool $ready = false;
+	protected int $leafSize = self::NO_LEAVES;
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->thick = ($stateMeta & BlockLegacyMetadata::BAMBOO_FLAG_THICK) !== 0;
+		$this->leafSize = BlockDataSerializer::readBoundedInt("leafSize", ($stateMeta >> BlockLegacyMetadata::BAMBOO_LEAF_SIZE_SHIFT) & BlockLegacyMetadata::BAMBOO_LEAF_SIZE_MASK, self::NO_LEAVES, self::LARGE_LEAVES);
+		$this->ready = ($stateMeta & BlockLegacyMetadata::BAMBOO_FLAG_READY) !== 0;
+	}
+
+	public function writeStateToMeta() : int{
+		return ($this->thick ? BlockLegacyMetadata::BAMBOO_FLAG_THICK : 0) | ($this->leafSize << BlockLegacyMetadata::BAMBOO_LEAF_SIZE_SHIFT) | ($this->ready ? BlockLegacyMetadata::BAMBOO_FLAG_READY : 0);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function isThick() : bool{ return $this->thick; }
+
+	/** @return $this */
+	public function setThick(bool $thick) : self{
+		$this->thick = $thick;
+		return $this;
+	}
+
+	public function isReady() : bool{ return $this->ready; }
+
+	/** @return $this */
+	public function setReady(bool $ready) : self{
+		$this->ready = $ready;
+		return $this;
+	}
+
+	public function getLeafSize() : int{ return $this->leafSize; }
+
+	/** @return $this */
+	public function setLeafSize(int $leafSize) : self{
+		$this->leafSize = $leafSize;
+		return $this;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		//this places the BB at the northwest corner, not the center
+		$inset = 1 - (($this->thick ? 3 : 2) / 16);
+		return [AxisAlignedBB::one()->trim(Facing::SOUTH, $inset)->trim(Facing::EAST, $inset)];
+	}
+
+	private static function getOffsetSeed(int $x, int $y, int $z) : int{
+		$p1 = gmp_mul($z, 0x6ebfff5);
+		$p2 = gmp_mul($x, 0x2fc20f);
+		$p3 = $y;
+
+		$xord = gmp_xor(gmp_xor($p1, $p2), $p3);
+
+		$fullResult = gmp_mul(gmp_add(gmp_mul($xord, 0x285b825), 0xb), $xord);
+		return gmp_intval(gmp_and($fullResult, 0xffffffff));
+	}
+
+	private static function getMaxHeight(int $x, int $z) : int{
+		return 12 + (self::getOffsetSeed($x, 0, $z) % 5);
+	}
+
+	public function getModelPositionOffset() : ?Vector3{
+		$seed = self::getOffsetSeed($this->position->getFloorX(), 0, $this->position->getFloorZ());
+		$retX = (($seed % 12) + 1) / 16;
+		$retZ = ((($seed >> 8) % 12) + 1) / 16;
+		return new Vector3($retX, 0, $retZ);
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		//TODO: tags would be better for this
+		return
+			$block instanceof Dirt ||
+			$block instanceof Grass ||
+			$block instanceof Gravel ||
+			$block instanceof Sand ||
+			$block instanceof Mycelium ||
+			$block instanceof Podzol;
+	}
+
+	private function seekToTop() : Bamboo{
+		$world = $this->position->getWorld();
+		$top = $this;
+		while(($next = $world->getBlock($top->position->up())) instanceof Bamboo && $next->isSameType($this)){
+			$top = $next;
+		}
+		return $top;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof Fertilizer){
+			$top = $this->seekToTop();
+			if($top->grow(self::getMaxHeight($top->position->getFloorX(), $top->position->getFloorZ()), mt_rand(1, 2), $player)){
+				$item->pop();
+				return true;
+			}
+		}elseif($item instanceof ItemBamboo){
+			if($this->seekToTop()->grow(PHP_INT_MAX, 1, $player)){
+				$item->pop();
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		$below = $this->position->getWorld()->getBlock($this->position->down());
+		if(!$this->canBeSupportedBy($below) and !$below->isSameType($this)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	private function grow(int $maxHeight, int $growAmount, ?Player $player) : bool{
+		$world = $this->position->getWorld();
+		if(!$world->getBlock($this->position->up())->canBeReplaced()){
+			return false;
+		}
+
+		$height = 1;
+		while($world->getBlock($this->position->subtract(0, $height, 0))->isSameType($this)){
+			if(++$height >= $maxHeight){
+				return false;
+			}
+		}
+
+		$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
+			$stemBlock = $stemBlock->setThick(true);
+		}
+		$smallLeavesBlock = (clone $stemBlock)->setLeafSize(self::SMALL_LEAVES);
+		$bigLeavesBlock = (clone $stemBlock)->setLeafSize(self::LARGE_LEAVES);
+
+		$newBlocks = [];
+		if($newHeight === 2){
+			$newBlocks[] = $smallLeavesBlock;
+		}elseif($newHeight === 3){
+			$newBlocks[] = $smallLeavesBlock;
+			$newBlocks[] = $smallLeavesBlock;
+		}elseif($newHeight === 4){
+			$newBlocks[] = $bigLeavesBlock;
+			$newBlocks[] = $smallLeavesBlock;
+			$newBlocks[] = $stemBlock;
+			$newBlocks[] = $stemBlock;
+		}elseif($newHeight > 4){
+			$newBlocks[] = $bigLeavesBlock;
+			$newBlocks[] = $bigLeavesBlock;
+			$newBlocks[] = $smallLeavesBlock;
+			for($i = 0, $max = min($growAmount, $newHeight - count($newBlocks)); $i < $max; ++$i){
+				$newBlocks[] = $stemBlock; //to replace the bottom blocks that currently have leaves
+			}
+		}
+
+		$tx = new BlockTransaction($this->position->getWorld());
+		foreach($newBlocks as $idx => $newBlock){
+			$tx->addBlock($this->position->subtract(0, $idx - $growAmount, 0), $newBlock);
+		}
+
+		$ev = new StructureGrowEvent($this, $tx, $player);
+		$ev->call();
+		if($ev->isCancelled()){
+			return false;
+		}
+
+		return $tx->apply();
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		$world = $this->position->getWorld();
+		if($this->ready){
+			$this->ready = false;
+			if($world->getFullLight($this->position) < 9 || !$this->grow(self::getMaxHeight($this->position->getFloorX(), $this->position->getFloorZ()), 1, null)){
+				$world->setBlock($this->position, $this);
+			}
+		}elseif($world->getBlock($this->position->up())->canBeReplaced()){
+			$this->ready = true;
+			$world->setBlock($this->position, $this);
+		}
+	}
+}

src/block/BambooSapling.php

@@ -0,0 +1,130 @@
+<?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\event\block\StructureGrowEvent;
+use pocketmine\item\Bamboo as ItemBamboo;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+final class BambooSapling extends Flowable{
+
+	private bool $ready = false;
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->ready = ($stateMeta & BlockLegacyMetadata::SAPLING_FLAG_READY) !== 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return $this->ready ? BlockLegacyMetadata::SAPLING_FLAG_READY : 0;
+	}
+
+	public function getStateBitmask() : int{ return 0b1000; }
+
+	public function isReady() : bool{ return $this->ready; }
+
+	/** @return $this */
+	public function setReady(bool $ready) : self{
+		$this->ready = $ready;
+		return $this;
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		//TODO: tags would be better for this
+		return
+			$block instanceof Dirt ||
+			$block instanceof Grass ||
+			$block instanceof Gravel ||
+			$block instanceof Sand ||
+			$block instanceof Mycelium ||
+			$block instanceof Podzol;
+	}
+
+	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);
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof Fertilizer || $item instanceof ItemBamboo){
+			if($this->grow($player)){
+				$item->pop();
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canBeSupportedBy($this->position->getWorld()->getBlock($this->position->down()))){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	private function grow(?Player $player) : bool{
+		$world = $this->position->getWorld();
+		if(!$world->getBlock($this->position->up())->canBeReplaced()){
+			return false;
+		}
+
+		$tx = new BlockTransaction($world);
+		$bamboo = VanillaBlocks::BAMBOO();
+		$tx->addBlock($this->position, $bamboo)
+			->addBlock($this->position->up(), (clone $bamboo)->setLeafSize(Bamboo::SMALL_LEAVES));
+
+		$ev = new StructureGrowEvent($this, $tx, $player);
+		$ev->call();
+		if($ev->isCancelled()){
+			return false;
+		}
+
+		return $tx->apply();
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		$world = $this->position->getWorld();
+		if($this->ready){
+			$this->ready = false;
+			if($world->getFullLight($this->position) < 9 || !$this->grow(null)){
+				$world->setBlock($this->position, $this);
+			}
+		}elseif($world->getBlock($this->position->up())->canBeReplaced()){
+			$this->ready = true;
+			$world->setBlock($this->position, $this);
+		}
+	}
+
+	public function asItem() : Item{
+		return VanillaBlocks::BAMBOO()->asItem();
+	}
+}

src/block/Barrel.php

@@ -0,0 +1,102 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\tile\Barrel as TileBarrel;
+use pocketmine\block\utils\AnyFacingTrait;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function abs;
+
+class Barrel extends Opaque{
+	use AnyFacingTrait;
+
+	protected bool $open = false;
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeFacing($this->facing) | ($this->open ? BlockLegacyMetadata::BARREL_FLAG_OPEN : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readFacing($stateMeta & 0x07);
+		$this->open = ($stateMeta & BlockLegacyMetadata::BARREL_FLAG_OPEN) === BlockLegacyMetadata::BARREL_FLAG_OPEN;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function isOpen() : bool{
+		return $this->open;
+	}
+
+	/** @return $this */
+	public function setOpen(bool $open) : Barrel{
+		$this->open = $open;
+		return $this;
+	}
+
+	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($y - $this->position->getY() > 2){
+					$this->facing = Facing::UP;
+				}elseif($this->position->getY() - $y > 0){
+					$this->facing = Facing::DOWN;
+				}else{
+					$this->facing = Facing::opposite($player->getHorizontalFacing());
+				}
+			}else{
+				$this->facing = Facing::opposite($player->getHorizontalFacing());
+			}
+		}
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$barrel = $this->position->getWorld()->getTile($this->position);
+			if($barrel instanceof TileBarrel){
+				if(!$barrel->canOpenWith($item->getCustomName())){
+					return true;
+				}
+
+				$player->setCurrentWindow($barrel->getInventory());
+			}
+		}
+
+		return true;
+	}
+
+	public function getFuelTime() : int{
+		return 300;
+	}
+}

src/block/BaseBanner.php

@@ -0,0 +1,147 @@
+<?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\Banner as TileBanner;
+use pocketmine\block\utils\BannerPatternLayer;
+use pocketmine\block\utils\ColoredTrait;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\data\bedrock\DyeColorIdMap;
+use pocketmine\item\Banner as ItemBanner;
+use pocketmine\item\Item;
+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;
+
+abstract class BaseBanner extends Transparent{
+	use ColoredTrait;
+
+	/**
+	 * @var BannerPatternLayer[]
+	 * @phpstan-var list<BannerPatternLayer>
+	 */
+	protected array $patterns = [];
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->color = DyeColor::BLACK();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileBanner){
+			$this->color = $tile->getBaseColor();
+			$this->setPatterns($tile->getPatterns());
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		assert($tile instanceof TileBanner);
+		$tile->setBaseColor($this->color);
+		$tile->setPatterns($this->patterns);
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	public function getMaxStackSize() : int{
+		return 16;
+	}
+
+	/**
+	 * @return BannerPatternLayer[]
+	 * @phpstan-return list<BannerPatternLayer>
+	 */
+	public function getPatterns() : array{
+		return $this->patterns;
+	}
+
+	/**
+	 * @param BannerPatternLayer[]             $patterns
+	 *
+	 * @phpstan-param list<BannerPatternLayer> $patterns
+	 * @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");
+		}
+		$this->patterns = $checked;
+		return $this;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof ItemBanner){
+			$this->color = $item->getColor();
+			$this->setPatterns($item->getPatterns());
+		}
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	abstract protected function getSupportingFace() : int;
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide($this->getSupportingFace())->getId() === BlockLegacyIds::AIR){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return DyeColorIdMap::getInstance()->toInvertedId($this->color);
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		$drop = $this->asItem();
+		if($drop instanceof ItemBanner and count($this->patterns) > 0){
+			$drop->setPatterns($this->patterns);
+		}
+
+		return [$drop];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		$result = $this->asItem();
+		if($addUserData and $result instanceof ItemBanner and count($this->patterns) > 0){
+			$result->setPatterns($this->patterns);
+		}
+		return $result;
+	}
+}

src/block/BaseCoral.php

@@ -0,0 +1,85 @@
+<?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\CoralType;
+use pocketmine\item\Item;
+
+abstract class BaseCoral extends Transparent{
+
+	protected CoralType $coralType;
+	protected bool $dead = false;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		parent::__construct($idInfo, $name, $breakInfo);
+		$this->coralType = CoralType::TUBE();
+	}
+
+	public function getCoralType() : CoralType{ return $this->coralType; }
+
+	/** @return $this */
+	public function setCoralType(CoralType $coralType) : self{
+		$this->coralType = $coralType;
+		return $this;
+	}
+
+	public function isDead() : bool{ return $this->dead; }
+
+	/** @return $this */
+	public function setDead(bool $dead) : self{
+		$this->dead = $dead;
+		return $this;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->dead){
+			$world = $this->position->getWorld();
+
+			$hasWater = false;
+			foreach($this->position->sides() as $vector3){
+				if($world->getBlock($vector3) instanceof Water){
+					$hasWater = true;
+					break;
+				}
+			}
+
+			//TODO: check water inside the block itself (not supported on the API yet)
+			if(!$hasWater){
+				$world->setBlock($this->position, $this->setDead(true));
+			}
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	public function isSolid() : bool{ return false; }
+
+	protected function recalculateCollisionBoxes() : array{ return []; }
+}

src/block/BaseRail.php

@@ -0,0 +1,234 @@
+<?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\RailConnectionInfo;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function array_reverse;
+use function array_search;
+use function array_shift;
+use function count;
+use function in_array;
+
+abstract class BaseRail extends Flowable{
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$blockReplace->getSide(Facing::DOWN)->isTransparent()){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onPostPlace() : void{
+		$this->tryReconnect();
+	}
+
+	/**
+	 * @param int[]   $connections
+	 * @param int[][] $lookup
+	 * @phpstan-param array<int, list<int>> $lookup
+	 */
+	protected static function searchState(array $connections, array $lookup) : ?int{
+		$shape = array_search($connections, $lookup, true);
+		if($shape === false){
+			$shape = array_search(array_reverse($connections), $lookup, true);
+		}
+		return $shape === false ? null : $shape;
+	}
+
+	/**
+	 * Sets the rail shape according to the given connections, if a shape matches.
+	 *
+	 * @param int[] $connections
+	 *
+	 * @throws \InvalidArgumentException if no shape matches the given connections
+	 */
+	abstract protected function setShapeFromConnections(array $connections) : void;
+
+	/**
+	 * Returns the connection directions of this rail (depending on the current block state)
+	 *
+	 * @return int[]
+	 */
+	abstract protected function getCurrentShapeConnections() : array;
+
+	/**
+	 * Returns all the directions this rail is already connected in.
+	 *
+	 * @return int[]
+	 */
+	private function getConnectedDirections() : array{
+		/** @var int[] $connections */
+		$connections = [];
+
+		/** @var int $connection */
+		foreach($this->getCurrentShapeConnections() as $connection){
+			$other = $this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND);
+			$otherConnection = Facing::opposite($connection & ~RailConnectionInfo::FLAG_ASCEND);
+
+			if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0){
+				$other = $other->getSide(Facing::UP);
+
+			}elseif(!($other instanceof BaseRail)){ //check for rail sloping up to meet this one
+				$other = $other->getSide(Facing::DOWN);
+				$otherConnection |= RailConnectionInfo::FLAG_ASCEND;
+			}
+
+			if(
+				$other instanceof BaseRail and
+				in_array($otherConnection, $other->getCurrentShapeConnections(), true)
+			){
+				$connections[] = $connection;
+			}
+		}
+
+		return $connections;
+	}
+
+	/**
+	 * @param int[] $constraints
+	 *
+	 * @return true[]
+	 * @phpstan-return array<int, true>
+	 */
+	private function getPossibleConnectionDirections(array $constraints) : array{
+		switch(count($constraints)){
+			case 0:
+				//No constraints, can connect in any direction
+				$possible = [
+					Facing::NORTH => true,
+					Facing::SOUTH => true,
+					Facing::WEST => true,
+					Facing::EAST => true
+				];
+				foreach($possible as $p => $_){
+					$possible[$p | RailConnectionInfo::FLAG_ASCEND] = true;
+				}
+
+				return $possible;
+			case 1:
+				return $this->getPossibleConnectionDirectionsOneConstraint(array_shift($constraints));
+			case 2:
+				return [];
+			default:
+				throw new \InvalidArgumentException("Expected at most 2 constraints, got " . count($constraints));
+		}
+	}
+
+	/**
+	 * @return true[]
+	 * @phpstan-return array<int, true>
+	 */
+	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
+		$opposite = Facing::opposite($constraint & ~RailConnectionInfo::FLAG_ASCEND);
+
+		$possible = [$opposite => true];
+
+		if(($constraint & RailConnectionInfo::FLAG_ASCEND) === 0){
+			//We can slope the other way if this connection isn't already a slope
+			$possible[$opposite | RailConnectionInfo::FLAG_ASCEND] = true;
+		}
+
+		return $possible;
+	}
+
+	private function tryReconnect() : void{
+		$thisConnections = $this->getConnectedDirections();
+		$changed = false;
+
+		do{
+			$possible = $this->getPossibleConnectionDirections($thisConnections);
+			$continue = false;
+
+			foreach($possible as $thisSide => $_){
+				$otherSide = Facing::opposite($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
+
+				$other = $this->getSide($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
+
+				if(($thisSide & RailConnectionInfo::FLAG_ASCEND) !== 0){
+					$other = $other->getSide(Facing::UP);
+
+				}elseif(!($other instanceof BaseRail)){ //check if other rails can slope up to meet this one
+					$other = $other->getSide(Facing::DOWN);
+					$otherSide |= RailConnectionInfo::FLAG_ASCEND;
+				}
+
+				if(!($other instanceof BaseRail) or count($otherConnections = $other->getConnectedDirections()) >= 2){
+					//we can only connect to a rail that has less than 2 connections
+					continue;
+				}
+
+				$otherPossible = $other->getPossibleConnectionDirections($otherConnections);
+
+				if(isset($otherPossible[$otherSide])){
+					$otherConnections[] = $otherSide;
+					$other->setConnections($otherConnections);
+					$this->position->getWorld()->setBlock($other->position, $other);
+
+					$changed = true;
+					$thisConnections[] = $thisSide;
+					$continue = count($thisConnections) < 2;
+
+					break; //force recomputing possible directions, since this connection could invalidate others
+				}
+			}
+		}while($continue);
+
+		if($changed){
+			$this->setConnections($thisConnections);
+			$this->position->getWorld()->setBlock($this->position, $this);
+		}
+	}
+
+	/**
+	 * @param int[] $connections
+	 */
+	private function setConnections(array $connections) : void{
+		if(count($connections) === 1){
+			$connections[] = Facing::opposite($connections[0] & ~RailConnectionInfo::FLAG_ASCEND);
+		}elseif(count($connections) !== 2){
+			throw new \InvalidArgumentException("Expected exactly 2 connections, got " . count($connections));
+		}
+
+		$this->setShapeFromConnections($connections);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}else{
+			foreach($this->getCurrentShapeConnections() as $connection){
+				if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0 and $this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND)->isTransparent()){
+					$this->position->getWorld()->useBreakOn($this->position);
+					break;
+				}
+			}
+		}
+	}
+}

src/block/BaseSign.php

@@ -0,0 +1,137 @@
+<?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\Sign as TileSign;
+use pocketmine\block\utils\SignText;
+use pocketmine\event\block\SignChangeEvent;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\world\BlockTransaction;
+use function array_map;
+use function assert;
+use function strlen;
+
+abstract class BaseSign extends Transparent{
+	protected SignText $text;
+	protected ?int $editorEntityRuntimeId = null;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		parent::__construct($idInfo, $name, $breakInfo);
+		$this->text = new SignText();
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileSign){
+			$this->text = $tile->getText();
+			$this->editorEntityRuntimeId = $tile->getEditorEntityRuntimeId();
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		$tile = $this->position->getWorld()->getTile($this->position);
+		assert($tile instanceof TileSign);
+		$tile->setText($this->text);
+		$tile->setEditorEntityRuntimeId($this->editorEntityRuntimeId);
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	public function getMaxStackSize() : int{
+		return 16;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+
+	abstract protected function getSupportingFace() : int;
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide($this->getSupportingFace())->getId() === BlockLegacyIds::AIR){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->editorEntityRuntimeId = $player->getId();
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	/**
+	 * Returns an object containing information about the sign text.
+	 */
+	public function getText() : SignText{
+		return $this->text;
+	}
+
+	/** @return $this */
+	public function setText(SignText $text) : self{
+		$this->text = $text;
+		return $this;
+	}
+
+	/**
+	 * Called by the player controller (network session) to update the sign text, firing events as appropriate.
+	 *
+	 * @return bool if the sign update was successful.
+	 * @throws \UnexpectedValueException if the text payload is too large
+	 */
+	public function updateText(Player $author, SignText $text) : bool{
+		$size = 0;
+		foreach($text->getLines() as $line){
+			$size += strlen($line);
+		}
+		if($size > 1000){
+			throw new \UnexpectedValueException($author->getName() . " tried to write $size bytes of text onto a sign (bigger than max 1000)");
+		}
+		$ev = new SignChangeEvent($this, $author, new SignText(array_map(function(string $line) : string{
+			return TextFormat::clean($line, false);
+		}, $text->getLines())));
+		if($this->editorEntityRuntimeId === null || $this->editorEntityRuntimeId !== $author->getId()){
+			$ev->cancel();
+		}
+		$ev->call();
+		if(!$ev->isCancelled()){
+			$this->setText($ev->getNewText());
+			$this->position->getWorld()->setBlock($this->position, $this);
+			return true;
+		}
+
+		return false;
+	}
+}

src/block/Beacon.php

@@ -23,11 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class StillLava extends Lava{
+final class Beacon extends Transparent{
 
-	protected $id = self::STILL_LAVA;
-
-	public function getName() : string{
-		return "Still Lava";
+	public function getLightLevel() : int{
+		return 15;
 	}
+
+	//TODO
 }

src/block/Bed.php

@@ -0,0 +1,219 @@
+<?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\Bed as TileBed;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\ColoredTrait;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\data\bedrock\DyeColorIdMap;
+use pocketmine\entity\Entity;
+use pocketmine\entity\Living;
+use pocketmine\item\Item;
+use pocketmine\lang\KnownTranslationFactory;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\World;
+
+class Bed extends Transparent{
+	use ColoredTrait;
+	use HorizontalFacingTrait;
+
+	protected bool $occupied = false;
+	protected bool $head = false;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->color = DyeColor::RED();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) |
+			($this->occupied ? BlockLegacyMetadata::BED_FLAG_OCCUPIED : 0) |
+			($this->head ? BlockLegacyMetadata::BED_FLAG_HEAD : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+		$this->occupied = ($stateMeta & BlockLegacyMetadata::BED_FLAG_OCCUPIED) !== 0;
+		$this->head = ($stateMeta & BlockLegacyMetadata::BED_FLAG_HEAD) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		//read extra state information from the tile - this is an ugly hack
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileBed){
+			$this->color = $tile->getColor();
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		//extra block properties storage hack
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileBed){
+			$tile->setColor($this->color);
+		}
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()->trim(Facing::UP, 7 / 16)];
+	}
+
+	public function isHeadPart() : bool{
+		return $this->head;
+	}
+
+	/** @return $this */
+	public function setHead(bool $head) : self{
+		$this->head = $head;
+		return $this;
+	}
+
+	public function isOccupied() : bool{
+		return $this->occupied;
+	}
+
+	/** @return $this */
+	public function setOccupied(bool $occupied = true) : self{
+		$this->occupied = $occupied;
+		return $this;
+	}
+
+	private function getOtherHalfSide() : int{
+		return $this->head ? Facing::opposite($this->facing) : $this->facing;
+	}
+
+	public function getOtherHalf() : ?Bed{
+		$other = $this->getSide($this->getOtherHalfSide());
+		if($other instanceof Bed and $other->head !== $this->head and $other->facing === $this->facing){
+			return $other;
+		}
+
+		return null;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$other = $this->getOtherHalf();
+			$playerPos = $player->getPosition();
+			if($other === null){
+				$player->sendMessage(TextFormat::GRAY . "This bed is incomplete");
+
+				return true;
+			}elseif($playerPos->distanceSquared($this->position) > 4 and $playerPos->distanceSquared($other->position) > 4){
+				$player->sendMessage(KnownTranslationFactory::tile_bed_tooFar()->prefix(TextFormat::GRAY));
+				return true;
+			}
+
+			$time = $this->position->getWorld()->getTimeOfDay();
+
+			$isNight = ($time >= World::TIME_NIGHT and $time < World::TIME_SUNRISE);
+
+			if(!$isNight){
+				$player->sendMessage(KnownTranslationFactory::tile_bed_noSleep()->prefix(TextFormat::GRAY));
+
+				return true;
+			}
+
+			$b = ($this->isHeadPart() ? $this : $other);
+
+			if($b->isOccupied()){
+				$player->sendMessage(KnownTranslationFactory::tile_bed_occupied()->prefix(TextFormat::GRAY));
+
+				return true;
+			}
+
+			$player->sleepOn($b->position);
+		}
+
+		return true;
+
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(($other = $this->getOtherHalf()) !== null and $other->occupied !== $this->occupied){
+			$this->occupied = $other->occupied;
+			$this->position->getWorld()->setBlock($this->position, $this);
+		}
+	}
+
+	public function onEntityLand(Entity $entity) : ?float{
+		if($entity instanceof Living && $entity->isSneaking()){
+			return null;
+		}
+		$entity->fallDistance *= 0.5;
+		return $entity->getMotion()->y * -3 / 4; // 2/3 in Java, according to the wiki
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if(!$down->isTransparent()){
+			$this->facing = $player !== null ? $player->getHorizontalFacing() : Facing::NORTH;
+
+			$next = $this->getSide($this->getOtherHalfSide());
+			if($next->canBeReplaced() and !$next->getSide(Facing::DOWN)->isTransparent()){
+				$nextState = clone $this;
+				$nextState->head = true;
+				$tx->addBlock($blockReplace->position, $this)->addBlock($next->position, $nextState);
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public function getDrops(Item $item) : array{
+		if($this->head){
+			return parent::getDrops($item);
+		}
+
+		return [];
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return DyeColorIdMap::getInstance()->toId($this->color);
+	}
+
+	public function getAffectedBlocks() : array{
+		if(($other = $this->getOtherHalf()) !== null){
+			return [$this, $other];
+		}
+
+		return parent::getAffectedBlocks();
+	}
+}

src/block/Bedrock.php

@@ -23,33 +23,29 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\TieredTool;
+class Bedrock extends Opaque{
 
-class Netherrack extends Solid{
+	private bool $burnsForever = false;
 
-	protected $id = self::NETHERRACK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->burnsForever = ($stateMeta & BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN) !== 0;
 	}
 
-	public function getName() : string{
-		return "Netherrack";
+	protected function writeStateToMeta() : int{
+		return $this->burnsForever ? BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN : 0;
 	}
 
-	public function getHardness() : float{
-		return 0.4;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
+	public function getStateBitmask() : int{
+		return 0b1;
 	}
 
 	public function burnsForever() : bool{
-		return true;
+		return $this->burnsForever;
+	}
+
+	/** @return $this */
+	public function setBurnsForever(bool $burnsForever) : self{
+		$this->burnsForever = $burnsForever;
+		return $this;
 	}
 }

src/block/Beetroot.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use function mt_rand;
+
+class Beetroot extends Crops{
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		if($this->age >= 7){
+			return [
+				VanillaItems::BEETROOT(),
+				VanillaItems::BEETROOT_SEEDS()->setCount(mt_rand(0, 3))
+			];
+		}
+
+		return [
+			VanillaItems::BEETROOT_SEEDS()
+		];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::BEETROOT_SEEDS();
+	}
+}

src/block/Bell.php

@@ -0,0 +1,160 @@
+<?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\Bell as TileBell;
+use pocketmine\block\utils\BellAttachmentType;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\BellRingSound;
+
+final class Bell extends Transparent{
+	use HorizontalFacingTrait;
+
+	private BellAttachmentType $attachmentType;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->attachmentType = BellAttachmentType::FLOOR();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->setFacing(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03));
+
+		$attachmentType = [
+			BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR => BellAttachmentType::FLOOR(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_CEILING => BellAttachmentType::CEILING(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL => BellAttachmentType::ONE_WALL(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS => BellAttachmentType::TWO_WALLS()
+		][($stateMeta >> 2) & 0b11] ?? null;
+		if($attachmentType === null){
+			throw new InvalidBlockStateException("No such attachment type");
+		}
+		$this->setAttachmentType($attachmentType);
+	}
+
+	public function writeStateToMeta() : int{
+		$attachmentTypeMeta = [
+			BellAttachmentType::FLOOR()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR,
+			BellAttachmentType::CEILING()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_CEILING,
+			BellAttachmentType::ONE_WALL()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL,
+			BellAttachmentType::TWO_WALLS()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS
+		][$this->getAttachmentType()->id()] ?? null;
+		if($attachmentTypeMeta === null){
+			throw new AssumptionFailedError("Mapping should cover all cases");
+		}
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->getFacing()) | ($attachmentTypeMeta << 2);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function getAttachmentType() : BellAttachmentType{ return $this->attachmentType; }
+
+	/** @return $this */
+	public function setAttachmentType(BellAttachmentType $attachmentType) : self{
+		$this->attachmentType = $attachmentType;
+		return $this;
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		//TODO: this isn't the actual logic, but it's the closest approximation we can support for now
+		return $block->isSolid();
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP){
+			if(!$this->canBeSupportedBy($tx->fetchBlock($this->position->down()))){
+				return false;
+			}
+			if($player !== null){
+				$this->setFacing(Facing::opposite($player->getHorizontalFacing()));
+			}
+			$this->setAttachmentType(BellAttachmentType::FLOOR());
+		}elseif($face === Facing::DOWN){
+			if(!$this->canBeSupportedBy($tx->fetchBlock($this->position->up()))){
+				return false;
+			}
+			$this->setAttachmentType(BellAttachmentType::CEILING());
+		}else{
+			$this->setFacing($face);
+			if($this->canBeSupportedBy($tx->fetchBlock($this->position->getSide(Facing::opposite($face))))){
+				$this->setAttachmentType(BellAttachmentType::ONE_WALL());
+			}else{
+				return false;
+			}
+			if($this->canBeSupportedBy($tx->fetchBlock($this->position->getSide($face)))){
+				$this->setAttachmentType(BellAttachmentType::TWO_WALLS());
+			}
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(
+			($this->attachmentType->equals(BellAttachmentType::CEILING()) && !$this->canBeSupportedBy($this->getSide(Facing::UP))) ||
+			($this->attachmentType->equals(BellAttachmentType::FLOOR()) && !$this->canBeSupportedBy($this->getSide(Facing::DOWN))) ||
+			($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) && !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)))) ||
+			($this->attachmentType->equals(BellAttachmentType::TWO_WALLS()) && (!$this->canBeSupportedBy($this->getSide($this->facing)) || !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)))))
+		){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$faceHit = Facing::opposite($player->getHorizontalFacing());
+			if($this->attachmentType->equals(BellAttachmentType::CEILING())){
+				$this->ring($faceHit);
+			}
+			if($this->attachmentType->equals(BellAttachmentType::FLOOR()) && Facing::axis($faceHit) === Facing::axis($this->facing)){
+				$this->ring($faceHit);
+			}
+			if(
+				($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) || $this->attachmentType->equals(BellAttachmentType::TWO_WALLS())) &&
+				($faceHit === Facing::rotateY($this->facing, false) || $faceHit === Facing::rotateY($this->facing, true))
+			){
+				$this->ring($faceHit);
+			}
+		}
+
+		return true;
+	}
+
+	public function ring(int $faceHit) : void{
+		$this->position->getWorld()->addSound($this->position, new BellRingSound());
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileBell){
+			$this->position->getWorld()->broadcastPacketToViewers($this->position, $tile->createFakeUpdatePacket($faceHit));
+		}
+	}
+}

src/block/Block.php

@@ -0,0 +1,637 @@
+<?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);
+
+/**
+ * All Block classes are in here
+ */
+namespace pocketmine\block;
+
+use pocketmine\block\tile\Spawnable;
+use pocketmine\block\tile\Tile;
+use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\entity\Entity;
+use pocketmine\item\enchantment\VanillaEnchantments;
+use pocketmine\item\Item;
+use pocketmine\item\ItemFactory;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\RayTraceResult;
+use pocketmine\math\Vector3;
+use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\format\Chunk;
+use pocketmine\world\Position;
+use pocketmine\world\World;
+use function assert;
+use function count;
+use function dechex;
+use const PHP_INT_MAX;
+
+class Block{
+	public const INTERNAL_METADATA_BITS = 4;
+	public const INTERNAL_METADATA_MASK = ~(~0 << self::INTERNAL_METADATA_BITS);
+
+	protected BlockIdentifier $idInfo;
+	protected string $fallbackName;
+	protected BlockBreakInfo $breakInfo;
+	protected Position $position;
+
+	/** @var AxisAlignedBB[]|null */
+	protected ?array $collisionBoxes = null;
+
+	/**
+	 * @param string          $name English name of the block type (TODO: implement translations)
+	 */
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		if(($idInfo->getVariant() & $this->getStateBitmask()) !== 0){
+			throw new \InvalidArgumentException("Variant 0x" . dechex($idInfo->getVariant()) . " collides with state bitmask 0x" . dechex($this->getStateBitmask()));
+		}
+		$this->idInfo = $idInfo;
+		$this->fallbackName = $name;
+		$this->breakInfo = $breakInfo;
+		$this->position = new Position(0, 0, 0, null);
+	}
+
+	public function __clone(){
+		$this->position = clone $this->position;
+	}
+
+	public function getIdInfo() : BlockIdentifier{
+		return $this->idInfo;
+	}
+
+	public function getName() : string{
+		return $this->fallbackName;
+	}
+
+	public function getId() : int{
+		return $this->idInfo->getBlockId();
+	}
+
+	/**
+	 * @internal
+	 */
+	public function getFullId() : int{
+		return ($this->getId() << self::INTERNAL_METADATA_BITS) | $this->getMeta();
+	}
+
+	public function asItem() : Item{
+		return ItemFactory::getInstance()->get(
+			$this->idInfo->getItemId(),
+			$this->idInfo->getVariant() | $this->writeStateToItemMeta()
+		);
+	}
+
+	public function getMeta() : int{
+		$stateMeta = $this->writeStateToMeta();
+		assert(($stateMeta & ~$this->getStateBitmask()) === 0);
+		return $this->idInfo->getVariant() | $stateMeta;
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns a bitmask used to extract state bits from block metadata.
+	 */
+	public function getStateBitmask() : int{
+		return 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return 0;
+	}
+
+	/**
+	 * @throws InvalidBlockStateException
+	 */
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		//NOOP
+	}
+
+	/**
+	 * 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.
+	 */
+	public function readStateFromWorld() : void{
+		$this->collisionBoxes = null;
+	}
+
+	public function writeStateToWorld() : void{
+		$this->position->getWorld()->getOrLoadChunkAtPosition($this->position)->setFullBlock($this->position->x & Chunk::COORD_MASK, $this->position->y, $this->position->z & Chunk::COORD_MASK, $this->getFullId());
+
+		$tileType = $this->idInfo->getTileClass();
+		$oldTile = $this->position->getWorld()->getTile($this->position);
+		if($oldTile !== null){
+			if($tileType === null or !($oldTile instanceof $tileType)){
+				$oldTile->close();
+				$oldTile = null;
+			}elseif($oldTile instanceof Spawnable){
+				$oldTile->setDirty(); //destroy old network cache
+			}
+		}
+		if($oldTile === null and $tileType !== null){
+			/**
+			 * @var Tile $tile
+			 * @see Tile::__construct()
+			 */
+			$tile = new $tileType($this->position->getWorld(), $this->position->asVector3());
+			$this->position->getWorld()->addTile($tile);
+		}
+	}
+
+	/**
+	 * Returns whether the given block has an equivalent type to this one. This compares base legacy ID and variant.
+	 *
+	 * Note: This ignores additional IDs used to represent additional states. This means that, for example, a lit
+	 * furnace and unlit furnace are considered the same type.
+	 */
+	public function isSameType(Block $other) : bool{
+		return $this->idInfo->getBlockId() === $other->idInfo->getBlockId() and $this->idInfo->getVariant() === $other->idInfo->getVariant();
+	}
+
+	/**
+	 * Returns whether the given block has the same type and properties as this block.
+	 */
+	public function isSameState(Block $other) : bool{
+		return $this->getFullId() === $other->getFullId();
+	}
+
+	/**
+	 * AKA: Block->isPlaceable
+	 */
+	public function canBePlaced() : bool{
+		return true;
+	}
+
+	public function canBeReplaced() : bool{
+		return false;
+	}
+
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
+		return $blockReplace->canBeReplaced();
+	}
+
+	/**
+	 * Places the Block, using block space and block target, and side. Returns if the block has been placed.
+	 */
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$tx->addBlock($blockReplace->position, $this);
+		return true;
+	}
+
+	public function onPostPlace() : void{
+
+	}
+
+	/**
+	 * Returns an object containing information about the destruction requirements of this block.
+	 */
+	public function getBreakInfo() : BlockBreakInfo{
+		return $this->breakInfo;
+	}
+
+	/**
+	 * Do the actions needed so the block is broken with the Item
+	 */
+	public function onBreak(Item $item, ?Player $player = null) : bool{
+		if(($t = $this->position->getWorld()->getTile($this->position)) !== null){
+			$t->onBlockDestroyed();
+		}
+		$this->position->getWorld()->setBlock($this->position, VanillaBlocks::AIR());
+		return true;
+	}
+
+	/**
+	 * Called when this block or a block immediately adjacent to it changes state.
+	 */
+	public function onNearbyBlockChange() : void{
+
+	}
+
+	/**
+	 * Returns whether random block updates will be done on this block.
+	 */
+	public function ticksRandomly() : bool{
+		return false;
+	}
+
+	/**
+	 * Called when this block is randomly updated due to chunk ticking.
+	 * WARNING: This will not be called if ticksRandomly() does not return true!
+	 */
+	public function onRandomTick() : void{
+
+	}
+
+	/**
+	 * Called when this block is updated by the delayed blockupdate scheduler in the world.
+	 */
+	public function onScheduledUpdate() : void{
+
+	}
+
+	/**
+	 * Do actions when interacted by Item. Returns if it has done anything
+	 */
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		return false;
+	}
+
+	/**
+	 * Called when this block is attacked (left-clicked). This is called when a player left-clicks the block to try and
+	 * start to break it in survival mode.
+	 *
+	 * @return bool if an action took place, prevents starting to break the block if true.
+	 */
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
+		return false;
+	}
+
+	public function getFrictionFactor() : float{
+		return 0.6;
+	}
+
+	/**
+	 * @return int 0-15
+	 */
+	public function getLightLevel() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns the amount of light this block will filter out when light passes through this block.
+	 * This value is used in light spread calculation.
+	 *
+	 * @return int 0-15
+	 */
+	public function getLightFilter() : int{
+		return $this->isTransparent() ? 0 : 15;
+	}
+
+	/**
+	 * Returns whether this block blocks direct sky light from passing through it. This is independent from the light
+	 * filter value, which is used during propagation.
+	 *
+	 * In most cases, this is the same as isTransparent(); however, some special cases exist such as leaves and cobwebs,
+	 * which don't have any additional effect on light propagation, but don't allow direct sky light to pass through.
+	 */
+	public function blocksDirectSkyLight() : bool{
+		return $this->getLightFilter() > 0;
+	}
+
+	public function isTransparent() : bool{
+		return false;
+	}
+
+	public function isSolid() : bool{
+		return true;
+	}
+
+	/**
+	 * AKA: Block->isFlowable
+	 */
+	public function canBeFlowedInto() : bool{
+		return false;
+	}
+
+	public function hasEntityCollision() : bool{
+		return false;
+	}
+
+	/**
+	 * Returns whether entities can climb up this block.
+	 */
+	public function canClimb() : bool{
+		return false;
+	}
+
+	public function addVelocityToEntity(Entity $entity) : ?Vector3{
+		return null;
+	}
+
+	final public function getPosition() : Position{
+		return $this->position;
+	}
+
+	/**
+	 * @internal
+	 */
+	final public function position(World $world, int $x, int $y, int $z) : void{
+		$this->position = new Position($x, $y, $z, $world);
+	}
+
+	/**
+	 * Returns an array of Item objects to be dropped
+	 *
+	 * @return Item[]
+	 */
+	public function getDrops(Item $item) : array{
+		if($this->breakInfo->isToolCompatible($item)){
+			if($this->isAffectedBySilkTouch() and $item->hasEnchantment(VanillaEnchantments::SILK_TOUCH())){
+				return $this->getSilkTouchDrops($item);
+			}
+
+			return $this->getDropsForCompatibleTool($item);
+		}
+
+		return $this->getDropsForIncompatibleTool($item);
+	}
+
+	/**
+	 * Returns an array of Items to be dropped when the block is broken using the correct tool type.
+	 *
+	 * @return Item[]
+	 */
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [$this->asItem()];
+	}
+
+	/**
+	 * Returns the items dropped by this block when broken with an incorrect tool type (or tool with a too-low tier).
+	 *
+	 * @return Item[]
+	 */
+	public function getDropsForIncompatibleTool(Item $item) : array{
+		return [];
+	}
+
+	/**
+	 * Returns an array of Items to be dropped when the block is broken using a compatible Silk Touch-enchanted tool.
+	 *
+	 * @return Item[]
+	 */
+	public function getSilkTouchDrops(Item $item) : array{
+		return [$this->asItem()];
+	}
+
+	/**
+	 * Returns how much XP will be dropped by breaking this block with the given item.
+	 */
+	public function getXpDropForTool(Item $item) : int{
+		if($item->hasEnchantment(VanillaEnchantments::SILK_TOUCH()) or !$this->breakInfo->isToolCompatible($item)){
+			return 0;
+		}
+
+		return $this->getXpDropAmount();
+	}
+
+	/**
+	 * Returns how much XP this block will drop when broken with an appropriate tool.
+	 */
+	protected function getXpDropAmount() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns whether Silk Touch enchanted tools will cause this block to drop as itself.
+	 */
+	public function isAffectedBySilkTouch() : bool{
+		return false;
+	}
+
+	/**
+	 * Returns the item that players will equip when middle-clicking on this block.
+	 */
+	public function getPickedItem(bool $addUserData = false) : Item{
+		$item = $this->asItem();
+		if($addUserData){
+			$tile = $this->position->getWorld()->getTile($this->position);
+			if($tile instanceof Tile){
+				$nbt = $tile->getCleanedNBT();
+				if($nbt instanceof CompoundTag){
+					$item->setCustomBlockData($nbt);
+					$item->setLore(["+(DATA)"]);
+				}
+			}
+		}
+		return $item;
+	}
+
+	/**
+	 * Returns the time in ticks which the block will fuel a furnace for.
+	 */
+	public function getFuelTime() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns the maximum number of this block that can fit into a single item stack.
+	 */
+	public function getMaxStackSize() : int{
+		return 64;
+	}
+
+	/**
+	 * Returns the chance that the block will catch fire from nearby fire sources. Higher values lead to faster catching
+	 * fire.
+	 */
+	public function getFlameEncouragement() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns the base flammability of this block. Higher values lead to the block burning away more quickly.
+	 */
+	public function getFlammability() : int{
+		return 0;
+	}
+
+	/**
+	 * Returns whether fire lit on this block will burn indefinitely.
+	 */
+	public function burnsForever() : bool{
+		return false;
+	}
+
+	/**
+	 * Returns whether this block can catch fire.
+	 */
+	public function isFlammable() : bool{
+		return $this->getFlammability() > 0;
+	}
+
+	/**
+	 * Called when this block is burned away by being on fire.
+	 */
+	public function onIncinerate() : void{
+
+	}
+
+	/**
+	 * Returns the Block on the side $side, works like Vector3::getSide()
+	 *
+	 * @return Block
+	 */
+	public function getSide(int $side, int $step = 1){
+		if($this->position->isValid()){
+			return $this->position->getWorld()->getBlock($this->position->getSide($side, $step));
+		}
+
+		throw new \LogicException("Block does not have a valid world");
+	}
+
+	/**
+	 * Returns the 4 blocks on the horizontal axes around the block (north, south, east, west)
+	 *
+	 * @return Block[]|\Generator
+	 * @phpstan-return \Generator<int, Block, void, void>
+	 */
+	public function getHorizontalSides() : \Generator{
+		$world = $this->position->getWorld();
+		foreach($this->position->sidesAroundAxis(Axis::Y) as $vector3){
+			yield $world->getBlock($vector3);
+		}
+	}
+
+	/**
+	 * Returns the six blocks around this block.
+	 *
+	 * @return Block[]|\Generator
+	 * @phpstan-return \Generator<int, Block, void, void>
+	 */
+	public function getAllSides() : \Generator{
+		$world = $this->position->getWorld();
+		foreach($this->position->sides() as $vector3){
+			yield $world->getBlock($vector3);
+		}
+	}
+
+	/**
+	 * Returns a list of blocks that this block is part of. In most cases, only contains the block itself, but in cases
+	 * such as double plants, beds and doors, will contain both halves.
+	 *
+	 * @return Block[]
+	 */
+	public function getAffectedBlocks() : array{
+		return [$this];
+	}
+
+	/**
+	 * @return string
+	 */
+	public function __toString(){
+		return "Block[" . $this->getName() . "] (" . $this->getId() . ":" . $this->getMeta() . ")";
+	}
+
+	/**
+	 * Checks for collision against an AxisAlignedBB
+	 */
+	public function collidesWithBB(AxisAlignedBB $bb) : bool{
+		foreach($this->getCollisionBoxes() as $bb2){
+			if($bb->intersectsWith($bb2)){
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Called when an entity's bounding box clips inside this block's cell. Note that the entity may not be intersecting
+	 * with the collision box or bounding box.
+	 *
+	 * @return bool Whether the block is still the same after the intersection. If it changed (e.g. due to an explosive
+	 * being ignited), this should return false.
+	 */
+	public function onEntityInside(Entity $entity) : bool{
+		return true;
+	}
+
+	/**
+	 * Called when an entity lands on this block (usually due to falling).
+	 * @return float|null The new vertical velocity of the entity, or null if unchanged.
+	 */
+	public function onEntityLand(Entity $entity) : ?float{
+		return null;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	final public function getCollisionBoxes() : array{
+		if($this->collisionBoxes === null){
+			$this->collisionBoxes = $this->recalculateCollisionBoxes();
+			$extraOffset = $this->getModelPositionOffset();
+			$offset = $extraOffset !== null ? $this->position->addVector($extraOffset) : $this->position;
+			foreach($this->collisionBoxes as $bb){
+				$bb->offset($offset->x, $offset->y, $offset->z);
+			}
+		}
+
+		return $this->collisionBoxes;
+	}
+
+	/**
+	 * Returns an additional fractional vector to shift the block model's position by based on the current position.
+	 * Used to randomize position of things like bamboo canes and tall grass.
+	 */
+	public function getModelPositionOffset() : ?Vector3{
+		return null;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()];
+	}
+
+	public function isFullCube() : bool{
+		$bb = $this->getCollisionBoxes();
+
+		return count($bb) === 1 and $bb[0]->getAverageEdgeLength() >= 1 and $bb[0]->isCube();
+	}
+
+	public function calculateIntercept(Vector3 $pos1, Vector3 $pos2) : ?RayTraceResult{
+		$bbs = $this->getCollisionBoxes();
+		if(count($bbs) === 0){
+			return null;
+		}
+
+		/** @var RayTraceResult|null $currentHit */
+		$currentHit = null;
+		/** @var int|float $currentDistance */
+		$currentDistance = PHP_INT_MAX;
+
+		foreach($bbs as $bb){
+			$nextHit = $bb->calculateIntercept($pos1, $pos2);
+			if($nextHit === null){
+				continue;
+			}
+
+			$nextDistance = $nextHit->hitVector->distanceSquared($pos1);
+			if($nextDistance < $currentDistance){
+				$currentHit = $nextHit;
+				$currentDistance = $nextDistance;
+			}
+		}
+
+		return $currentHit;
+	}
+}

src/block/BlockBreakInfo.php

@@ -0,0 +1,148 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\item\Item;
+use function get_class;
+
+class BlockBreakInfo{
+	/**
+	 * If the tool is the correct type and high enough harvest level (tool tier), base break time is hardness multiplied
+	 * by this value.
+	 */
+	public const COMPATIBLE_TOOL_MULTIPLIER = 1.5;
+	/**
+	 * If the tool is an incorrect type or too low harvest level (tool tier), base break time is hardness multiplied by
+	 * this value.
+	 */
+	public const INCOMPATIBLE_TOOL_MULTIPLIER = 5.0;
+
+	private float $hardness;
+	private float $blastResistance;
+	private int $toolType;
+	private int $toolHarvestLevel;
+
+	/**
+	 * @param float|null $blastResistance default 5x hardness
+	 */
+	public function __construct(float $hardness, int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0, ?float $blastResistance = null){
+		$this->hardness = $hardness;
+		$this->toolType = $toolType;
+		$this->toolHarvestLevel = $toolHarvestLevel;
+		$this->blastResistance = $blastResistance ?? $hardness * 5;
+	}
+
+	public static function instant(int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0) : self{
+		return new self(0.0, $toolType, $toolHarvestLevel, 0.0);
+	}
+
+	public static function indestructible(float $blastResistance = 18000000.0) : self{
+		return new self(-1.0, BlockToolType::NONE, 0, $blastResistance);
+	}
+
+	/**
+	 * Returns a base value used to compute block break times.
+	 */
+	public function getHardness() : float{
+		return $this->hardness;
+	}
+
+	/**
+	 * Returns whether the block can be broken at all.
+	 */
+	public function isBreakable() : bool{
+		return $this->hardness >= 0;
+	}
+
+	/**
+	 * Returns whether this block can be instantly broken.
+	 */
+	public function breaksInstantly() : bool{
+		return $this->hardness == 0.0;
+	}
+
+	/**
+	 * Returns the block's resistance to explosions. Usually 5x hardness.
+	 */
+	public function getBlastResistance() : float{
+		return $this->blastResistance;
+	}
+
+	public function getToolType() : int{
+		return $this->toolType;
+	}
+
+	/**
+	 * Returns the level of tool required to harvest the block (for normal blocks). When the tool type matches the
+	 * block's required tool type, the tool must have a harvest level greater than or equal to this value to be able to
+	 * successfully harvest the block.
+	 *
+	 * If the block requires a specific minimum tier of tiered tool, the minimum tier required should be returned.
+	 * Otherwise, 1 should be returned if a tool is required, 0 if not.
+	 *
+	 * @see Item::getBlockToolHarvestLevel()
+	 */
+	public function getToolHarvestLevel() : int{
+		return $this->toolHarvestLevel;
+	}
+
+	/**
+	 * Returns whether the specified item is the proper tool to use for breaking this block. This checks tool type and
+	 * harvest level requirement.
+	 *
+	 * In most cases this is also used to determine whether block drops should be created or not, except in some
+	 * special cases such as vines.
+	 */
+	public function isToolCompatible(Item $tool) : bool{
+		if($this->hardness < 0){
+			return false;
+		}
+
+		return $this->toolType === BlockToolType::NONE or $this->toolHarvestLevel === 0 or (
+				($this->toolType & $tool->getBlockToolType()) !== 0 and $tool->getBlockToolHarvestLevel() >= $this->toolHarvestLevel);
+	}
+
+	/**
+	 * Returns the seconds that this block takes to be broken using an specific Item
+	 *
+	 * @throws \InvalidArgumentException if the item efficiency is not a positive number
+	 */
+	public function getBreakTime(Item $item) : float{
+		$base = $this->hardness;
+		if($this->isToolCompatible($item)){
+			$base *= self::COMPATIBLE_TOOL_MULTIPLIER;
+		}else{
+			$base *= self::INCOMPATIBLE_TOOL_MULTIPLIER;
+		}
+
+		$efficiency = $item->getMiningEfficiency(($this->toolType & $item->getBlockToolType()) !== 0);
+		if($efficiency <= 0){
+			throw new \InvalidArgumentException(get_class($item) . " has invalid mining efficiency: expected >= 0, got $efficiency");
+		}
+
+		$base /= $efficiency;
+
+		return $base;
+	}
+}

src/block/BlockIdentifier.php

@@ -0,0 +1,76 @@
+<?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\Tile;
+use pocketmine\utils\Utils;
+
+class BlockIdentifier{
+
+	private int $blockId;
+	private int $variant;
+	private ?int $itemId;
+	/** @phpstan-var class-string<Tile>|null */
+	private ?string $tileClass;
+
+	/**
+	 * @phpstan-param class-string<Tile>|null $tileClass
+	 */
+	public function __construct(int $blockId, int $variant, ?int $itemId = null, ?string $tileClass = null){
+		$this->blockId = $blockId;
+		$this->variant = $variant;
+		$this->itemId = $itemId;
+
+		if($tileClass !== null){
+			Utils::testValidInstance($tileClass, Tile::class);
+		}
+		$this->tileClass = $tileClass;
+	}
+
+	public function getBlockId() : int{
+		return $this->blockId;
+	}
+
+	/**
+	 * @return int[]
+	 */
+	public function getAllBlockIds() : array{
+		return [$this->blockId];
+	}
+
+	public function getVariant() : int{
+		return $this->variant;
+	}
+
+	public function getItemId() : int{
+		return $this->itemId ?? ($this->blockId > 255 ? 255 - $this->blockId : $this->blockId);
+	}
+
+	/**
+	 * @phpstan-return class-string<Tile>|null
+	 */
+	public function getTileClass() : ?string{
+		return $this->tileClass;
+	}
+}

src/block/BlockIdentifierFlattened.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use function count;
+
+class BlockIdentifierFlattened extends BlockIdentifier{
+
+	/** @var int[] */
+	private array $additionalIds;
+
+	/**
+	 * @param int[] $additionalIds
+	 */
+	public function __construct(int $blockId, array $additionalIds, int $variant, ?int $itemId = null, ?string $tileClass = null){
+		if(count($additionalIds) === 0){
+			throw new \InvalidArgumentException("Expected at least 1 additional ID");
+		}
+		parent::__construct($blockId, $variant, $itemId, $tileClass);
+
+		$this->additionalIds = $additionalIds;
+	}
+
+	public function getAdditionalId(int $index) : int{
+		if(!isset($this->additionalIds[$index])){
+			throw new \InvalidArgumentException("No such ID at index $index");
+		}
+		return $this->additionalIds[$index];
+	}
+
+	public function getSecondId() : int{
+		return $this->getAdditionalId(0);
+	}
+
+	public function getAllBlockIds() : array{
+		return [$this->getBlockId(), ...$this->additionalIds];
+	}
+}

src/block/BlockLegacyIdHelper.php

@@ -0,0 +1,248 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\BlockIdentifier as BID;
+use pocketmine\block\BlockLegacyIds as Ids;
+use pocketmine\block\tile\Sign as TileSign;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\block\utils\TreeType;
+use pocketmine\item\ItemIds;
+use pocketmine\utils\AssumptionFailedError;
+
+final class BlockLegacyIdHelper{
+
+	public static function getWoodenFloorSignIdentifier(TreeType $treeType) : BID{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BID(Ids::SIGN_POST, 0, ItemIds::SIGN, TileSign::class);
+			case TreeType::SPRUCE()->id():
+				return new BID(Ids::SPRUCE_STANDING_SIGN, 0, ItemIds::SPRUCE_SIGN, TileSign::class);
+			case TreeType::BIRCH()->id():
+				return new BID(Ids::BIRCH_STANDING_SIGN, 0, ItemIds::BIRCH_SIGN, TileSign::class);
+			case TreeType::JUNGLE()->id():
+				return new BID(Ids::JUNGLE_STANDING_SIGN, 0, ItemIds::JUNGLE_SIGN, TileSign::class);
+			case TreeType::ACACIA()->id():
+				return new BID(Ids::ACACIA_STANDING_SIGN,0, ItemIds::ACACIA_SIGN, TileSign::class);
+			case TreeType::DARK_OAK()->id():
+				return new BID(Ids::DARKOAK_STANDING_SIGN, 0, ItemIds::DARKOAK_SIGN, TileSign::class);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenWallSignIdentifier(TreeType $treeType) : BID{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BID(Ids::WALL_SIGN, 0, ItemIds::SIGN, TileSign::class);
+			case TreeType::SPRUCE()->id():
+				return new BID(Ids::SPRUCE_WALL_SIGN, 0, ItemIds::SPRUCE_SIGN, TileSign::class);
+			case TreeType::BIRCH()->id():
+				return new BID(Ids::BIRCH_WALL_SIGN, 0, ItemIds::BIRCH_SIGN, TileSign::class);
+			case TreeType::JUNGLE()->id():
+				return new BID(Ids::JUNGLE_WALL_SIGN, 0, ItemIds::JUNGLE_SIGN, TileSign::class);
+			case TreeType::ACACIA()->id():
+				return new BID(Ids::ACACIA_WALL_SIGN, 0, ItemIds::ACACIA_SIGN, TileSign::class);
+			case TreeType::DARK_OAK()->id():
+				return new BID(Ids::DARKOAK_WALL_SIGN, 0, ItemIds::DARKOAK_SIGN, TileSign::class);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenTrapdoorIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::WOODEN_TRAPDOOR, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::SPRUCE_TRAPDOOR, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::BIRCH_TRAPDOOR, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::JUNGLE_TRAPDOOR, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::ACACIA_TRAPDOOR, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::DARK_OAK_TRAPDOOR, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenButtonIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::WOODEN_BUTTON, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::SPRUCE_BUTTON, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::BIRCH_BUTTON, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::JUNGLE_BUTTON, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::ACACIA_BUTTON, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::DARK_OAK_BUTTON, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenPressurePlateIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::WOODEN_PRESSURE_PLATE, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::SPRUCE_PRESSURE_PLATE, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::BIRCH_PRESSURE_PLATE, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::JUNGLE_PRESSURE_PLATE, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::ACACIA_PRESSURE_PLATE, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::DARK_OAK_PRESSURE_PLATE, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenDoorIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BID(Ids::OAK_DOOR_BLOCK, 0, ItemIds::OAK_DOOR);
+			case TreeType::SPRUCE()->id():
+				return new BID(Ids::SPRUCE_DOOR_BLOCK, 0, ItemIds::SPRUCE_DOOR);
+			case TreeType::BIRCH()->id():
+				return new BID(Ids::BIRCH_DOOR_BLOCK, 0, ItemIds::BIRCH_DOOR);
+			case TreeType::JUNGLE()->id():
+				return new BID(Ids::JUNGLE_DOOR_BLOCK, 0, ItemIds::JUNGLE_DOOR);
+			case TreeType::ACACIA()->id():
+				return new BID(Ids::ACACIA_DOOR_BLOCK, 0, ItemIds::ACACIA_DOOR);
+			case TreeType::DARK_OAK()->id():
+				return new BID(Ids::DARK_OAK_DOOR_BLOCK, 0, ItemIds::DARK_OAK_DOOR);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenFenceIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::OAK_FENCE_GATE, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::SPRUCE_FENCE_GATE, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::BIRCH_FENCE_GATE, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::JUNGLE_FENCE_GATE, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::ACACIA_FENCE_GATE, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::DARK_OAK_FENCE_GATE, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getWoodenStairsIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::OAK_STAIRS, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::SPRUCE_STAIRS, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::BIRCH_STAIRS, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::JUNGLE_STAIRS, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::ACACIA_STAIRS, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::DARK_OAK_STAIRS, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getStrippedLogIdentifier(TreeType $treeType) : BlockIdentifier{
+		switch($treeType->id()){
+			case TreeType::OAK()->id():
+				return new BlockIdentifier(Ids::STRIPPED_OAK_LOG, 0);
+			case TreeType::SPRUCE()->id():
+				return new BlockIdentifier(Ids::STRIPPED_SPRUCE_LOG, 0);
+			case TreeType::BIRCH()->id():
+				return new BlockIdentifier(Ids::STRIPPED_BIRCH_LOG, 0);
+			case TreeType::JUNGLE()->id():
+				return new BlockIdentifier(Ids::STRIPPED_JUNGLE_LOG, 0);
+			case TreeType::ACACIA()->id():
+				return new BlockIdentifier(Ids::STRIPPED_ACACIA_LOG, 0);
+			case TreeType::DARK_OAK()->id():
+				return new BlockIdentifier(Ids::STRIPPED_DARK_OAK_LOG, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all wood types");
+	}
+
+	public static function getGlazedTerracottaIdentifier(DyeColor $color) : BlockIdentifier{
+		switch($color->id()){
+			case DyeColor::WHITE()->id():
+				return new BlockIdentifier(Ids::WHITE_GLAZED_TERRACOTTA, 0);
+			case DyeColor::ORANGE()->id():
+				return new BlockIdentifier(Ids::ORANGE_GLAZED_TERRACOTTA, 0);
+			case DyeColor::MAGENTA()->id():
+				return new BlockIdentifier(Ids::MAGENTA_GLAZED_TERRACOTTA, 0);
+			case DyeColor::LIGHT_BLUE()->id():
+				return new BlockIdentifier(Ids::LIGHT_BLUE_GLAZED_TERRACOTTA, 0);
+			case DyeColor::YELLOW()->id():
+				return new BlockIdentifier(Ids::YELLOW_GLAZED_TERRACOTTA, 0);
+			case DyeColor::LIME()->id():
+				return new BlockIdentifier(Ids::LIME_GLAZED_TERRACOTTA, 0);
+			case DyeColor::PINK()->id():
+				return new BlockIdentifier(Ids::PINK_GLAZED_TERRACOTTA, 0);
+			case DyeColor::GRAY()->id():
+				return new BlockIdentifier(Ids::GRAY_GLAZED_TERRACOTTA, 0);
+			case DyeColor::LIGHT_GRAY()->id():
+				return new BlockIdentifier(Ids::SILVER_GLAZED_TERRACOTTA, 0);
+			case DyeColor::CYAN()->id():
+				return new BlockIdentifier(Ids::CYAN_GLAZED_TERRACOTTA, 0);
+			case DyeColor::PURPLE()->id():
+				return new BlockIdentifier(Ids::PURPLE_GLAZED_TERRACOTTA, 0);
+			case DyeColor::BLUE()->id():
+				return new BlockIdentifier(Ids::BLUE_GLAZED_TERRACOTTA, 0);
+			case DyeColor::BROWN()->id():
+				return new BlockIdentifier(Ids::BROWN_GLAZED_TERRACOTTA, 0);
+			case DyeColor::GREEN()->id():
+				return new BlockIdentifier(Ids::GREEN_GLAZED_TERRACOTTA, 0);
+			case DyeColor::RED()->id():
+				return new BlockIdentifier(Ids::RED_GLAZED_TERRACOTTA, 0);
+			case DyeColor::BLACK()->id():
+				return new BlockIdentifier(Ids::BLACK_GLAZED_TERRACOTTA, 0);
+		}
+		throw new AssumptionFailedError("Switch should cover all colours");
+	}
+
+	public static function getStoneSlabIdentifier(int $stoneSlabId, int $meta) : BlockIdentifierFlattened{
+		$id = [
+			1 => [Ids::STONE_SLAB, Ids::DOUBLE_STONE_SLAB],
+			2 => [Ids::STONE_SLAB2, Ids::DOUBLE_STONE_SLAB2],
+			3 => [Ids::STONE_SLAB3, Ids::DOUBLE_STONE_SLAB3],
+			4 => [Ids::STONE_SLAB4, Ids::DOUBLE_STONE_SLAB4]
+		][$stoneSlabId] ?? null;
+		if($id === null){
+			throw new \InvalidArgumentException("Stone slab type should be 1, 2, 3 or 4");
+		}
+		return new BlockIdentifierFlattened($id[0], [$id[1]], $meta);
+	}
+}

src/block/BlockLegacyIds.php

@@ -23,7 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-interface BlockIds{
+final class BlockLegacyIds{
+
+	private function __construct(){
+		//NOOP
+	}
 
 	public const AIR = 0;
 	public const STONE = 1;
@@ -42,7 +46,7 @@ interface BlockIds{
 	public const GOLD_ORE = 14;
 	public const IRON_ORE = 15;
 	public const COAL_ORE = 16;
-	public const LOG = 17, WOOD = 17;
+	public const LOG = 17;
 	public const LEAVES = 18;
 	public const SPONGE = 19;
 	public const GLASS = 20;
@@ -61,7 +65,7 @@ interface BlockIds{
 	public const PISTON = 33;
 	public const PISTONARMCOLLISION = 34, PISTON_ARM_COLLISION = 34;
 	public const WOOL = 35;
-
+	public const ELEMENT_0 = 36;
 	public const DANDELION = 37, YELLOW_FLOWER = 37;
 	public const POPPY = 38, RED_FLOWER = 38;
 	public const BROWN_MUSHROOM = 39;
@@ -187,11 +191,11 @@ interface BlockIds{
 	public const STAINED_CLAY = 159, STAINED_HARDENED_CLAY = 159, TERRACOTTA = 159;
 	public const STAINED_GLASS_PANE = 160;
 	public const LEAVES2 = 161;
-	public const LOG2 = 162, WOOD2 = 162;
+	public const LOG2 = 162;
 	public const ACACIA_STAIRS = 163;
 	public const DARK_OAK_STAIRS = 164;
 	public const SLIME = 165, SLIME_BLOCK = 165;
-
+	public const GLOW_STICK = 166;
 	public const IRON_TRAPDOOR = 167;
 	public const PRISMARINE = 168;
 	public const SEALANTERN = 169, SEA_LANTERN = 169;
@@ -215,7 +219,9 @@ interface BlockIds{
 	public const ACACIA_FENCE_GATE = 187;
 	public const REPEATING_COMMAND_BLOCK = 188;
 	public const CHAIN_COMMAND_BLOCK = 189;
-
+	public const HARD_GLASS_PANE = 190;
+	public const HARD_STAINED_GLASS_PANE = 191;
+	public const CHEMICAL_HEAT = 192;
 	public const SPRUCE_DOOR_BLOCK = 193;
 	public const BIRCH_DOOR_BLOCK = 194;
 	public const JUNGLE_DOOR_BLOCK = 195;
@@ -225,9 +231,9 @@ interface BlockIds{
 	public const FRAME_BLOCK = 199, ITEM_FRAME_BLOCK = 199;
 	public const CHORUS_FLOWER = 200;
 	public const PURPUR_BLOCK = 201;
-
+	public const COLORED_TORCH_RG = 202;
 	public const PURPUR_STAIRS = 203;
-
+	public const COLORED_TORCH_BP = 204;
 	public const UNDYED_SHULKER_BOX = 205;
 	public const END_BRICKS = 206;
 	public const FROSTED_ICE = 207;
@@ -259,7 +265,8 @@ interface BlockIds{
 	public const BLACK_GLAZED_TERRACOTTA = 235;
 	public const CONCRETE = 236;
 	public const CONCRETEPOWDER = 237, CONCRETE_POWDER = 237;
-
+	public const CHEMISTRY_TABLE = 238;
+	public const UNDERWATER_TORCH = 239;
 	public const CHORUS_PLANT = 240;
 	public const STAINED_GLASS = 241;
 
@@ -273,7 +280,222 @@ interface BlockIds{
 	public const MOVINGBLOCK = 250, MOVING_BLOCK = 250;
 	public const OBSERVER = 251;
 	public const STRUCTURE_BLOCK = 252;
-
+	public const HARD_GLASS = 253;
+	public const HARD_STAINED_GLASS = 254;
 	public const RESERVED6 = 255;
 
+	public const PRISMARINE_STAIRS = 257;
+	public const DARK_PRISMARINE_STAIRS = 258;
+	public const PRISMARINE_BRICKS_STAIRS = 259;
+	public const STRIPPED_SPRUCE_LOG = 260;
+	public const STRIPPED_BIRCH_LOG = 261;
+	public const STRIPPED_JUNGLE_LOG = 262;
+	public const STRIPPED_ACACIA_LOG = 263;
+	public const STRIPPED_DARK_OAK_LOG = 264;
+	public const STRIPPED_OAK_LOG = 265;
+	public const BLUE_ICE = 266;
+	public const ELEMENT_1 = 267;
+	public const ELEMENT_2 = 268;
+	public const ELEMENT_3 = 269;
+	public const ELEMENT_4 = 270;
+	public const ELEMENT_5 = 271;
+	public const ELEMENT_6 = 272;
+	public const ELEMENT_7 = 273;
+	public const ELEMENT_8 = 274;
+	public const ELEMENT_9 = 275;
+	public const ELEMENT_10 = 276;
+	public const ELEMENT_11 = 277;
+	public const ELEMENT_12 = 278;
+	public const ELEMENT_13 = 279;
+	public const ELEMENT_14 = 280;
+	public const ELEMENT_15 = 281;
+	public const ELEMENT_16 = 282;
+	public const ELEMENT_17 = 283;
+	public const ELEMENT_18 = 284;
+	public const ELEMENT_19 = 285;
+	public const ELEMENT_20 = 286;
+	public const ELEMENT_21 = 287;
+	public const ELEMENT_22 = 288;
+	public const ELEMENT_23 = 289;
+	public const ELEMENT_24 = 290;
+	public const ELEMENT_25 = 291;
+	public const ELEMENT_26 = 292;
+	public const ELEMENT_27 = 293;
+	public const ELEMENT_28 = 294;
+	public const ELEMENT_29 = 295;
+	public const ELEMENT_30 = 296;
+	public const ELEMENT_31 = 297;
+	public const ELEMENT_32 = 298;
+	public const ELEMENT_33 = 299;
+	public const ELEMENT_34 = 300;
+	public const ELEMENT_35 = 301;
+	public const ELEMENT_36 = 302;
+	public const ELEMENT_37 = 303;
+	public const ELEMENT_38 = 304;
+	public const ELEMENT_39 = 305;
+	public const ELEMENT_40 = 306;
+	public const ELEMENT_41 = 307;
+	public const ELEMENT_42 = 308;
+	public const ELEMENT_43 = 309;
+	public const ELEMENT_44 = 310;
+	public const ELEMENT_45 = 311;
+	public const ELEMENT_46 = 312;
+	public const ELEMENT_47 = 313;
+	public const ELEMENT_48 = 314;
+	public const ELEMENT_49 = 315;
+	public const ELEMENT_50 = 316;
+	public const ELEMENT_51 = 317;
+	public const ELEMENT_52 = 318;
+	public const ELEMENT_53 = 319;
+	public const ELEMENT_54 = 320;
+	public const ELEMENT_55 = 321;
+	public const ELEMENT_56 = 322;
+	public const ELEMENT_57 = 323;
+	public const ELEMENT_58 = 324;
+	public const ELEMENT_59 = 325;
+	public const ELEMENT_60 = 326;
+	public const ELEMENT_61 = 327;
+	public const ELEMENT_62 = 328;
+	public const ELEMENT_63 = 329;
+	public const ELEMENT_64 = 330;
+	public const ELEMENT_65 = 331;
+	public const ELEMENT_66 = 332;
+	public const ELEMENT_67 = 333;
+	public const ELEMENT_68 = 334;
+	public const ELEMENT_69 = 335;
+	public const ELEMENT_70 = 336;
+	public const ELEMENT_71 = 337;
+	public const ELEMENT_72 = 338;
+	public const ELEMENT_73 = 339;
+	public const ELEMENT_74 = 340;
+	public const ELEMENT_75 = 341;
+	public const ELEMENT_76 = 342;
+	public const ELEMENT_77 = 343;
+	public const ELEMENT_78 = 344;
+	public const ELEMENT_79 = 345;
+	public const ELEMENT_80 = 346;
+	public const ELEMENT_81 = 347;
+	public const ELEMENT_82 = 348;
+	public const ELEMENT_83 = 349;
+	public const ELEMENT_84 = 350;
+	public const ELEMENT_85 = 351;
+	public const ELEMENT_86 = 352;
+	public const ELEMENT_87 = 353;
+	public const ELEMENT_88 = 354;
+	public const ELEMENT_89 = 355;
+	public const ELEMENT_90 = 356;
+	public const ELEMENT_91 = 357;
+	public const ELEMENT_92 = 358;
+	public const ELEMENT_93 = 359;
+	public const ELEMENT_94 = 360;
+	public const ELEMENT_95 = 361;
+	public const ELEMENT_96 = 362;
+	public const ELEMENT_97 = 363;
+	public const ELEMENT_98 = 364;
+	public const ELEMENT_99 = 365;
+	public const ELEMENT_100 = 366;
+	public const ELEMENT_101 = 367;
+	public const ELEMENT_102 = 368;
+	public const ELEMENT_103 = 369;
+	public const ELEMENT_104 = 370;
+	public const ELEMENT_105 = 371;
+	public const ELEMENT_106 = 372;
+	public const ELEMENT_107 = 373;
+	public const ELEMENT_108 = 374;
+	public const ELEMENT_109 = 375;
+	public const ELEMENT_110 = 376;
+	public const ELEMENT_111 = 377;
+	public const ELEMENT_112 = 378;
+	public const ELEMENT_113 = 379;
+	public const ELEMENT_114 = 380;
+	public const ELEMENT_115 = 381;
+	public const ELEMENT_116 = 382;
+	public const ELEMENT_117 = 383;
+	public const ELEMENT_118 = 384;
+	public const SEAGRASS = 385;
+	public const CORAL = 386;
+	public const CORAL_BLOCK = 387;
+	public const CORAL_FAN = 388;
+	public const CORAL_FAN_DEAD = 389;
+	public const CORAL_FAN_HANG = 390;
+	public const CORAL_FAN_HANG2 = 391;
+	public const CORAL_FAN_HANG3 = 392;
+	public const KELP = 393;
+	public const DRIED_KELP_BLOCK = 394;
+	public const ACACIA_BUTTON = 395;
+	public const BIRCH_BUTTON = 396;
+	public const DARK_OAK_BUTTON = 397;
+	public const JUNGLE_BUTTON = 398;
+	public const SPRUCE_BUTTON = 399;
+	public const ACACIA_TRAPDOOR = 400;
+	public const BIRCH_TRAPDOOR = 401;
+	public const DARK_OAK_TRAPDOOR = 402;
+	public const JUNGLE_TRAPDOOR = 403;
+	public const SPRUCE_TRAPDOOR = 404;
+	public const ACACIA_PRESSURE_PLATE = 405;
+	public const BIRCH_PRESSURE_PLATE = 406;
+	public const DARK_OAK_PRESSURE_PLATE = 407;
+	public const JUNGLE_PRESSURE_PLATE = 408;
+	public const SPRUCE_PRESSURE_PLATE = 409;
+	public const CARVED_PUMPKIN = 410;
+	public const SEA_PICKLE = 411;
+	public const CONDUIT = 412;
+
+	public const TURTLE_EGG = 414;
+	public const BUBBLE_COLUMN = 415;
+	public const BARRIER = 416;
+	public const STONE_SLAB3 = 417;
+	public const BAMBOO = 418;
+	public const BAMBOO_SAPLING = 419;
+	public const SCAFFOLDING = 420;
+	public const STONE_SLAB4 = 421;
+	public const DOUBLE_STONE_SLAB3 = 422;
+	public const DOUBLE_STONE_SLAB4 = 423;
+	public const GRANITE_STAIRS = 424;
+	public const DIORITE_STAIRS = 425;
+	public const ANDESITE_STAIRS = 426;
+	public const POLISHED_GRANITE_STAIRS = 427;
+	public const POLISHED_DIORITE_STAIRS = 428;
+	public const POLISHED_ANDESITE_STAIRS = 429;
+	public const MOSSY_STONE_BRICK_STAIRS = 430;
+	public const SMOOTH_RED_SANDSTONE_STAIRS = 431;
+	public const SMOOTH_SANDSTONE_STAIRS = 432;
+	public const END_BRICK_STAIRS = 433;
+	public const MOSSY_COBBLESTONE_STAIRS = 434;
+	public const NORMAL_STONE_STAIRS = 435;
+	public const SPRUCE_STANDING_SIGN = 436;
+	public const SPRUCE_WALL_SIGN = 437;
+	public const SMOOTH_STONE = 438;
+	public const RED_NETHER_BRICK_STAIRS = 439;
+	public const SMOOTH_QUARTZ_STAIRS = 440;
+	public const BIRCH_STANDING_SIGN = 441;
+	public const BIRCH_WALL_SIGN = 442;
+	public const JUNGLE_STANDING_SIGN = 443;
+	public const JUNGLE_WALL_SIGN = 444;
+	public const ACACIA_STANDING_SIGN = 445;
+	public const ACACIA_WALL_SIGN = 446;
+	public const DARKOAK_STANDING_SIGN = 447;
+	public const DARKOAK_WALL_SIGN = 448;
+	public const LECTERN = 449;
+	public const GRINDSTONE = 450;
+	public const BLAST_FURNACE = 451;
+	public const STONECUTTER_BLOCK = 452;
+	public const SMOKER = 453;
+	public const LIT_SMOKER = 454;
+	public const CARTOGRAPHY_TABLE = 455;
+	public const FLETCHING_TABLE = 456;
+	public const SMITHING_TABLE = 457;
+	public const BARREL = 458;
+	public const LOOM = 459;
+
+	public const BELL = 461;
+	public const SWEET_BERRY_BUSH = 462;
+	public const LANTERN = 463;
+	public const CAMPFIRE = 464;
+	public const LAVA_CAULDRON = 465;
+	public const JIGSAW = 466;
+	public const WOOD = 467;
+	public const COMPOSTER = 468;
+	public const LIT_BLAST_FURNACE = 469;
+
 }

src/block/BlockLegacyMetadata.php

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

src/block/BlockToolType.php

@@ -27,14 +27,18 @@ namespace pocketmine\block;
  * Types of tools that can be used to break blocks
  * Blocks may allow multiple tool types by combining these bitflags
  */
-interface BlockToolType{
+final class BlockToolType{
 
-	public const TYPE_NONE = 0;
-	public const TYPE_SWORD = 1 << 0;
-	public const TYPE_SHOVEL = 1 << 1;
-	public const TYPE_PICKAXE = 1 << 2;
-	public const TYPE_AXE = 1 << 3;
-	public const TYPE_SHEARS = 1 << 4;
-	public const TYPE_HOE = 1 << 5;
+	private function __construct(){
+		//NOOP
+	}
+
+	public const NONE = 0;
+	public const SWORD = 1 << 0;
+	public const SHOVEL = 1 << 1;
+	public const PICKAXE = 1 << 2;
+	public const AXE = 1 << 3;
+	public const SHEARS = 1 << 4;
+	public const HOE = 1 << 5;
 
 }

src/block/BlueIce.php

@@ -23,15 +23,19 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class Furnace extends BurningFurnace{
+use pocketmine\item\Item;
 
-	protected $id = self::FURNACE;
-
-	public function getName() : string{
-		return "Furnace";
-	}
+class BlueIce extends Opaque{
 
 	public function getLightLevel() : int{
-		return 0;
+		return 1;
+	}
+
+	public function getFrictionFactor() : float{
+		return 0.99;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
 	}
 }

src/block/BoneBlock.php

@@ -0,0 +1,30 @@
+<?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\PillarRotationInMetadataTrait;
+
+class BoneBlock extends Opaque{
+	use PillarRotationInMetadataTrait;
+}

src/block/Bookshelf.php

@@ -24,34 +24,20 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 
-class Bookshelf extends Solid{
-
-	protected $id = self::BOOKSHELF;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Bookshelf";
-	}
-
-	public function getHardness() : float{
-		return 1.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
-	}
+class Bookshelf extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::BOOK, 0, 3)
+			VanillaItems::BOOK()->setCount(3)
 		];
 	}
 
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
 	public function getFuelTime() : int{
 		return 300;
 	}

src/block/BrewingStand.php

@@ -0,0 +1,130 @@
+<?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\BrewingStand as TileBrewingStand;
+use pocketmine\block\utils\BrewingStandSlot;
+use pocketmine\item\Item;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use function array_key_exists;
+
+class BrewingStand extends Transparent{
+
+	/**
+	 * @var BrewingStandSlot[]
+	 * @phpstan-var array<int, BrewingStandSlot>
+	 */
+	protected array $slots = [];
+
+	protected function writeStateToMeta() : int{
+		$flags = 0;
+		foreach([
+			BlockLegacyMetadata::BREWING_STAND_FLAG_EAST => BrewingStandSlot::EAST(),
+			BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST => BrewingStandSlot::NORTHWEST(),
+			BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST => BrewingStandSlot::SOUTHWEST(),
+		] as $flag => $slot){
+			$flags |= (array_key_exists($slot->id(), $this->slots) ? $flag : 0);
+		}
+		return $flags;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->slots = [];
+		foreach([
+			BlockLegacyMetadata::BREWING_STAND_FLAG_EAST => BrewingStandSlot::EAST(),
+			BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST => BrewingStandSlot::NORTHWEST(),
+			BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST => BrewingStandSlot::SOUTHWEST(),
+		] as $flag => $slot){
+			if(($stateMeta & $flag) !== 0){
+				$this->slots[$slot->id()] = $slot;
+			}
+		}
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	protected function recalculateCollisionBoxes() : array{
+		return [
+			//bottom slab part - in PC this is also inset on X/Z by 1/16, but Bedrock sucks
+			AxisAlignedBB::one()->trim(Facing::UP, 7 / 8),
+
+			//center post
+			AxisAlignedBB::one()
+				->squash(Axis::X, 7 / 16)
+				->squash(Axis::Z, 7 / 16)
+				->trim(Facing::UP, 1 / 8)
+		];
+	}
+
+	public function hasSlot(BrewingStandSlot $slot) : bool{
+		return array_key_exists($slot->id(), $this->slots);
+	}
+
+	public function setSlot(BrewingStandSlot $slot, bool $occupied) : self{
+		if($occupied){
+			$this->slots[$slot->id()] = $slot;
+		}else{
+			unset($this->slots[$slot->id()]);
+		}
+		return $this;
+	}
+
+	/**
+	 * @return BrewingStandSlot[]
+	 * @phpstan-return array<int, BrewingStandSlot>
+	 */
+	public function getSlots() : array{
+		return $this->slots;
+	}
+
+	/** @param BrewingStandSlot[] $slots */
+	public function setSlots(array $slots) : self{
+		$this->slots = [];
+		foreach($slots as $slot){
+			$this->slots[$slot->id()] = $slot;
+		}
+		return $this;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$stand = $this->position->getWorld()->getTile($this->position);
+			if($stand instanceof TileBrewingStand and $stand->canOpenWith($item->getCustomName())){
+				$player->setCurrentWindow($stand->getInventory());
+			}
+		}
+
+		return true;
+	}
+
+	public function onScheduledUpdate() : void{
+		//TODO
+	}
+}

src/block/BrownMushroom.php

@@ -25,12 +25,6 @@ namespace pocketmine\block;
 
 class BrownMushroom extends RedMushroom{
 
-	protected $id = self::BROWN_MUSHROOM;
-
-	public function getName() : string{
-		return "Brown Mushroom";
-	}
-
 	public function getLightLevel() : int{
 		return 1;
 	}

src/block/BrownMushroomBlock.php

@@ -28,15 +28,9 @@ use function mt_rand;
 
 class BrownMushroomBlock extends RedMushroomBlock{
 
-	protected $id = Block::BROWN_MUSHROOM_BLOCK;
-
-	public function getName() : string{
-		return "Brown Mushroom Block";
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			Item::get(Item::BROWN_MUSHROOM, 0, mt_rand(0, 2))
+			VanillaBlocks::BROWN_MUSHROOM()->asItem()->setCount(mt_rand(0, 2))
 		];
 	}
 }

src/block/Button.php

@@ -0,0 +1,89 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\utils\AnyFacingTrait;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\RedstonePowerOffSound;
+use pocketmine\world\sound\RedstonePowerOnSound;
+
+abstract class Button extends Flowable{
+	use AnyFacingTrait;
+
+	protected bool $pressed = false;
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeFacing($this->facing) | ($this->pressed ? BlockLegacyMetadata::BUTTON_FLAG_POWERED : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		//TODO: in PC it's (6 - facing) for every meta except 0 (down)
+		$this->facing = BlockDataSerializer::readFacing($stateMeta & 0x07);
+		$this->pressed = ($stateMeta & BlockLegacyMetadata::BUTTON_FLAG_POWERED) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function isPressed() : bool{ return $this->pressed; }
+
+	/** @return $this */
+	public function setPressed(bool $pressed) : self{
+		$this->pressed = $pressed;
+		return $this;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		//TODO: check valid target block
+		$this->facing = $face;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	abstract protected function getActivationTime() : int;
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->pressed){
+			$this->pressed = true;
+			$this->position->getWorld()->setBlock($this->position, $this);
+			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, $this->getActivationTime());
+			$this->position->getWorld()->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOnSound());
+		}
+
+		return true;
+	}
+
+	public function onScheduledUpdate() : void{
+		if($this->pressed){
+			$this->pressed = false;
+			$this->position->getWorld()->setBlock($this->position, $this);
+			$this->position->getWorld()->addSound($this->position->add(0.5, 0.5, 0.5), new RedstonePowerOffSound());
+		}
+	}
+}

src/block/Cactus.php

@@ -0,0 +1,144 @@
+<?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\BlockDataSerializer;
+use pocketmine\entity\Entity;
+use pocketmine\event\block\BlockGrowEvent;
+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{
+
+	protected int $age = 0;
+
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 15);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function getAge() : int{ return $this->age; }
+
+	/** @return $this */
+	public function setAge(int $age) : self{
+		if($age < 0 || $age > 15){
+			throw new \InvalidArgumentException("Age must be in range 0-15");
+		}
+		$this->age = $age;
+		return $this;
+	}
+
+	public function hasEntityCollision() : bool{
+		return true;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		static $shrinkSize = 1 / 16;
+		return [AxisAlignedBB::one()->contract($shrinkSize, 0, $shrinkSize)->trim(Facing::UP, $shrinkSize)];
+	}
+
+	public function onEntityInside(Entity $entity) : bool{
+		$ev = new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_CONTACT, 1);
+		$entity->attack($ev);
+		return true;
+	}
+
+	public function onNearbyBlockChange() : void{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::SAND and !$down->isSameType($this)){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}else{
+			foreach(Facing::HORIZONTAL as $side){
+				$b = $this->getSide($side);
+				if($b->isSolid()){
+					$this->position->getWorld()->useBreakOn($this->position);
+					break;
+				}
+			}
+		}
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if(!$this->getSide(Facing::DOWN)->isSameType($this)){
+			if($this->age === 15){
+				for($y = 1; $y < 3; ++$y){
+					if(!$this->position->getWorld()->isInWorld($this->position->x, $this->position->y + $y, $this->position->z)){
+						break;
+					}
+					$b = $this->position->getWorld()->getBlockAt($this->position->x, $this->position->y + $y, $this->position->z);
+					if($b->getId() === BlockLegacyIds::AIR){
+						$ev = new BlockGrowEvent($b, VanillaBlocks::CACTUS());
+						$ev->call();
+						if($ev->isCancelled()){
+							break;
+						}
+						$this->position->getWorld()->setBlock($b->position, $ev->getNewState());
+					}else{
+						break;
+					}
+				}
+				$this->age = 0;
+				$this->position->getWorld()->setBlock($this->position, $this);
+			}else{
+				++$this->age;
+				$this->position->getWorld()->setBlock($this->position, $this);
+			}
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() === BlockLegacyIds::SAND or $down->isSameType($this)){
+			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

@@ -0,0 +1,137 @@
+<?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\BlockDataSerializer;
+use pocketmine\entity\effect\EffectInstance;
+use pocketmine\entity\FoodSource;
+use pocketmine\entity\Living;
+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 Cake extends Transparent implements FoodSource{
+
+	protected int $bites = 0;
+
+	protected function writeStateToMeta() : int{
+		return $this->bites;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->bites = BlockDataSerializer::readBoundedInt("bites", $stateMeta, 0, 6);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [
+			AxisAlignedBB::one()
+				->contract(1 / 16, 0, 1 / 16)
+				->trim(Facing::UP, 0.5)
+				->trim(Facing::WEST, $this->bites / 8)
+		];
+	}
+
+	public function getBites() : int{ return $this->bites; }
+
+	/** @return $this */
+	public function setBites(int $bites) : self{
+		if($bites < 0 || $bites > 6){
+			throw new \InvalidArgumentException("Bites must be in range 0-6");
+		}
+		$this->bites = $bites;
+		return $this;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::AIR){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){ //Replace with common break method
+			$this->position->getWorld()->setBlock($this->position, VanillaBlocks::AIR());
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			return $player->consumeObject($this);
+		}
+
+		return false;
+	}
+
+	public function getFoodRestore() : int{
+		return 2;
+	}
+
+	public function getSaturationRestore() : float{
+		return 0.4;
+	}
+
+	public function requiresHunger() : bool{
+		return true;
+	}
+
+	/**
+	 * @return Block
+	 */
+	public function getResidue(){
+		$clone = clone $this;
+		$clone->bites++;
+		if($clone->bites > 6){
+			$clone = VanillaBlocks::AIR();
+		}
+		return $clone;
+	}
+
+	/**
+	 * @return EffectInstance[]
+	 */
+	public function getAdditionalEffects() : array{
+		return [];
+	}
+
+	public function onConsume(Living $consumer) : void{
+		$this->position->getWorld()->setBlock($this->position, $this->getResidue());
+	}
+}

src/block/Carpet.php

@@ -23,58 +23,46 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorBlockMetaHelper;
+use pocketmine\block\utils\ColorInMetadataTrait;
+use pocketmine\block\utils\DyeColor;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Carpet extends Flowable{
+	use ColorInMetadataTrait;
 
-	protected $id = self::CARPET;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 0.1;
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->color = DyeColor::WHITE();
+		parent::__construct($idInfo, $name, $breakInfo);
 	}
 
 	public function isSolid() : bool{
 		return true;
 	}
 
-	public function getName() : string{
-		return ColorBlockMetaHelper::getColorFromMeta($this->getVariant()) . " Carpet";
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()->trim(Facing::UP, 15 / 16)];
 	}
 
-	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 0.0625,
-			$this->z + 1
-		);
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() !== self::AIR){
-			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
-
-			return true;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::AIR){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){
-			$this->getLevelNonNull()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){
+			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 

src/block/Carrot.php

@@ -24,28 +24,18 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
 class Carrot extends Crops{
 
-	protected $id = self::CARROT_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Carrot Block";
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::CARROT, 0, $this->meta >= 0x07 ? mt_rand(1, 4) : 1)
+			VanillaItems::CARROT()->setCount($this->age >= 7 ? mt_rand(1, 4) : 1)
 		];
 	}
 
-	public function getPickedItem() : Item{
-		return ItemFactory::get(Item::CARROT);
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::CARROT();
 	}
 }

src/block/CarvedPumpkin.php

@@ -0,0 +1,45 @@
+<?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\BlockDataSerializer;
+use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
+use pocketmine\block\utils\HorizontalFacingTrait;
+
+class CarvedPumpkin extends Opaque{
+	use FacesOppositePlacingPlayerTrait;
+	use HorizontalFacingTrait;
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+	}
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b11;
+	}
+}

src/block/ChemicalHeat.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+final class ChemicalHeat extends Transparent{
+
+	/*
+	 * TODO: this block causes melting of nearby ice and snow within 2 blocks taxicab distance.
+	 * Since it doesn't emit any light, the mechanics of this block's behaviour are not currently clear.
+	 */
+}

src/block/ChemistryTable.php

@@ -23,43 +23,32 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\PillarRotationHelper;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
+use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
 
-class HayBale extends Solid{
+final class ChemistryTable extends Opaque{
+	use FacesOppositePlacingPlayerTrait;
+	use HorizontalFacingTrait;
 
-	protected $id = self::HAY_BALE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = Facing::opposite(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x3));
 	}
 
-	public function getName() : string{
-		return "Hay Bale";
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::opposite($this->facing));
 	}
 
-	public function getHardness() : float{
-		return 0.5;
+	public function getStateBitmask() : int{
+		return 0b0011;
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$this->meta = PillarRotationHelper::getMetaFromFace($this->meta, $face);
-		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
-
-		return true;
-	}
-
-	public function getVariantBitmask() : int{
-		return 0x03;
-	}
-
-	public function getFlameEncouragement() : int{
-		return 60;
-	}
-
-	public function getFlammability() : int{
-		return 20;
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		//TODO
+		return false;
 	}
 }

src/block/Chest.php

@@ -0,0 +1,90 @@
+<?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\Chest as TileChest;
+use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
+use pocketmine\block\utils\NormalHorizontalFacingInMetadataTrait;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+
+class Chest extends Transparent{
+	use FacesOppositePlacingPlayerTrait;
+	use NormalHorizontalFacingInMetadataTrait;
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		//these are slightly bigger than in PC
+		return [AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05)];
+	}
+
+	public function onPostPlace() : void{
+		$tile = $this->position->getWorld()->getTile($this->position);
+		if($tile instanceof TileChest){
+			foreach([
+				Facing::rotateY($this->facing, true),
+				Facing::rotateY($this->facing, false)
+			] as $side){
+				$c = $this->getSide($side);
+				if($c instanceof Chest and $c->isSameType($this) and $c->facing === $this->facing){
+					$pair = $this->position->getWorld()->getTile($c->position);
+					if($pair instanceof TileChest and !$pair->isPaired()){
+						$pair->pairWith($tile);
+						$tile->pairWith($pair);
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+
+			$chest = $this->position->getWorld()->getTile($this->position);
+			if($chest instanceof TileChest){
+				if(
+					!$this->getSide(Facing::UP)->isTransparent() or
+					(($pair = $chest->getPair()) !== null and !$pair->getBlock()->getSide(Facing::UP)->isTransparent()) or
+					!$chest->canOpenWith($item->getCustomName())
+				){
+					return true;
+				}
+
+				$player->setCurrentWindow($chest->getInventory());
+			}
+		}
+
+		return true;
+	}
+
+	public function getFuelTime() : int{
+		return 300;
+	}
+}

src/block/Clay.php

@@ -23,18 +23,18 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class Wood2 extends Wood{
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 
-	public const ACACIA = 0;
-	public const DARK_OAK = 1;
+class Clay extends Opaque{
 
-	protected $id = self::WOOD2;
-
-	public function getName() : string{
-		static $names = [
-			0 => "Acacia Wood",
-			1 => "Dark Oak Wood"
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			VanillaItems::CLAY()->setCount(4)
 		];
-		return $names[$this->getVariant()] ?? "Unknown";
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
 	}
 }

src/block/Coal.php

@@ -21,16 +21,19 @@
 
 declare(strict_types=1);
 
-namespace pocketmine\item;
+namespace pocketmine\block;
 
-class Boat extends Item{
-	public function __construct(int $meta = 0){
-		parent::__construct(self::BOAT, $meta, "Boat");
-	}
+class Coal extends Opaque{
 
 	public function getFuelTime() : int{
-		return 1200; //400 in PC
+		return 16000;
 	}
 
-	//TODO
+	public function getFlameEncouragement() : int{
+		return 5;
+	}
+
+	public function getFlammability() : int{
+		return 5;
+	}
 }

src/block/CoalOre.php

@@ -24,27 +24,22 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
+use function mt_rand;
 
-class Tripwire extends Flowable{
-
-	protected $id = self::TRIPWIRE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Tripwire";
-	}
+class CoalOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::STRING)
+			VanillaItems::COAL()
 		];
 	}
 
 	public function isAffectedBySilkTouch() : bool{
-		return false;
+		return true;
+	}
+
+	protected function getXpDropAmount() : int{
+		return mt_rand(0, 2);
 	}
 }

src/block/Cobweb.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\entity\Entity;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+
+class Cobweb extends Flowable{
+
+	public function hasEntityCollision() : bool{
+		return true;
+	}
+
+	public function onEntityInside(Entity $entity) : bool{
+		$entity->resetFallDistance();
+		return true;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			VanillaItems::STRING()
+		];
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	public function blocksDirectSkyLight() : bool{
+		return true;
+	}
+}

src/block/CocoaBlock.php

@@ -0,0 +1,146 @@
+<?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\BlockDataSerializer;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\TreeType;
+use pocketmine\event\block\BlockGrowEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function mt_rand;
+
+class CocoaBlock extends Transparent{
+	use HorizontalFacingTrait;
+
+	protected int $age = 0;
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::opposite($this->facing)) | ($this->age << 2);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = Facing::opposite(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03));
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta >> 2, 0, 2);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function getAge() : int{ return $this->age; }
+
+	/** @return $this */
+	public function setAge(int $age) : self{
+		if($age < 0 || $age > 2){
+			throw new \InvalidArgumentException("Age must be in range 0-2");
+		}
+		$this->age = $age;
+		return $this;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [
+			AxisAlignedBB::one()
+				->squash(Facing::axis(Facing::rotateY($this->facing, true)), (6 - $this->age) / 16) //sides
+				->trim(Facing::DOWN, (7 - $this->age * 2) / 16)
+				->trim(Facing::UP, 0.25)
+				->trim(Facing::opposite($this->facing), 1 / 16) //gap between log and pod
+				->trim($this->facing, (11 - $this->age * 2) / 16) //outward face
+		];
+	}
+
+	private function canAttachTo(Block $block) : bool{
+		return $block instanceof Wood && $block->getTreeType()->equals(TreeType::JUNGLE());
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(Facing::axis($face) !== Axis::Y and $this->canAttachTo($blockClicked)){
+			$this->facing = $face;
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof Fertilizer && $this->grow()){
+			$item->pop();
+
+			return true;
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->canAttachTo($this->getSide(Facing::opposite($this->facing)))){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if(mt_rand(1, 5) === 1){
+			$this->grow();
+		}
+	}
+
+	private function grow() : bool{
+		if($this->age < 2){
+			$block = clone $this;
+			$block->age++;
+			$ev = new BlockGrowEvent($this, $block);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				$this->position->getWorld()->setBlock($this->position, $ev->getNewState());
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			VanillaItems::COCOA_BEANS()->setCount($this->age === 2 ? mt_rand(2, 3) : 1)
+		];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::COCOA_BEANS();
+	}
+}

src/block/Concrete.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\utils\ColorInMetadataTrait;
+use pocketmine\block\utils\DyeColor;
+
+class Concrete extends Opaque{
+	use ColorInMetadataTrait;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->color = DyeColor::WHITE();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+}

src/block/ConcretePowder.php

@@ -23,33 +23,28 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorBlockMetaHelper;
+use pocketmine\block\utils\ColorInMetadataTrait;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
+use pocketmine\math\Facing;
 
-class ConcretePowder extends Fallable{
-
-	protected $id = self::CONCRETE_POWDER;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+class ConcretePowder extends Opaque implements Fallable{
+	use ColorInMetadataTrait;
+	use FallableTrait {
+		onNearbyBlockChange as protected startFalling;
 	}
 
-	public function getName() : string{
-		return ColorBlockMetaHelper::getColorFromMeta($this->getVariant()) . " Concrete Powder";
-	}
-
-	public function getHardness() : float{
-		return 0.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->color = DyeColor::WHITE();
+		parent::__construct($idInfo, $name, $breakInfo);
 	}
 
 	public function onNearbyBlockChange() : void{
 		if(($block = $this->checkAdjacentWater()) !== null){
-			$this->level->setBlock($this, $block);
+			$this->position->getWorld()->setBlock($this->position, $block);
 		}else{
-			parent::onNearbyBlockChange();
+			$this->startFalling();
 		}
 	}
 
@@ -58,9 +53,12 @@ class ConcretePowder extends Fallable{
 	}
 
 	private function checkAdjacentWater() : ?Block{
-		for($i = 1; $i < 6; ++$i){ //Do not check underneath
+		foreach(Facing::ALL as $i){
+			if($i === Facing::DOWN){
+				continue;
+			}
 			if($this->getSide($i) instanceof Water){
-				return BlockFactory::get(Block::CONCRETE, $this->meta);
+				return VanillaBlocks::CONCRETE()->setColor($this->color);
 			}
 		}
 

src/block/Coral.php

@@ -0,0 +1,82 @@
+<?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\InvalidBlockStateException;
+use pocketmine\data\bedrock\CoralTypeIdMap;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+final class Coral extends BaseCoral{
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$coralType = CoralTypeIdMap::getInstance()->fromId($stateMeta);
+		if($coralType === null){
+			throw new InvalidBlockStateException("No such coral type");
+		}
+		$this->coralType = $coralType;
+	}
+
+	public function writeStateToMeta() : int{
+		return CoralTypeIdMap::getInstance()->toId($this->coralType);
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return $this->writeStateToMeta();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b0111;
+	}
+
+	public function readStateFromWorld() : void{
+		//TODO: this hack ensures correct state of coral plants, because they don't retain their dead flag in metadata
+		$world = $this->position->getWorld();
+		$this->dead = true;
+		foreach($this->position->sides() as $vector3){
+			if($world->getBlock($vector3) instanceof Water){
+				$this->dead = false;
+				break;
+			}
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$tx->fetchBlock($blockReplace->getPosition()->down())->isSolid()){
+			return false;
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		$world = $this->position->getWorld();
+		if(!$world->getBlock($this->position->down())->isSolid()){
+			$world->useBreakOn($this->position);
+		}else{
+			parent::onNearbyBlockChange();
+		}
+	}
+}

src/block/CoralBlock.php

@@ -0,0 +1,109 @@
+<?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\CoralType;
+use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\data\bedrock\CoralTypeIdMap;
+use pocketmine\item\Item;
+use function mt_rand;
+
+final class CoralBlock extends Opaque{
+
+	private CoralType $coralType;
+	private bool $dead = false;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->coralType = CoralType::TUBE();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$coralType = CoralTypeIdMap::getInstance()->fromId($stateMeta & 0x7);
+		if($coralType === null){
+			throw new InvalidBlockStateException("No such coral type");
+		}
+		$this->coralType = $coralType;
+		$this->dead = ($stateMeta & BlockLegacyMetadata::CORAL_BLOCK_FLAG_DEAD) !== 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return ($this->dead ? BlockLegacyMetadata::CORAL_BLOCK_FLAG_DEAD : 0) | CoralTypeIdMap::getInstance()->toId($this->coralType);
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return $this->writeStateToMeta();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function getCoralType() : CoralType{ return $this->coralType; }
+
+	/** @return $this */
+	public function setCoralType(CoralType $coralType) : self{
+		$this->coralType = $coralType;
+		return $this;
+	}
+
+	public function isDead() : bool{ return $this->dead; }
+
+	/** @return $this */
+	public function setDead(bool $dead) : self{
+		$this->dead = $dead;
+		return $this;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->dead){
+			$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, mt_rand(40, 200));
+		}
+	}
+
+	public function onScheduledUpdate() : void{
+		if(!$this->dead){
+			$world = $this->position->getWorld();
+
+			$hasWater = false;
+			foreach($this->position->sides() as $vector3){
+				if($world->getBlock($vector3) instanceof Water){
+					$hasWater = true;
+					break;
+				}
+			}
+			if(!$hasWater){
+				$world->setBlock($this->position, $this->setDead(true));
+			}
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [$this->setDead(true)->asItem()];
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+}

src/block/CraftingTable.php

@@ -23,29 +23,22 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class NoteBlock extends Solid{
+use pocketmine\block\inventory\CraftingTableInventory;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
 
-	protected $id = self::NOTE_BLOCK;
+class CraftingTable extends Opaque{
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$player->setCurrentWindow(new CraftingTableInventory($this->position));
 		}
 
-	public function getName() : string{
-		return "Note Block";
+		return true;
 	}
 
 	public function getFuelTime() : int{
 		return 300;
 	}
-
-	public function getHardness() : float{
-		return 0.8;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
-	}
-
-	//TODO
 }

src/block/Crops.php

@@ -0,0 +1,113 @@
+<?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\BlockDataSerializer;
+use pocketmine\event\block\BlockGrowEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function mt_rand;
+
+abstract class Crops extends Flowable{
+
+	protected int $age = 0;
+
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 7);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	public function getAge() : int{ return $this->age; }
+
+	/** @return $this */
+	public function setAge(int $age) : self{
+		if($age < 0 || $age > 7){
+			throw new \InvalidArgumentException("Age must be in range 0-7");
+		}
+		$this->age = $age;
+		return $this;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($blockReplace->getSide(Facing::DOWN)->getId() === BlockLegacyIds::FARMLAND){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->age < 7 and $item instanceof Fertilizer){
+			$block = clone $this;
+			$block->age += mt_rand(2, 5);
+			if($block->age > 7){
+				$block->age = 7;
+			}
+
+			$ev = new BlockGrowEvent($this, $block);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				$this->position->getWorld()->setBlock($this->position, $ev->getNewState());
+				$item->pop();
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::DOWN)->getId() !== BlockLegacyIds::FARMLAND){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if($this->age < 7 and mt_rand(0, 2) === 1){
+			$block = clone $this;
+			++$block->age;
+			$ev = new BlockGrowEvent($this, $block);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				$this->position->getWorld()->setBlock($this->position, $ev->getNewState());
+			}
+		}
+	}
+}

src/block/DaylightSensor.php

@@ -0,0 +1,117 @@
+<?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\AnalogRedstoneSignalEmitterTrait;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use function cos;
+use function max;
+use function round;
+use const M_PI;
+
+class DaylightSensor extends Transparent{
+	use AnalogRedstoneSignalEmitterTrait;
+
+	protected BlockIdentifierFlattened $idInfoFlattened;
+
+	protected bool $inverted = false;
+
+	public function __construct(BlockIdentifierFlattened $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->idInfoFlattened = $idInfo;
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function getId() : int{
+		return $this->inverted ? $this->idInfoFlattened->getSecondId() : parent::getId();
+	}
+
+	protected function writeStateToMeta() : int{
+		return $this->signalStrength;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->signalStrength = BlockDataSerializer::readBoundedInt("signalStrength", $stateMeta, 0, 15);
+		$this->inverted = $id === $this->idInfoFlattened->getSecondId();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function isInverted() : bool{
+		return $this->inverted;
+	}
+
+	/**
+	 * @return $this
+	 */
+	public function setInverted(bool $inverted = true) : self{
+		$this->inverted = $inverted;
+		return $this;
+	}
+
+	public function getFuelTime() : int{
+		return 300;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [AxisAlignedBB::one()->trim(Facing::UP, 10 / 16)];
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->inverted = !$this->inverted;
+		$this->signalStrength = $this->recalculateSignalStrength();
+		$this->position->getWorld()->setBlock($this->position, $this);
+		return true;
+	}
+
+	public function onScheduledUpdate() : void{
+		$signalStrength = $this->recalculateSignalStrength();
+		if($this->signalStrength !== $signalStrength){
+			$this->signalStrength = $signalStrength;
+			$this->position->getWorld()->setBlock($this->position, $this);
+		}
+		$this->position->getWorld()->scheduleDelayedBlockUpdate($this->position, 20);
+	}
+
+	private function recalculateSignalStrength() : int{
+		$lightLevel = $this->position->getWorld()->getRealBlockSkyLightAt($this->position->x, $this->position->y, $this->position->z);
+		if($this->inverted){
+			return 15 - $lightLevel;
+		}
+
+		$sunAngle = $this->position->getWorld()->getSunAnglePercentage();
+		return max(0, (int) round($lightLevel * cos(($sunAngle + ((($sunAngle < 0.5 ? 0 : 1) - $sunAngle) / 5)) * 2 * M_PI)));
+	}
+
+	//TODO
+}

src/block/DeadBush.php

@@ -24,53 +24,37 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
 class DeadBush extends Flowable{
 
-	protected $id = self::DEAD_BUSH;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Dead Bush";
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if(!$this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			return parent::place($item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->getSide(Facing::DOWN)->isTransparent()){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevelNonNull()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHEARS;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return 1;
-	}
-
-	public function getDrops(Item $item) : array{
-		if(!$this->isCompatibleWithTool($item)){
+	public function getDropsForIncompatibleTool(Item $item) : array{
 		return [
-				ItemFactory::get(Item::STICK, 0, mt_rand(0, 2))
+			VanillaItems::STICK()->setCount(mt_rand(0, 2))
 		];
 	}
 
-		return parent::getDrops($item);
+	public function isAffectedBySilkTouch() : bool{
+		return true;
 	}
 
 	public function getFlameEncouragement() : int{

src/block/DetectorRail.php

@@ -0,0 +1,51 @@
+<?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;
+
+class DetectorRail extends StraightOnlyRail{
+	protected bool $activated = false;
+
+	public function isActivated() : bool{ return $this->activated; }
+
+	/** @return $this */
+	public function setActivated(bool $activated) : self{
+		$this->activated = $activated;
+		return $this;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		parent::readStateFromData($id, $stateMeta & ~BlockLegacyMetadata::REDSTONE_RAIL_FLAG_POWERED);
+		$this->activated = ($stateMeta & BlockLegacyMetadata::REDSTONE_RAIL_FLAG_POWERED) !== 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return parent::writeStateToMeta() | ($this->activated ? BlockLegacyMetadata::REDSTONE_RAIL_FLAG_POWERED : 0);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	//TODO
+}

src/block/DiamondOre.php

@@ -24,31 +24,22 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
-class RedMushroomBlock extends Solid{
-
-	protected $id = Block::RED_MUSHROOM_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Red Mushroom Block";
-	}
-
-	public function getHardness() : float{
-		return 0.2;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
-	}
+class DiamondOre extends Opaque{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			Item::get(Item::RED_MUSHROOM, 0, mt_rand(0, 2))
+			VanillaItems::DIAMOND()
 		];
 	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return true;
+	}
+
+	protected function getXpDropAmount() : int{
+		return mt_rand(3, 7);
+	}
 }

src/block/Dirt.php

@@ -0,0 +1,70 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\item\Hoe;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+
+class Dirt extends Opaque{
+
+	protected bool $coarse = false;
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->coarse = ($stateMeta & BlockLegacyMetadata::DIRT_FLAG_COARSE) !== 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return $this->coarse ? BlockLegacyMetadata::DIRT_FLAG_COARSE : 0;
+	}
+
+	protected function writeStateToItemMeta() : int{
+		return $this->writeStateToMeta();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1;
+	}
+
+	public function isCoarse() : bool{ return $this->coarse; }
+
+	/** @return $this */
+	public function setCoarse(bool $coarse) : self{
+		$this->coarse = $coarse;
+		return $this;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP and $item instanceof Hoe){
+			$item->applyDamage(1);
+			$this->position->getWorld()->setBlock($this->position, $this->coarse ? VanillaBlocks::DIRT() : VanillaBlocks::FARMLAND());
+
+			return true;
+		}
+
+		return false;
+	}
+}

src/block/Door.php

@@ -0,0 +1,187 @@
+<?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\BlockDataSerializer;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\PoweredByRedstoneTrait;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\DoorSound;
+
+class Door extends Transparent{
+	use HorizontalFacingTrait;
+	use PoweredByRedstoneTrait;
+
+	protected bool $top = false;
+	protected bool $hingeRight = false;
+	protected bool $open = false;
+
+	protected function writeStateToMeta() : int{
+		if($this->top){
+			return BlockLegacyMetadata::DOOR_FLAG_TOP |
+				($this->hingeRight ? BlockLegacyMetadata::DOOR_TOP_FLAG_RIGHT : 0) |
+				($this->powered ? BlockLegacyMetadata::DOOR_TOP_FLAG_POWERED : 0);
+		}
+
+		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::rotateY($this->facing, true)) | ($this->open ? BlockLegacyMetadata::DOOR_BOTTOM_FLAG_OPEN : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->top = ($stateMeta & BlockLegacyMetadata::DOOR_FLAG_TOP) !== 0;
+		if($this->top){
+			$this->hingeRight = ($stateMeta & BlockLegacyMetadata::DOOR_TOP_FLAG_RIGHT) !== 0;
+			$this->powered = ($stateMeta & BlockLegacyMetadata::DOOR_TOP_FLAG_POWERED) !== 0;
+		}else{
+			$this->facing = Facing::rotateY(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03), false);
+			$this->open = ($stateMeta & BlockLegacyMetadata::DOOR_BOTTOM_FLAG_OPEN) !== 0;
+		}
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+
+		//copy door properties from other half
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other instanceof Door and $other->isSameType($this)){
+			if($this->top){
+				$this->facing = $other->facing;
+				$this->open = $other->open;
+			}else{
+				$this->hingeRight = $other->hingeRight;
+				$this->powered = $other->powered;
+			}
+		}
+	}
+
+	public function isTop() : bool{ return $this->top; }
+
+	/** @return $this */
+	public function setTop(bool $top) : self{
+		$this->top = $top;
+		return $this;
+	}
+
+	public function isHingeRight() : bool{ return $this->hingeRight; }
+
+	/** @return $this */
+	public function setHingeRight(bool $hingeRight) : self{
+		$this->hingeRight = $hingeRight;
+		return $this;
+	}
+
+	public function isOpen() : bool{ return $this->open; }
+
+	/** @return $this */
+	public function setOpen(bool $open) : self{
+		$this->open = $open;
+		return $this;
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		//TODO: doors are 0.1825 blocks thick, instead of 0.1875 like JE (https://bugs.mojang.com/browse/MCPE-19214)
+		return [AxisAlignedBB::one()->trim($this->open ? Facing::rotateY($this->facing, !$this->hingeRight) : $this->facing, 327 / 400)];
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){ //Replace with common break method
+			$this->position->getWorld()->useBreakOn($this->position); //this will delete both halves if they exist
+		}
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP){
+			$blockUp = $this->getSide(Facing::UP);
+			$blockDown = $this->getSide(Facing::DOWN);
+			if(!$blockUp->canBeReplaced() or $blockDown->isTransparent()){
+				return false;
+			}
+
+			if($player !== null){
+				$this->facing = $player->getHorizontalFacing();
+			}
+
+			$next = $this->getSide(Facing::rotateY($this->facing, false));
+			$next2 = $this->getSide(Facing::rotateY($this->facing, true));
+
+			if($next->isSameType($this) or (!$next2->isTransparent() and $next->isTransparent())){ //Door hinge
+				$this->hingeRight = true;
+			}
+
+			$topHalf = clone $this;
+			$topHalf->top = true;
+
+			$tx->addBlock($blockReplace->position, $this)->addBlock($blockUp->position, $topHalf);
+			return true;
+		}
+
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->open = !$this->open;
+
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other instanceof Door and $other->isSameType($this)){
+			$other->open = $this->open;
+			$this->position->getWorld()->setBlock($other->position, $other);
+		}
+
+		$this->position->getWorld()->setBlock($this->position, $this);
+		$this->position->getWorld()->addSound($this->position, new DoorSound());
+
+		return true;
+	}
+
+	public function getDrops(Item $item) : array{
+		if(!$this->top){
+			return parent::getDrops($item);
+		}
+
+		return [];
+	}
+
+	public function getAffectedBlocks() : array{
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other->isSameType($this)){
+			return [$this, $other];
+		}
+		return parent::getAffectedBlocks();
+	}
+}

src/block/DoublePlant.php

@@ -0,0 +1,106 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+class DoublePlant extends Flowable{
+
+	protected bool $top = false;
+
+	protected function writeStateToMeta() : int{
+		return ($this->top ? BlockLegacyMetadata::DOUBLE_PLANT_FLAG_TOP : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->top = ($stateMeta & BlockLegacyMetadata::DOUBLE_PLANT_FLAG_TOP) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1000;
+	}
+
+	public function isTop() : bool{ return $this->top; }
+
+	/** @return $this */
+	public function setTop(bool $top) : self{
+		$this->top = $top;
+		return $this;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$id = $blockReplace->getSide(Facing::DOWN)->getId();
+		if(($id === BlockLegacyIds::GRASS or $id === BlockLegacyIds::DIRT) and $blockReplace->getSide(Facing::UP)->canBeReplaced()){
+			$top = clone $this;
+			$top->top = true;
+			$tx->addBlock($blockReplace->position, $this)->addBlock($blockReplace->position->getSide(Facing::UP), $top);
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns whether this double-plant has a corresponding other half.
+	 */
+	public function isValidHalfPlant() : bool{
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+
+		return (
+			$other instanceof DoublePlant and
+			$other->isSameType($this) and
+			$other->top !== $this->top
+		);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->isValidHalfPlant() or (!$this->top and $this->getSide(Facing::DOWN)->isTransparent())){
+			$this->position->getWorld()->useBreakOn($this->position);
+		}
+	}
+
+	public function getDrops(Item $item) : array{
+		return $this->top ? parent::getDrops($item) : [];
+	}
+
+	public function getAffectedBlocks() : array{
+		if($this->isValidHalfPlant()){
+			return [$this, $this->getSide($this->top ? Facing::DOWN : Facing::UP)];
+		}
+
+		return parent::getAffectedBlocks();
+	}
+
+	public function getFlameEncouragement() : int{
+		return 60;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
+}